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