xref: /openbmc/linux/net/tipc/socket.c (revision 643d1f7f)
1 /*
2  * net/tipc/socket.c: TIPC socket API
3  *
4  * Copyright (c) 2001-2007, Ericsson AB
5  * Copyright (c) 2004-2007, Wind River Systems
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. Neither the names of the copyright holders nor the names of its
17  *    contributors may be used to endorse or promote products derived from
18  *    this software without specific prior written permission.
19  *
20  * Alternatively, this software may be distributed under the terms of the
21  * GNU General Public License ("GPL") version 2 as published by the Free
22  * Software Foundation.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
28  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34  * POSSIBILITY OF SUCH DAMAGE.
35  */
36 
37 #include <linux/module.h>
38 #include <linux/types.h>
39 #include <linux/net.h>
40 #include <linux/socket.h>
41 #include <linux/errno.h>
42 #include <linux/mm.h>
43 #include <linux/slab.h>
44 #include <linux/poll.h>
45 #include <linux/fcntl.h>
46 #include <asm/semaphore.h>
47 #include <asm/string.h>
48 #include <asm/atomic.h>
49 #include <net/sock.h>
50 
51 #include <linux/tipc.h>
52 #include <linux/tipc_config.h>
53 #include <net/tipc/tipc_msg.h>
54 #include <net/tipc/tipc_port.h>
55 
56 #include "core.h"
57 
58 #define SS_LISTENING	-1	/* socket is listening */
59 #define SS_READY	-2	/* socket is connectionless */
60 
61 #define OVERLOAD_LIMIT_BASE    5000
62 
63 struct tipc_sock {
64 	struct sock sk;
65 	struct tipc_port *p;
66 	struct semaphore sem;
67 };
68 
69 #define tipc_sk(sk) ((struct tipc_sock*)sk)
70 
71 static u32 dispatch(struct tipc_port *tport, struct sk_buff *buf);
72 static void wakeupdispatch(struct tipc_port *tport);
73 
74 static struct proto_ops packet_ops;
75 static struct proto_ops stream_ops;
76 static struct proto_ops msg_ops;
77 
78 static struct proto tipc_proto;
79 
80 static int sockets_enabled = 0;
81 
82 static atomic_t tipc_queue_size = ATOMIC_INIT(0);
83 
84 
85 /*
86  * sock_lock(): Lock a port/socket pair. lock_sock() can
87  * not be used here, since the same lock must protect ports
88  * with non-socket interfaces.
89  * See net.c for description of locking policy.
90  */
91 static void sock_lock(struct tipc_sock* tsock)
92 {
93 	spin_lock_bh(tsock->p->lock);
94 }
95 
96 /*
97  * sock_unlock(): Unlock a port/socket pair
98  */
99 static void sock_unlock(struct tipc_sock* tsock)
100 {
101 	spin_unlock_bh(tsock->p->lock);
102 }
103 
104 /**
105  * pollmask - determine the current set of poll() events for a socket
106  * @sock: socket structure
107  *
108  * TIPC sets the returned events as follows:
109  * a) POLLRDNORM and POLLIN are set if the socket's receive queue is non-empty
110  *    or if a connection-oriented socket is does not have an active connection
111  *    (i.e. a read operation will not block).
112  * b) POLLOUT is set except when a socket's connection has been terminated
113  *    (i.e. a write operation will not block).
114  * c) POLLHUP is set when a socket's connection has been terminated.
115  *
116  * IMPORTANT: The fact that a read or write operation will not block does NOT
117  * imply that the operation will succeed!
118  *
119  * Returns pollmask value
120  */
121 
122 static u32 pollmask(struct socket *sock)
123 {
124 	u32 mask;
125 
126 	if ((skb_queue_len(&sock->sk->sk_receive_queue) != 0) ||
127 	    (sock->state == SS_UNCONNECTED) ||
128 	    (sock->state == SS_DISCONNECTING))
129 		mask = (POLLRDNORM | POLLIN);
130 	else
131 		mask = 0;
132 
133 	if (sock->state == SS_DISCONNECTING)
134 		mask |= POLLHUP;
135 	else
136 		mask |= POLLOUT;
137 
138 	return mask;
139 }
140 
141 
142 /**
143  * advance_queue - discard first buffer in queue
144  * @tsock: TIPC socket
145  */
146 
147 static void advance_queue(struct tipc_sock *tsock)
148 {
149 	sock_lock(tsock);
150 	buf_discard(skb_dequeue(&tsock->sk.sk_receive_queue));
151 	sock_unlock(tsock);
152 	atomic_dec(&tipc_queue_size);
153 }
154 
155 /**
156  * tipc_create - create a TIPC socket
157  * @sock: pre-allocated socket structure
158  * @protocol: protocol indicator (must be 0)
159  *
160  * This routine creates and attaches a 'struct sock' to the 'struct socket',
161  * then create and attaches a TIPC port to the 'struct sock' part.
162  *
163  * Returns 0 on success, errno otherwise
164  */
165 static int tipc_create(struct net *net, struct socket *sock, int protocol)
166 {
167 	struct tipc_sock *tsock;
168 	struct tipc_port *port;
169 	struct sock *sk;
170 	u32 ref;
171 
172 	if (net != &init_net)
173 		return -EAFNOSUPPORT;
174 
175 	if (unlikely(protocol != 0))
176 		return -EPROTONOSUPPORT;
177 
178 	ref = tipc_createport_raw(NULL, &dispatch, &wakeupdispatch, TIPC_LOW_IMPORTANCE);
179 	if (unlikely(!ref))
180 		return -ENOMEM;
181 
182 	sock->state = SS_UNCONNECTED;
183 
184 	switch (sock->type) {
185 	case SOCK_STREAM:
186 		sock->ops = &stream_ops;
187 		break;
188 	case SOCK_SEQPACKET:
189 		sock->ops = &packet_ops;
190 		break;
191 	case SOCK_DGRAM:
192 		tipc_set_portunreliable(ref, 1);
193 		/* fall through */
194 	case SOCK_RDM:
195 		tipc_set_portunreturnable(ref, 1);
196 		sock->ops = &msg_ops;
197 		sock->state = SS_READY;
198 		break;
199 	default:
200 		tipc_deleteport(ref);
201 		return -EPROTOTYPE;
202 	}
203 
204 	sk = sk_alloc(net, AF_TIPC, GFP_KERNEL, &tipc_proto);
205 	if (!sk) {
206 		tipc_deleteport(ref);
207 		return -ENOMEM;
208 	}
209 
210 	sock_init_data(sock, sk);
211 	init_waitqueue_head(sk->sk_sleep);
212 	sk->sk_rcvtimeo = 8 * HZ;   /* default connect timeout = 8s */
213 
214 	tsock = tipc_sk(sk);
215 	port = tipc_get_port(ref);
216 
217 	tsock->p = port;
218 	port->usr_handle = tsock;
219 
220 	init_MUTEX(&tsock->sem);
221 
222 	dbg("sock_create: %x\n",tsock);
223 
224 	atomic_inc(&tipc_user_count);
225 
226 	return 0;
227 }
228 
229 /**
230  * release - destroy a TIPC socket
231  * @sock: socket to destroy
232  *
233  * This routine cleans up any messages that are still queued on the socket.
234  * For DGRAM and RDM socket types, all queued messages are rejected.
235  * For SEQPACKET and STREAM socket types, the first message is rejected
236  * and any others are discarded.  (If the first message on a STREAM socket
237  * is partially-read, it is discarded and the next one is rejected instead.)
238  *
239  * NOTE: Rejected messages are not necessarily returned to the sender!  They
240  * are returned or discarded according to the "destination droppable" setting
241  * specified for the message by the sender.
242  *
243  * Returns 0 on success, errno otherwise
244  */
245 
246 static int release(struct socket *sock)
247 {
248 	struct tipc_sock *tsock = tipc_sk(sock->sk);
249 	struct sock *sk = sock->sk;
250 	int res = TIPC_OK;
251 	struct sk_buff *buf;
252 
253 	dbg("sock_delete: %x\n",tsock);
254 	if (!tsock)
255 		return 0;
256 	down(&tsock->sem);
257 	if (!sock->sk) {
258 		up(&tsock->sem);
259 		return 0;
260 	}
261 
262 	/* Reject unreceived messages, unless no longer connected */
263 
264 	while (sock->state != SS_DISCONNECTING) {
265 		sock_lock(tsock);
266 		buf = skb_dequeue(&sk->sk_receive_queue);
267 		if (!buf)
268 			tsock->p->usr_handle = NULL;
269 		sock_unlock(tsock);
270 		if (!buf)
271 			break;
272 		if (TIPC_SKB_CB(buf)->handle != msg_data(buf_msg(buf)))
273 			buf_discard(buf);
274 		else
275 			tipc_reject_msg(buf, TIPC_ERR_NO_PORT);
276 		atomic_dec(&tipc_queue_size);
277 	}
278 
279 	/* Delete TIPC port */
280 
281 	res = tipc_deleteport(tsock->p->ref);
282 	sock->sk = NULL;
283 
284 	/* Discard any remaining messages */
285 
286 	while ((buf = skb_dequeue(&sk->sk_receive_queue))) {
287 		buf_discard(buf);
288 		atomic_dec(&tipc_queue_size);
289 	}
290 
291 	up(&tsock->sem);
292 
293 	sock_put(sk);
294 
295 	atomic_dec(&tipc_user_count);
296 	return res;
297 }
298 
299 /**
300  * bind - associate or disassocate TIPC name(s) with a socket
301  * @sock: socket structure
302  * @uaddr: socket address describing name(s) and desired operation
303  * @uaddr_len: size of socket address data structure
304  *
305  * Name and name sequence binding is indicated using a positive scope value;
306  * a negative scope value unbinds the specified name.  Specifying no name
307  * (i.e. a socket address length of 0) unbinds all names from the socket.
308  *
309  * Returns 0 on success, errno otherwise
310  */
311 
312 static int bind(struct socket *sock, struct sockaddr *uaddr, int uaddr_len)
313 {
314 	struct tipc_sock *tsock = tipc_sk(sock->sk);
315 	struct sockaddr_tipc *addr = (struct sockaddr_tipc *)uaddr;
316 	int res;
317 
318 	if (down_interruptible(&tsock->sem))
319 		return -ERESTARTSYS;
320 
321 	if (unlikely(!uaddr_len)) {
322 		res = tipc_withdraw(tsock->p->ref, 0, NULL);
323 		goto exit;
324 	}
325 
326 	if (uaddr_len < sizeof(struct sockaddr_tipc)) {
327 		res = -EINVAL;
328 		goto exit;
329 	}
330 
331 	if (addr->family != AF_TIPC) {
332 		res = -EAFNOSUPPORT;
333 		goto exit;
334 	}
335 	if (addr->addrtype == TIPC_ADDR_NAME)
336 		addr->addr.nameseq.upper = addr->addr.nameseq.lower;
337 	else if (addr->addrtype != TIPC_ADDR_NAMESEQ) {
338 		res = -EAFNOSUPPORT;
339 		goto exit;
340 	}
341 
342 	if (addr->scope > 0)
343 		res = tipc_publish(tsock->p->ref, addr->scope,
344 				   &addr->addr.nameseq);
345 	else
346 		res = tipc_withdraw(tsock->p->ref, -addr->scope,
347 				    &addr->addr.nameseq);
348 exit:
349 	up(&tsock->sem);
350 	return res;
351 }
352 
353 /**
354  * get_name - get port ID of socket or peer socket
355  * @sock: socket structure
356  * @uaddr: area for returned socket address
357  * @uaddr_len: area for returned length of socket address
358  * @peer: 0 to obtain socket name, 1 to obtain peer socket name
359  *
360  * Returns 0 on success, errno otherwise
361  */
362 
363 static int get_name(struct socket *sock, struct sockaddr *uaddr,
364 		    int *uaddr_len, int peer)
365 {
366 	struct tipc_sock *tsock = tipc_sk(sock->sk);
367 	struct sockaddr_tipc *addr = (struct sockaddr_tipc *)uaddr;
368 	u32 res;
369 
370 	if (down_interruptible(&tsock->sem))
371 		return -ERESTARTSYS;
372 
373 	*uaddr_len = sizeof(*addr);
374 	addr->addrtype = TIPC_ADDR_ID;
375 	addr->family = AF_TIPC;
376 	addr->scope = 0;
377 	if (peer)
378 		res = tipc_peer(tsock->p->ref, &addr->addr.id);
379 	else
380 		res = tipc_ownidentity(tsock->p->ref, &addr->addr.id);
381 	addr->addr.name.domain = 0;
382 
383 	up(&tsock->sem);
384 	return res;
385 }
386 
387 /**
388  * poll - read and possibly block on pollmask
389  * @file: file structure associated with the socket
390  * @sock: socket for which to calculate the poll bits
391  * @wait: ???
392  *
393  * Returns the pollmask
394  */
395 
396 static unsigned int poll(struct file *file, struct socket *sock,
397 			 poll_table *wait)
398 {
399 	poll_wait(file, sock->sk->sk_sleep, wait);
400 	/* NEED LOCK HERE? */
401 	return pollmask(sock);
402 }
403 
404 /**
405  * dest_name_check - verify user is permitted to send to specified port name
406  * @dest: destination address
407  * @m: descriptor for message to be sent
408  *
409  * Prevents restricted configuration commands from being issued by
410  * unauthorized users.
411  *
412  * Returns 0 if permission is granted, otherwise errno
413  */
414 
415 static int dest_name_check(struct sockaddr_tipc *dest, struct msghdr *m)
416 {
417 	struct tipc_cfg_msg_hdr hdr;
418 
419 	if (likely(dest->addr.name.name.type >= TIPC_RESERVED_TYPES))
420 		return 0;
421 	if (likely(dest->addr.name.name.type == TIPC_TOP_SRV))
422 		return 0;
423 
424 	if (likely(dest->addr.name.name.type != TIPC_CFG_SRV))
425 		return -EACCES;
426 
427 	if (copy_from_user(&hdr, m->msg_iov[0].iov_base, sizeof(hdr)))
428 		return -EFAULT;
429 	if ((ntohs(hdr.tcm_type) & 0xC000) && (!capable(CAP_NET_ADMIN)))
430 		return -EACCES;
431 
432 	return 0;
433 }
434 
435 /**
436  * send_msg - send message in connectionless manner
437  * @iocb: (unused)
438  * @sock: socket structure
439  * @m: message to send
440  * @total_len: length of message
441  *
442  * Message must have an destination specified explicitly.
443  * Used for SOCK_RDM and SOCK_DGRAM messages,
444  * and for 'SYN' messages on SOCK_SEQPACKET and SOCK_STREAM connections.
445  * (Note: 'SYN+' is prohibited on SOCK_STREAM.)
446  *
447  * Returns the number of bytes sent on success, or errno otherwise
448  */
449 
450 static int send_msg(struct kiocb *iocb, struct socket *sock,
451 		    struct msghdr *m, size_t total_len)
452 {
453 	struct tipc_sock *tsock = tipc_sk(sock->sk);
454 	struct sockaddr_tipc *dest = (struct sockaddr_tipc *)m->msg_name;
455 	struct sk_buff *buf;
456 	int needs_conn;
457 	int res = -EINVAL;
458 
459 	if (unlikely(!dest))
460 		return -EDESTADDRREQ;
461 	if (unlikely((m->msg_namelen < sizeof(*dest)) ||
462 		     (dest->family != AF_TIPC)))
463 		return -EINVAL;
464 
465 	needs_conn = (sock->state != SS_READY);
466 	if (unlikely(needs_conn)) {
467 		if (sock->state == SS_LISTENING)
468 			return -EPIPE;
469 		if (sock->state != SS_UNCONNECTED)
470 			return -EISCONN;
471 		if ((tsock->p->published) ||
472 		    ((sock->type == SOCK_STREAM) && (total_len != 0)))
473 			return -EOPNOTSUPP;
474 		if (dest->addrtype == TIPC_ADDR_NAME) {
475 			tsock->p->conn_type = dest->addr.name.name.type;
476 			tsock->p->conn_instance = dest->addr.name.name.instance;
477 		}
478 	}
479 
480 	if (down_interruptible(&tsock->sem))
481 		return -ERESTARTSYS;
482 
483 	if (needs_conn) {
484 
485 		/* Abort any pending connection attempts (very unlikely) */
486 
487 		while ((buf = skb_dequeue(&sock->sk->sk_receive_queue))) {
488 			tipc_reject_msg(buf, TIPC_ERR_NO_PORT);
489 			atomic_dec(&tipc_queue_size);
490 		}
491 
492 		sock->state = SS_CONNECTING;
493 	}
494 
495 	do {
496 		if (dest->addrtype == TIPC_ADDR_NAME) {
497 			if ((res = dest_name_check(dest, m)))
498 				goto exit;
499 			res = tipc_send2name(tsock->p->ref,
500 					     &dest->addr.name.name,
501 					     dest->addr.name.domain,
502 					     m->msg_iovlen,
503 					     m->msg_iov);
504 		}
505 		else if (dest->addrtype == TIPC_ADDR_ID) {
506 			res = tipc_send2port(tsock->p->ref,
507 					     &dest->addr.id,
508 					     m->msg_iovlen,
509 					     m->msg_iov);
510 		}
511 		else if (dest->addrtype == TIPC_ADDR_MCAST) {
512 			if (needs_conn) {
513 				res = -EOPNOTSUPP;
514 				goto exit;
515 			}
516 			if ((res = dest_name_check(dest, m)))
517 				goto exit;
518 			res = tipc_multicast(tsock->p->ref,
519 					     &dest->addr.nameseq,
520 					     0,
521 					     m->msg_iovlen,
522 					     m->msg_iov);
523 		}
524 		if (likely(res != -ELINKCONG)) {
525 exit:
526 			up(&tsock->sem);
527 			return res;
528 		}
529 		if (m->msg_flags & MSG_DONTWAIT) {
530 			res = -EWOULDBLOCK;
531 			goto exit;
532 		}
533 		if (wait_event_interruptible(*sock->sk->sk_sleep,
534 					     !tsock->p->congested)) {
535 		    res = -ERESTARTSYS;
536 		    goto exit;
537 		}
538 	} while (1);
539 }
540 
541 /**
542  * send_packet - send a connection-oriented message
543  * @iocb: (unused)
544  * @sock: socket structure
545  * @m: message to send
546  * @total_len: length of message
547  *
548  * Used for SOCK_SEQPACKET messages and SOCK_STREAM data.
549  *
550  * Returns the number of bytes sent on success, or errno otherwise
551  */
552 
553 static int send_packet(struct kiocb *iocb, struct socket *sock,
554 		       struct msghdr *m, size_t total_len)
555 {
556 	struct tipc_sock *tsock = tipc_sk(sock->sk);
557 	struct sockaddr_tipc *dest = (struct sockaddr_tipc *)m->msg_name;
558 	int res;
559 
560 	/* Handle implied connection establishment */
561 
562 	if (unlikely(dest))
563 		return send_msg(iocb, sock, m, total_len);
564 
565 	if (down_interruptible(&tsock->sem)) {
566 		return -ERESTARTSYS;
567 	}
568 
569 	do {
570 		if (unlikely(sock->state != SS_CONNECTED)) {
571 			if (sock->state == SS_DISCONNECTING)
572 				res = -EPIPE;
573 			else
574 				res = -ENOTCONN;
575 			goto exit;
576 		}
577 
578 		res = tipc_send(tsock->p->ref, m->msg_iovlen, m->msg_iov);
579 		if (likely(res != -ELINKCONG)) {
580 exit:
581 			up(&tsock->sem);
582 			return res;
583 		}
584 		if (m->msg_flags & MSG_DONTWAIT) {
585 			res = -EWOULDBLOCK;
586 			goto exit;
587 		}
588 		if (wait_event_interruptible(*sock->sk->sk_sleep,
589 					     !tsock->p->congested)) {
590 		    res = -ERESTARTSYS;
591 		    goto exit;
592 		}
593 	} while (1);
594 }
595 
596 /**
597  * send_stream - send stream-oriented data
598  * @iocb: (unused)
599  * @sock: socket structure
600  * @m: data to send
601  * @total_len: total length of data to be sent
602  *
603  * Used for SOCK_STREAM data.
604  *
605  * Returns the number of bytes sent on success (or partial success),
606  * or errno if no data sent
607  */
608 
609 
610 static int send_stream(struct kiocb *iocb, struct socket *sock,
611 		       struct msghdr *m, size_t total_len)
612 {
613 	struct tipc_port *tport;
614 	struct msghdr my_msg;
615 	struct iovec my_iov;
616 	struct iovec *curr_iov;
617 	int curr_iovlen;
618 	char __user *curr_start;
619 	u32 hdr_size;
620 	int curr_left;
621 	int bytes_to_send;
622 	int bytes_sent;
623 	int res;
624 
625 	/* Handle special cases where there is no connection */
626 
627 	if (unlikely(sock->state != SS_CONNECTED)) {
628 		if (sock->state == SS_UNCONNECTED)
629 			return send_packet(iocb, sock, m, total_len);
630 		else if (sock->state == SS_DISCONNECTING)
631 			return -EPIPE;
632 		else
633 			return -ENOTCONN;
634 	}
635 
636 	if (unlikely(m->msg_name))
637 		return -EISCONN;
638 
639 	/*
640 	 * Send each iovec entry using one or more messages
641 	 *
642 	 * Note: This algorithm is good for the most likely case
643 	 * (i.e. one large iovec entry), but could be improved to pass sets
644 	 * of small iovec entries into send_packet().
645 	 */
646 
647 	curr_iov = m->msg_iov;
648 	curr_iovlen = m->msg_iovlen;
649 	my_msg.msg_iov = &my_iov;
650 	my_msg.msg_iovlen = 1;
651 	my_msg.msg_flags = m->msg_flags;
652 	my_msg.msg_name = NULL;
653 	bytes_sent = 0;
654 
655 	tport = tipc_sk(sock->sk)->p;
656 	hdr_size = msg_hdr_sz(&tport->phdr);
657 
658 	while (curr_iovlen--) {
659 		curr_start = curr_iov->iov_base;
660 		curr_left = curr_iov->iov_len;
661 
662 		while (curr_left) {
663 			bytes_to_send = tport->max_pkt - hdr_size;
664 			if (bytes_to_send > TIPC_MAX_USER_MSG_SIZE)
665 				bytes_to_send = TIPC_MAX_USER_MSG_SIZE;
666 			if (curr_left < bytes_to_send)
667 				bytes_to_send = curr_left;
668 			my_iov.iov_base = curr_start;
669 			my_iov.iov_len = bytes_to_send;
670 			if ((res = send_packet(iocb, sock, &my_msg, 0)) < 0) {
671 				if (bytes_sent != 0)
672 					res = bytes_sent;
673 				return res;
674 			}
675 			curr_left -= bytes_to_send;
676 			curr_start += bytes_to_send;
677 			bytes_sent += bytes_to_send;
678 		}
679 
680 		curr_iov++;
681 	}
682 
683 	return bytes_sent;
684 }
685 
686 /**
687  * auto_connect - complete connection setup to a remote port
688  * @sock: socket structure
689  * @tsock: TIPC-specific socket structure
690  * @msg: peer's response message
691  *
692  * Returns 0 on success, errno otherwise
693  */
694 
695 static int auto_connect(struct socket *sock, struct tipc_sock *tsock,
696 			struct tipc_msg *msg)
697 {
698 	struct tipc_portid peer;
699 
700 	if (msg_errcode(msg)) {
701 		sock->state = SS_DISCONNECTING;
702 		return -ECONNREFUSED;
703 	}
704 
705 	peer.ref = msg_origport(msg);
706 	peer.node = msg_orignode(msg);
707 	tipc_connect2port(tsock->p->ref, &peer);
708 	tipc_set_portimportance(tsock->p->ref, msg_importance(msg));
709 	sock->state = SS_CONNECTED;
710 	return 0;
711 }
712 
713 /**
714  * set_orig_addr - capture sender's address for received message
715  * @m: descriptor for message info
716  * @msg: received message header
717  *
718  * Note: Address is not captured if not requested by receiver.
719  */
720 
721 static void set_orig_addr(struct msghdr *m, struct tipc_msg *msg)
722 {
723 	struct sockaddr_tipc *addr = (struct sockaddr_tipc *)m->msg_name;
724 
725 	if (addr) {
726 		addr->family = AF_TIPC;
727 		addr->addrtype = TIPC_ADDR_ID;
728 		addr->addr.id.ref = msg_origport(msg);
729 		addr->addr.id.node = msg_orignode(msg);
730 		addr->addr.name.domain = 0;   	/* could leave uninitialized */
731 		addr->scope = 0;   		/* could leave uninitialized */
732 		m->msg_namelen = sizeof(struct sockaddr_tipc);
733 	}
734 }
735 
736 /**
737  * anc_data_recv - optionally capture ancillary data for received message
738  * @m: descriptor for message info
739  * @msg: received message header
740  * @tport: TIPC port associated with message
741  *
742  * Note: Ancillary data is not captured if not requested by receiver.
743  *
744  * Returns 0 if successful, otherwise errno
745  */
746 
747 static int anc_data_recv(struct msghdr *m, struct tipc_msg *msg,
748 				struct tipc_port *tport)
749 {
750 	u32 anc_data[3];
751 	u32 err;
752 	u32 dest_type;
753 	int has_name;
754 	int res;
755 
756 	if (likely(m->msg_controllen == 0))
757 		return 0;
758 
759 	/* Optionally capture errored message object(s) */
760 
761 	err = msg ? msg_errcode(msg) : 0;
762 	if (unlikely(err)) {
763 		anc_data[0] = err;
764 		anc_data[1] = msg_data_sz(msg);
765 		if ((res = put_cmsg(m, SOL_TIPC, TIPC_ERRINFO, 8, anc_data)))
766 			return res;
767 		if (anc_data[1] &&
768 		    (res = put_cmsg(m, SOL_TIPC, TIPC_RETDATA, anc_data[1],
769 				    msg_data(msg))))
770 			return res;
771 	}
772 
773 	/* Optionally capture message destination object */
774 
775 	dest_type = msg ? msg_type(msg) : TIPC_DIRECT_MSG;
776 	switch (dest_type) {
777 	case TIPC_NAMED_MSG:
778 		has_name = 1;
779 		anc_data[0] = msg_nametype(msg);
780 		anc_data[1] = msg_namelower(msg);
781 		anc_data[2] = msg_namelower(msg);
782 		break;
783 	case TIPC_MCAST_MSG:
784 		has_name = 1;
785 		anc_data[0] = msg_nametype(msg);
786 		anc_data[1] = msg_namelower(msg);
787 		anc_data[2] = msg_nameupper(msg);
788 		break;
789 	case TIPC_CONN_MSG:
790 		has_name = (tport->conn_type != 0);
791 		anc_data[0] = tport->conn_type;
792 		anc_data[1] = tport->conn_instance;
793 		anc_data[2] = tport->conn_instance;
794 		break;
795 	default:
796 		has_name = 0;
797 	}
798 	if (has_name &&
799 	    (res = put_cmsg(m, SOL_TIPC, TIPC_DESTNAME, 12, anc_data)))
800 		return res;
801 
802 	return 0;
803 }
804 
805 /**
806  * recv_msg - receive packet-oriented message
807  * @iocb: (unused)
808  * @m: descriptor for message info
809  * @buf_len: total size of user buffer area
810  * @flags: receive flags
811  *
812  * Used for SOCK_DGRAM, SOCK_RDM, and SOCK_SEQPACKET messages.
813  * If the complete message doesn't fit in user area, truncate it.
814  *
815  * Returns size of returned message data, errno otherwise
816  */
817 
818 static int recv_msg(struct kiocb *iocb, struct socket *sock,
819 		    struct msghdr *m, size_t buf_len, int flags)
820 {
821 	struct tipc_sock *tsock = tipc_sk(sock->sk);
822 	struct sk_buff *buf;
823 	struct tipc_msg *msg;
824 	unsigned int q_len;
825 	unsigned int sz;
826 	u32 err;
827 	int res;
828 
829 	/* Currently doesn't support receiving into multiple iovec entries */
830 
831 	if (m->msg_iovlen != 1)
832 		return -EOPNOTSUPP;
833 
834 	/* Catch invalid receive attempts */
835 
836 	if (unlikely(!buf_len))
837 		return -EINVAL;
838 
839 	if (sock->type == SOCK_SEQPACKET) {
840 		if (unlikely(sock->state == SS_UNCONNECTED))
841 			return -ENOTCONN;
842 		if (unlikely((sock->state == SS_DISCONNECTING) &&
843 			     (skb_queue_len(&sock->sk->sk_receive_queue) == 0)))
844 			return -ENOTCONN;
845 	}
846 
847 	/* Look for a message in receive queue; wait if necessary */
848 
849 	if (unlikely(down_interruptible(&tsock->sem)))
850 		return -ERESTARTSYS;
851 
852 restart:
853 	if (unlikely((skb_queue_len(&sock->sk->sk_receive_queue) == 0) &&
854 		     (flags & MSG_DONTWAIT))) {
855 		res = -EWOULDBLOCK;
856 		goto exit;
857 	}
858 
859 	if ((res = wait_event_interruptible(
860 		*sock->sk->sk_sleep,
861 		((q_len = skb_queue_len(&sock->sk->sk_receive_queue)) ||
862 		 (sock->state == SS_DISCONNECTING))) )) {
863 		goto exit;
864 	}
865 
866 	/* Catch attempt to receive on an already terminated connection */
867 	/* [THIS CHECK MAY OVERLAP WITH AN EARLIER CHECK] */
868 
869 	if (!q_len) {
870 		res = -ENOTCONN;
871 		goto exit;
872 	}
873 
874 	/* Get access to first message in receive queue */
875 
876 	buf = skb_peek(&sock->sk->sk_receive_queue);
877 	msg = buf_msg(buf);
878 	sz = msg_data_sz(msg);
879 	err = msg_errcode(msg);
880 
881 	/* Complete connection setup for an implied connect */
882 
883 	if (unlikely(sock->state == SS_CONNECTING)) {
884 		if ((res = auto_connect(sock, tsock, msg)))
885 			goto exit;
886 	}
887 
888 	/* Discard an empty non-errored message & try again */
889 
890 	if ((!sz) && (!err)) {
891 		advance_queue(tsock);
892 		goto restart;
893 	}
894 
895 	/* Capture sender's address (optional) */
896 
897 	set_orig_addr(m, msg);
898 
899 	/* Capture ancillary data (optional) */
900 
901 	if ((res = anc_data_recv(m, msg, tsock->p)))
902 		goto exit;
903 
904 	/* Capture message data (if valid) & compute return value (always) */
905 
906 	if (!err) {
907 		if (unlikely(buf_len < sz)) {
908 			sz = buf_len;
909 			m->msg_flags |= MSG_TRUNC;
910 		}
911 		if (unlikely(copy_to_user(m->msg_iov->iov_base, msg_data(msg),
912 					  sz))) {
913 			res = -EFAULT;
914 			goto exit;
915 		}
916 		res = sz;
917 	} else {
918 		if ((sock->state == SS_READY) ||
919 		    ((err == TIPC_CONN_SHUTDOWN) || m->msg_control))
920 			res = 0;
921 		else
922 			res = -ECONNRESET;
923 	}
924 
925 	/* Consume received message (optional) */
926 
927 	if (likely(!(flags & MSG_PEEK))) {
928 		if (unlikely(++tsock->p->conn_unacked >= TIPC_FLOW_CONTROL_WIN))
929 			tipc_acknowledge(tsock->p->ref, tsock->p->conn_unacked);
930 		advance_queue(tsock);
931 	}
932 exit:
933 	up(&tsock->sem);
934 	return res;
935 }
936 
937 /**
938  * recv_stream - receive stream-oriented data
939  * @iocb: (unused)
940  * @m: descriptor for message info
941  * @buf_len: total size of user buffer area
942  * @flags: receive flags
943  *
944  * Used for SOCK_STREAM messages only.  If not enough data is available
945  * will optionally wait for more; never truncates data.
946  *
947  * Returns size of returned message data, errno otherwise
948  */
949 
950 static int recv_stream(struct kiocb *iocb, struct socket *sock,
951 		       struct msghdr *m, size_t buf_len, int flags)
952 {
953 	struct tipc_sock *tsock = tipc_sk(sock->sk);
954 	struct sk_buff *buf;
955 	struct tipc_msg *msg;
956 	unsigned int q_len;
957 	unsigned int sz;
958 	int sz_to_copy;
959 	int sz_copied = 0;
960 	int needed;
961 	char __user *crs = m->msg_iov->iov_base;
962 	unsigned char *buf_crs;
963 	u32 err;
964 	int res;
965 
966 	/* Currently doesn't support receiving into multiple iovec entries */
967 
968 	if (m->msg_iovlen != 1)
969 		return -EOPNOTSUPP;
970 
971 	/* Catch invalid receive attempts */
972 
973 	if (unlikely(!buf_len))
974 		return -EINVAL;
975 
976 	if (unlikely(sock->state == SS_DISCONNECTING)) {
977 		if (skb_queue_len(&sock->sk->sk_receive_queue) == 0)
978 			return -ENOTCONN;
979 	} else if (unlikely(sock->state != SS_CONNECTED))
980 		return -ENOTCONN;
981 
982 	/* Look for a message in receive queue; wait if necessary */
983 
984 	if (unlikely(down_interruptible(&tsock->sem)))
985 		return -ERESTARTSYS;
986 
987 restart:
988 	if (unlikely((skb_queue_len(&sock->sk->sk_receive_queue) == 0) &&
989 		     (flags & MSG_DONTWAIT))) {
990 		res = -EWOULDBLOCK;
991 		goto exit;
992 	}
993 
994 	if ((res = wait_event_interruptible(
995 		*sock->sk->sk_sleep,
996 		((q_len = skb_queue_len(&sock->sk->sk_receive_queue)) ||
997 		 (sock->state == SS_DISCONNECTING))) )) {
998 		goto exit;
999 	}
1000 
1001 	/* Catch attempt to receive on an already terminated connection */
1002 	/* [THIS CHECK MAY OVERLAP WITH AN EARLIER CHECK] */
1003 
1004 	if (!q_len) {
1005 		res = -ENOTCONN;
1006 		goto exit;
1007 	}
1008 
1009 	/* Get access to first message in receive queue */
1010 
1011 	buf = skb_peek(&sock->sk->sk_receive_queue);
1012 	msg = buf_msg(buf);
1013 	sz = msg_data_sz(msg);
1014 	err = msg_errcode(msg);
1015 
1016 	/* Discard an empty non-errored message & try again */
1017 
1018 	if ((!sz) && (!err)) {
1019 		advance_queue(tsock);
1020 		goto restart;
1021 	}
1022 
1023 	/* Optionally capture sender's address & ancillary data of first msg */
1024 
1025 	if (sz_copied == 0) {
1026 		set_orig_addr(m, msg);
1027 		if ((res = anc_data_recv(m, msg, tsock->p)))
1028 			goto exit;
1029 	}
1030 
1031 	/* Capture message data (if valid) & compute return value (always) */
1032 
1033 	if (!err) {
1034 		buf_crs = (unsigned char *)(TIPC_SKB_CB(buf)->handle);
1035 		sz = skb_tail_pointer(buf) - buf_crs;
1036 
1037 		needed = (buf_len - sz_copied);
1038 		sz_to_copy = (sz <= needed) ? sz : needed;
1039 		if (unlikely(copy_to_user(crs, buf_crs, sz_to_copy))) {
1040 			res = -EFAULT;
1041 			goto exit;
1042 		}
1043 		sz_copied += sz_to_copy;
1044 
1045 		if (sz_to_copy < sz) {
1046 			if (!(flags & MSG_PEEK))
1047 				TIPC_SKB_CB(buf)->handle = buf_crs + sz_to_copy;
1048 			goto exit;
1049 		}
1050 
1051 		crs += sz_to_copy;
1052 	} else {
1053 		if (sz_copied != 0)
1054 			goto exit; /* can't add error msg to valid data */
1055 
1056 		if ((err == TIPC_CONN_SHUTDOWN) || m->msg_control)
1057 			res = 0;
1058 		else
1059 			res = -ECONNRESET;
1060 	}
1061 
1062 	/* Consume received message (optional) */
1063 
1064 	if (likely(!(flags & MSG_PEEK))) {
1065 		if (unlikely(++tsock->p->conn_unacked >= TIPC_FLOW_CONTROL_WIN))
1066 			tipc_acknowledge(tsock->p->ref, tsock->p->conn_unacked);
1067 		advance_queue(tsock);
1068 	}
1069 
1070 	/* Loop around if more data is required */
1071 
1072 	if ((sz_copied < buf_len)    /* didn't get all requested data */
1073 	    && (flags & MSG_WAITALL) /* ... and need to wait for more */
1074 	    && (!(flags & MSG_PEEK)) /* ... and aren't just peeking at data */
1075 	    && (!err)                /* ... and haven't reached a FIN */
1076 	    )
1077 		goto restart;
1078 
1079 exit:
1080 	up(&tsock->sem);
1081 	return sz_copied ? sz_copied : res;
1082 }
1083 
1084 /**
1085  * queue_overloaded - test if queue overload condition exists
1086  * @queue_size: current size of queue
1087  * @base: nominal maximum size of queue
1088  * @msg: message to be added to queue
1089  *
1090  * Returns 1 if queue is currently overloaded, 0 otherwise
1091  */
1092 
1093 static int queue_overloaded(u32 queue_size, u32 base, struct tipc_msg *msg)
1094 {
1095 	u32 threshold;
1096 	u32 imp = msg_importance(msg);
1097 
1098 	if (imp == TIPC_LOW_IMPORTANCE)
1099 		threshold = base;
1100 	else if (imp == TIPC_MEDIUM_IMPORTANCE)
1101 		threshold = base * 2;
1102 	else if (imp == TIPC_HIGH_IMPORTANCE)
1103 		threshold = base * 100;
1104 	else
1105 		return 0;
1106 
1107 	if (msg_connected(msg))
1108 		threshold *= 4;
1109 
1110 	return (queue_size > threshold);
1111 }
1112 
1113 /**
1114  * async_disconnect - wrapper function used to disconnect port
1115  * @portref: TIPC port reference (passed as pointer-sized value)
1116  */
1117 
1118 static void async_disconnect(unsigned long portref)
1119 {
1120 	tipc_disconnect((u32)portref);
1121 }
1122 
1123 /**
1124  * dispatch - handle arriving message
1125  * @tport: TIPC port that received message
1126  * @buf: message
1127  *
1128  * Called with port locked.  Must not take socket lock to avoid deadlock risk.
1129  *
1130  * Returns TIPC error status code (TIPC_OK if message is not to be rejected)
1131  */
1132 
1133 static u32 dispatch(struct tipc_port *tport, struct sk_buff *buf)
1134 {
1135 	struct tipc_msg *msg = buf_msg(buf);
1136 	struct tipc_sock *tsock = (struct tipc_sock *)tport->usr_handle;
1137 	struct socket *sock;
1138 	u32 recv_q_len;
1139 
1140 	/* Reject message if socket is closing */
1141 
1142 	if (!tsock)
1143 		return TIPC_ERR_NO_PORT;
1144 
1145 	/* Reject message if it is wrong sort of message for socket */
1146 
1147 	/*
1148 	 * WOULD IT BE BETTER TO JUST DISCARD THESE MESSAGES INSTEAD?
1149 	 * "NO PORT" ISN'T REALLY THE RIGHT ERROR CODE, AND THERE MAY
1150 	 * BE SECURITY IMPLICATIONS INHERENT IN REJECTING INVALID TRAFFIC
1151 	 */
1152 	sock = tsock->sk.sk_socket;
1153 	if (sock->state == SS_READY) {
1154 		if (msg_connected(msg)) {
1155 			msg_dbg(msg, "dispatch filter 1\n");
1156 			return TIPC_ERR_NO_PORT;
1157 		}
1158 	} else {
1159 		if (msg_mcast(msg)) {
1160 			msg_dbg(msg, "dispatch filter 2\n");
1161 			return TIPC_ERR_NO_PORT;
1162 		}
1163 		if (sock->state == SS_CONNECTED) {
1164 			if (!msg_connected(msg)) {
1165 				msg_dbg(msg, "dispatch filter 3\n");
1166 				return TIPC_ERR_NO_PORT;
1167 			}
1168 		}
1169 		else if (sock->state == SS_CONNECTING) {
1170 			if (!msg_connected(msg) && (msg_errcode(msg) == 0)) {
1171 				msg_dbg(msg, "dispatch filter 4\n");
1172 				return TIPC_ERR_NO_PORT;
1173 			}
1174 		}
1175 		else if (sock->state == SS_LISTENING) {
1176 			if (msg_connected(msg) || msg_errcode(msg)) {
1177 				msg_dbg(msg, "dispatch filter 5\n");
1178 				return TIPC_ERR_NO_PORT;
1179 			}
1180 		}
1181 		else if (sock->state == SS_DISCONNECTING) {
1182 			msg_dbg(msg, "dispatch filter 6\n");
1183 			return TIPC_ERR_NO_PORT;
1184 		}
1185 		else /* (sock->state == SS_UNCONNECTED) */ {
1186 			if (msg_connected(msg) || msg_errcode(msg)) {
1187 				msg_dbg(msg, "dispatch filter 7\n");
1188 				return TIPC_ERR_NO_PORT;
1189 			}
1190 		}
1191 	}
1192 
1193 	/* Reject message if there isn't room to queue it */
1194 
1195 	if (unlikely((u32)atomic_read(&tipc_queue_size) >
1196 		     OVERLOAD_LIMIT_BASE)) {
1197 		if (queue_overloaded(atomic_read(&tipc_queue_size),
1198 				     OVERLOAD_LIMIT_BASE, msg))
1199 			return TIPC_ERR_OVERLOAD;
1200 	}
1201 	recv_q_len = skb_queue_len(&tsock->sk.sk_receive_queue);
1202 	if (unlikely(recv_q_len > (OVERLOAD_LIMIT_BASE / 2))) {
1203 		if (queue_overloaded(recv_q_len,
1204 				     OVERLOAD_LIMIT_BASE / 2, msg))
1205 			return TIPC_ERR_OVERLOAD;
1206 	}
1207 
1208 	/* Initiate connection termination for an incoming 'FIN' */
1209 
1210 	if (unlikely(msg_errcode(msg) && (sock->state == SS_CONNECTED))) {
1211 		sock->state = SS_DISCONNECTING;
1212 		/* Note: Use signal since port lock is already taken! */
1213 		tipc_k_signal((Handler)async_disconnect, tport->ref);
1214 	}
1215 
1216 	/* Enqueue message (finally!) */
1217 
1218 	msg_dbg(msg,"<DISP<: ");
1219 	TIPC_SKB_CB(buf)->handle = msg_data(msg);
1220 	atomic_inc(&tipc_queue_size);
1221 	skb_queue_tail(&sock->sk->sk_receive_queue, buf);
1222 
1223 	if (waitqueue_active(sock->sk->sk_sleep))
1224 		wake_up_interruptible(sock->sk->sk_sleep);
1225 	return TIPC_OK;
1226 }
1227 
1228 /**
1229  * wakeupdispatch - wake up port after congestion
1230  * @tport: port to wakeup
1231  *
1232  * Called with port lock on.
1233  */
1234 
1235 static void wakeupdispatch(struct tipc_port *tport)
1236 {
1237 	struct tipc_sock *tsock = (struct tipc_sock *)tport->usr_handle;
1238 
1239 	if (waitqueue_active(tsock->sk.sk_sleep))
1240 		wake_up_interruptible(tsock->sk.sk_sleep);
1241 }
1242 
1243 /**
1244  * connect - establish a connection to another TIPC port
1245  * @sock: socket structure
1246  * @dest: socket address for destination port
1247  * @destlen: size of socket address data structure
1248  * @flags: (unused)
1249  *
1250  * Returns 0 on success, errno otherwise
1251  */
1252 
1253 static int connect(struct socket *sock, struct sockaddr *dest, int destlen,
1254 		   int flags)
1255 {
1256    struct tipc_sock *tsock = tipc_sk(sock->sk);
1257    struct sockaddr_tipc *dst = (struct sockaddr_tipc *)dest;
1258    struct msghdr m = {NULL,};
1259    struct sk_buff *buf;
1260    struct tipc_msg *msg;
1261    int res;
1262 
1263    /* For now, TIPC does not allow use of connect() with DGRAM or RDM types */
1264 
1265    if (sock->state == SS_READY)
1266 	   return -EOPNOTSUPP;
1267 
1268    /* Issue Posix-compliant error code if socket is in the wrong state */
1269 
1270    if (sock->state == SS_LISTENING)
1271 	   return -EOPNOTSUPP;
1272    if (sock->state == SS_CONNECTING)
1273 	   return -EALREADY;
1274    if (sock->state != SS_UNCONNECTED)
1275 	   return -EISCONN;
1276 
1277    /*
1278     * Reject connection attempt using multicast address
1279     *
1280     * Note: send_msg() validates the rest of the address fields,
1281     *       so there's no need to do it here
1282     */
1283 
1284    if (dst->addrtype == TIPC_ADDR_MCAST)
1285 	   return -EINVAL;
1286 
1287    /* Send a 'SYN-' to destination */
1288 
1289    m.msg_name = dest;
1290    m.msg_namelen = destlen;
1291    if ((res = send_msg(NULL, sock, &m, 0)) < 0) {
1292 	   sock->state = SS_DISCONNECTING;
1293 	   return res;
1294    }
1295 
1296    if (down_interruptible(&tsock->sem))
1297 	   return -ERESTARTSYS;
1298 
1299    /* Wait for destination's 'ACK' response */
1300 
1301    res = wait_event_interruptible_timeout(*sock->sk->sk_sleep,
1302 					  skb_queue_len(&sock->sk->sk_receive_queue),
1303 					  sock->sk->sk_rcvtimeo);
1304    buf = skb_peek(&sock->sk->sk_receive_queue);
1305    if (res > 0) {
1306 	   msg = buf_msg(buf);
1307 	   res = auto_connect(sock, tsock, msg);
1308 	   if (!res) {
1309 		   if (!msg_data_sz(msg))
1310 			   advance_queue(tsock);
1311 	   }
1312    } else {
1313 	   if (res == 0) {
1314 		   res = -ETIMEDOUT;
1315 	   } else
1316 		   { /* leave "res" unchanged */ }
1317 	   sock->state = SS_DISCONNECTING;
1318    }
1319 
1320    up(&tsock->sem);
1321    return res;
1322 }
1323 
1324 /**
1325  * listen - allow socket to listen for incoming connections
1326  * @sock: socket structure
1327  * @len: (unused)
1328  *
1329  * Returns 0 on success, errno otherwise
1330  */
1331 
1332 static int listen(struct socket *sock, int len)
1333 {
1334 	/* REQUIRES SOCKET LOCKING OF SOME SORT? */
1335 
1336 	if (sock->state == SS_READY)
1337 		return -EOPNOTSUPP;
1338 	if (sock->state != SS_UNCONNECTED)
1339 		return -EINVAL;
1340 	sock->state = SS_LISTENING;
1341 	return 0;
1342 }
1343 
1344 /**
1345  * accept - wait for connection request
1346  * @sock: listening socket
1347  * @newsock: new socket that is to be connected
1348  * @flags: file-related flags associated with socket
1349  *
1350  * Returns 0 on success, errno otherwise
1351  */
1352 
1353 static int accept(struct socket *sock, struct socket *newsock, int flags)
1354 {
1355 	struct tipc_sock *tsock = tipc_sk(sock->sk);
1356 	struct sk_buff *buf;
1357 	int res = -EFAULT;
1358 
1359 	if (sock->state == SS_READY)
1360 		return -EOPNOTSUPP;
1361 	if (sock->state != SS_LISTENING)
1362 		return -EINVAL;
1363 
1364 	if (unlikely((skb_queue_len(&sock->sk->sk_receive_queue) == 0) &&
1365 		     (flags & O_NONBLOCK)))
1366 		return -EWOULDBLOCK;
1367 
1368 	if (down_interruptible(&tsock->sem))
1369 		return -ERESTARTSYS;
1370 
1371 	if (wait_event_interruptible(*sock->sk->sk_sleep,
1372 				     skb_queue_len(&sock->sk->sk_receive_queue))) {
1373 		res = -ERESTARTSYS;
1374 		goto exit;
1375 	}
1376 	buf = skb_peek(&sock->sk->sk_receive_queue);
1377 
1378 	res = tipc_create(sock->sk->sk_net, newsock, 0);
1379 	if (!res) {
1380 		struct tipc_sock *new_tsock = tipc_sk(newsock->sk);
1381 		struct tipc_portid id;
1382 		struct tipc_msg *msg = buf_msg(buf);
1383 		u32 new_ref = new_tsock->p->ref;
1384 
1385 		id.ref = msg_origport(msg);
1386 		id.node = msg_orignode(msg);
1387 		tipc_connect2port(new_ref, &id);
1388 		newsock->state = SS_CONNECTED;
1389 
1390 		tipc_set_portimportance(new_ref, msg_importance(msg));
1391 		if (msg_named(msg)) {
1392 			new_tsock->p->conn_type = msg_nametype(msg);
1393 			new_tsock->p->conn_instance = msg_nameinst(msg);
1394 		}
1395 
1396 	       /*
1397 		 * Respond to 'SYN-' by discarding it & returning 'ACK'-.
1398 		 * Respond to 'SYN+' by queuing it on new socket.
1399 		 */
1400 
1401 		msg_dbg(msg,"<ACC<: ");
1402 		if (!msg_data_sz(msg)) {
1403 			struct msghdr m = {NULL,};
1404 
1405 			send_packet(NULL, newsock, &m, 0);
1406 			advance_queue(tsock);
1407 		} else {
1408 			sock_lock(tsock);
1409 			skb_dequeue(&sock->sk->sk_receive_queue);
1410 			sock_unlock(tsock);
1411 			skb_queue_head(&newsock->sk->sk_receive_queue, buf);
1412 		}
1413 	}
1414 exit:
1415 	up(&tsock->sem);
1416 	return res;
1417 }
1418 
1419 /**
1420  * shutdown - shutdown socket connection
1421  * @sock: socket structure
1422  * @how: direction to close (unused; always treated as read + write)
1423  *
1424  * Terminates connection (if necessary), then purges socket's receive queue.
1425  *
1426  * Returns 0 on success, errno otherwise
1427  */
1428 
1429 static int shutdown(struct socket *sock, int how)
1430 {
1431 	struct tipc_sock* tsock = tipc_sk(sock->sk);
1432 	struct sk_buff *buf;
1433 	int res;
1434 
1435 	/* Could return -EINVAL for an invalid "how", but why bother? */
1436 
1437 	if (down_interruptible(&tsock->sem))
1438 		return -ERESTARTSYS;
1439 
1440 	sock_lock(tsock);
1441 
1442 	switch (sock->state) {
1443 	case SS_CONNECTED:
1444 
1445 		/* Send 'FIN+' or 'FIN-' message to peer */
1446 
1447 		sock_unlock(tsock);
1448 restart:
1449 		if ((buf = skb_dequeue(&sock->sk->sk_receive_queue))) {
1450 			atomic_dec(&tipc_queue_size);
1451 			if (TIPC_SKB_CB(buf)->handle != msg_data(buf_msg(buf))) {
1452 				buf_discard(buf);
1453 				goto restart;
1454 			}
1455 			tipc_reject_msg(buf, TIPC_CONN_SHUTDOWN);
1456 		}
1457 		else {
1458 			tipc_shutdown(tsock->p->ref);
1459 		}
1460 		sock_lock(tsock);
1461 
1462 		/* fall through */
1463 
1464 	case SS_DISCONNECTING:
1465 
1466 		/* Discard any unreceived messages */
1467 
1468 		while ((buf = skb_dequeue(&sock->sk->sk_receive_queue))) {
1469 			atomic_dec(&tipc_queue_size);
1470 			buf_discard(buf);
1471 		}
1472 		tsock->p->conn_unacked = 0;
1473 
1474 		/* fall through */
1475 
1476 	case SS_CONNECTING:
1477 		sock->state = SS_DISCONNECTING;
1478 		res = 0;
1479 		break;
1480 
1481 	default:
1482 		res = -ENOTCONN;
1483 	}
1484 
1485 	sock_unlock(tsock);
1486 
1487 	up(&tsock->sem);
1488 	return res;
1489 }
1490 
1491 /**
1492  * setsockopt - set socket option
1493  * @sock: socket structure
1494  * @lvl: option level
1495  * @opt: option identifier
1496  * @ov: pointer to new option value
1497  * @ol: length of option value
1498  *
1499  * For stream sockets only, accepts and ignores all IPPROTO_TCP options
1500  * (to ease compatibility).
1501  *
1502  * Returns 0 on success, errno otherwise
1503  */
1504 
1505 static int setsockopt(struct socket *sock,
1506 		      int lvl, int opt, char __user *ov, int ol)
1507 {
1508 	struct tipc_sock *tsock = tipc_sk(sock->sk);
1509 	u32 value;
1510 	int res;
1511 
1512 	if ((lvl == IPPROTO_TCP) && (sock->type == SOCK_STREAM))
1513 		return 0;
1514 	if (lvl != SOL_TIPC)
1515 		return -ENOPROTOOPT;
1516 	if (ol < sizeof(value))
1517 		return -EINVAL;
1518 	if ((res = get_user(value, (u32 __user *)ov)))
1519 		return res;
1520 
1521 	if (down_interruptible(&tsock->sem))
1522 		return -ERESTARTSYS;
1523 
1524 	switch (opt) {
1525 	case TIPC_IMPORTANCE:
1526 		res = tipc_set_portimportance(tsock->p->ref, value);
1527 		break;
1528 	case TIPC_SRC_DROPPABLE:
1529 		if (sock->type != SOCK_STREAM)
1530 			res = tipc_set_portunreliable(tsock->p->ref, value);
1531 		else
1532 			res = -ENOPROTOOPT;
1533 		break;
1534 	case TIPC_DEST_DROPPABLE:
1535 		res = tipc_set_portunreturnable(tsock->p->ref, value);
1536 		break;
1537 	case TIPC_CONN_TIMEOUT:
1538 		sock->sk->sk_rcvtimeo = (value * HZ / 1000);
1539 		break;
1540 	default:
1541 		res = -EINVAL;
1542 	}
1543 
1544 	up(&tsock->sem);
1545 	return res;
1546 }
1547 
1548 /**
1549  * getsockopt - get socket option
1550  * @sock: socket structure
1551  * @lvl: option level
1552  * @opt: option identifier
1553  * @ov: receptacle for option value
1554  * @ol: receptacle for length of option value
1555  *
1556  * For stream sockets only, returns 0 length result for all IPPROTO_TCP options
1557  * (to ease compatibility).
1558  *
1559  * Returns 0 on success, errno otherwise
1560  */
1561 
1562 static int getsockopt(struct socket *sock,
1563 		      int lvl, int opt, char __user *ov, int __user *ol)
1564 {
1565 	struct tipc_sock *tsock = tipc_sk(sock->sk);
1566 	int len;
1567 	u32 value;
1568 	int res;
1569 
1570 	if ((lvl == IPPROTO_TCP) && (sock->type == SOCK_STREAM))
1571 		return put_user(0, ol);
1572 	if (lvl != SOL_TIPC)
1573 		return -ENOPROTOOPT;
1574 	if ((res = get_user(len, ol)))
1575 		return res;
1576 
1577 	if (down_interruptible(&tsock->sem))
1578 		return -ERESTARTSYS;
1579 
1580 	switch (opt) {
1581 	case TIPC_IMPORTANCE:
1582 		res = tipc_portimportance(tsock->p->ref, &value);
1583 		break;
1584 	case TIPC_SRC_DROPPABLE:
1585 		res = tipc_portunreliable(tsock->p->ref, &value);
1586 		break;
1587 	case TIPC_DEST_DROPPABLE:
1588 		res = tipc_portunreturnable(tsock->p->ref, &value);
1589 		break;
1590 	case TIPC_CONN_TIMEOUT:
1591 		value = (sock->sk->sk_rcvtimeo * 1000) / HZ;
1592 		break;
1593 	default:
1594 		res = -EINVAL;
1595 	}
1596 
1597 	if (res) {
1598 		/* "get" failed */
1599 	}
1600 	else if (len < sizeof(value)) {
1601 		res = -EINVAL;
1602 	}
1603 	else if ((res = copy_to_user(ov, &value, sizeof(value)))) {
1604 		/* couldn't return value */
1605 	}
1606 	else {
1607 		res = put_user(sizeof(value), ol);
1608 	}
1609 
1610 	up(&tsock->sem);
1611 	return res;
1612 }
1613 
1614 /**
1615  * Protocol switches for the various types of TIPC sockets
1616  */
1617 
1618 static struct proto_ops msg_ops = {
1619 	.owner 		= THIS_MODULE,
1620 	.family		= AF_TIPC,
1621 	.release	= release,
1622 	.bind		= bind,
1623 	.connect	= connect,
1624 	.socketpair	= sock_no_socketpair,
1625 	.accept		= accept,
1626 	.getname	= get_name,
1627 	.poll		= poll,
1628 	.ioctl		= sock_no_ioctl,
1629 	.listen		= listen,
1630 	.shutdown	= shutdown,
1631 	.setsockopt	= setsockopt,
1632 	.getsockopt	= getsockopt,
1633 	.sendmsg	= send_msg,
1634 	.recvmsg	= recv_msg,
1635 	.mmap		= sock_no_mmap,
1636 	.sendpage	= sock_no_sendpage
1637 };
1638 
1639 static struct proto_ops packet_ops = {
1640 	.owner 		= THIS_MODULE,
1641 	.family		= AF_TIPC,
1642 	.release	= release,
1643 	.bind		= bind,
1644 	.connect	= connect,
1645 	.socketpair	= sock_no_socketpair,
1646 	.accept		= accept,
1647 	.getname	= get_name,
1648 	.poll		= poll,
1649 	.ioctl		= sock_no_ioctl,
1650 	.listen		= listen,
1651 	.shutdown	= shutdown,
1652 	.setsockopt	= setsockopt,
1653 	.getsockopt	= getsockopt,
1654 	.sendmsg	= send_packet,
1655 	.recvmsg	= recv_msg,
1656 	.mmap		= sock_no_mmap,
1657 	.sendpage	= sock_no_sendpage
1658 };
1659 
1660 static struct proto_ops stream_ops = {
1661 	.owner 		= THIS_MODULE,
1662 	.family		= AF_TIPC,
1663 	.release	= release,
1664 	.bind		= bind,
1665 	.connect	= connect,
1666 	.socketpair	= sock_no_socketpair,
1667 	.accept		= accept,
1668 	.getname	= get_name,
1669 	.poll		= poll,
1670 	.ioctl		= sock_no_ioctl,
1671 	.listen		= listen,
1672 	.shutdown	= shutdown,
1673 	.setsockopt	= setsockopt,
1674 	.getsockopt	= getsockopt,
1675 	.sendmsg	= send_stream,
1676 	.recvmsg	= recv_stream,
1677 	.mmap		= sock_no_mmap,
1678 	.sendpage	= sock_no_sendpage
1679 };
1680 
1681 static struct net_proto_family tipc_family_ops = {
1682 	.owner 		= THIS_MODULE,
1683 	.family		= AF_TIPC,
1684 	.create		= tipc_create
1685 };
1686 
1687 static struct proto tipc_proto = {
1688 	.name		= "TIPC",
1689 	.owner		= THIS_MODULE,
1690 	.obj_size	= sizeof(struct tipc_sock)
1691 };
1692 
1693 /**
1694  * tipc_socket_init - initialize TIPC socket interface
1695  *
1696  * Returns 0 on success, errno otherwise
1697  */
1698 int tipc_socket_init(void)
1699 {
1700 	int res;
1701 
1702 	res = proto_register(&tipc_proto, 1);
1703 	if (res) {
1704 		err("Failed to register TIPC protocol type\n");
1705 		goto out;
1706 	}
1707 
1708 	res = sock_register(&tipc_family_ops);
1709 	if (res) {
1710 		err("Failed to register TIPC socket type\n");
1711 		proto_unregister(&tipc_proto);
1712 		goto out;
1713 	}
1714 
1715 	sockets_enabled = 1;
1716  out:
1717 	return res;
1718 }
1719 
1720 /**
1721  * tipc_socket_stop - stop TIPC socket interface
1722  */
1723 void tipc_socket_stop(void)
1724 {
1725 	if (!sockets_enabled)
1726 		return;
1727 
1728 	sockets_enabled = 0;
1729 	sock_unregister(tipc_family_ops.family);
1730 	proto_unregister(&tipc_proto);
1731 }
1732 
1733