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.
81 struct notifier_block notifier
;
85 int count
; /* number of active filters */
86 struct can_filter dfilter
; /* default/single filter */
87 struct can_filter
*filter
; /* pointer to filter(s) */
88 can_err_mask_t err_mask
;
92 * Return pointer to store the extra msg flags for raw_recvmsg().
93 * We use the space of one unsigned int beyond the 'struct sockaddr_can'
96 static inline unsigned int *raw_flags(struct sk_buff
*skb
)
98 BUILD_BUG_ON(sizeof(skb
->cb
) <= (sizeof(struct sockaddr_can
) +
99 sizeof(unsigned int)));
101 /* return pointer after struct sockaddr_can */
102 return (unsigned int *)(&((struct sockaddr_can
*)skb
->cb
)[1]);
105 static inline struct raw_sock
*raw_sk(const struct sock
*sk
)
107 return (struct raw_sock
*)sk
;
110 static void raw_rcv(struct sk_buff
*oskb
, void *data
)
112 struct sock
*sk
= (struct sock
*)data
;
113 struct raw_sock
*ro
= raw_sk(sk
);
114 struct sockaddr_can
*addr
;
116 unsigned int *pflags
;
118 /* check the received tx sock reference */
119 if (!ro
->recv_own_msgs
&& oskb
->sk
== sk
)
122 /* do not pass non-CAN2.0 frames to a legacy socket */
123 if (!ro
->fd_frames
&& oskb
->len
!= CAN_MTU
)
126 /* clone the given skb to be able to enqueue it into the rcv queue */
127 skb
= skb_clone(oskb
, GFP_ATOMIC
);
132 * Put the datagram to the queue so that raw_recvmsg() can
133 * get it from there. We need to pass the interface index to
134 * raw_recvmsg(). We pass a whole struct sockaddr_can in skb->cb
135 * containing the interface index.
138 BUILD_BUG_ON(sizeof(skb
->cb
) < sizeof(struct sockaddr_can
));
139 addr
= (struct sockaddr_can
*)skb
->cb
;
140 memset(addr
, 0, sizeof(*addr
));
141 addr
->can_family
= AF_CAN
;
142 addr
->can_ifindex
= skb
->dev
->ifindex
;
144 /* add CAN specific message flags for raw_recvmsg() */
145 pflags
= raw_flags(skb
);
148 *pflags
|= MSG_DONTROUTE
;
150 *pflags
|= MSG_CONFIRM
;
152 if (sock_queue_rcv_skb(sk
, skb
) < 0)
156 static int raw_enable_filters(struct net_device
*dev
, struct sock
*sk
,
157 struct can_filter
*filter
, int count
)
162 for (i
= 0; i
< count
; i
++) {
163 err
= can_rx_register(dev
, filter
[i
].can_id
,
167 /* clean up successfully registered filters */
169 can_rx_unregister(dev
, filter
[i
].can_id
,
179 static int raw_enable_errfilter(struct net_device
*dev
, struct sock
*sk
,
180 can_err_mask_t err_mask
)
185 err
= can_rx_register(dev
, 0, err_mask
| CAN_ERR_FLAG
,
191 static void raw_disable_filters(struct net_device
*dev
, struct sock
*sk
,
192 struct can_filter
*filter
, int count
)
196 for (i
= 0; i
< count
; i
++)
197 can_rx_unregister(dev
, filter
[i
].can_id
, filter
[i
].can_mask
,
201 static inline void raw_disable_errfilter(struct net_device
*dev
,
203 can_err_mask_t err_mask
)
207 can_rx_unregister(dev
, 0, err_mask
| CAN_ERR_FLAG
,
211 static inline void raw_disable_allfilters(struct net_device
*dev
,
214 struct raw_sock
*ro
= raw_sk(sk
);
216 raw_disable_filters(dev
, sk
, ro
->filter
, ro
->count
);
217 raw_disable_errfilter(dev
, sk
, ro
->err_mask
);
220 static int raw_enable_allfilters(struct net_device
*dev
, struct sock
*sk
)
222 struct raw_sock
*ro
= raw_sk(sk
);
225 err
= raw_enable_filters(dev
, sk
, ro
->filter
, ro
->count
);
227 err
= raw_enable_errfilter(dev
, sk
, ro
->err_mask
);
229 raw_disable_filters(dev
, sk
, ro
->filter
, ro
->count
);
235 static int raw_notifier(struct notifier_block
*nb
,
236 unsigned long msg
, void *ptr
)
238 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
239 struct raw_sock
*ro
= container_of(nb
, struct raw_sock
, notifier
);
240 struct sock
*sk
= &ro
->sk
;
242 if (!net_eq(dev_net(dev
), &init_net
))
245 if (dev
->type
!= ARPHRD_CAN
)
248 if (ro
->ifindex
!= dev
->ifindex
)
253 case NETDEV_UNREGISTER
:
255 /* remove current filters & unregister */
257 raw_disable_allfilters(dev
, sk
);
268 if (!sock_flag(sk
, SOCK_DEAD
))
269 sk
->sk_error_report(sk
);
273 sk
->sk_err
= ENETDOWN
;
274 if (!sock_flag(sk
, SOCK_DEAD
))
275 sk
->sk_error_report(sk
);
282 static int raw_init(struct sock
*sk
)
284 struct raw_sock
*ro
= raw_sk(sk
);
289 /* set default filter to single entry dfilter */
290 ro
->dfilter
.can_id
= 0;
291 ro
->dfilter
.can_mask
= MASK_ALL
;
292 ro
->filter
= &ro
->dfilter
;
295 /* set default loopback behaviour */
297 ro
->recv_own_msgs
= 0;
301 ro
->notifier
.notifier_call
= raw_notifier
;
303 register_netdevice_notifier(&ro
->notifier
);
308 static int raw_release(struct socket
*sock
)
310 struct sock
*sk
= sock
->sk
;
318 unregister_netdevice_notifier(&ro
->notifier
);
322 /* remove current filters & unregister */
325 struct net_device
*dev
;
327 dev
= dev_get_by_index(&init_net
, ro
->ifindex
);
329 raw_disable_allfilters(dev
, sk
);
333 raw_disable_allfilters(NULL
, sk
);
352 static int raw_bind(struct socket
*sock
, struct sockaddr
*uaddr
, int len
)
354 struct sockaddr_can
*addr
= (struct sockaddr_can
*)uaddr
;
355 struct sock
*sk
= sock
->sk
;
356 struct raw_sock
*ro
= raw_sk(sk
);
359 int notify_enetdown
= 0;
361 if (len
< sizeof(*addr
))
366 if (ro
->bound
&& addr
->can_ifindex
== ro
->ifindex
)
369 if (addr
->can_ifindex
) {
370 struct net_device
*dev
;
372 dev
= dev_get_by_index(&init_net
, addr
->can_ifindex
);
377 if (dev
->type
!= ARPHRD_CAN
) {
382 if (!(dev
->flags
& IFF_UP
))
385 ifindex
= dev
->ifindex
;
387 /* filters set by default/setsockopt */
388 err
= raw_enable_allfilters(dev
, sk
);
393 /* filters set by default/setsockopt */
394 err
= raw_enable_allfilters(NULL
, sk
);
399 /* unregister old filters */
401 struct net_device
*dev
;
403 dev
= dev_get_by_index(&init_net
, ro
->ifindex
);
405 raw_disable_allfilters(dev
, sk
);
409 raw_disable_allfilters(NULL
, sk
);
411 ro
->ifindex
= ifindex
;
418 if (notify_enetdown
) {
419 sk
->sk_err
= ENETDOWN
;
420 if (!sock_flag(sk
, SOCK_DEAD
))
421 sk
->sk_error_report(sk
);
427 static int raw_getname(struct socket
*sock
, struct sockaddr
*uaddr
,
430 struct sockaddr_can
*addr
= (struct sockaddr_can
*)uaddr
;
431 struct sock
*sk
= sock
->sk
;
432 struct raw_sock
*ro
= raw_sk(sk
);
437 memset(addr
, 0, sizeof(*addr
));
438 addr
->can_family
= AF_CAN
;
439 addr
->can_ifindex
= ro
->ifindex
;
441 *len
= sizeof(*addr
);
446 static int raw_setsockopt(struct socket
*sock
, int level
, int optname
,
447 char __user
*optval
, unsigned int optlen
)
449 struct sock
*sk
= sock
->sk
;
450 struct raw_sock
*ro
= raw_sk(sk
);
451 struct can_filter
*filter
= NULL
; /* dyn. alloc'ed filters */
452 struct can_filter sfilter
; /* single filter */
453 struct net_device
*dev
= NULL
;
454 can_err_mask_t err_mask
= 0;
458 if (level
!= SOL_CAN_RAW
)
464 if (optlen
% sizeof(struct can_filter
) != 0)
467 count
= optlen
/ sizeof(struct can_filter
);
470 /* filter does not fit into dfilter => alloc space */
471 filter
= memdup_user(optval
, optlen
);
473 return PTR_ERR(filter
);
474 } else if (count
== 1) {
475 if (copy_from_user(&sfilter
, optval
, sizeof(sfilter
)))
481 if (ro
->bound
&& ro
->ifindex
)
482 dev
= dev_get_by_index(&init_net
, ro
->ifindex
);
485 /* (try to) register the new filters */
487 err
= raw_enable_filters(dev
, sk
, &sfilter
, 1);
489 err
= raw_enable_filters(dev
, sk
, filter
,
497 /* remove old filter registrations */
498 raw_disable_filters(dev
, sk
, ro
->filter
, ro
->count
);
501 /* remove old filter space */
505 /* link new filters to the socket */
507 /* copy filter data for single filter */
508 ro
->dfilter
= sfilter
;
509 filter
= &ro
->dfilter
;
522 case CAN_RAW_ERR_FILTER
:
523 if (optlen
!= sizeof(err_mask
))
526 if (copy_from_user(&err_mask
, optval
, optlen
))
529 err_mask
&= CAN_ERR_MASK
;
533 if (ro
->bound
&& ro
->ifindex
)
534 dev
= dev_get_by_index(&init_net
, ro
->ifindex
);
536 /* remove current error mask */
538 /* (try to) register the new err_mask */
539 err
= raw_enable_errfilter(dev
, sk
, err_mask
);
544 /* remove old err_mask registration */
545 raw_disable_errfilter(dev
, sk
, ro
->err_mask
);
548 /* link new err_mask to the socket */
549 ro
->err_mask
= err_mask
;
559 case CAN_RAW_LOOPBACK
:
560 if (optlen
!= sizeof(ro
->loopback
))
563 if (copy_from_user(&ro
->loopback
, optval
, optlen
))
568 case CAN_RAW_RECV_OWN_MSGS
:
569 if (optlen
!= sizeof(ro
->recv_own_msgs
))
572 if (copy_from_user(&ro
->recv_own_msgs
, optval
, optlen
))
577 case CAN_RAW_FD_FRAMES
:
578 if (optlen
!= sizeof(ro
->fd_frames
))
581 if (copy_from_user(&ro
->fd_frames
, optval
, optlen
))
592 static int raw_getsockopt(struct socket
*sock
, int level
, int optname
,
593 char __user
*optval
, int __user
*optlen
)
595 struct sock
*sk
= sock
->sk
;
596 struct raw_sock
*ro
= raw_sk(sk
);
601 if (level
!= SOL_CAN_RAW
)
603 if (get_user(len
, optlen
))
613 int fsize
= ro
->count
* sizeof(struct can_filter
);
616 if (copy_to_user(optval
, ro
->filter
, len
))
623 err
= put_user(len
, optlen
);
626 case CAN_RAW_ERR_FILTER
:
627 if (len
> sizeof(can_err_mask_t
))
628 len
= sizeof(can_err_mask_t
);
632 case CAN_RAW_LOOPBACK
:
633 if (len
> sizeof(int))
638 case CAN_RAW_RECV_OWN_MSGS
:
639 if (len
> sizeof(int))
641 val
= &ro
->recv_own_msgs
;
644 case CAN_RAW_FD_FRAMES
:
645 if (len
> sizeof(int))
647 val
= &ro
->fd_frames
;
654 if (put_user(len
, optlen
))
656 if (copy_to_user(optval
, val
, len
))
661 static int raw_sendmsg(struct kiocb
*iocb
, struct socket
*sock
,
662 struct msghdr
*msg
, size_t size
)
664 struct sock
*sk
= sock
->sk
;
665 struct raw_sock
*ro
= raw_sk(sk
);
667 struct net_device
*dev
;
672 DECLARE_SOCKADDR(struct sockaddr_can
*, addr
, msg
->msg_name
);
674 if (msg
->msg_namelen
< sizeof(*addr
))
677 if (addr
->can_family
!= AF_CAN
)
680 ifindex
= addr
->can_ifindex
;
682 ifindex
= ro
->ifindex
;
685 if (unlikely(size
!= CANFD_MTU
&& size
!= CAN_MTU
))
688 if (unlikely(size
!= CAN_MTU
))
692 dev
= dev_get_by_index(&init_net
, ifindex
);
696 skb
= sock_alloc_send_skb(sk
, size
+ sizeof(struct can_skb_priv
),
697 msg
->msg_flags
& MSG_DONTWAIT
, &err
);
701 can_skb_reserve(skb
);
702 can_skb_prv(skb
)->ifindex
= dev
->ifindex
;
704 err
= memcpy_from_msg(skb_put(skb
, size
), msg
, size
);
708 sock_tx_timestamp(sk
, &skb_shinfo(skb
)->tx_flags
);
712 skb
->priority
= sk
->sk_priority
;
714 err
= can_send(skb
, ro
->loopback
);
731 static int raw_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
732 struct msghdr
*msg
, size_t size
, int flags
)
734 struct sock
*sk
= sock
->sk
;
739 noblock
= flags
& MSG_DONTWAIT
;
740 flags
&= ~MSG_DONTWAIT
;
742 skb
= skb_recv_datagram(sk
, flags
, noblock
, &err
);
747 msg
->msg_flags
|= MSG_TRUNC
;
751 err
= memcpy_to_msg(msg
, skb
->data
, size
);
753 skb_free_datagram(sk
, skb
);
757 sock_recv_ts_and_drops(msg
, sk
, skb
);
760 __sockaddr_check_size(sizeof(struct sockaddr_can
));
761 msg
->msg_namelen
= sizeof(struct sockaddr_can
);
762 memcpy(msg
->msg_name
, skb
->cb
, msg
->msg_namelen
);
765 /* assign the flags that have been recorded in raw_rcv() */
766 msg
->msg_flags
|= *(raw_flags(skb
));
768 skb_free_datagram(sk
, skb
);
773 static const struct proto_ops raw_ops
= {
775 .release
= raw_release
,
777 .connect
= sock_no_connect
,
778 .socketpair
= sock_no_socketpair
,
779 .accept
= sock_no_accept
,
780 .getname
= raw_getname
,
781 .poll
= datagram_poll
,
782 .ioctl
= can_ioctl
, /* 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 static struct proto raw_proto __read_mostly
= {
795 .owner
= THIS_MODULE
,
796 .obj_size
= sizeof(struct raw_sock
),
800 static const struct can_proto raw_can_proto
= {
807 static __init
int raw_module_init(void)
811 pr_info("can: raw protocol (rev " CAN_RAW_VERSION
")\n");
813 err
= can_proto_register(&raw_can_proto
);
815 printk(KERN_ERR
"can: registration of raw protocol failed\n");
820 static __exit
void raw_module_exit(void)
822 can_proto_unregister(&raw_can_proto
);
825 module_init(raw_module_init
);
826 module_exit(raw_module_exit
);