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
40 * Send feedback to <socketcan-users@lists.berlios.de>
44 #include <linux/module.h>
45 #include <linux/init.h>
46 #include <linux/uio.h>
47 #include <linux/net.h>
48 #include <linux/slab.h>
49 #include <linux/netdevice.h>
50 #include <linux/socket.h>
51 #include <linux/if_arp.h>
52 #include <linux/skbuff.h>
53 #include <linux/can.h>
54 #include <linux/can/core.h>
55 #include <linux/can/raw.h>
57 #include <net/net_namespace.h>
59 #define CAN_RAW_VERSION CAN_VERSION
60 static __initdata
const char banner
[] =
61 KERN_INFO
"can: raw protocol (rev " CAN_RAW_VERSION
")\n";
63 MODULE_DESCRIPTION("PF_CAN raw protocol");
64 MODULE_LICENSE("Dual BSD/GPL");
65 MODULE_AUTHOR("Urs Thuermann <urs.thuermann@volkswagen.de>");
66 MODULE_ALIAS("can-proto-1");
71 * A raw socket has a list of can_filters attached to it, each receiving
72 * the CAN frames matching that filter. If the filter list is empty,
73 * no CAN frames will be received by the socket. The default after
74 * opening the socket, is to have one filter which receives all frames.
75 * The filter list is allocated dynamically with the exception of the
76 * list containing only one item. This common case is optimized by
77 * storing the single filter in dfilter, to avoid using dynamic memory.
84 struct notifier_block notifier
;
87 int count
; /* number of active filters */
88 struct can_filter dfilter
; /* default/single filter */
89 struct can_filter
*filter
; /* pointer to filter(s) */
90 can_err_mask_t err_mask
;
93 static inline struct raw_sock
*raw_sk(const struct sock
*sk
)
95 return (struct raw_sock
*)sk
;
98 static void raw_rcv(struct sk_buff
*skb
, void *data
)
100 struct sock
*sk
= (struct sock
*)data
;
101 struct raw_sock
*ro
= raw_sk(sk
);
102 struct sockaddr_can
*addr
;
104 /* check the received tx sock reference */
105 if (!ro
->recv_own_msgs
&& skb
->sk
== sk
)
108 /* clone the given skb to be able to enqueue it into the rcv queue */
109 skb
= skb_clone(skb
, GFP_ATOMIC
);
114 * Put the datagram to the queue so that raw_recvmsg() can
115 * get it from there. We need to pass the interface index to
116 * raw_recvmsg(). We pass a whole struct sockaddr_can in skb->cb
117 * containing the interface index.
120 BUILD_BUG_ON(sizeof(skb
->cb
) < sizeof(struct sockaddr_can
));
121 addr
= (struct sockaddr_can
*)skb
->cb
;
122 memset(addr
, 0, sizeof(*addr
));
123 addr
->can_family
= AF_CAN
;
124 addr
->can_ifindex
= skb
->dev
->ifindex
;
126 if (sock_queue_rcv_skb(sk
, skb
) < 0)
130 static int raw_enable_filters(struct net_device
*dev
, struct sock
*sk
,
131 struct can_filter
*filter
, int count
)
136 for (i
= 0; i
< count
; i
++) {
137 err
= can_rx_register(dev
, filter
[i
].can_id
,
141 /* clean up successfully registered filters */
143 can_rx_unregister(dev
, filter
[i
].can_id
,
153 static int raw_enable_errfilter(struct net_device
*dev
, struct sock
*sk
,
154 can_err_mask_t err_mask
)
159 err
= can_rx_register(dev
, 0, err_mask
| CAN_ERR_FLAG
,
165 static void raw_disable_filters(struct net_device
*dev
, struct sock
*sk
,
166 struct can_filter
*filter
, int count
)
170 for (i
= 0; i
< count
; i
++)
171 can_rx_unregister(dev
, filter
[i
].can_id
, filter
[i
].can_mask
,
175 static inline void raw_disable_errfilter(struct net_device
*dev
,
177 can_err_mask_t err_mask
)
181 can_rx_unregister(dev
, 0, err_mask
| CAN_ERR_FLAG
,
185 static inline void raw_disable_allfilters(struct net_device
*dev
,
188 struct raw_sock
*ro
= raw_sk(sk
);
190 raw_disable_filters(dev
, sk
, ro
->filter
, ro
->count
);
191 raw_disable_errfilter(dev
, sk
, ro
->err_mask
);
194 static int raw_enable_allfilters(struct net_device
*dev
, struct sock
*sk
)
196 struct raw_sock
*ro
= raw_sk(sk
);
199 err
= raw_enable_filters(dev
, sk
, ro
->filter
, ro
->count
);
201 err
= raw_enable_errfilter(dev
, sk
, ro
->err_mask
);
203 raw_disable_filters(dev
, sk
, ro
->filter
, ro
->count
);
209 static int raw_notifier(struct notifier_block
*nb
,
210 unsigned long msg
, void *data
)
212 struct net_device
*dev
= (struct net_device
*)data
;
213 struct raw_sock
*ro
= container_of(nb
, struct raw_sock
, notifier
);
214 struct sock
*sk
= &ro
->sk
;
216 if (!net_eq(dev_net(dev
), &init_net
))
219 if (dev
->type
!= ARPHRD_CAN
)
222 if (ro
->ifindex
!= dev
->ifindex
)
227 case NETDEV_UNREGISTER
:
229 /* remove current filters & unregister */
231 raw_disable_allfilters(dev
, sk
);
242 if (!sock_flag(sk
, SOCK_DEAD
))
243 sk
->sk_error_report(sk
);
247 sk
->sk_err
= ENETDOWN
;
248 if (!sock_flag(sk
, SOCK_DEAD
))
249 sk
->sk_error_report(sk
);
256 static int raw_init(struct sock
*sk
)
258 struct raw_sock
*ro
= raw_sk(sk
);
263 /* set default filter to single entry dfilter */
264 ro
->dfilter
.can_id
= 0;
265 ro
->dfilter
.can_mask
= MASK_ALL
;
266 ro
->filter
= &ro
->dfilter
;
269 /* set default loopback behaviour */
271 ro
->recv_own_msgs
= 0;
274 ro
->notifier
.notifier_call
= raw_notifier
;
276 register_netdevice_notifier(&ro
->notifier
);
281 static int raw_release(struct socket
*sock
)
283 struct sock
*sk
= sock
->sk
;
284 struct raw_sock
*ro
= raw_sk(sk
);
286 unregister_netdevice_notifier(&ro
->notifier
);
290 /* remove current filters & unregister */
293 struct net_device
*dev
;
295 dev
= dev_get_by_index(&init_net
, ro
->ifindex
);
297 raw_disable_allfilters(dev
, sk
);
301 raw_disable_allfilters(NULL
, sk
);
320 static int raw_bind(struct socket
*sock
, struct sockaddr
*uaddr
, int len
)
322 struct sockaddr_can
*addr
= (struct sockaddr_can
*)uaddr
;
323 struct sock
*sk
= sock
->sk
;
324 struct raw_sock
*ro
= raw_sk(sk
);
327 int notify_enetdown
= 0;
329 if (len
< sizeof(*addr
))
334 if (ro
->bound
&& addr
->can_ifindex
== ro
->ifindex
)
337 if (addr
->can_ifindex
) {
338 struct net_device
*dev
;
340 dev
= dev_get_by_index(&init_net
, addr
->can_ifindex
);
345 if (dev
->type
!= ARPHRD_CAN
) {
350 if (!(dev
->flags
& IFF_UP
))
353 ifindex
= dev
->ifindex
;
355 /* filters set by default/setsockopt */
356 err
= raw_enable_allfilters(dev
, sk
);
361 /* filters set by default/setsockopt */
362 err
= raw_enable_allfilters(NULL
, sk
);
367 /* unregister old filters */
369 struct net_device
*dev
;
371 dev
= dev_get_by_index(&init_net
, ro
->ifindex
);
373 raw_disable_allfilters(dev
, sk
);
377 raw_disable_allfilters(NULL
, sk
);
379 ro
->ifindex
= ifindex
;
386 if (notify_enetdown
) {
387 sk
->sk_err
= ENETDOWN
;
388 if (!sock_flag(sk
, SOCK_DEAD
))
389 sk
->sk_error_report(sk
);
395 static int raw_getname(struct socket
*sock
, struct sockaddr
*uaddr
,
398 struct sockaddr_can
*addr
= (struct sockaddr_can
*)uaddr
;
399 struct sock
*sk
= sock
->sk
;
400 struct raw_sock
*ro
= raw_sk(sk
);
405 memset(addr
, 0, sizeof(*addr
));
406 addr
->can_family
= AF_CAN
;
407 addr
->can_ifindex
= ro
->ifindex
;
409 *len
= sizeof(*addr
);
414 static int raw_setsockopt(struct socket
*sock
, int level
, int optname
,
415 char __user
*optval
, unsigned int optlen
)
417 struct sock
*sk
= sock
->sk
;
418 struct raw_sock
*ro
= raw_sk(sk
);
419 struct can_filter
*filter
= NULL
; /* dyn. alloc'ed filters */
420 struct can_filter sfilter
; /* single filter */
421 struct net_device
*dev
= NULL
;
422 can_err_mask_t err_mask
= 0;
426 if (level
!= SOL_CAN_RAW
)
432 if (optlen
% sizeof(struct can_filter
) != 0)
435 count
= optlen
/ sizeof(struct can_filter
);
438 /* filter does not fit into dfilter => alloc space */
439 filter
= memdup_user(optval
, optlen
);
441 return PTR_ERR(filter
);
442 } else if (count
== 1) {
443 if (copy_from_user(&sfilter
, optval
, sizeof(sfilter
)))
449 if (ro
->bound
&& ro
->ifindex
)
450 dev
= dev_get_by_index(&init_net
, ro
->ifindex
);
453 /* (try to) register the new filters */
455 err
= raw_enable_filters(dev
, sk
, &sfilter
, 1);
457 err
= raw_enable_filters(dev
, sk
, filter
,
465 /* remove old filter registrations */
466 raw_disable_filters(dev
, sk
, ro
->filter
, ro
->count
);
469 /* remove old filter space */
473 /* link new filters to the socket */
475 /* copy filter data for single filter */
476 ro
->dfilter
= sfilter
;
477 filter
= &ro
->dfilter
;
490 case CAN_RAW_ERR_FILTER
:
491 if (optlen
!= sizeof(err_mask
))
494 if (copy_from_user(&err_mask
, optval
, optlen
))
497 err_mask
&= CAN_ERR_MASK
;
501 if (ro
->bound
&& ro
->ifindex
)
502 dev
= dev_get_by_index(&init_net
, ro
->ifindex
);
504 /* remove current error mask */
506 /* (try to) register the new err_mask */
507 err
= raw_enable_errfilter(dev
, sk
, err_mask
);
512 /* remove old err_mask registration */
513 raw_disable_errfilter(dev
, sk
, ro
->err_mask
);
516 /* link new err_mask to the socket */
517 ro
->err_mask
= err_mask
;
527 case CAN_RAW_LOOPBACK
:
528 if (optlen
!= sizeof(ro
->loopback
))
531 if (copy_from_user(&ro
->loopback
, optval
, optlen
))
536 case CAN_RAW_RECV_OWN_MSGS
:
537 if (optlen
!= sizeof(ro
->recv_own_msgs
))
540 if (copy_from_user(&ro
->recv_own_msgs
, optval
, optlen
))
551 static int raw_getsockopt(struct socket
*sock
, int level
, int optname
,
552 char __user
*optval
, int __user
*optlen
)
554 struct sock
*sk
= sock
->sk
;
555 struct raw_sock
*ro
= raw_sk(sk
);
560 if (level
!= SOL_CAN_RAW
)
562 if (get_user(len
, optlen
))
572 int fsize
= ro
->count
* sizeof(struct can_filter
);
575 if (copy_to_user(optval
, ro
->filter
, len
))
582 err
= put_user(len
, optlen
);
585 case CAN_RAW_ERR_FILTER
:
586 if (len
> sizeof(can_err_mask_t
))
587 len
= sizeof(can_err_mask_t
);
591 case CAN_RAW_LOOPBACK
:
592 if (len
> sizeof(int))
597 case CAN_RAW_RECV_OWN_MSGS
:
598 if (len
> sizeof(int))
600 val
= &ro
->recv_own_msgs
;
607 if (put_user(len
, optlen
))
609 if (copy_to_user(optval
, val
, len
))
614 static int raw_sendmsg(struct kiocb
*iocb
, struct socket
*sock
,
615 struct msghdr
*msg
, size_t size
)
617 struct sock
*sk
= sock
->sk
;
618 struct raw_sock
*ro
= raw_sk(sk
);
620 struct net_device
*dev
;
625 struct sockaddr_can
*addr
=
626 (struct sockaddr_can
*)msg
->msg_name
;
628 if (addr
->can_family
!= AF_CAN
)
631 ifindex
= addr
->can_ifindex
;
633 ifindex
= ro
->ifindex
;
635 if (size
!= sizeof(struct can_frame
))
638 dev
= dev_get_by_index(&init_net
, ifindex
);
642 skb
= sock_alloc_send_skb(sk
, size
, msg
->msg_flags
& MSG_DONTWAIT
,
647 err
= memcpy_fromiovec(skb_put(skb
, size
), msg
->msg_iov
, size
);
650 err
= sock_tx_timestamp(msg
, sk
, skb_tx(skb
));
654 /* to be able to check the received tx sock reference in raw_rcv() */
655 skb_tx(skb
)->prevent_sk_orphan
= 1;
660 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 noblock
= flags
& MSG_DONTWAIT
;
686 flags
&= ~MSG_DONTWAIT
;
688 skb
= skb_recv_datagram(sk
, flags
, noblock
, &err
);
693 msg
->msg_flags
|= MSG_TRUNC
;
697 err
= memcpy_toiovec(msg
->msg_iov
, skb
->data
, size
);
699 skb_free_datagram(sk
, skb
);
703 sock_recv_ts_and_drops(msg
, sk
, skb
);
706 msg
->msg_namelen
= sizeof(struct sockaddr_can
);
707 memcpy(msg
->msg_name
, skb
->cb
, msg
->msg_namelen
);
710 skb_free_datagram(sk
, skb
);
715 static struct proto_ops raw_ops __read_mostly
= {
717 .release
= raw_release
,
719 .connect
= sock_no_connect
,
720 .socketpair
= sock_no_socketpair
,
721 .accept
= sock_no_accept
,
722 .getname
= raw_getname
,
723 .poll
= datagram_poll
,
724 .ioctl
= NULL
, /* use can_ioctl() from af_can.c */
725 .listen
= sock_no_listen
,
726 .shutdown
= sock_no_shutdown
,
727 .setsockopt
= raw_setsockopt
,
728 .getsockopt
= raw_getsockopt
,
729 .sendmsg
= raw_sendmsg
,
730 .recvmsg
= raw_recvmsg
,
731 .mmap
= sock_no_mmap
,
732 .sendpage
= sock_no_sendpage
,
735 static struct proto raw_proto __read_mostly
= {
737 .owner
= THIS_MODULE
,
738 .obj_size
= sizeof(struct raw_sock
),
742 static struct can_proto raw_can_proto __read_mostly
= {
749 static __init
int raw_module_init(void)
755 err
= can_proto_register(&raw_can_proto
);
757 printk(KERN_ERR
"can: registration of raw protocol failed\n");
762 static __exit
void raw_module_exit(void)
764 can_proto_unregister(&raw_can_proto
);
767 module_init(raw_module_init
);
768 module_exit(raw_module_exit
);