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 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.
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.
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.
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
42 #include <linux/module.h>
43 #include <linux/init.h>
44 #include <linux/uio.h>
45 #include <linux/net.h>
46 #include <linux/slab.h>
47 #include <linux/netdevice.h>
48 #include <linux/socket.h>
49 #include <linux/if_arp.h>
50 #include <linux/skbuff.h>
51 #include <linux/can.h>
52 #include <linux/can/core.h>
53 #include <linux/can/skb.h>
54 #include <linux/can/raw.h>
56 #include <net/net_namespace.h>
58 #define CAN_RAW_VERSION CAN_VERSION
60 MODULE_DESCRIPTION("PF_CAN raw protocol");
61 MODULE_LICENSE("Dual BSD/GPL");
62 MODULE_AUTHOR("Urs Thuermann <urs.thuermann@volkswagen.de>");
63 MODULE_ALIAS("can-proto-1");
68 * A raw socket has a list of can_filters attached to it, each receiving
69 * the CAN frames matching that filter. If the filter list is empty,
70 * no CAN frames will be received by the socket. The default after
71 * opening the socket, is to have one filter which receives all frames.
72 * The filter list is allocated dynamically with the exception of the
73 * list containing only one item. This common case is optimized by
74 * storing the single filter in dfilter, to avoid using dynamic memory.
79 const struct sk_buff *skb;
86 struct notifier_block notifier;
90 int count; /* number of active filters */
91 struct can_filter dfilter; /* default/single filter */
92 struct can_filter *filter; /* pointer to filter(s) */
93 can_err_mask_t err_mask;
94 struct uniqframe __percpu *uniq;
98 * Return pointer to store the extra msg flags for raw_recvmsg().
99 * We use the space of one unsigned int beyond the 'struct sockaddr_can'
102 static inline unsigned int *raw_flags(struct sk_buff *skb)
104 sock_skb_cb_check_size(sizeof(struct sockaddr_can) +
105 sizeof(unsigned int));
107 /* return pointer after struct sockaddr_can */
108 return (unsigned int *)(&((struct sockaddr_can *)skb->cb)[1]);
111 static inline struct raw_sock *raw_sk(const struct sock *sk)
113 return (struct raw_sock *)sk;
116 static void raw_rcv(struct sk_buff *oskb, void *data)
118 struct sock *sk = (struct sock *)data;
119 struct raw_sock *ro = raw_sk(sk);
120 struct sockaddr_can *addr;
122 unsigned int *pflags;
124 /* check the received tx sock reference */
125 if (!ro->recv_own_msgs && oskb->sk == sk)
128 /* do not pass non-CAN2.0 frames to a legacy socket */
129 if (!ro->fd_frames && oskb->len != CAN_MTU)
132 /* eliminate multiple filter matches for the same skb */
133 if (this_cpu_ptr(ro->uniq)->skb == oskb &&
134 ktime_equal(this_cpu_ptr(ro->uniq)->tstamp, oskb->tstamp)) {
137 this_cpu_ptr(ro->uniq)->skb = oskb;
138 this_cpu_ptr(ro->uniq)->tstamp = oskb->tstamp;
141 /* clone the given skb to be able to enqueue it into the rcv queue */
142 skb = skb_clone(oskb, GFP_ATOMIC);
147 * Put the datagram to the queue so that raw_recvmsg() can
148 * get it from there. We need to pass the interface index to
149 * raw_recvmsg(). We pass a whole struct sockaddr_can in skb->cb
150 * containing the interface index.
153 sock_skb_cb_check_size(sizeof(struct sockaddr_can));
154 addr = (struct sockaddr_can *)skb->cb;
155 memset(addr, 0, sizeof(*addr));
156 addr->can_family = AF_CAN;
157 addr->can_ifindex = skb->dev->ifindex;
159 /* add CAN specific message flags for raw_recvmsg() */
160 pflags = raw_flags(skb);
163 *pflags |= MSG_DONTROUTE;
165 *pflags |= MSG_CONFIRM;
167 if (sock_queue_rcv_skb(sk, skb) < 0)
171 static int raw_enable_filters(struct net_device *dev, struct sock *sk,
172 struct can_filter *filter, int count)
177 for (i = 0; i < count; i++) {
178 err = can_rx_register(dev, filter[i].can_id,
182 /* clean up successfully registered filters */
184 can_rx_unregister(dev, filter[i].can_id,
194 static int raw_enable_errfilter(struct net_device *dev, struct sock *sk,
195 can_err_mask_t err_mask)
200 err = can_rx_register(dev, 0, err_mask | CAN_ERR_FLAG,
206 static void raw_disable_filters(struct net_device *dev, struct sock *sk,
207 struct can_filter *filter, int count)
211 for (i = 0; i < count; i++)
212 can_rx_unregister(dev, filter[i].can_id, filter[i].can_mask,
216 static inline void raw_disable_errfilter(struct net_device *dev,
218 can_err_mask_t err_mask)
222 can_rx_unregister(dev, 0, err_mask | CAN_ERR_FLAG,
226 static inline void raw_disable_allfilters(struct net_device *dev,
229 struct raw_sock *ro = raw_sk(sk);
231 raw_disable_filters(dev, sk, ro->filter, ro->count);
232 raw_disable_errfilter(dev, sk, ro->err_mask);
235 static int raw_enable_allfilters(struct net_device *dev, struct sock *sk)
237 struct raw_sock *ro = raw_sk(sk);
240 err = raw_enable_filters(dev, sk, ro->filter, ro->count);
242 err = raw_enable_errfilter(dev, sk, ro->err_mask);
244 raw_disable_filters(dev, sk, ro->filter, ro->count);
250 static int raw_notifier(struct notifier_block *nb,
251 unsigned long msg, void *ptr)
253 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
254 struct raw_sock *ro = container_of(nb, struct raw_sock, notifier);
255 struct sock *sk = &ro->sk;
257 if (!net_eq(dev_net(dev), &init_net))
260 if (dev->type != ARPHRD_CAN)
263 if (ro->ifindex != dev->ifindex)
268 case NETDEV_UNREGISTER:
270 /* remove current filters & unregister */
272 raw_disable_allfilters(dev, sk);
283 if (!sock_flag(sk, SOCK_DEAD))
284 sk->sk_error_report(sk);
288 sk->sk_err = ENETDOWN;
289 if (!sock_flag(sk, SOCK_DEAD))
290 sk->sk_error_report(sk);
297 static int raw_init(struct sock *sk)
299 struct raw_sock *ro = raw_sk(sk);
304 /* set default filter to single entry dfilter */
305 ro->dfilter.can_id = 0;
306 ro->dfilter.can_mask = MASK_ALL;
307 ro->filter = &ro->dfilter;
310 /* set default loopback behaviour */
312 ro->recv_own_msgs = 0;
315 /* alloc_percpu provides zero'ed memory */
316 ro->uniq = alloc_percpu(struct uniqframe);
317 if (unlikely(!ro->uniq))
321 ro->notifier.notifier_call = raw_notifier;
323 register_netdevice_notifier(&ro->notifier);
328 static int raw_release(struct socket *sock)
330 struct sock *sk = sock->sk;
338 unregister_netdevice_notifier(&ro->notifier);
342 /* remove current filters & unregister */
345 struct net_device *dev;
347 dev = dev_get_by_index(&init_net, ro->ifindex);
349 raw_disable_allfilters(dev, sk);
353 raw_disable_allfilters(NULL, sk);
362 free_percpu(ro->uniq);
373 static int raw_bind(struct socket *sock, struct sockaddr *uaddr, int len)
375 struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
376 struct sock *sk = sock->sk;
377 struct raw_sock *ro = raw_sk(sk);
380 int notify_enetdown = 0;
382 if (len < sizeof(*addr))
387 if (ro->bound && addr->can_ifindex == ro->ifindex)
390 if (addr->can_ifindex) {
391 struct net_device *dev;
393 dev = dev_get_by_index(&init_net, addr->can_ifindex);
398 if (dev->type != ARPHRD_CAN) {
403 if (!(dev->flags & IFF_UP))
406 ifindex = dev->ifindex;
408 /* filters set by default/setsockopt */
409 err = raw_enable_allfilters(dev, sk);
414 /* filters set by default/setsockopt */
415 err = raw_enable_allfilters(NULL, sk);
420 /* unregister old filters */
422 struct net_device *dev;
424 dev = dev_get_by_index(&init_net, ro->ifindex);
426 raw_disable_allfilters(dev, sk);
430 raw_disable_allfilters(NULL, sk);
432 ro->ifindex = ifindex;
439 if (notify_enetdown) {
440 sk->sk_err = ENETDOWN;
441 if (!sock_flag(sk, SOCK_DEAD))
442 sk->sk_error_report(sk);
448 static int raw_getname(struct socket *sock, struct sockaddr *uaddr,
451 struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
452 struct sock *sk = sock->sk;
453 struct raw_sock *ro = raw_sk(sk);
458 memset(addr, 0, sizeof(*addr));
459 addr->can_family = AF_CAN;
460 addr->can_ifindex = ro->ifindex;
462 *len = sizeof(*addr);
467 static int raw_setsockopt(struct socket *sock, int level, int optname,
468 char __user *optval, unsigned 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)
485 if (optlen % sizeof(struct can_filter) != 0)
488 count = optlen / sizeof(struct can_filter);
491 /* filter does not fit into dfilter => alloc space */
492 filter = memdup_user(optval, optlen);
494 return PTR_ERR(filter);
495 } else if (count == 1) {
496 if (copy_from_user(&sfilter, optval, sizeof(sfilter)))
502 if (ro->bound && ro->ifindex)
503 dev = dev_get_by_index(&init_net, ro->ifindex);
506 /* (try to) register the new filters */
508 err = raw_enable_filters(dev, sk, &sfilter, 1);
510 err = raw_enable_filters(dev, sk, filter,
518 /* remove old filter registrations */
519 raw_disable_filters(dev, sk, ro->filter, ro->count);
522 /* remove old filter space */
526 /* link new filters to the socket */
528 /* copy filter data for single filter */
529 ro->dfilter = sfilter;
530 filter = &ro->dfilter;
543 case CAN_RAW_ERR_FILTER:
544 if (optlen != sizeof(err_mask))
547 if (copy_from_user(&err_mask, optval, optlen))
550 err_mask &= CAN_ERR_MASK;
554 if (ro->bound && ro->ifindex)
555 dev = dev_get_by_index(&init_net, ro->ifindex);
557 /* remove current error mask */
559 /* (try to) register the new err_mask */
560 err = raw_enable_errfilter(dev, sk, err_mask);
565 /* remove old err_mask registration */
566 raw_disable_errfilter(dev, sk, ro->err_mask);
569 /* link new err_mask to the socket */
570 ro->err_mask = err_mask;
580 case CAN_RAW_LOOPBACK:
581 if (optlen != sizeof(ro->loopback))
584 if (copy_from_user(&ro->loopback, optval, optlen))
589 case CAN_RAW_RECV_OWN_MSGS:
590 if (optlen != sizeof(ro->recv_own_msgs))
593 if (copy_from_user(&ro->recv_own_msgs, optval, optlen))
598 case CAN_RAW_FD_FRAMES:
599 if (optlen != sizeof(ro->fd_frames))
602 if (copy_from_user(&ro->fd_frames, optval, optlen))
613 static int raw_getsockopt(struct socket *sock, int level, int optname,
614 char __user *optval, int __user *optlen)
616 struct sock *sk = sock->sk;
617 struct raw_sock *ro = raw_sk(sk);
622 if (level != SOL_CAN_RAW)
624 if (get_user(len, optlen))
634 int fsize = ro->count * sizeof(struct can_filter);
637 if (copy_to_user(optval, ro->filter, len))
644 err = put_user(len, optlen);
647 case CAN_RAW_ERR_FILTER:
648 if (len > sizeof(can_err_mask_t))
649 len = sizeof(can_err_mask_t);
653 case CAN_RAW_LOOPBACK:
654 if (len > sizeof(int))
659 case CAN_RAW_RECV_OWN_MSGS:
660 if (len > sizeof(int))
662 val = &ro->recv_own_msgs;
665 case CAN_RAW_FD_FRAMES:
666 if (len > sizeof(int))
668 val = &ro->fd_frames;
675 if (put_user(len, optlen))
677 if (copy_to_user(optval, val, len))
682 static int raw_sendmsg(struct socket *sock, struct msghdr *msg, size_t size)
684 struct sock *sk = sock->sk;
685 struct raw_sock *ro = raw_sk(sk);
687 struct net_device *dev;
692 DECLARE_SOCKADDR(struct sockaddr_can *, addr, msg->msg_name);
694 if (msg->msg_namelen < sizeof(*addr))
697 if (addr->can_family != AF_CAN)
700 ifindex = addr->can_ifindex;
702 ifindex = ro->ifindex;
705 if (unlikely(size != CANFD_MTU && size != CAN_MTU))
708 if (unlikely(size != CAN_MTU))
712 dev = dev_get_by_index(&init_net, ifindex);
716 skb = sock_alloc_send_skb(sk, size + sizeof(struct can_skb_priv),
717 msg->msg_flags & MSG_DONTWAIT, &err);
721 can_skb_reserve(skb);
722 can_skb_prv(skb)->ifindex = dev->ifindex;
724 err = memcpy_from_msg(skb_put(skb, size), msg, size);
728 sock_tx_timestamp(sk, &skb_shinfo(skb)->tx_flags);
732 skb->priority = sk->sk_priority;
734 err = can_send(skb, ro->loopback);
751 static int raw_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
754 struct sock *sk = sock->sk;
759 noblock = flags & MSG_DONTWAIT;
760 flags &= ~MSG_DONTWAIT;
762 skb = skb_recv_datagram(sk, flags, noblock, &err);
767 msg->msg_flags |= MSG_TRUNC;
771 err = memcpy_to_msg(msg, skb->data, size);
773 skb_free_datagram(sk, skb);
777 sock_recv_ts_and_drops(msg, sk, skb);
780 __sockaddr_check_size(sizeof(struct sockaddr_can));
781 msg->msg_namelen = sizeof(struct sockaddr_can);
782 memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
785 /* assign the flags that have been recorded in raw_rcv() */
786 msg->msg_flags |= *(raw_flags(skb));
788 skb_free_datagram(sk, skb);
793 static const struct proto_ops raw_ops = {
795 .release = raw_release,
797 .connect = sock_no_connect,
798 .socketpair = sock_no_socketpair,
799 .accept = sock_no_accept,
800 .getname = raw_getname,
801 .poll = datagram_poll,
802 .ioctl = can_ioctl, /* use can_ioctl() from af_can.c */
803 .listen = sock_no_listen,
804 .shutdown = sock_no_shutdown,
805 .setsockopt = raw_setsockopt,
806 .getsockopt = raw_getsockopt,
807 .sendmsg = raw_sendmsg,
808 .recvmsg = raw_recvmsg,
809 .mmap = sock_no_mmap,
810 .sendpage = sock_no_sendpage,
813 static struct proto raw_proto __read_mostly = {
815 .owner = THIS_MODULE,
816 .obj_size = sizeof(struct raw_sock),
820 static const struct can_proto raw_can_proto = {
827 static __init int raw_module_init(void)
831 pr_info("can: raw protocol (rev " CAN_RAW_VERSION ")\n");
833 err = can_proto_register(&raw_can_proto);
835 printk(KERN_ERR "can: registration of raw protocol failed\n");
840 static __exit void raw_module_exit(void)
842 can_proto_unregister(&raw_can_proto);
845 module_init(raw_module_init);
846 module_exit(raw_module_exit);