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/autoconf.h>
46 #include <linux/module.h>
47 #include <linux/version.h>
48 #include <linux/init.h>
49 #include <linux/net.h>
50 #include <linux/netdevice.h>
51 #include <linux/uio.h>
52 #include <linux/poll.h>
55 #include <linux/can.h>
56 #include <linux/can/core.h>
57 #include <linux/can/raw.h>
59 #include <linux/can/version.h> /* for RCSID. Removed by mkpatch script */
63 #define CAN_RAW_VERSION CAN_VERSION
64 static __initdata const char banner[] =
65 KERN_INFO "can: raw protocol # rev " CAN_RAW_VERSION "\n";
67 MODULE_DESCRIPTION("PF_CAN raw protocol");
68 MODULE_LICENSE("Dual BSD/GPL");
69 MODULE_AUTHOR("Urs Thuermann <urs.thuermann@volkswagen.de>");
71 #ifdef CONFIG_CAN_DEBUG_CORE
73 module_param(debug, int, S_IRUGO);
74 MODULE_PARM_DESC(debug, "debug print mask: 1:debug, 2:frames, 4:skbs");
77 #ifdef CONFIG_CAN_RAW_USER
80 #define RAW_CAP CAP_NET_RAW
83 #undef CAN_RAW_SUPPORT_REBIND /* allow bind on already bound socket */
88 * A raw socket has a list of can_filters attached to it, each receiving
89 * the CAN frames matching that filter. If the filter list is empty,
90 * no CAN frames will be received by the socket. The default after
91 * opening the socket, is to have one filter which receives all frames.
92 * The filter list is allocated dynamically with the exception of the
93 * list containing only one item. This common case is optimized by
94 * storing the single filter in dfilter, to avoid using dynamic memory.
102 int count; /* number of active filters */
103 struct can_filter dfilter; /* default/single filter */
104 struct can_filter *filter; /* pointer to filter(s) */
105 can_err_mask_t err_mask;
108 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12)
114 static inline struct raw_opt *raw_sk(const struct sock *sk)
116 return &((struct raw_sock *)sk)->opt;
119 static inline struct raw_opt *raw_sk(const struct sock *sk)
121 return (struct raw_opt *)sk->sk_protinfo;
125 static void raw_notifier(unsigned long msg, void *data)
127 struct sock *sk = (struct sock *)data;
128 struct raw_opt *ro = raw_sk(sk);
130 DBG("called for sock %p\n", sk);
134 case NETDEV_UNREGISTER:
139 sk->sk_err = ENETDOWN;
140 if (!sock_flag(sk, SOCK_DEAD))
141 sk->sk_error_report(sk);
146 static void raw_rcv(struct sk_buff *skb, void *data)
148 struct sock *sk = (struct sock*)data;
149 struct raw_opt *ro = raw_sk(sk);
150 struct sockaddr_can *addr;
153 DBG("received skbuff %p, sk %p\n", skb, sk);
156 if (!ro->recv_own_msgs) {
157 /* check the received tx sock reference */
158 if (*(struct sock **)skb->cb == sk) {
159 DBG("trashed own tx msg\n");
165 addr = (struct sockaddr_can *)skb->cb;
166 memset(addr, 0, sizeof(*addr));
167 addr->can_family = AF_CAN;
168 addr->can_ifindex = skb->dev->ifindex;
170 error = sock_queue_rcv_skb(sk, skb);
172 DBG("sock_queue_rcv_skb failed: %d\n", error);
173 DBG("freeing skbuff %p\n", skb);
178 static void raw_add_filters(struct net_device *dev, struct sock *sk)
180 struct raw_opt *ro = raw_sk(sk);
181 struct can_filter *filter = ro->filter;
184 for (i = 0; i < ro->count; i++) {
185 can_rx_register(dev, filter[i].can_id, filter[i].can_mask,
187 DBG("filter can_id %08X, can_mask %08X%s, sk %p\n",
188 filter[i].can_id, filter[i].can_mask,
189 filter[i].can_id & CAN_INV_FILTER ? " (inv)" : "", sk);
193 static void raw_remove_filters(struct net_device *dev, struct sock *sk)
195 struct raw_opt *ro = raw_sk(sk);
196 struct can_filter *filter = ro->filter;
199 for (i = 0; i < ro->count; i++) {
200 can_rx_unregister(dev, filter[i].can_id, filter[i].can_mask,
202 DBG("filter can_id %08X, can_mask %08X%s, sk %p\n",
203 filter[i].can_id, filter[i].can_mask,
204 filter[i].can_id & CAN_INV_FILTER ? " (inv)" : "", sk);
208 static int raw_init(struct sock *sk)
210 struct raw_opt *ro = raw_sk(sk);
214 /* set default filter to single entry dfilter */
215 ro->dfilter.can_id = 0;
216 ro->dfilter.can_mask = MASK_ALL;
217 ro->filter = &ro->dfilter;
220 /* set default loopback behaviour */
222 ro->recv_own_msgs = 0;
227 static int raw_release(struct socket *sock)
229 struct sock *sk = sock->sk;
230 struct raw_opt *ro = raw_sk(sk);
231 struct net_device *dev = NULL;
233 DBG("socket %p, sk %p, refcnt %d\n", sock, sk,
234 atomic_read(&sk->sk_refcnt));
236 if (ro->bound && ro->ifindex)
237 dev = dev_get_by_index(ro->ifindex);
239 /* remove current filters & unregister */
241 raw_remove_filters(dev, sk);
246 /* remove current error mask */
247 if (ro->err_mask && ro->bound)
248 can_rx_unregister(dev, 0, ro->err_mask | CAN_ERR_FLAG,
252 can_dev_unregister(dev, raw_notifier, sk);
261 static int raw_bind(struct socket *sock, struct sockaddr *uaddr, int len)
263 struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
264 struct sock *sk = sock->sk;
265 struct raw_opt *ro = raw_sk(sk);
266 struct net_device *dev;
268 DBG("socket %p to device %d\n", sock, addr->can_ifindex);
270 if (len < sizeof(*addr))
274 #ifdef CAN_RAW_SUPPORT_REBIND
275 /* remove current bindings / notifier */
277 dev = dev_get_by_index(ro->ifindex);
279 DBG("could not find device %d\n",
283 if (!(dev->flags & IFF_UP)) {
284 sk->sk_err = ENETDOWN;
285 if (!sock_flag(sk, SOCK_DEAD))
286 sk->sk_error_report(sk);
289 can_dev_unregister(dev, raw_notifier, sk);
293 /* unregister current filters for this device */
294 raw_remove_filters(dev, sk);
305 if (addr->can_ifindex) {
306 dev = dev_get_by_index(addr->can_ifindex);
308 DBG("could not find device %d\n", addr->can_ifindex);
311 if (!(dev->flags & IFF_UP)) {
312 sk->sk_err = ENETDOWN;
313 if (!sock_flag(sk, SOCK_DEAD))
314 sk->sk_error_report(sk);
317 can_dev_register(dev, raw_notifier, sk);
321 ro->ifindex = addr->can_ifindex;
323 /* filters set by default/setsockopt */
324 raw_add_filters(dev, sk);
326 /* error frame filter set by setsockopt */
328 can_rx_register(dev, 0, ro->err_mask | CAN_ERR_FLAG,
340 static int raw_getname(struct socket *sock, struct sockaddr *uaddr,
343 struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
344 struct sock *sk = sock->sk;
345 struct raw_opt *ro = raw_sk(sk);
350 addr->can_family = AF_CAN;
351 addr->can_ifindex = ro->ifindex;
352 *len = sizeof(*addr);
357 static unsigned int raw_poll(struct file *file, struct socket *sock,
360 unsigned int mask = 0;
362 DBG("socket %p\n", sock);
364 mask = datagram_poll(file, sock, wait);
368 static int raw_setsockopt(struct socket *sock, int level, int optname,
369 char __user *optval, int optlen)
371 struct sock *sk = sock->sk;
372 struct raw_opt *ro = raw_sk(sk);
373 struct can_filter *filter = NULL; /* dyn. alloc'ed filters */
374 struct can_filter sfilter; /* single filter */
375 struct net_device *dev = NULL;
376 can_err_mask_t err_mask = 0;
380 if (level != SOL_CAN_RAW)
386 if (optlen % sizeof(struct can_filter) != 0)
389 count = optlen / sizeof(struct can_filter);
392 /* filter does not fit into dfilter => alloc space */
393 filter = kmalloc(optlen, GFP_KERNEL);
397 err = copy_from_user(filter, optval, optlen);
402 } else if (count == 1) {
403 err = copy_from_user(&sfilter, optval, optlen);
408 if (ro->bound && ro->ifindex)
409 dev = dev_get_by_index(ro->ifindex);
411 /* remove current filters & unregister */
413 raw_remove_filters(dev, sk);
419 /* copy filter data for single filter */
420 ro->dfilter = sfilter;
421 filter = &ro->dfilter;
424 /* add new filters & register */
428 raw_add_filters(dev, sk);
435 case CAN_RAW_ERR_FILTER:
436 if (optlen != sizeof(err_mask))
439 err = copy_from_user(&err_mask, optval, optlen);
443 err_mask &= CAN_ERR_MASK;
445 if (ro->bound && ro->ifindex)
446 dev = dev_get_by_index(ro->ifindex);
448 /* remove current error mask */
449 if (ro->err_mask && ro->bound)
450 can_rx_unregister(dev, 0, ro->err_mask | CAN_ERR_FLAG,
453 /* add new error mask */
454 ro->err_mask = err_mask;
455 if (ro->err_mask && ro->bound)
456 can_rx_register(dev, 0, ro->err_mask | CAN_ERR_FLAG,
464 case CAN_RAW_LOOPBACK:
465 if (optlen != sizeof(ro->loopback))
468 err = copy_from_user(&ro->loopback, optval, optlen);
474 case CAN_RAW_RECV_OWN_MSGS:
475 if (optlen != sizeof(ro->recv_own_msgs))
478 err = copy_from_user(&ro->recv_own_msgs, optval, optlen);
490 static int raw_getsockopt(struct socket *sock, int level, int optname,
491 char __user *optval, int __user *optlen)
493 struct sock *sk = sock->sk;
494 struct raw_opt *ro = raw_sk(sk);
495 struct can_filter *filter = ro->filter;
496 int count = ro->count;
499 if (level != SOL_CAN_RAW)
505 if (get_user(len, optlen))
508 if (count && filter) {
509 int filter_size = count * sizeof(struct can_filter);
510 if (len < filter_size)
512 if (len > filter_size)
514 if (copy_to_user(optval, filter, len))
519 if (put_user(len, optlen))
524 case CAN_RAW_ERR_FILTER:
525 if (get_user(len, optlen))
528 if (len < sizeof(can_err_mask_t))
531 if (len > sizeof(can_err_mask_t))
532 len = sizeof(can_err_mask_t);
534 if (copy_to_user(optval, &ro->err_mask, len))
537 if (put_user(len, optlen))
542 case CAN_RAW_LOOPBACK:
543 if (get_user(len, optlen))
546 if (len < sizeof(int))
549 if (len > sizeof(int))
552 if (copy_to_user(optval, &ro->loopback, len))
555 if (put_user(len, optlen))
560 case CAN_RAW_RECV_OWN_MSGS:
561 if (get_user(len, optlen))
564 if (len < sizeof(int))
567 if (len > sizeof(int))
570 if (copy_to_user(optval, &ro->recv_own_msgs, len))
573 if (put_user(len, optlen))
584 static int raw_sendmsg(struct kiocb *iocb, struct socket *sock,
585 struct msghdr *msg, size_t size)
587 struct sock *sk = sock->sk;
588 struct raw_opt *ro = raw_sk(sk);
590 struct net_device *dev;
594 DBG("socket %p, sk %p\n", sock, sk);
597 struct sockaddr_can *addr =
598 (struct sockaddr_can *)msg->msg_name;
600 if (addr->can_family != AF_CAN)
603 ifindex = addr->can_ifindex;
605 ifindex = ro->ifindex;
607 dev = dev_get_by_index(ifindex);
609 DBG("device %d not found\n", ifindex);
613 skb = alloc_skb(size, GFP_KERNEL);
619 err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
628 DBG("sending skbuff to interface %d\n", ifindex);
631 err = can_send(skb, ro->loopback);
641 static int raw_recvmsg(struct kiocb *iocb, struct socket *sock,
642 struct msghdr *msg, size_t size, int flags)
644 struct sock *sk = sock->sk;
649 DBG("socket %p, sk %p\n", sock, sk);
651 noblock = flags & MSG_DONTWAIT;
652 flags &= ~MSG_DONTWAIT;
654 skb = skb_recv_datagram(sk, flags, noblock, &error);
658 DBG("delivering skbuff %p\n", skb);
662 msg->msg_flags |= MSG_TRUNC;
666 error = memcpy_toiovec(msg->msg_iov, skb->data, size);
668 skb_free_datagram(sk, skb);
672 sock_recv_timestamp(msg, sk, skb);
675 msg->msg_namelen = sizeof(struct sockaddr_can);
676 memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
679 DBG("freeing sock %p, skbuff %p\n", sk, skb);
680 skb_free_datagram(sk, skb);
685 static struct proto_ops raw_ops = {
687 .release = raw_release,
689 .connect = sock_no_connect,
690 .socketpair = sock_no_socketpair,
691 .accept = sock_no_accept,
692 .getname = raw_getname,
694 .ioctl = NULL, /* use can_ioctl() from af_can.c */
695 .listen = sock_no_listen,
696 .shutdown = sock_no_shutdown,
697 .setsockopt = raw_setsockopt,
698 .getsockopt = raw_getsockopt,
699 .sendmsg = raw_sendmsg,
700 .recvmsg = raw_recvmsg,
701 .mmap = sock_no_mmap,
702 .sendpage = sock_no_sendpage,
705 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12)
706 static struct proto raw_proto = {
708 .owner = THIS_MODULE,
709 .obj_size = sizeof(struct raw_sock),
713 static struct can_proto raw_can_proto = {
716 .capability = RAW_CAP,
721 static struct can_proto raw_can_proto = {
724 .capability = RAW_CAP,
726 .owner = THIS_MODULE,
727 .obj_size = sizeof(struct raw_opt),
732 static __init int raw_module_init(void)
736 can_proto_register(&raw_can_proto);
740 static __exit void raw_module_exit(void)
742 can_proto_unregister(&raw_can_proto);
745 module_init(raw_module_init);
746 module_exit(raw_module_exit);