raw.c revision 3b885787ea4112eaa80945999ea0901bf742707f 
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>");
65MODULE_ALIAS("can-proto-1");
66
67#define MASK_ALL 0
68
69/*
70 * A raw socket has a list of can_filters attached to it, each receiving
71 * the CAN frames matching that filter.  If the filter list is empty,
72 * no CAN frames will be received by the socket.  The default after
73 * opening the socket, is to have one filter which receives all frames.
74 * The filter list is allocated dynamically with the exception of the
75 * list containing only one item.  This common case is optimized by
76 * storing the single filter in dfilter, to avoid using dynamic memory.
77 */
78
79struct raw_sock {
80	struct sock sk;
81	int bound;
82	int ifindex;
83	struct notifier_block notifier;
84	int loopback;
85	int recv_own_msgs;
86	int count;                 /* number of active filters */
87	struct can_filter dfilter; /* default/single filter */
88	struct can_filter *filter; /* pointer to filter(s) */
89	can_err_mask_t err_mask;
90};
91
92static inline struct raw_sock *raw_sk(const struct sock *sk)
93{
94	return (struct raw_sock *)sk;
95}
96
97static void raw_rcv(struct sk_buff *skb, void *data)
98{
99	struct sock *sk = (struct sock *)data;
100	struct raw_sock *ro = raw_sk(sk);
101	struct sockaddr_can *addr;
102
103	/* check the received tx sock reference */
104	if (!ro->recv_own_msgs && skb->sk == sk)
105		return;
106
107	/* clone the given skb to be able to enqueue it into the rcv queue */
108	skb = skb_clone(skb, GFP_ATOMIC);
109	if (!skb)
110		return;
111
112	/*
113	 *  Put the datagram to the queue so that raw_recvmsg() can
114	 *  get it from there.  We need to pass the interface index to
115	 *  raw_recvmsg().  We pass a whole struct sockaddr_can in skb->cb
116	 *  containing the interface index.
117	 */
118
119	BUILD_BUG_ON(sizeof(skb->cb) < sizeof(struct sockaddr_can));
120	addr = (struct sockaddr_can *)skb->cb;
121	memset(addr, 0, sizeof(*addr));
122	addr->can_family  = AF_CAN;
123	addr->can_ifindex = skb->dev->ifindex;
124
125	if (sock_queue_rcv_skb(sk, skb) < 0)
126		kfree_skb(skb);
127}
128
129static int raw_enable_filters(struct net_device *dev, struct sock *sk,
130			      struct can_filter *filter, int count)
131{
132	int err = 0;
133	int i;
134
135	for (i = 0; i < count; i++) {
136		err = can_rx_register(dev, filter[i].can_id,
137				      filter[i].can_mask,
138				      raw_rcv, sk, "raw");
139		if (err) {
140			/* clean up successfully registered filters */
141			while (--i >= 0)
142				can_rx_unregister(dev, filter[i].can_id,
143						  filter[i].can_mask,
144						  raw_rcv, sk);
145			break;
146		}
147	}
148
149	return err;
150}
151
152static int raw_enable_errfilter(struct net_device *dev, struct sock *sk,
153				can_err_mask_t err_mask)
154{
155	int err = 0;
156
157	if (err_mask)
158		err = can_rx_register(dev, 0, err_mask | CAN_ERR_FLAG,
159				      raw_rcv, sk, "raw");
160
161	return err;
162}
163
164static void raw_disable_filters(struct net_device *dev, struct sock *sk,
165			      struct can_filter *filter, int count)
166{
167	int i;
168
169	for (i = 0; i < count; i++)
170		can_rx_unregister(dev, filter[i].can_id, filter[i].can_mask,
171				  raw_rcv, sk);
172}
173
174static inline void raw_disable_errfilter(struct net_device *dev,
175					 struct sock *sk,
176					 can_err_mask_t err_mask)
177
178{
179	if (err_mask)
180		can_rx_unregister(dev, 0, err_mask | CAN_ERR_FLAG,
181				  raw_rcv, sk);
182}
183
184static inline void raw_disable_allfilters(struct net_device *dev,
185					  struct sock *sk)
186{
187	struct raw_sock *ro = raw_sk(sk);
188
189	raw_disable_filters(dev, sk, ro->filter, ro->count);
190	raw_disable_errfilter(dev, sk, ro->err_mask);
191}
192
193static int raw_enable_allfilters(struct net_device *dev, struct sock *sk)
194{
195	struct raw_sock *ro = raw_sk(sk);
196	int err;
197
198	err = raw_enable_filters(dev, sk, ro->filter, ro->count);
199	if (!err) {
200		err = raw_enable_errfilter(dev, sk, ro->err_mask);
201		if (err)
202			raw_disable_filters(dev, sk, ro->filter, ro->count);
203	}
204
205	return err;
206}
207
208static int raw_notifier(struct notifier_block *nb,
209			unsigned long msg, void *data)
210{
211	struct net_device *dev = (struct net_device *)data;
212	struct raw_sock *ro = container_of(nb, struct raw_sock, notifier);
213	struct sock *sk = &ro->sk;
214
215	if (!net_eq(dev_net(dev), &init_net))
216		return NOTIFY_DONE;
217
218	if (dev->type != ARPHRD_CAN)
219		return NOTIFY_DONE;
220
221	if (ro->ifindex != dev->ifindex)
222		return NOTIFY_DONE;
223
224	switch (msg) {
225
226	case NETDEV_UNREGISTER:
227		lock_sock(sk);
228		/* remove current filters & unregister */
229		if (ro->bound)
230			raw_disable_allfilters(dev, sk);
231
232		if (ro->count > 1)
233			kfree(ro->filter);
234
235		ro->ifindex = 0;
236		ro->bound   = 0;
237		ro->count   = 0;
238		release_sock(sk);
239
240		sk->sk_err = ENODEV;
241		if (!sock_flag(sk, SOCK_DEAD))
242			sk->sk_error_report(sk);
243		break;
244
245	case NETDEV_DOWN:
246		sk->sk_err = ENETDOWN;
247		if (!sock_flag(sk, SOCK_DEAD))
248			sk->sk_error_report(sk);
249		break;
250	}
251
252	return NOTIFY_DONE;
253}
254
255static int raw_init(struct sock *sk)
256{
257	struct raw_sock *ro = raw_sk(sk);
258
259	ro->bound            = 0;
260	ro->ifindex          = 0;
261
262	/* set default filter to single entry dfilter */
263	ro->dfilter.can_id   = 0;
264	ro->dfilter.can_mask = MASK_ALL;
265	ro->filter           = &ro->dfilter;
266	ro->count            = 1;
267
268	/* set default loopback behaviour */
269	ro->loopback         = 1;
270	ro->recv_own_msgs    = 0;
271
272	/* set notifier */
273	ro->notifier.notifier_call = raw_notifier;
274
275	register_netdevice_notifier(&ro->notifier);
276
277	return 0;
278}
279
280static int raw_release(struct socket *sock)
281{
282	struct sock *sk = sock->sk;
283	struct raw_sock *ro = raw_sk(sk);
284
285	unregister_netdevice_notifier(&ro->notifier);
286
287	lock_sock(sk);
288
289	/* remove current filters & unregister */
290	if (ro->bound) {
291		if (ro->ifindex) {
292			struct net_device *dev;
293
294			dev = dev_get_by_index(&init_net, ro->ifindex);
295			if (dev) {
296				raw_disable_allfilters(dev, sk);
297				dev_put(dev);
298			}
299		} else
300			raw_disable_allfilters(NULL, sk);
301	}
302
303	if (ro->count > 1)
304		kfree(ro->filter);
305
306	ro->ifindex = 0;
307	ro->bound   = 0;
308	ro->count   = 0;
309
310	sock_orphan(sk);
311	sock->sk = NULL;
312
313	release_sock(sk);
314	sock_put(sk);
315
316	return 0;
317}
318
319static int raw_bind(struct socket *sock, struct sockaddr *uaddr, int len)
320{
321	struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
322	struct sock *sk = sock->sk;
323	struct raw_sock *ro = raw_sk(sk);
324	int ifindex;
325	int err = 0;
326	int notify_enetdown = 0;
327
328	if (len < sizeof(*addr))
329		return -EINVAL;
330
331	lock_sock(sk);
332
333	if (ro->bound && addr->can_ifindex == ro->ifindex)
334		goto out;
335
336	if (addr->can_ifindex) {
337		struct net_device *dev;
338
339		dev = dev_get_by_index(&init_net, addr->can_ifindex);
340		if (!dev) {
341			err = -ENODEV;
342			goto out;
343		}
344		if (dev->type != ARPHRD_CAN) {
345			dev_put(dev);
346			err = -ENODEV;
347			goto out;
348		}
349		if (!(dev->flags & IFF_UP))
350			notify_enetdown = 1;
351
352		ifindex = dev->ifindex;
353
354		/* filters set by default/setsockopt */
355		err = raw_enable_allfilters(dev, sk);
356		dev_put(dev);
357	} else {
358		ifindex = 0;
359
360		/* filters set by default/setsockopt */
361		err = raw_enable_allfilters(NULL, sk);
362	}
363
364	if (!err) {
365		if (ro->bound) {
366			/* unregister old filters */
367			if (ro->ifindex) {
368				struct net_device *dev;
369
370				dev = dev_get_by_index(&init_net, ro->ifindex);
371				if (dev) {
372					raw_disable_allfilters(dev, sk);
373					dev_put(dev);
374				}
375			} else
376				raw_disable_allfilters(NULL, sk);
377		}
378		ro->ifindex = ifindex;
379		ro->bound = 1;
380	}
381
382 out:
383	release_sock(sk);
384
385	if (notify_enetdown) {
386		sk->sk_err = ENETDOWN;
387		if (!sock_flag(sk, SOCK_DEAD))
388			sk->sk_error_report(sk);
389	}
390
391	return err;
392}
393
394static int raw_getname(struct socket *sock, struct sockaddr *uaddr,
395		       int *len, int peer)
396{
397	struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
398	struct sock *sk = sock->sk;
399	struct raw_sock *ro = raw_sk(sk);
400
401	if (peer)
402		return -EOPNOTSUPP;
403
404	memset(addr, 0, sizeof(*addr));
405	addr->can_family  = AF_CAN;
406	addr->can_ifindex = ro->ifindex;
407
408	*len = sizeof(*addr);
409
410	return 0;
411}
412
413static int raw_setsockopt(struct socket *sock, int level, int optname,
414			  char __user *optval, unsigned int optlen)
415{
416	struct sock *sk = sock->sk;
417	struct raw_sock *ro = raw_sk(sk);
418	struct can_filter *filter = NULL;  /* dyn. alloc'ed filters */
419	struct can_filter sfilter;         /* single filter */
420	struct net_device *dev = NULL;
421	can_err_mask_t err_mask = 0;
422	int count = 0;
423	int err = 0;
424
425	if (level != SOL_CAN_RAW)
426		return -EINVAL;
427	if (optlen < 0)
428		return -EINVAL;
429
430	switch (optname) {
431
432	case CAN_RAW_FILTER:
433		if (optlen % sizeof(struct can_filter) != 0)
434			return -EINVAL;
435
436		count = optlen / sizeof(struct can_filter);
437
438		if (count > 1) {
439			/* filter does not fit into dfilter => alloc space */
440			filter = kmalloc(optlen, GFP_KERNEL);
441			if (!filter)
442				return -ENOMEM;
443
444			if (copy_from_user(filter, optval, optlen)) {
445				kfree(filter);
446				return -EFAULT;
447			}
448		} else if (count == 1) {
449			if (copy_from_user(&sfilter, optval, optlen))
450				return -EFAULT;
451		}
452
453		lock_sock(sk);
454
455		if (ro->bound && ro->ifindex)
456			dev = dev_get_by_index(&init_net, ro->ifindex);
457
458		if (ro->bound) {
459			/* (try to) register the new filters */
460			if (count == 1)
461				err = raw_enable_filters(dev, sk, &sfilter, 1);
462			else
463				err = raw_enable_filters(dev, sk, filter,
464							 count);
465			if (err) {
466				if (count > 1)
467					kfree(filter);
468				goto out_fil;
469			}
470
471			/* remove old filter registrations */
472			raw_disable_filters(dev, sk, ro->filter, ro->count);
473		}
474
475		/* remove old filter space */
476		if (ro->count > 1)
477			kfree(ro->filter);
478
479		/* link new filters to the socket */
480		if (count == 1) {
481			/* copy filter data for single filter */
482			ro->dfilter = sfilter;
483			filter = &ro->dfilter;
484		}
485		ro->filter = filter;
486		ro->count  = count;
487
488 out_fil:
489		if (dev)
490			dev_put(dev);
491
492		release_sock(sk);
493
494		break;
495
496	case CAN_RAW_ERR_FILTER:
497		if (optlen != sizeof(err_mask))
498			return -EINVAL;
499
500		if (copy_from_user(&err_mask, optval, optlen))
501			return -EFAULT;
502
503		err_mask &= CAN_ERR_MASK;
504
505		lock_sock(sk);
506
507		if (ro->bound && ro->ifindex)
508			dev = dev_get_by_index(&init_net, ro->ifindex);
509
510		/* remove current error mask */
511		if (ro->bound) {
512			/* (try to) register the new err_mask */
513			err = raw_enable_errfilter(dev, sk, err_mask);
514
515			if (err)
516				goto out_err;
517
518			/* remove old err_mask registration */
519			raw_disable_errfilter(dev, sk, ro->err_mask);
520		}
521
522		/* link new err_mask to the socket */
523		ro->err_mask = err_mask;
524
525 out_err:
526		if (dev)
527			dev_put(dev);
528
529		release_sock(sk);
530
531		break;
532
533	case CAN_RAW_LOOPBACK:
534		if (optlen != sizeof(ro->loopback))
535			return -EINVAL;
536
537		if (copy_from_user(&ro->loopback, optval, optlen))
538			return -EFAULT;
539
540		break;
541
542	case CAN_RAW_RECV_OWN_MSGS:
543		if (optlen != sizeof(ro->recv_own_msgs))
544			return -EINVAL;
545
546		if (copy_from_user(&ro->recv_own_msgs, optval, optlen))
547			return -EFAULT;
548
549		break;
550
551	default:
552		return -ENOPROTOOPT;
553	}
554	return err;
555}
556
557static int raw_getsockopt(struct socket *sock, int level, int optname,
558			  char __user *optval, int __user *optlen)
559{
560	struct sock *sk = sock->sk;
561	struct raw_sock *ro = raw_sk(sk);
562	int len;
563	void *val;
564	int err = 0;
565
566	if (level != SOL_CAN_RAW)
567		return -EINVAL;
568	if (get_user(len, optlen))
569		return -EFAULT;
570	if (len < 0)
571		return -EINVAL;
572
573	switch (optname) {
574
575	case CAN_RAW_FILTER:
576		lock_sock(sk);
577		if (ro->count > 0) {
578			int fsize = ro->count * sizeof(struct can_filter);
579			if (len > fsize)
580				len = fsize;
581			if (copy_to_user(optval, ro->filter, len))
582				err = -EFAULT;
583		} else
584			len = 0;
585		release_sock(sk);
586
587		if (!err)
588			err = put_user(len, optlen);
589		return err;
590
591	case CAN_RAW_ERR_FILTER:
592		if (len > sizeof(can_err_mask_t))
593			len = sizeof(can_err_mask_t);
594		val = &ro->err_mask;
595		break;
596
597	case CAN_RAW_LOOPBACK:
598		if (len > sizeof(int))
599			len = sizeof(int);
600		val = &ro->loopback;
601		break;
602
603	case CAN_RAW_RECV_OWN_MSGS:
604		if (len > sizeof(int))
605			len = sizeof(int);
606		val = &ro->recv_own_msgs;
607		break;
608
609	default:
610		return -ENOPROTOOPT;
611	}
612
613	if (put_user(len, optlen))
614		return -EFAULT;
615	if (copy_to_user(optval, val, len))
616		return -EFAULT;
617	return 0;
618}
619
620static int raw_sendmsg(struct kiocb *iocb, struct socket *sock,
621		       struct msghdr *msg, size_t size)
622{
623	struct sock *sk = sock->sk;
624	struct raw_sock *ro = raw_sk(sk);
625	struct sk_buff *skb;
626	struct net_device *dev;
627	int ifindex;
628	int err;
629
630	if (msg->msg_name) {
631		struct sockaddr_can *addr =
632			(struct sockaddr_can *)msg->msg_name;
633
634		if (addr->can_family != AF_CAN)
635			return -EINVAL;
636
637		ifindex = addr->can_ifindex;
638	} else
639		ifindex = ro->ifindex;
640
641	if (size != sizeof(struct can_frame))
642		return -EINVAL;
643
644	dev = dev_get_by_index(&init_net, ifindex);
645	if (!dev)
646		return -ENXIO;
647
648	skb = sock_alloc_send_skb(sk, size, msg->msg_flags & MSG_DONTWAIT,
649				  &err);
650	if (!skb)
651		goto put_dev;
652
653	err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
654	if (err < 0)
655		goto free_skb;
656	err = sock_tx_timestamp(msg, sk, skb_tx(skb));
657	if (err < 0)
658		goto free_skb;
659	skb->dev = dev;
660	skb->sk  = sk;
661
662	err = can_send(skb, ro->loopback);
663
664	dev_put(dev);
665
666	if (err)
667		goto send_failed;
668
669	return size;
670
671free_skb:
672	kfree_skb(skb);
673put_dev:
674	dev_put(dev);
675send_failed:
676	return err;
677}
678
679static int raw_recvmsg(struct kiocb *iocb, struct socket *sock,
680		       struct msghdr *msg, size_t size, int flags)
681{
682	struct sock *sk = sock->sk;
683	struct sk_buff *skb;
684	int err = 0;
685	int noblock;
686
687	noblock =  flags & MSG_DONTWAIT;
688	flags   &= ~MSG_DONTWAIT;
689
690	skb = skb_recv_datagram(sk, flags, noblock, &err);
691	if (!skb)
692		return err;
693
694	if (size < skb->len)
695		msg->msg_flags |= MSG_TRUNC;
696	else
697		size = skb->len;
698
699	err = memcpy_toiovec(msg->msg_iov, skb->data, size);
700	if (err < 0) {
701		skb_free_datagram(sk, skb);
702		return err;
703	}
704
705	sock_recv_ts_and_drops(msg, sk, skb);
706
707	if (msg->msg_name) {
708		msg->msg_namelen = sizeof(struct sockaddr_can);
709		memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
710	}
711
712	skb_free_datagram(sk, skb);
713
714	return size;
715}
716
717static struct proto_ops raw_ops __read_mostly = {
718	.family        = PF_CAN,
719	.release       = raw_release,
720	.bind          = raw_bind,
721	.connect       = sock_no_connect,
722	.socketpair    = sock_no_socketpair,
723	.accept        = sock_no_accept,
724	.getname       = raw_getname,
725	.poll          = datagram_poll,
726	.ioctl         = NULL,		/* use can_ioctl() from af_can.c */
727	.listen        = sock_no_listen,
728	.shutdown      = sock_no_shutdown,
729	.setsockopt    = raw_setsockopt,
730	.getsockopt    = raw_getsockopt,
731	.sendmsg       = raw_sendmsg,
732	.recvmsg       = raw_recvmsg,
733	.mmap          = sock_no_mmap,
734	.sendpage      = sock_no_sendpage,
735};
736
737static struct proto raw_proto __read_mostly = {
738	.name       = "CAN_RAW",
739	.owner      = THIS_MODULE,
740	.obj_size   = sizeof(struct raw_sock),
741	.init       = raw_init,
742};
743
744static struct can_proto raw_can_proto __read_mostly = {
745	.type       = SOCK_RAW,
746	.protocol   = CAN_RAW,
747	.capability = -1,
748	.ops        = &raw_ops,
749	.prot       = &raw_proto,
750};
751
752static __init int raw_module_init(void)
753{
754	int err;
755
756	printk(banner);
757
758	err = can_proto_register(&raw_can_proto);
759	if (err < 0)
760		printk(KERN_ERR "can: registration of raw protocol failed\n");
761
762	return err;
763}
764
765static __exit void raw_module_exit(void)
766{
767	can_proto_unregister(&raw_can_proto);
768}
769
770module_init(raw_module_init);
771module_exit(raw_module_exit);
772