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