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>
60 #include <linux/can/version.h> /* for RCSID. Removed by mkpatch script */
64 #define CAN_RAW_VERSION CAN_VERSION
65 static __initdata const char banner[] =
66 KERN_INFO "can: raw protocol (rev " CAN_RAW_VERSION ")\n";
68 MODULE_DESCRIPTION("PF_CAN raw protocol");
69 MODULE_LICENSE("Dual BSD/GPL");
70 MODULE_AUTHOR("Urs Thuermann <urs.thuermann@volkswagen.de>");
72 #ifdef CONFIG_CAN_DEBUG_CORE
74 module_param(debug, int, S_IRUGO);
75 MODULE_PARM_DESC(debug, "debug print mask: 1:debug, 2:frames, 4:skbs");
78 #ifdef CONFIG_CAN_RAW_USER
81 #define RAW_CAP CAP_NET_RAW
87 * A raw socket has a list of can_filters attached to it, each receiving
88 * the CAN frames matching that filter. If the filter list is empty,
89 * no CAN frames will be received by the socket. The default after
90 * opening the socket, is to have one filter which receives all frames.
91 * The filter list is allocated dynamically with the exception of the
92 * list containing only one item. This common case is optimized by
93 * storing the single filter in dfilter, to avoid using dynamic memory.
97 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12)
104 struct notifier_block notifier;
107 int count; /* number of active filters */
108 struct can_filter dfilter; /* default/single filter */
109 struct can_filter *filter; /* pointer to filter(s) */
110 can_err_mask_t err_mask;
113 static inline struct raw_sock *raw_sk(const struct sock *sk)
115 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12)
116 return (struct raw_sock *)sk;
118 return (struct raw_sock *)sk->sk_protinfo;
122 static void raw_rcv(struct sk_buff *skb, void *data)
124 struct sock *sk = (struct sock*)data;
125 struct raw_sock *ro = raw_sk(sk);
128 DBG("received skbuff %p, sk %p\n", skb, sk);
131 if (!ro->recv_own_msgs) {
132 /* check the received tx sock reference */
134 DBG("trashed own tx msg\n");
140 error = sock_queue_rcv_skb(sk, skb);
142 DBG("sock_queue_rcv_skb failed: %d\n", error);
143 DBG("freeing skbuff %p\n", skb);
148 static void raw_enable_filters(struct net_device *dev, struct sock *sk)
150 struct raw_sock *ro = raw_sk(sk);
151 struct can_filter *filter = ro->filter;
154 for (i = 0; i < ro->count; i++) {
155 DBG("filter can_id %08X, can_mask %08X%s, sk %p\n",
156 filter[i].can_id, filter[i].can_mask,
157 filter[i].can_id & CAN_INV_FILTER ? " (inv)" : "", sk);
159 can_rx_register(dev, filter[i].can_id, filter[i].can_mask,
164 static void raw_enable_errfilter(struct net_device *dev, struct sock *sk)
166 struct raw_sock *ro = raw_sk(sk);
169 can_rx_register(dev, 0, ro->err_mask | CAN_ERR_FLAG,
173 static void raw_disable_filters(struct net_device *dev, struct sock *sk)
175 struct raw_sock *ro = raw_sk(sk);
176 struct can_filter *filter = ro->filter;
179 for (i = 0; i < ro->count; i++) {
180 DBG("filter can_id %08X, can_mask %08X%s, sk %p\n",
181 filter[i].can_id, filter[i].can_mask,
182 filter[i].can_id & CAN_INV_FILTER ? " (inv)" : "", sk);
184 can_rx_unregister(dev, filter[i].can_id, filter[i].can_mask,
189 static void raw_disable_errfilter(struct net_device *dev, struct sock *sk)
191 struct raw_sock *ro = raw_sk(sk);
194 can_rx_unregister(dev, 0, ro->err_mask | CAN_ERR_FLAG,
198 static int raw_notifier(struct notifier_block *nb,
199 unsigned long msg, void *data)
201 struct net_device *dev = (struct net_device *)data;
202 struct raw_sock *ro = container_of(nb, struct raw_sock, notifier);
203 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12)
204 struct sock *sk = &ro->sk;
206 struct sock *sk = ro->sk;
209 DBG("msg %ld for dev %p (%s idx %d) sk %p ro->ifindex %d\n",
210 msg, dev, dev->name, dev->ifindex, sk, ro->ifindex);
212 if (dev->type != ARPHRD_CAN)
215 if (ro->ifindex != dev->ifindex)
220 case NETDEV_UNREGISTER:
222 /* remove current filters & unregister */
224 raw_disable_filters(dev, sk);
225 raw_disable_errfilter(dev, sk);
237 if (!sock_flag(sk, SOCK_DEAD))
238 sk->sk_error_report(sk);
242 sk->sk_err = ENETDOWN;
243 if (!sock_flag(sk, SOCK_DEAD))
244 sk->sk_error_report(sk);
251 static int raw_init(struct sock *sk)
253 struct raw_sock *ro = raw_sk(sk);
255 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,12)
261 /* set default filter to single entry dfilter */
262 ro->dfilter.can_id = 0;
263 ro->dfilter.can_mask = MASK_ALL;
264 ro->filter = &ro->dfilter;
267 /* set default loopback behaviour */
269 ro->recv_own_msgs = 0;
272 ro->notifier.notifier_call = raw_notifier;
274 register_netdevice_notifier(&ro->notifier);
279 static int raw_release(struct socket *sock)
281 struct sock *sk = sock->sk;
282 struct raw_sock *ro = raw_sk(sk);
284 DBG("socket %p, sk %p, refcnt %d\n", sock, sk,
285 atomic_read(&sk->sk_refcnt));
287 unregister_netdevice_notifier(&ro->notifier);
291 /* remove current filters & unregister */
294 struct net_device *dev = dev_get_by_index(ro->ifindex);
296 raw_disable_filters(dev, sk);
297 raw_disable_errfilter(dev, sk);
301 raw_disable_filters(NULL, sk);
302 raw_disable_errfilter(NULL, sk);
319 static int raw_bind(struct socket *sock, struct sockaddr *uaddr, int len)
321 struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
322 struct sock *sk = sock->sk;
323 struct raw_sock *ro = raw_sk(sk);
325 int notify_enetdown = 0;
327 DBG("socket %p to device %d\n", sock, addr->can_ifindex);
329 if (len < sizeof(*addr))
335 /* unregister current filters for this device */
337 struct net_device *dev = dev_get_by_index(ro->ifindex);
339 raw_disable_filters(dev, sk);
340 raw_disable_errfilter(dev, sk);
346 raw_disable_filters(NULL, sk);
347 raw_disable_errfilter(NULL, sk);
353 if (addr->can_ifindex) {
354 struct net_device *dev = dev_get_by_index(addr->can_ifindex);
356 DBG("could not find device %d\n", addr->can_ifindex);
360 if (dev->type != ARPHRD_CAN) {
361 DBG("device %d no CAN device\n", addr->can_ifindex);
366 if (!(dev->flags & IFF_UP))
369 ro->ifindex = dev->ifindex;
371 /* filters set by default/setsockopt */
372 raw_enable_filters(dev, sk);
373 raw_enable_errfilter(dev, sk);
379 /* filters set by default/setsockopt */
380 raw_enable_filters(NULL, sk);
381 raw_enable_errfilter(NULL, sk);
389 if (notify_enetdown) {
390 sk->sk_err = ENETDOWN;
391 if (!sock_flag(sk, SOCK_DEAD))
392 sk->sk_error_report(sk);
398 static int raw_getname(struct socket *sock, struct sockaddr *uaddr,
401 struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
402 struct sock *sk = sock->sk;
403 struct raw_sock *ro = raw_sk(sk);
408 addr->can_family = AF_CAN;
409 addr->can_ifindex = ro->ifindex;
411 *len = sizeof(*addr);
416 static unsigned int raw_poll(struct file *file, struct socket *sock,
419 unsigned int mask = 0;
421 DBG("socket %p\n", sock);
423 mask = datagram_poll(file, sock, wait);
427 static int raw_setsockopt(struct socket *sock, int level, int optname,
428 char __user *optval, int optlen)
430 struct sock *sk = sock->sk;
431 struct raw_sock *ro = raw_sk(sk);
432 struct can_filter *filter = NULL; /* dyn. alloc'ed filters */
433 struct can_filter sfilter; /* single filter */
434 struct net_device *dev = NULL;
435 can_err_mask_t err_mask = 0;
439 if (level != SOL_CAN_RAW)
447 if (optlen % sizeof(struct can_filter) != 0)
450 count = optlen / sizeof(struct can_filter);
453 /* filter does not fit into dfilter => alloc space */
454 filter = kmalloc(optlen, GFP_KERNEL);
458 err = copy_from_user(filter, optval, optlen);
463 } else if (count == 1) {
464 err = copy_from_user(&sfilter, optval, optlen);
471 if (ro->bound && ro->ifindex)
472 dev = dev_get_by_index(ro->ifindex);
474 /* remove current filters & unregister */
476 raw_disable_filters(dev, sk);
482 /* copy filter data for single filter */
483 ro->dfilter = sfilter;
484 filter = &ro->dfilter;
487 /* add new filters & register */
491 raw_enable_filters(dev, sk);
500 case CAN_RAW_ERR_FILTER:
501 if (optlen != sizeof(err_mask))
504 err = copy_from_user(&err_mask, optval, optlen);
508 err_mask &= CAN_ERR_MASK;
512 if (ro->bound && ro->ifindex)
513 dev = dev_get_by_index(ro->ifindex);
515 /* remove current error mask */
517 raw_disable_errfilter(dev, sk);
519 ro->err_mask = err_mask;
521 /* add new error mask */
523 raw_enable_errfilter(dev, sk);
532 case CAN_RAW_LOOPBACK:
533 if (optlen != sizeof(ro->loopback))
536 err = copy_from_user(&ro->loopback, optval, optlen);
542 case CAN_RAW_RECV_OWN_MSGS:
543 if (optlen != sizeof(ro->recv_own_msgs))
546 err = copy_from_user(&ro->recv_own_msgs, optval, optlen);
558 static int raw_getsockopt(struct socket *sock, int level, int optname,
559 char __user *optval, int __user *optlen)
561 struct sock *sk = sock->sk;
562 struct raw_sock *ro = raw_sk(sk);
567 if (level != SOL_CAN_RAW)
569 if (get_user(len, optlen))
579 int fsize = ro->count * sizeof(struct can_filter);
582 err = copy_to_user(optval, ro->filter, len);
588 err = put_user(len, optlen);
591 case CAN_RAW_ERR_FILTER:
592 if (len > sizeof(can_err_mask_t))
593 len = sizeof(can_err_mask_t);
597 case CAN_RAW_LOOPBACK:
598 if (len > sizeof(int))
603 case CAN_RAW_RECV_OWN_MSGS:
604 if (len > sizeof(int))
606 val = &ro->recv_own_msgs;
613 if (put_user(len, optlen))
615 if (copy_to_user(optval, val, len))
620 static int raw_sendmsg(struct kiocb *iocb, struct socket *sock,
621 struct msghdr *msg, size_t size)
623 struct sock *sk = sock->sk;
624 struct raw_sock *ro = raw_sk(sk);
626 struct net_device *dev;
630 DBG("socket %p, sk %p\n", sock, sk);
633 struct sockaddr_can *addr =
634 (struct sockaddr_can *)msg->msg_name;
636 if (addr->can_family != AF_CAN)
639 ifindex = addr->can_ifindex;
641 ifindex = ro->ifindex;
643 dev = dev_get_by_index(ifindex);
645 DBG("device %d not found\n", ifindex);
649 skb = alloc_skb(size, GFP_KERNEL);
655 err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
664 DBG("sending skbuff to interface %d\n", ifindex);
667 err = can_send(skb, ro->loopback);
677 static int raw_recvmsg(struct kiocb *iocb, struct socket *sock,
678 struct msghdr *msg, size_t size, int flags)
680 struct sock *sk = sock->sk;
685 DBG("socket %p, sk %p\n", sock, sk);
687 noblock = flags & MSG_DONTWAIT;
688 flags &= ~MSG_DONTWAIT;
690 skb = skb_recv_datagram(sk, flags, noblock, &error);
694 DBG("delivering skbuff %p\n", skb);
698 msg->msg_flags |= MSG_TRUNC;
702 error = memcpy_toiovec(msg->msg_iov, skb->data, size);
704 skb_free_datagram(sk, skb);
708 sock_recv_timestamp(msg, sk, skb);
711 struct sockaddr_can *addr = msg->msg_name;
712 msg->msg_namelen = sizeof(*addr);
713 memset(addr, 0, sizeof(*addr));
714 addr->can_family = AF_CAN;
715 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)
716 addr->can_ifindex = skb->iif;
719 * FIXME: Race condition, skb->input_dev might disappear
720 * while skb is waiting on the queue.
722 addr->can_ifindex = skb->input_dev->ifindex;
726 DBG("freeing sock %p, skbuff %p\n", sk, skb);
727 skb_free_datagram(sk, skb);
732 static struct proto_ops raw_ops = {
734 .release = raw_release,
736 .connect = sock_no_connect,
737 .socketpair = sock_no_socketpair,
738 .accept = sock_no_accept,
739 .getname = raw_getname,
741 .ioctl = NULL, /* use can_ioctl() from af_can.c */
742 .listen = sock_no_listen,
743 .shutdown = sock_no_shutdown,
744 .setsockopt = raw_setsockopt,
745 .getsockopt = raw_getsockopt,
746 .sendmsg = raw_sendmsg,
747 .recvmsg = raw_recvmsg,
748 .mmap = sock_no_mmap,
749 .sendpage = sock_no_sendpage,
752 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12)
753 static struct proto raw_proto = {
755 .owner = THIS_MODULE,
756 .obj_size = sizeof(struct raw_sock),
760 static struct can_proto raw_can_proto = {
763 .capability = RAW_CAP,
768 static struct can_proto raw_can_proto = {
771 .capability = RAW_CAP,
773 .owner = THIS_MODULE,
774 .obj_size = sizeof(struct raw_sock),
779 static __init int raw_module_init(void)
783 can_proto_register(&raw_can_proto);
787 static __exit void raw_module_exit(void)
789 can_proto_unregister(&raw_can_proto);
792 module_init(raw_module_init);
793 module_exit(raw_module_exit);