raw.c revision c346dca10840a874240c78efe3f39acf4312a1f2 
1/*
2 * raw.c - Raw sockets for protocol family CAN
3 *
4 * Copyright (c) 2002-2007 Volkswagen Group Electronic Research
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of Volkswagen nor the names of its contributors
16 *    may be used to endorse or promote products derived from this software
17 *    without specific prior written permission.
18 *
19 * Alternatively, provided that this notice is retained in full, this
20 * software may be distributed under the terms of the GNU General
21 * Public License ("GPL") version 2, in which case the provisions of the
22 * GPL apply INSTEAD OF those given above.
23 *
24 * The provided data structures and external interfaces from this code
25 * are not restricted to be used by modules with a GPL compatible license.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
28 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
29 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
30 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
31 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
32 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
33 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
34 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
35 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
36 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
37 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
38 * DAMAGE.
39 *
40 * Send feedback to <socketcan-users@lists.berlios.de>
41 *
42 */
43
44#include <linux/module.h>
45#include <linux/init.h>
46#include <linux/uio.h>
47#include <linux/net.h>
48#include <linux/netdevice.h>
49#include <linux/socket.h>
50#include <linux/if_arp.h>
51#include <linux/skbuff.h>
52#include <linux/can.h>
53#include <linux/can/core.h>
54#include <linux/can/raw.h>
55#include <net/sock.h>
56#include <net/net_namespace.h>
57
58#define CAN_RAW_VERSION CAN_VERSION
59static __initdata const char banner[] =
60	KERN_INFO "can: raw protocol (rev " CAN_RAW_VERSION ")\n";
61
62MODULE_DESCRIPTION("PF_CAN raw protocol");
63MODULE_LICENSE("Dual BSD/GPL");
64MODULE_AUTHOR("Urs Thuermann <urs.thuermann@volkswagen.de>");
65
66#define MASK_ALL 0
67
68/*
69 * A raw socket has a list of can_filters attached to it, each receiving
70 * the CAN frames matching that filter.  If the filter list is empty,
71 * no CAN frames will be received by the socket.  The default after
72 * opening the socket, is to have one filter which receives all frames.
73 * The filter list is allocated dynamically with the exception of the
74 * list containing only one item.  This common case is optimized by
75 * storing the single filter in dfilter, to avoid using dynamic memory.
76 */
77
78struct raw_sock {
79	struct sock sk;
80	int bound;
81	int ifindex;
82	struct notifier_block notifier;
83	int loopback;
84	int recv_own_msgs;
85	int count;                 /* number of active filters */
86	struct can_filter dfilter; /* default/single filter */
87	struct can_filter *filter; /* pointer to filter(s) */
88	can_err_mask_t err_mask;
89};
90
91static inline struct raw_sock *raw_sk(const struct sock *sk)
92{
93	return (struct raw_sock *)sk;
94}
95
96static void raw_rcv(struct sk_buff *skb, void *data)
97{
98	struct sock *sk = (struct sock *)data;
99	struct raw_sock *ro = raw_sk(sk);
100	struct sockaddr_can *addr;
101
102	if (!ro->recv_own_msgs) {
103		/* check the received tx sock reference */
104		if (skb->sk == sk) {
105			kfree_skb(skb);
106			return;
107		}
108	}
109
110	/*
111	 *  Put the datagram to the queue so that raw_recvmsg() can
112	 *  get it from there.  We need to pass the interface index to
113	 *  raw_recvmsg().  We pass a whole struct sockaddr_can in skb->cb
114	 *  containing the interface index.
115	 */
116
117	BUILD_BUG_ON(sizeof(skb->cb) < sizeof(struct sockaddr_can));
118	addr = (struct sockaddr_can *)skb->cb;
119	memset(addr, 0, sizeof(*addr));
120	addr->can_family  = AF_CAN;
121	addr->can_ifindex = skb->dev->ifindex;
122
123	if (sock_queue_rcv_skb(sk, skb) < 0)
124		kfree_skb(skb);
125}
126
127static int raw_enable_filters(struct net_device *dev, struct sock *sk,
128			      struct can_filter *filter, int count)
129{
130	int err = 0;
131	int i;
132
133	for (i = 0; i < count; i++) {
134		err = can_rx_register(dev, filter[i].can_id,
135				      filter[i].can_mask,
136				      raw_rcv, sk, "raw");
137		if (err) {
138			/* clean up successfully registered filters */
139			while (--i >= 0)
140				can_rx_unregister(dev, filter[i].can_id,
141						  filter[i].can_mask,
142						  raw_rcv, sk);
143			break;
144		}
145	}
146
147	return err;
148}
149
150static int raw_enable_errfilter(struct net_device *dev, struct sock *sk,
151				can_err_mask_t err_mask)
152{
153	int err = 0;
154
155	if (err_mask)
156		err = can_rx_register(dev, 0, err_mask | CAN_ERR_FLAG,
157				      raw_rcv, sk, "raw");
158
159	return err;
160}
161
162static void raw_disable_filters(struct net_device *dev, struct sock *sk,
163			      struct can_filter *filter, int count)
164{
165	int i;
166
167	for (i = 0; i < count; i++)
168		can_rx_unregister(dev, filter[i].can_id, filter[i].can_mask,
169				  raw_rcv, sk);
170}
171
172static inline void raw_disable_errfilter(struct net_device *dev,
173					 struct sock *sk,
174					 can_err_mask_t err_mask)
175
176{
177	if (err_mask)
178		can_rx_unregister(dev, 0, err_mask | CAN_ERR_FLAG,
179				  raw_rcv, sk);
180}
181
182static inline void raw_disable_allfilters(struct net_device *dev,
183					  struct sock *sk)
184{
185	struct raw_sock *ro = raw_sk(sk);
186
187	raw_disable_filters(dev, sk, ro->filter, ro->count);
188	raw_disable_errfilter(dev, sk, ro->err_mask);
189}
190
191static int raw_enable_allfilters(struct net_device *dev, struct sock *sk)
192{
193	struct raw_sock *ro = raw_sk(sk);
194	int err;
195
196	err = raw_enable_filters(dev, sk, ro->filter, ro->count);
197	if (!err) {
198		err = raw_enable_errfilter(dev, sk, ro->err_mask);
199		if (err)
200			raw_disable_filters(dev, sk, ro->filter, ro->count);
201	}
202
203	return err;
204}
205
206static int raw_notifier(struct notifier_block *nb,
207			unsigned long msg, void *data)
208{
209	struct net_device *dev = (struct net_device *)data;
210	struct raw_sock *ro = container_of(nb, struct raw_sock, notifier);
211	struct sock *sk = &ro->sk;
212
213	if (dev_net(dev) != &init_net)
214		return NOTIFY_DONE;
215
216	if (dev->type != ARPHRD_CAN)
217		return NOTIFY_DONE;
218
219	if (ro->ifindex != dev->ifindex)
220		return NOTIFY_DONE;
221
222	switch (msg) {
223
224	case NETDEV_UNREGISTER:
225		lock_sock(sk);
226		/* remove current filters & unregister */
227		if (ro->bound)
228			raw_disable_allfilters(dev, sk);
229
230		if (ro->count > 1)
231			kfree(ro->filter);
232
233		ro->ifindex = 0;
234		ro->bound   = 0;
235		ro->count   = 0;
236		release_sock(sk);
237
238		sk->sk_err = ENODEV;
239		if (!sock_flag(sk, SOCK_DEAD))
240			sk->sk_error_report(sk);
241		break;
242
243	case NETDEV_DOWN:
244		sk->sk_err = ENETDOWN;
245		if (!sock_flag(sk, SOCK_DEAD))
246			sk->sk_error_report(sk);
247		break;
248	}
249
250	return NOTIFY_DONE;
251}
252
253static int raw_init(struct sock *sk)
254{
255	struct raw_sock *ro = raw_sk(sk);
256
257	ro->bound            = 0;
258	ro->ifindex          = 0;
259
260	/* set default filter to single entry dfilter */
261	ro->dfilter.can_id   = 0;
262	ro->dfilter.can_mask = MASK_ALL;
263	ro->filter           = &ro->dfilter;
264	ro->count            = 1;
265
266	/* set default loopback behaviour */
267	ro->loopback         = 1;
268	ro->recv_own_msgs    = 0;
269
270	/* set notifier */
271	ro->notifier.notifier_call = raw_notifier;
272
273	register_netdevice_notifier(&ro->notifier);
274
275	return 0;
276}
277
278static int raw_release(struct socket *sock)
279{
280	struct sock *sk = sock->sk;
281	struct raw_sock *ro = raw_sk(sk);
282
283	unregister_netdevice_notifier(&ro->notifier);
284
285	lock_sock(sk);
286
287	/* remove current filters & unregister */
288	if (ro->bound) {
289		if (ro->ifindex) {
290			struct net_device *dev;
291
292			dev = dev_get_by_index(&init_net, ro->ifindex);
293			if (dev) {
294				raw_disable_allfilters(dev, sk);
295				dev_put(dev);
296			}
297		} else
298			raw_disable_allfilters(NULL, sk);
299	}
300
301	if (ro->count > 1)
302		kfree(ro->filter);
303
304	ro->ifindex = 0;
305	ro->bound   = 0;
306	ro->count   = 0;
307
308	release_sock(sk);
309	sock_put(sk);
310
311	return 0;
312}
313
314static int raw_bind(struct socket *sock, struct sockaddr *uaddr, int len)
315{
316	struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
317	struct sock *sk = sock->sk;
318	struct raw_sock *ro = raw_sk(sk);
319	int ifindex;
320	int err = 0;
321	int notify_enetdown = 0;
322
323	if (len < sizeof(*addr))
324		return -EINVAL;
325
326	lock_sock(sk);
327
328	if (ro->bound && addr->can_ifindex == ro->ifindex)
329		goto out;
330
331	if (addr->can_ifindex) {
332		struct net_device *dev;
333
334		dev = dev_get_by_index(&init_net, addr->can_ifindex);
335		if (!dev) {
336			err = -ENODEV;
337			goto out;
338		}
339		if (dev->type != ARPHRD_CAN) {
340			dev_put(dev);
341			err = -ENODEV;
342			goto out;
343		}
344		if (!(dev->flags & IFF_UP))
345			notify_enetdown = 1;
346
347		ifindex = dev->ifindex;
348
349		/* filters set by default/setsockopt */
350		err = raw_enable_allfilters(dev, sk);
351		dev_put(dev);
352	} else {
353		ifindex = 0;
354
355		/* filters set by default/setsockopt */
356		err = raw_enable_allfilters(NULL, sk);
357	}
358
359	if (!err) {
360		if (ro->bound) {
361			/* unregister old filters */
362			if (ro->ifindex) {
363				struct net_device *dev;
364
365				dev = dev_get_by_index(&init_net, ro->ifindex);
366				if (dev) {
367					raw_disable_allfilters(dev, sk);
368					dev_put(dev);
369				}
370			} else
371				raw_disable_allfilters(NULL, sk);
372		}
373		ro->ifindex = ifindex;
374		ro->bound = 1;
375	}
376
377 out:
378	release_sock(sk);
379
380	if (notify_enetdown) {
381		sk->sk_err = ENETDOWN;
382		if (!sock_flag(sk, SOCK_DEAD))
383			sk->sk_error_report(sk);
384	}
385
386	return err;
387}
388
389static int raw_getname(struct socket *sock, struct sockaddr *uaddr,
390		       int *len, int peer)
391{
392	struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
393	struct sock *sk = sock->sk;
394	struct raw_sock *ro = raw_sk(sk);
395
396	if (peer)
397		return -EOPNOTSUPP;
398
399	addr->can_family  = AF_CAN;
400	addr->can_ifindex = ro->ifindex;
401
402	*len = sizeof(*addr);
403
404	return 0;
405}
406
407static int raw_setsockopt(struct socket *sock, int level, int optname,
408			  char __user *optval, int optlen)
409{
410	struct sock *sk = sock->sk;
411	struct raw_sock *ro = raw_sk(sk);
412	struct can_filter *filter = NULL;  /* dyn. alloc'ed filters */
413	struct can_filter sfilter;         /* single filter */
414	struct net_device *dev = NULL;
415	can_err_mask_t err_mask = 0;
416	int count = 0;
417	int err = 0;
418
419	if (level != SOL_CAN_RAW)
420		return -EINVAL;
421	if (optlen < 0)
422		return -EINVAL;
423
424	switch (optname) {
425
426	case CAN_RAW_FILTER:
427		if (optlen % sizeof(struct can_filter) != 0)
428			return -EINVAL;
429
430		count = optlen / sizeof(struct can_filter);
431
432		if (count > 1) {
433			/* filter does not fit into dfilter => alloc space */
434			filter = kmalloc(optlen, GFP_KERNEL);
435			if (!filter)
436				return -ENOMEM;
437
438			err = copy_from_user(filter, optval, optlen);
439			if (err) {
440				kfree(filter);
441				return err;
442			}
443		} else if (count == 1) {
444			err = copy_from_user(&sfilter, optval, optlen);
445			if (err)
446				return err;
447		}
448
449		lock_sock(sk);
450
451		if (ro->bound && ro->ifindex)
452			dev = dev_get_by_index(&init_net, ro->ifindex);
453
454		if (ro->bound) {
455			/* (try to) register the new filters */
456			if (count == 1)
457				err = raw_enable_filters(dev, sk, &sfilter, 1);
458			else
459				err = raw_enable_filters(dev, sk, filter,
460							 count);
461			if (err) {
462				if (count > 1)
463					kfree(filter);
464				goto out_fil;
465			}
466
467			/* remove old filter registrations */
468			raw_disable_filters(dev, sk, ro->filter, ro->count);
469		}
470
471		/* remove old filter space */
472		if (ro->count > 1)
473			kfree(ro->filter);
474
475		/* link new filters to the socket */
476		if (count == 1) {
477			/* copy filter data for single filter */
478			ro->dfilter = sfilter;
479			filter = &ro->dfilter;
480		}
481		ro->filter = filter;
482		ro->count  = count;
483
484 out_fil:
485		if (dev)
486			dev_put(dev);
487
488		release_sock(sk);
489
490		break;
491
492	case CAN_RAW_ERR_FILTER:
493		if (optlen != sizeof(err_mask))
494			return -EINVAL;
495
496		err = copy_from_user(&err_mask, optval, optlen);
497		if (err)
498			return err;
499
500		err_mask &= CAN_ERR_MASK;
501
502		lock_sock(sk);
503
504		if (ro->bound && ro->ifindex)
505			dev = dev_get_by_index(&init_net, ro->ifindex);
506
507		/* remove current error mask */
508		if (ro->bound) {
509			/* (try to) register the new err_mask */
510			err = raw_enable_errfilter(dev, sk, err_mask);
511
512			if (err)
513				goto out_err;
514
515			/* remove old err_mask registration */
516			raw_disable_errfilter(dev, sk, ro->err_mask);
517		}
518
519		/* link new err_mask to the socket */
520		ro->err_mask = err_mask;
521
522 out_err:
523		if (dev)
524			dev_put(dev);
525
526		release_sock(sk);
527
528		break;
529
530	case CAN_RAW_LOOPBACK:
531		if (optlen != sizeof(ro->loopback))
532			return -EINVAL;
533
534		err = copy_from_user(&ro->loopback, optval, optlen);
535
536		break;
537
538	case CAN_RAW_RECV_OWN_MSGS:
539		if (optlen != sizeof(ro->recv_own_msgs))
540			return -EINVAL;
541
542		err = copy_from_user(&ro->recv_own_msgs, optval, optlen);
543
544		break;
545
546	default:
547		return -ENOPROTOOPT;
548	}
549	return err;
550}
551
552static int raw_getsockopt(struct socket *sock, int level, int optname,
553			  char __user *optval, int __user *optlen)
554{
555	struct sock *sk = sock->sk;
556	struct raw_sock *ro = raw_sk(sk);
557	int len;
558	void *val;
559	int err = 0;
560
561	if (level != SOL_CAN_RAW)
562		return -EINVAL;
563	if (get_user(len, optlen))
564		return -EFAULT;
565	if (len < 0)
566		return -EINVAL;
567
568	switch (optname) {
569
570	case CAN_RAW_FILTER:
571		lock_sock(sk);
572		if (ro->count > 0) {
573			int fsize = ro->count * sizeof(struct can_filter);
574			if (len > fsize)
575				len = fsize;
576			err = copy_to_user(optval, ro->filter, len);
577		} else
578			len = 0;
579		release_sock(sk);
580
581		if (!err)
582			err = put_user(len, optlen);
583		return err;
584
585	case CAN_RAW_ERR_FILTER:
586		if (len > sizeof(can_err_mask_t))
587			len = sizeof(can_err_mask_t);
588		val = &ro->err_mask;
589		break;
590
591	case CAN_RAW_LOOPBACK:
592		if (len > sizeof(int))
593			len = sizeof(int);
594		val = &ro->loopback;
595		break;
596
597	case CAN_RAW_RECV_OWN_MSGS:
598		if (len > sizeof(int))
599			len = sizeof(int);
600		val = &ro->recv_own_msgs;
601		break;
602
603	default:
604		return -ENOPROTOOPT;
605	}
606
607	if (put_user(len, optlen))
608		return -EFAULT;
609	if (copy_to_user(optval, val, len))
610		return -EFAULT;
611	return 0;
612}
613
614static int raw_sendmsg(struct kiocb *iocb, struct socket *sock,
615		       struct msghdr *msg, size_t size)
616{
617	struct sock *sk = sock->sk;
618	struct raw_sock *ro = raw_sk(sk);
619	struct sk_buff *skb;
620	struct net_device *dev;
621	int ifindex;
622	int err;
623
624	if (msg->msg_name) {
625		struct sockaddr_can *addr =
626			(struct sockaddr_can *)msg->msg_name;
627
628		if (addr->can_family != AF_CAN)
629			return -EINVAL;
630
631		ifindex = addr->can_ifindex;
632	} else
633		ifindex = ro->ifindex;
634
635	dev = dev_get_by_index(&init_net, ifindex);
636	if (!dev)
637		return -ENXIO;
638
639	skb = sock_alloc_send_skb(sk, size, msg->msg_flags & MSG_DONTWAIT,
640				  &err);
641	if (!skb) {
642		dev_put(dev);
643		return err;
644	}
645
646	err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
647	if (err < 0) {
648		kfree_skb(skb);
649		dev_put(dev);
650		return err;
651	}
652	skb->dev = dev;
653	skb->sk  = sk;
654
655	err = can_send(skb, ro->loopback);
656
657	dev_put(dev);
658
659	if (err)
660		return err;
661
662	return size;
663}
664
665static int raw_recvmsg(struct kiocb *iocb, struct socket *sock,
666		       struct msghdr *msg, size_t size, int flags)
667{
668	struct sock *sk = sock->sk;
669	struct sk_buff *skb;
670	int err = 0;
671	int noblock;
672
673	noblock =  flags & MSG_DONTWAIT;
674	flags   &= ~MSG_DONTWAIT;
675
676	skb = skb_recv_datagram(sk, flags, noblock, &err);
677	if (!skb)
678		return err;
679
680	if (size < skb->len)
681		msg->msg_flags |= MSG_TRUNC;
682	else
683		size = skb->len;
684
685	err = memcpy_toiovec(msg->msg_iov, skb->data, size);
686	if (err < 0) {
687		skb_free_datagram(sk, skb);
688		return err;
689	}
690
691	sock_recv_timestamp(msg, sk, skb);
692
693	if (msg->msg_name) {
694		msg->msg_namelen = sizeof(struct sockaddr_can);
695		memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
696	}
697
698	skb_free_datagram(sk, skb);
699
700	return size;
701}
702
703static struct proto_ops raw_ops __read_mostly = {
704	.family        = PF_CAN,
705	.release       = raw_release,
706	.bind          = raw_bind,
707	.connect       = sock_no_connect,
708	.socketpair    = sock_no_socketpair,
709	.accept        = sock_no_accept,
710	.getname       = raw_getname,
711	.poll          = datagram_poll,
712	.ioctl         = NULL,		/* use can_ioctl() from af_can.c */
713	.listen        = sock_no_listen,
714	.shutdown      = sock_no_shutdown,
715	.setsockopt    = raw_setsockopt,
716	.getsockopt    = raw_getsockopt,
717	.sendmsg       = raw_sendmsg,
718	.recvmsg       = raw_recvmsg,
719	.mmap          = sock_no_mmap,
720	.sendpage      = sock_no_sendpage,
721};
722
723static struct proto raw_proto __read_mostly = {
724	.name       = "CAN_RAW",
725	.owner      = THIS_MODULE,
726	.obj_size   = sizeof(struct raw_sock),
727	.init       = raw_init,
728};
729
730static struct can_proto raw_can_proto __read_mostly = {
731	.type       = SOCK_RAW,
732	.protocol   = CAN_RAW,
733	.capability = -1,
734	.ops        = &raw_ops,
735	.prot       = &raw_proto,
736};
737
738static __init int raw_module_init(void)
739{
740	int err;
741
742	printk(banner);
743
744	err = can_proto_register(&raw_can_proto);
745	if (err < 0)
746		printk(KERN_ERR "can: registration of raw protocol failed\n");
747
748	return err;
749}
750
751static __exit void raw_module_exit(void)
752{
753	can_proto_unregister(&raw_can_proto);
754}
755
756module_init(raw_module_init);
757module_exit(raw_module_exit);
758