2 * raw.c - Raw sockets for protocol family CAN
4 * Copyright (c) 2002-2007 Volkswagen Group Electronic Research
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions, the following disclaimer and
12 * the referenced file 'COPYING'.
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 name of Volkswagen nor the names of its contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
20 * Alternatively, provided that this notice is retained in full, this
21 * software may be distributed under the terms of the GNU General
22 * Public License ("GPL") version 2 as distributed in the 'COPYING'
23 * file from the main directory of the linux kernel source.
25 * The provided data structures and external interfaces from this code
26 * are not restricted to be used by modules with a GPL compatible license.
28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
29 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
30 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
31 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
32 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
33 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
34 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
35 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
36 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
37 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
38 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
41 * Send feedback to <socketcan-users@lists.berlios.de>
45 #include <linux/module.h>
46 #include <linux/version.h>
47 #include <linux/init.h>
48 #include <linux/uio.h>
49 #include <linux/poll.h>
50 #include <linux/net.h>
51 #include <linux/netdevice.h>
52 #include <linux/socket.h>
53 #include <linux/if_arp.h>
54 #include <linux/skbuff.h>
55 #include <linux/can.h>
56 #include <linux/can/core.h>
57 #include <linux/can/raw.h>
59 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
60 #include <net/net_namespace.h>
63 #include <linux/can/version.h> /* for RCSID. Removed by mkpatch script */
67 #define CAN_RAW_VERSION CAN_VERSION
68 static __initdata const char banner[] =
69 KERN_INFO "can: raw protocol (rev " CAN_RAW_VERSION ")\n";
71 MODULE_DESCRIPTION("PF_CAN raw protocol");
72 MODULE_LICENSE("Dual BSD/GPL");
73 MODULE_AUTHOR("Urs Thuermann <urs.thuermann@volkswagen.de>");
75 #ifdef CONFIG_CAN_DEBUG_CORE
77 module_param(debug, int, S_IRUGO);
78 MODULE_PARM_DESC(debug, "debug print mask: 1:debug, 2:frames, 4:skbs");
81 #ifdef CONFIG_CAN_RAW_USER
84 #define RAW_CAP CAP_NET_RAW
90 * A raw socket has a list of can_filters attached to it, each receiving
91 * the CAN frames matching that filter. If the filter list is empty,
92 * no CAN frames will be received by the socket. The default after
93 * opening the socket, is to have one filter which receives all frames.
94 * The filter list is allocated dynamically with the exception of the
95 * list containing only one item. This common case is optimized by
96 * storing the single filter in dfilter, to avoid using dynamic memory.
100 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12)
107 struct notifier_block notifier;
110 int count; /* number of active filters */
111 struct can_filter dfilter; /* default/single filter */
112 struct can_filter *filter; /* pointer to filter(s) */
113 can_err_mask_t err_mask;
116 static inline struct raw_sock *raw_sk(const struct sock *sk)
118 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12)
119 return (struct raw_sock *)sk;
121 return (struct raw_sock *)sk->sk_protinfo;
125 static void raw_rcv(struct sk_buff *skb, void *data)
127 struct sock *sk = (struct sock *)data;
128 struct raw_sock *ro = raw_sk(sk);
129 struct sockaddr_can *addr;
132 DBG("received skbuff %p, sk %p\n", skb, sk);
135 if (!ro->recv_own_msgs) {
136 /* check the received tx sock reference */
138 DBG("trashed own tx msg\n");
145 * Put the datagram to the queue so that raw_recvmsg() can
146 * get it from there. We need to pass the interface index to
147 * raw_recvmsg(). We pass a whole struct sockaddr_can in skb->cb
148 * containing the interface index.
151 BUILD_BUG_ON(sizeof(skb->cb) < sizeof(struct sockaddr_can));
152 addr = (struct sockaddr_can *)skb->cb;
153 memset(addr, 0, sizeof(*addr));
154 addr->can_family = AF_CAN;
155 addr->can_ifindex = skb->dev->ifindex;
157 error = sock_queue_rcv_skb(sk, skb);
159 DBG("sock_queue_rcv_skb failed: %d\n", error);
160 DBG("freeing skbuff %p\n", skb);
165 static void raw_enable_filters(struct net_device *dev, struct sock *sk)
167 struct raw_sock *ro = raw_sk(sk);
168 struct can_filter *filter = ro->filter;
171 for (i = 0; i < ro->count; i++) {
172 DBG("filter can_id %08X, can_mask %08X%s, sk %p\n",
173 filter[i].can_id, filter[i].can_mask,
174 filter[i].can_id & CAN_INV_FILTER ? " (inv)" : "", sk);
176 can_rx_register(dev, filter[i].can_id, filter[i].can_mask,
181 static void raw_enable_errfilter(struct net_device *dev, struct sock *sk)
183 struct raw_sock *ro = raw_sk(sk);
186 can_rx_register(dev, 0, ro->err_mask | CAN_ERR_FLAG,
190 static void raw_disable_filters(struct net_device *dev, struct sock *sk)
192 struct raw_sock *ro = raw_sk(sk);
193 struct can_filter *filter = ro->filter;
196 for (i = 0; i < ro->count; i++) {
197 DBG("filter can_id %08X, can_mask %08X%s, sk %p\n",
198 filter[i].can_id, filter[i].can_mask,
199 filter[i].can_id & CAN_INV_FILTER ? " (inv)" : "", sk);
201 can_rx_unregister(dev, filter[i].can_id, filter[i].can_mask,
206 static void raw_disable_errfilter(struct net_device *dev, struct sock *sk)
208 struct raw_sock *ro = raw_sk(sk);
211 can_rx_unregister(dev, 0, ro->err_mask | CAN_ERR_FLAG,
215 static int raw_notifier(struct notifier_block *nb,
216 unsigned long msg, void *data)
218 struct net_device *dev = (struct net_device *)data;
219 struct raw_sock *ro = container_of(nb, struct raw_sock, notifier);
220 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12)
221 struct sock *sk = &ro->sk;
223 struct sock *sk = ro->sk;
226 DBG("msg %ld for dev %p (%s idx %d) sk %p ro->ifindex %d\n",
227 msg, dev, dev->name, dev->ifindex, sk, ro->ifindex);
229 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
230 if (dev->nd_net != &init_net)
234 if (dev->type != ARPHRD_CAN)
237 if (ro->ifindex != dev->ifindex)
242 case NETDEV_UNREGISTER:
244 /* remove current filters & unregister */
246 raw_disable_filters(dev, sk);
247 raw_disable_errfilter(dev, sk);
259 if (!sock_flag(sk, SOCK_DEAD))
260 sk->sk_error_report(sk);
264 sk->sk_err = ENETDOWN;
265 if (!sock_flag(sk, SOCK_DEAD))
266 sk->sk_error_report(sk);
273 static int raw_init(struct sock *sk)
275 struct raw_sock *ro = raw_sk(sk);
277 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,12)
283 /* set default filter to single entry dfilter */
284 ro->dfilter.can_id = 0;
285 ro->dfilter.can_mask = MASK_ALL;
286 ro->filter = &ro->dfilter;
289 /* set default loopback behaviour */
291 ro->recv_own_msgs = 0;
294 ro->notifier.notifier_call = raw_notifier;
296 register_netdevice_notifier(&ro->notifier);
301 static int raw_release(struct socket *sock)
303 struct sock *sk = sock->sk;
304 struct raw_sock *ro = raw_sk(sk);
306 DBG("socket %p, sk %p, refcnt %d\n", sock, sk,
307 atomic_read(&sk->sk_refcnt));
309 unregister_netdevice_notifier(&ro->notifier);
313 /* remove current filters & unregister */
316 struct net_device *dev;
318 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
319 dev = dev_get_by_index(&init_net, ro->ifindex);
321 dev = dev_get_by_index(ro->ifindex);
324 raw_disable_filters(dev, sk);
325 raw_disable_errfilter(dev, sk);
329 raw_disable_filters(NULL, sk);
330 raw_disable_errfilter(NULL, sk);
347 static int raw_bind(struct socket *sock, struct sockaddr *uaddr, int len)
349 struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
350 struct sock *sk = sock->sk;
351 struct raw_sock *ro = raw_sk(sk);
353 int notify_enetdown = 0;
355 DBG("socket %p to device %d\n", sock, addr->can_ifindex);
357 if (len < sizeof(*addr))
363 /* unregister current filters for this device */
365 struct net_device *dev;
367 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
368 dev = dev_get_by_index(&init_net, ro->ifindex);
370 dev = dev_get_by_index(ro->ifindex);
373 raw_disable_filters(dev, sk);
374 raw_disable_errfilter(dev, sk);
380 raw_disable_filters(NULL, sk);
381 raw_disable_errfilter(NULL, sk);
387 if (addr->can_ifindex) {
388 struct net_device *dev;
390 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
391 dev = dev_get_by_index(&init_net, addr->can_ifindex);
393 dev = dev_get_by_index(addr->can_ifindex);
396 DBG("could not find device %d\n", addr->can_ifindex);
400 if (dev->type != ARPHRD_CAN) {
401 DBG("device %d no CAN device\n", addr->can_ifindex);
406 if (!(dev->flags & IFF_UP))
409 ro->ifindex = dev->ifindex;
411 /* filters set by default/setsockopt */
412 raw_enable_filters(dev, sk);
413 raw_enable_errfilter(dev, sk);
419 /* filters set by default/setsockopt */
420 raw_enable_filters(NULL, sk);
421 raw_enable_errfilter(NULL, sk);
429 if (notify_enetdown) {
430 sk->sk_err = ENETDOWN;
431 if (!sock_flag(sk, SOCK_DEAD))
432 sk->sk_error_report(sk);
438 static int raw_getname(struct socket *sock, struct sockaddr *uaddr,
441 struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
442 struct sock *sk = sock->sk;
443 struct raw_sock *ro = raw_sk(sk);
448 addr->can_family = AF_CAN;
449 addr->can_ifindex = ro->ifindex;
451 *len = sizeof(*addr);
456 static unsigned int raw_poll(struct file *file, struct socket *sock,
459 unsigned int mask = 0;
461 DBG("socket %p\n", sock);
463 mask = datagram_poll(file, sock, wait);
467 static int raw_setsockopt(struct socket *sock, int level, int optname,
468 char __user *optval, int optlen)
470 struct sock *sk = sock->sk;
471 struct raw_sock *ro = raw_sk(sk);
472 struct can_filter *filter = NULL; /* dyn. alloc'ed filters */
473 struct can_filter sfilter; /* single filter */
474 struct net_device *dev = NULL;
475 can_err_mask_t err_mask = 0;
479 if (level != SOL_CAN_RAW)
487 if (optlen % sizeof(struct can_filter) != 0)
490 count = optlen / sizeof(struct can_filter);
493 /* filter does not fit into dfilter => alloc space */
494 filter = kmalloc(optlen, GFP_KERNEL);
498 err = copy_from_user(filter, optval, optlen);
503 } else if (count == 1) {
504 err = copy_from_user(&sfilter, optval, optlen);
511 if (ro->bound && ro->ifindex)
512 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
513 dev = dev_get_by_index(&init_net, ro->ifindex);
515 dev = dev_get_by_index(ro->ifindex);
518 /* remove current filters & unregister */
520 raw_disable_filters(dev, sk);
526 /* copy filter data for single filter */
527 ro->dfilter = sfilter;
528 filter = &ro->dfilter;
531 /* add new filters & register */
535 raw_enable_filters(dev, sk);
544 case CAN_RAW_ERR_FILTER:
545 if (optlen != sizeof(err_mask))
548 err = copy_from_user(&err_mask, optval, optlen);
552 err_mask &= CAN_ERR_MASK;
556 if (ro->bound && ro->ifindex)
557 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
558 dev = dev_get_by_index(&init_net, ro->ifindex);
560 dev = dev_get_by_index(ro->ifindex);
563 /* remove current error mask */
565 raw_disable_errfilter(dev, sk);
567 ro->err_mask = err_mask;
569 /* add new error mask */
571 raw_enable_errfilter(dev, sk);
580 case CAN_RAW_LOOPBACK:
581 if (optlen != sizeof(ro->loopback))
584 err = copy_from_user(&ro->loopback, optval, optlen);
590 case CAN_RAW_RECV_OWN_MSGS:
591 if (optlen != sizeof(ro->recv_own_msgs))
594 err = copy_from_user(&ro->recv_own_msgs, optval, optlen);
606 static int raw_getsockopt(struct socket *sock, int level, int optname,
607 char __user *optval, int __user *optlen)
609 struct sock *sk = sock->sk;
610 struct raw_sock *ro = raw_sk(sk);
615 if (level != SOL_CAN_RAW)
617 if (get_user(len, optlen))
627 int fsize = ro->count * sizeof(struct can_filter);
630 err = copy_to_user(optval, ro->filter, len);
636 err = put_user(len, optlen);
639 case CAN_RAW_ERR_FILTER:
640 if (len > sizeof(can_err_mask_t))
641 len = sizeof(can_err_mask_t);
645 case CAN_RAW_LOOPBACK:
646 if (len > sizeof(int))
651 case CAN_RAW_RECV_OWN_MSGS:
652 if (len > sizeof(int))
654 val = &ro->recv_own_msgs;
661 if (put_user(len, optlen))
663 if (copy_to_user(optval, val, len))
668 static int raw_sendmsg(struct kiocb *iocb, struct socket *sock,
669 struct msghdr *msg, size_t size)
671 struct sock *sk = sock->sk;
672 struct raw_sock *ro = raw_sk(sk);
674 struct net_device *dev;
678 DBG("socket %p, sk %p\n", sock, sk);
681 struct sockaddr_can *addr =
682 (struct sockaddr_can *)msg->msg_name;
684 if (addr->can_family != AF_CAN)
687 ifindex = addr->can_ifindex;
689 ifindex = ro->ifindex;
691 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
692 dev = dev_get_by_index(&init_net, ifindex);
694 dev = dev_get_by_index(ifindex);
697 DBG("device %d not found\n", ifindex);
701 skb = alloc_skb(size, GFP_KERNEL);
707 err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
716 DBG("sending skbuff to interface %d\n", ifindex);
719 err = can_send(skb, ro->loopback);
729 static int raw_recvmsg(struct kiocb *iocb, struct socket *sock,
730 struct msghdr *msg, size_t size, int flags)
732 struct sock *sk = sock->sk;
737 DBG("socket %p, sk %p\n", sock, sk);
739 noblock = flags & MSG_DONTWAIT;
740 flags &= ~MSG_DONTWAIT;
742 skb = skb_recv_datagram(sk, flags, noblock, &error);
746 DBG("delivering skbuff %p\n", skb);
750 msg->msg_flags |= MSG_TRUNC;
754 error = memcpy_toiovec(msg->msg_iov, skb->data, size);
756 skb_free_datagram(sk, skb);
760 sock_recv_timestamp(msg, sk, skb);
763 msg->msg_namelen = sizeof(struct sockaddr_can);
764 memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
767 DBG("freeing sock %p, skbuff %p\n", sk, skb);
768 skb_free_datagram(sk, skb);
773 static struct proto_ops raw_ops __read_mostly = {
775 .release = raw_release,
777 .connect = sock_no_connect,
778 .socketpair = sock_no_socketpair,
779 .accept = sock_no_accept,
780 .getname = raw_getname,
782 .ioctl = NULL, /* use can_ioctl() from af_can.c */
783 .listen = sock_no_listen,
784 .shutdown = sock_no_shutdown,
785 .setsockopt = raw_setsockopt,
786 .getsockopt = raw_getsockopt,
787 .sendmsg = raw_sendmsg,
788 .recvmsg = raw_recvmsg,
789 .mmap = sock_no_mmap,
790 .sendpage = sock_no_sendpage,
793 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12)
794 static struct proto raw_proto __read_mostly = {
796 .owner = THIS_MODULE,
797 .obj_size = sizeof(struct raw_sock),
801 static struct can_proto raw_can_proto __read_mostly = {
804 .capability = RAW_CAP,
809 static struct can_proto raw_can_proto __read_mostly = {
812 .capability = RAW_CAP,
814 .owner = THIS_MODULE,
815 .obj_size = sizeof(struct raw_sock),
820 static __init int raw_module_init(void)
826 err = can_proto_register(&raw_can_proto);
828 printk(KERN_ERR "can: registration of raw protocol failed\n");
833 static __exit void raw_module_exit(void)
835 can_proto_unregister(&raw_can_proto);
838 module_init(raw_module_init);
839 module_exit(raw_module_exit);