X-Git-Url: http://rtime.felk.cvut.cz/gitweb/socketcan-devel.git/blobdiff_plain/262e9f19c2ffe12db482460f10ab0adc32f05538..b1ebf063e1dac50565661c1219b7e36acc7e898c:/kernel/2.6/net/can/raw.c diff --git a/kernel/2.6/net/can/raw.c b/kernel/2.6/net/can/raw.c index 319be4f..b874bce 100644 --- a/kernel/2.6/net/can/raw.c +++ b/kernel/2.6/net/can/raw.c @@ -1,15 +1,14 @@ /* - * raw.c + * raw.c - Raw sockets for protocol family CAN * - * Copyright (c) 2002-2005 Volkswagen Group Electronic Research + * Copyright (c) 2002-2007 Volkswagen Group Electronic Research * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions, the following disclaimer and - * the referenced file 'COPYING'. + * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. @@ -19,8 +18,8 @@ * * Alternatively, provided that this notice is retained in full, this * software may be distributed under the terms of the GNU General - * Public License ("GPL") version 2 as distributed in the 'COPYING' - * file from the main directory of the linux kernel source. + * Public License ("GPL") version 2, in which case the provisions of the + * GPL apply INSTEAD OF those given above. * * The provided data structures and external interfaces from this code * are not restricted to be used by modules with a GPL compatible license. @@ -42,174 +41,291 @@ * */ -#include #include #include #include +#include #include #include -#include -#include +#include +#include +#include +#include +#include +#include #include +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24) +#include +#endif +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25) +#include "compat.h" +#endif -#include -#include -#include -#include - -#include "af_can.h" - - +#include /* for RCSID. Removed by mkpatch script */ RCSID("$Id$"); -#define NAME "RAW sockets for LLCF" -#define IDENT "raw" -static __initdata const char banner[] = BANNER(NAME); +#define CAN_RAW_VERSION CAN_VERSION +static __initdata const char banner[] = + KERN_INFO "can: raw protocol (rev " CAN_RAW_VERSION ")\n"; -MODULE_DESCRIPTION(NAME); +MODULE_DESCRIPTION("PF_CAN raw protocol"); MODULE_LICENSE("Dual BSD/GPL"); MODULE_AUTHOR("Urs Thuermann "); +MODULE_ALIAS("can-proto-1"); -#ifdef CONFIG_CAN_DEBUG_CORE -static int debug = 0; -module_param(debug, int, S_IRUGO); -#define DBG(args...) (debug & 1 ? \ - (printk(KERN_DEBUG "RAW %s: ", __func__), \ - printk(args)) : 0) -#define DBG_SKB(skb) (debug & 4 ? can_debug_skb(skb) : 0) -#else -#define DBG(args...) -#define DBG_SKB(skb) -#endif - -static int raw_init(struct sock *sk); -static int raw_release(struct socket *sock); -static int raw_bind (struct socket *sock, struct sockaddr *uaddr, int len); -static int raw_getname(struct socket *sock, struct sockaddr *uaddr, - int *len, int peer); -static unsigned int raw_poll(struct file *file, struct socket *sock, - poll_table *wait); -static int raw_setsockopt(struct socket *sock, int level, int optname, - char __user *optval, int optlen); -static int raw_getsockopt(struct socket *sock, int level, int optname, - char __user *optval, int __user *optlen); -static int raw_sendmsg(struct kiocb *iocb, struct socket *sock, - struct msghdr *msg, size_t size); -static int raw_recvmsg(struct kiocb *iocb, struct socket *sock, - struct msghdr *msg, size_t size, int flags); -static void raw_rcv(struct sk_buff *skb, void *data); -static void raw_notifier(unsigned long msg, void *data); - -static void raw_add_filters(struct net_device *dev, struct sock *sk); -static void raw_remove_filters(struct net_device *dev, struct sock *sk); - - -static struct proto_ops raw_ops = { - .family = PF_CAN, - .release = raw_release, - .bind = raw_bind, - .connect = sock_no_connect, - .socketpair = sock_no_socketpair, - .accept = sock_no_accept, - .getname = raw_getname, - .poll = raw_poll, - .ioctl = NULL, /* use can_ioctl() from af_can.c */ - .listen = sock_no_listen, - .shutdown = sock_no_shutdown, - .setsockopt = raw_setsockopt, - .getsockopt = raw_getsockopt, - .sendmsg = raw_sendmsg, - .recvmsg = raw_recvmsg, - .mmap = sock_no_mmap, - .sendpage = sock_no_sendpage, -}; +#define MASK_ALL 0 +/* + * A raw socket has a list of can_filters attached to it, each receiving + * the CAN frames matching that filter. If the filter list is empty, + * no CAN frames will be received by the socket. The default after + * opening the socket, is to have one filter which receives all frames. + * The filter list is allocated dynamically with the exception of the + * list containing only one item. This common case is optimized by + * storing the single filter in dfilter, to avoid using dynamic memory. + */ -struct raw_opt { +struct raw_sock { +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12) + struct sock sk; +#else + struct sock *sk; +#endif int bound; int ifindex; + struct notifier_block notifier; int loopback; int recv_own_msgs; int count; /* number of active filters */ - struct can_filter dfilter; /* default/single filter space */ + struct can_filter dfilter; /* default/single filter */ struct can_filter *filter; /* pointer to filter(s) */ can_err_mask_t err_mask; }; -#ifdef CONFIG_CAN_RAW_USER -#define RAW_CAP CAP_NET_RAW +/* + * Return pointer to store the extra msg flags for raw_recvmsg(). + * We use the space of one unsigned int beyond the 'struct sockaddr_can' + * in skb->cb. + */ +static inline unsigned int *raw_flags(struct sk_buff *skb) +{ + BUILD_BUG_ON(sizeof(skb->cb) <= (sizeof(struct sockaddr_can) + + sizeof(unsigned int))); + + /* return pointer after struct sockaddr_can */ + return (unsigned int *)(&((struct sockaddr_can *)skb->cb)[1]); +} + +static inline struct raw_sock *raw_sk(const struct sock *sk) +{ +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12) + return (struct raw_sock *)sk; #else -#define RAW_CAP (-1) + return (struct raw_sock *)sk->sk_protinfo; #endif +} -#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,13) +static void raw_rcv(struct sk_buff *oskb, void *data) +{ + struct sock *sk = (struct sock *)data; + struct raw_sock *ro = raw_sk(sk); + struct sockaddr_can *addr; + struct sk_buff *skb; + unsigned int *pflags; -struct raw_sock { - struct sock sk; - struct raw_opt opt; -}; + /* check the received tx sock reference */ + if (!ro->recv_own_msgs && oskb->sk == sk) + return; -#define canraw_sk(sk) (&((struct raw_sock *)(sk))->opt) + /* clone the given skb to be able to enqueue it into the rcv queue */ + skb = skb_clone(oskb, GFP_ATOMIC); + if (!skb) + return; -static struct proto raw_proto = { - .name = "CAN_RAW", - .owner = THIS_MODULE, - .obj_size = sizeof(struct raw_sock), - .init = raw_init, -}; + /* + * Put the datagram to the queue so that raw_recvmsg() can + * get it from there. We need to pass the interface index to + * raw_recvmsg(). We pass a whole struct sockaddr_can in skb->cb + * containing the interface index. + */ -static struct can_proto raw_can_proto = { - .type = SOCK_RAW, - .protocol = CAN_RAW, - .capability = RAW_CAP, - .ops = &raw_ops, - .prot = &raw_proto, -}; + BUILD_BUG_ON(sizeof(skb->cb) < sizeof(struct sockaddr_can)); + addr = (struct sockaddr_can *)skb->cb; + memset(addr, 0, sizeof(*addr)); + addr->can_family = AF_CAN; + addr->can_ifindex = skb->dev->ifindex; -#else + /* add CAN specific message flags for raw_recvmsg() */ + pflags = raw_flags(skb); + *pflags = 0; + if (oskb->sk) + *pflags |= MSG_DONTROUTE; + if (oskb->sk == sk) + *pflags |= MSG_CONFIRM; -#define canraw_sk(sk) ((struct raw_opt *)(sk)->sk_protinfo) + if (sock_queue_rcv_skb(sk, skb) < 0) + kfree_skb(skb); +} -static struct can_proto raw_can_proto = { - .type = SOCK_RAW, - .protocol = CAN_RAW, - .capability = RAW_CAP, - .ops = &raw_ops, - .owner = THIS_MODULE, - .obj_size = sizeof(struct raw_opt), - .init = raw_init, -}; +static int raw_enable_filters(struct net_device *dev, struct sock *sk, + struct can_filter *filter, int count) +{ + int err = 0; + int i; -#endif + for (i = 0; i < count; i++) { + err = can_rx_register(dev, filter[i].can_id, + filter[i].can_mask, + raw_rcv, sk, "raw"); + if (err) { + /* clean up successfully registered filters */ + while (--i >= 0) + can_rx_unregister(dev, filter[i].can_id, + filter[i].can_mask, + raw_rcv, sk); + break; + } + } -#define MASK_ALL 0 + return err; +} -static __init int raw_module_init(void) +static int raw_enable_errfilter(struct net_device *dev, struct sock *sk, + can_err_mask_t err_mask) { - printk(banner); + int err = 0; - can_proto_register(&raw_can_proto); - return 0; + if (err_mask) + err = can_rx_register(dev, 0, err_mask | CAN_ERR_FLAG, + raw_rcv, sk, "raw"); + + return err; } -static __exit void raw_module_exit(void) +static void raw_disable_filters(struct net_device *dev, struct sock *sk, + struct can_filter *filter, int count) { - can_proto_unregister(&raw_can_proto); + int i; + + for (i = 0; i < count; i++) + can_rx_unregister(dev, filter[i].can_id, filter[i].can_mask, + raw_rcv, sk); +} + +static inline void raw_disable_errfilter(struct net_device *dev, + struct sock *sk, + can_err_mask_t err_mask) + +{ + if (err_mask) + can_rx_unregister(dev, 0, err_mask | CAN_ERR_FLAG, + raw_rcv, sk); +} + +static inline void raw_disable_allfilters(struct net_device *dev, + struct sock *sk) +{ + struct raw_sock *ro = raw_sk(sk); + + raw_disable_filters(dev, sk, ro->filter, ro->count); + raw_disable_errfilter(dev, sk, ro->err_mask); +} + +static int raw_enable_allfilters(struct net_device *dev, struct sock *sk) +{ + struct raw_sock *ro = raw_sk(sk); + int err; + + err = raw_enable_filters(dev, sk, ro->filter, ro->count); + if (!err) { + err = raw_enable_errfilter(dev, sk, ro->err_mask); + if (err) + raw_disable_filters(dev, sk, ro->filter, ro->count); + } + + return err; +} + +static int raw_notifier(struct notifier_block *nb, + unsigned long msg, void *data) +{ + struct net_device *dev = (struct net_device *)data; + struct raw_sock *ro = container_of(nb, struct raw_sock, notifier); +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12) + struct sock *sk = &ro->sk; +#else + struct sock *sk = ro->sk; +#endif + +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26) + if (!net_eq(dev_net(dev), &init_net)) + return NOTIFY_DONE; +#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24) + if (dev->nd_net != &init_net) + return NOTIFY_DONE; +#endif + + if (dev->type != ARPHRD_CAN) + return NOTIFY_DONE; + + if (ro->ifindex != dev->ifindex) + return NOTIFY_DONE; + + switch (msg) { + + case NETDEV_UNREGISTER: + lock_sock(sk); + /* remove current filters & unregister */ + if (ro->bound) + raw_disable_allfilters(dev, sk); + + if (ro->count > 1) + kfree(ro->filter); + + ro->ifindex = 0; + ro->bound = 0; + ro->count = 0; + release_sock(sk); + + sk->sk_err = ENODEV; + if (!sock_flag(sk, SOCK_DEAD)) + sk->sk_error_report(sk); + break; + + case NETDEV_DOWN: + sk->sk_err = ENETDOWN; + if (!sock_flag(sk, SOCK_DEAD)) + sk->sk_error_report(sk); + break; + } + + return NOTIFY_DONE; } static int raw_init(struct sock *sk) { - canraw_sk(sk)->bound = 0; + struct raw_sock *ro = raw_sk(sk); + +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,12) + ro->sk = sk; +#endif + ro->bound = 0; + ro->ifindex = 0; /* set default filter to single entry dfilter */ - canraw_sk(sk)->dfilter.can_id = 0; - canraw_sk(sk)->dfilter.can_mask = MASK_ALL; - canraw_sk(sk)->filter = &canraw_sk(sk)->dfilter; - canraw_sk(sk)->count = 1; + ro->dfilter.can_id = 0; + ro->dfilter.can_mask = MASK_ALL; + ro->filter = &ro->dfilter; + ro->count = 1; - /* set default message behaviour */ - canraw_sk(sk)->loopback = 1; - canraw_sk(sk)->recv_own_msgs = 0; + /* set default loopback behaviour */ + ro->loopback = 1; + ro->recv_own_msgs = 0; + + /* set notifier */ + ro->notifier.notifier_call = raw_notifier; + + register_netdevice_notifier(&ro->notifier); return 0; } @@ -217,29 +333,42 @@ static int raw_init(struct sock *sk) static int raw_release(struct socket *sock) { struct sock *sk = sock->sk; - struct net_device *dev = NULL; + struct raw_sock *ro; - DBG("socket %p, sk %p, refcnt %d\n", sock, sk, - atomic_read(&sk->sk_refcnt)); + if (!sk) + return 0; - if (canraw_sk(sk)->bound && canraw_sk(sk)->ifindex) - dev = dev_get_by_index(canraw_sk(sk)->ifindex); + ro = raw_sk(sk); - /* remove current filters & unregister */ - if (canraw_sk(sk)->bound) - raw_remove_filters(dev, sk); - if (canraw_sk(sk)->count > 1) - kfree(canraw_sk(sk)->filter); + unregister_netdevice_notifier(&ro->notifier); - /* remove current error mask */ - if (canraw_sk(sk)->err_mask && canraw_sk(sk)->bound) - can_rx_unregister(dev, 0, (canid_t)(canraw_sk(sk)->err_mask | CAN_ERR_FLAG), raw_rcv, sk); + lock_sock(sk); - if (dev) { - can_dev_unregister(dev, raw_notifier, sk); - dev_put(dev); + /* remove current filters & unregister */ + if (ro->bound) { + if (ro->ifindex) { + struct net_device *dev; + + dev = dev_get_by_index(&init_net, ro->ifindex); + if (dev) { + raw_disable_allfilters(dev, sk); + dev_put(dev); + } + } else + raw_disable_allfilters(NULL, sk); } + if (ro->count > 1) + kfree(ro->filter); + + ro->ifindex = 0; + ro->bound = 0; + ro->count = 0; + + sock_orphan(sk); + sock->sk = NULL; + + release_sock(sk); sock_put(sk); return 0; @@ -249,75 +378,75 @@ static int raw_bind(struct socket *sock, struct sockaddr *uaddr, int len) { struct sockaddr_can *addr = (struct sockaddr_can *)uaddr; struct sock *sk = sock->sk; - struct net_device *dev; - - DBG("socket %p to device %d\n", sock, addr->can_ifindex); + struct raw_sock *ro = raw_sk(sk); + int ifindex; + int err = 0; + int notify_enetdown = 0; if (len < sizeof(*addr)) return -EINVAL; - if (canraw_sk(sk)->bound) { -#if 1 - return -EINVAL; -#else - /* remove current bindings / notifier */ - if (canraw_sk(sk)->ifindex) { - dev = dev_get_by_index(canraw_sk(sk)->ifindex); - if (!dev) { - DBG("could not find device %d\n", - addr->can_ifindex); - return -ENODEV; - } - if (!(dev->flags & IFF_UP)) { - sk->sk_err = ENETDOWN; - sk->sk_error_report(sk); - goto out; - } - can_dev_unregister(dev, raw_notifier, sk); - } else - dev = NULL; - - /* unregister current filters for this device */ - raw_remove_filters(dev, sk); - - /* the filter(s) content is just available here */ - - if (dev) - dev_put(dev); + lock_sock(sk); - canraw_sk(sk)->bound = 0; -#endif - } + if (ro->bound && addr->can_ifindex == ro->ifindex) + goto out; if (addr->can_ifindex) { - dev = dev_get_by_index(addr->can_ifindex); + struct net_device *dev; + + dev = dev_get_by_index(&init_net, addr->can_ifindex); if (!dev) { - DBG("could not find device %d\n", addr->can_ifindex); - return -ENODEV; + err = -ENODEV; + goto out; } - if (!(dev->flags & IFF_UP)) { - sk->sk_err = ENETDOWN; - sk->sk_error_report(sk); + if (dev->type != ARPHRD_CAN) { + dev_put(dev); + err = -ENODEV; goto out; } - can_dev_register(dev, raw_notifier, sk); - } else - dev = NULL; + if (!(dev->flags & IFF_UP)) + notify_enetdown = 1; - canraw_sk(sk)->ifindex = addr->can_ifindex; + ifindex = dev->ifindex; - raw_add_filters(dev, sk); /* filters set by default/setsockopt */ + /* filters set by default/setsockopt */ + err = raw_enable_allfilters(dev, sk); + dev_put(dev); + } else { + ifindex = 0; - if (canraw_sk(sk)->err_mask) /* error frame filter set by setsockopt */ - can_rx_register(dev, 0, (canid_t)(canraw_sk(sk)->err_mask | CAN_ERR_FLAG), raw_rcv, sk, IDENT); + /* filters set by default/setsockopt */ + err = raw_enable_allfilters(NULL, sk); + } - canraw_sk(sk)->bound = 1; + if (!err) { + if (ro->bound) { + /* unregister old filters */ + if (ro->ifindex) { + struct net_device *dev; + + dev = dev_get_by_index(&init_net, ro->ifindex); + if (dev) { + raw_disable_allfilters(dev, sk); + dev_put(dev); + } + } else + raw_disable_allfilters(NULL, sk); + } + ro->ifindex = ifindex; + ro->bound = 1; + } out: - if (dev) - dev_put(dev); + release_sock(sk); - return 0; + if (notify_enetdown) { + sk->sk_err = ENETDOWN; + if (!sock_flag(sk, SOCK_DEAD)) + sk->sk_error_report(sk); + } + + return err; } static int raw_getname(struct socket *sock, struct sockaddr *uaddr, @@ -325,303 +454,288 @@ static int raw_getname(struct socket *sock, struct sockaddr *uaddr, { struct sockaddr_can *addr = (struct sockaddr_can *)uaddr; struct sock *sk = sock->sk; + struct raw_sock *ro = raw_sk(sk); if (peer) return -EOPNOTSUPP; addr->can_family = AF_CAN; - addr->can_ifindex = canraw_sk(sk)->ifindex; + addr->can_ifindex = ro->ifindex; + *len = sizeof(*addr); return 0; } -static unsigned int raw_poll(struct file *file, struct socket *sock, - poll_table *wait) -{ - unsigned int mask = 0; - - DBG("socket %p\n", sock); - - mask = datagram_poll(file, sock, wait); - return mask; -} - +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32) +static int raw_setsockopt(struct socket *sock, int level, int optname, + char __user *optval, unsigned int optlen) +#else static int raw_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen) +#endif { struct sock *sk = sock->sk; - struct can_filter *filter = NULL; + struct raw_sock *ro = raw_sk(sk); + struct can_filter *filter = NULL; /* dyn. alloc'ed filters */ + struct can_filter sfilter; /* single filter */ struct net_device *dev = NULL; can_err_mask_t err_mask = 0; int count = 0; - int err; + int err = 0; if (level != SOL_CAN_RAW) return -EINVAL; + if (optlen < 0) + return -EINVAL; switch (optname) { + case CAN_RAW_FILTER: if (optlen % sizeof(struct can_filter) != 0) return -EINVAL; count = optlen / sizeof(struct can_filter); - if (count > 1) { /* does not fit into dfilter */ - if (!(filter = kmalloc(optlen, GFP_KERNEL))) + if (count > 1) { + /* filter does not fit into dfilter => alloc space */ + filter = kmalloc(optlen, GFP_KERNEL); + if (!filter) return -ENOMEM; - if ((err = copy_from_user(filter, optval, optlen))) { + + if (copy_from_user(filter, optval, optlen)) { kfree(filter); - return err; + return -EFAULT; } + } else if (count == 1) { + if (copy_from_user(&sfilter, optval, sizeof(sfilter))) + return -EFAULT; } - if (canraw_sk(sk)->bound && canraw_sk(sk)->ifindex) - dev = dev_get_by_index(canraw_sk(sk)->ifindex); + lock_sock(sk); + + if (ro->bound && ro->ifindex) + dev = dev_get_by_index(&init_net, ro->ifindex); + + if (ro->bound) { + /* (try to) register the new filters */ + if (count == 1) + err = raw_enable_filters(dev, sk, &sfilter, 1); + else + err = raw_enable_filters(dev, sk, filter, + count); + if (err) { + if (count > 1) + kfree(filter); + goto out_fil; + } - /* remove current filters & unregister */ - if (canraw_sk(sk)->bound) - raw_remove_filters(dev, sk); - if (canraw_sk(sk)->count > 1) - kfree(canraw_sk(sk)->filter); - - if (count == 1) { /* copy data for single filter */ - filter = &canraw_sk(sk)->dfilter; - if ((err = copy_from_user(filter, optval, optlen))) - return err; + /* remove old filter registrations */ + raw_disable_filters(dev, sk, ro->filter, ro->count); } - /* add new filters & register */ - canraw_sk(sk)->filter = filter; - canraw_sk(sk)->count = count; - if (canraw_sk(sk)->bound) - raw_add_filters(dev, sk); + /* remove old filter space */ + if (ro->count > 1) + kfree(ro->filter); + /* link new filters to the socket */ + if (count == 1) { + /* copy filter data for single filter */ + ro->dfilter = sfilter; + filter = &ro->dfilter; + } + ro->filter = filter; + ro->count = count; + + out_fil: if (dev) dev_put(dev); + release_sock(sk); + break; case CAN_RAW_ERR_FILTER: - if (optlen) { - if (optlen != sizeof(err_mask)) - return -EINVAL; - if ((err = copy_from_user(&err_mask, optval, optlen))) { - return err; - } - } + if (optlen != sizeof(err_mask)) + return -EINVAL; + + if (copy_from_user(&err_mask, optval, optlen)) + return -EFAULT; err_mask &= CAN_ERR_MASK; - if (canraw_sk(sk)->bound && canraw_sk(sk)->ifindex) - dev = dev_get_by_index(canraw_sk(sk)->ifindex); + lock_sock(sk); + + if (ro->bound && ro->ifindex) + dev = dev_get_by_index(&init_net, ro->ifindex); /* remove current error mask */ - if (canraw_sk(sk)->err_mask && canraw_sk(sk)->bound) - can_rx_unregister(dev, 0, (canid_t)(canraw_sk(sk)->err_mask | CAN_ERR_FLAG), raw_rcv, sk); - - /* add new error mask */ - if (optlen) { - canraw_sk(sk)->err_mask = err_mask; - if (canraw_sk(sk)->err_mask & canraw_sk(sk)->bound) - can_rx_register(dev, 0, (canid_t)(canraw_sk(sk)->err_mask | CAN_ERR_FLAG), raw_rcv, sk, IDENT); + if (ro->bound) { + /* (try to) register the new err_mask */ + err = raw_enable_errfilter(dev, sk, err_mask); + + if (err) + goto out_err; + + /* remove old err_mask registration */ + raw_disable_errfilter(dev, sk, ro->err_mask); } + /* link new err_mask to the socket */ + ro->err_mask = err_mask; + + out_err: if (dev) dev_put(dev); + release_sock(sk); + break; case CAN_RAW_LOOPBACK: - if (optlen) { - if (optlen != sizeof(canraw_sk(sk)->loopback)) - return -EINVAL; - if ((err = copy_from_user(&canraw_sk(sk)->loopback, optval, optlen))) { - return err; - } - } + if (optlen != sizeof(ro->loopback)) + return -EINVAL; + + if (copy_from_user(&ro->loopback, optval, optlen)) + return -EFAULT; + break; case CAN_RAW_RECV_OWN_MSGS: - if (optlen) { - if (optlen != sizeof(canraw_sk(sk)->recv_own_msgs)) - return -EINVAL; - if ((err = copy_from_user(&canraw_sk(sk)->recv_own_msgs, optval, optlen))) { - return err; - } - } + if (optlen != sizeof(ro->recv_own_msgs)) + return -EINVAL; + + if (copy_from_user(&ro->recv_own_msgs, optval, optlen)) + return -EFAULT; + break; default: return -ENOPROTOOPT; } - return 0; + return err; } static int raw_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen) { struct sock *sk = sock->sk; - struct can_filter *filter = canraw_sk(sk)->filter; - int count = canraw_sk(sk)->count; + struct raw_sock *ro = raw_sk(sk); int len; + void *val; + int err = 0; if (level != SOL_CAN_RAW) return -EINVAL; + if (get_user(len, optlen)) + return -EFAULT; + if (len < 0) + return -EINVAL; switch (optname) { - case CAN_RAW_FILTER: - if (get_user(len, optlen)) - return -EFAULT; - if (count && filter) { - int filter_size = count * sizeof(struct can_filter); - if (len < filter_size) - return -EINVAL; - if (len > filter_size) - len = filter_size; - if (copy_to_user(optval, filter, len)) - return -EFAULT; + case CAN_RAW_FILTER: + lock_sock(sk); + if (ro->count > 0) { + int fsize = ro->count * sizeof(struct can_filter); + if (len > fsize) + len = fsize; + if (copy_to_user(optval, ro->filter, len)) + err = -EFAULT; } else len = 0; + release_sock(sk); - if (put_user(len, optlen)) - return -EFAULT; - - break; + if (!err) + err = put_user(len, optlen); + return err; case CAN_RAW_ERR_FILTER: - if (get_user(len, optlen)) - return -EFAULT; - - if (len < sizeof(can_err_mask_t)) - return -EINVAL; - if (len > sizeof(can_err_mask_t)) len = sizeof(can_err_mask_t); - - if (copy_to_user(optval, &canraw_sk(sk)->err_mask, len)) - return -EFAULT; - - if (put_user(len, optlen)) - return -EFAULT; - + val = &ro->err_mask; break; case CAN_RAW_LOOPBACK: - if (get_user(len, optlen)) - return -EFAULT; - - if (len < sizeof(int)) - return -EINVAL; - if (len > sizeof(int)) len = sizeof(int); - - if (copy_to_user(optval, &canraw_sk(sk)->loopback, len)) - return -EFAULT; - - if (put_user(len, optlen)) - return -EFAULT; - + val = &ro->loopback; break; case CAN_RAW_RECV_OWN_MSGS: - if (get_user(len, optlen)) - return -EFAULT; - - if (len < sizeof(int)) - return -EINVAL; - if (len > sizeof(int)) len = sizeof(int); - - if (copy_to_user(optval, &canraw_sk(sk)->recv_own_msgs, len)) - return -EFAULT; - - if (put_user(len, optlen)) - return -EFAULT; - + val = &ro->recv_own_msgs; break; default: return -ENOPROTOOPT; } - return 0; -} - -static void raw_add_filters(struct net_device *dev, struct sock *sk) -{ - struct can_filter *filter = canraw_sk(sk)->filter; - int i; - for (i = 0; i < canraw_sk(sk)->count; i++) { - can_rx_register(dev, filter[i].can_id, filter[i].can_mask, - raw_rcv, sk, IDENT); - DBG("filter can_id %08X, can_mask %08X%s, sk %p\n", - filter[i].can_id, filter[i].can_mask, - filter[i].can_id & CAN_INV_FILTER ? " (inv)" : "", sk); - } -} - -static void raw_remove_filters(struct net_device *dev, struct sock *sk) -{ - struct can_filter *filter = canraw_sk(sk)->filter; - int i; - - for (i = 0; i < canraw_sk(sk)->count; i++) { - can_rx_unregister(dev, filter[i].can_id, filter[i].can_mask, - raw_rcv, sk); - DBG("filter can_id %08X, can_mask %08X%s, sk %p\n", - filter[i].can_id, filter[i].can_mask, - filter[i].can_id & CAN_INV_FILTER ? " (inv)" : "", sk); - } + if (put_user(len, optlen)) + return -EFAULT; + if (copy_to_user(optval, val, len)) + return -EFAULT; + return 0; } static int raw_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t size) { struct sock *sk = sock->sk; + struct raw_sock *ro = raw_sk(sk); struct sk_buff *skb; struct net_device *dev; int ifindex; int err; - DBG("socket %p, sk %p\n", sock, sk); - if (msg->msg_name) { - struct sockaddr_can *addr = (struct sockaddr_can *)msg->msg_name; + struct sockaddr_can *addr = + (struct sockaddr_can *)msg->msg_name; + + if (msg->msg_namelen < sizeof(*addr)) + return -EINVAL; + if (addr->can_family != AF_CAN) return -EINVAL; + ifindex = addr->can_ifindex; } else - ifindex = canraw_sk(sk)->ifindex; + ifindex = ro->ifindex; + + if (size != sizeof(struct can_frame)) + return -EINVAL; - if (!(dev = dev_get_by_index(ifindex))) { - DBG("device %d not found\n", ifindex); + dev = dev_get_by_index(&init_net, ifindex); + if (!dev) return -ENXIO; - } - skb = alloc_skb(size, GFP_KERNEL); - if ((err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size)) < 0) { - kfree_skb(skb); - dev_put(dev); - return err; - } + skb = sock_alloc_send_skb(sk, size, msg->msg_flags & MSG_DONTWAIT, + &err); + if (!skb) + goto put_dev; + + err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size); + if (err < 0) + goto free_skb; skb->dev = dev; skb->sk = sk; - DBG("sending skbuff to interface %d\n", ifindex); - DBG_SKB(skb); - - err = can_send(skb, canraw_sk(sk)->loopback); + err = can_send(skb, ro->loopback); dev_put(dev); if (err) - return err; + goto send_failed; return size; + +free_skb: + kfree_skb(skb); +put_dev: + dev_put(dev); +send_failed: + return err; } static int raw_recvmsg(struct kiocb *iocb, struct socket *sock, @@ -629,27 +743,25 @@ static int raw_recvmsg(struct kiocb *iocb, struct socket *sock, { struct sock *sk = sock->sk; struct sk_buff *skb; - int error = 0; + int err = 0; int noblock; - DBG("socket %p, sk %p\n", sock, sk); - noblock = flags & MSG_DONTWAIT; flags &= ~MSG_DONTWAIT; - if (!(skb = skb_recv_datagram(sk, flags, noblock, &error))) { - return error; - } - DBG("delivering skbuff %p\n", skb); - DBG_SKB(skb); + skb = skb_recv_datagram(sk, flags, noblock, &err); + if (!skb) + return err; if (size < skb->len) msg->msg_flags |= MSG_TRUNC; else size = skb->len; - if ((error = memcpy_toiovec(msg->msg_iov, skb->data, size)) < 0) { + + err = memcpy_toiovec(msg->msg_iov, skb->data, size); + if (err < 0) { skb_free_datagram(sk, skb); - return error; + return err; } sock_recv_timestamp(msg, sk, skb); @@ -659,59 +771,93 @@ static int raw_recvmsg(struct kiocb *iocb, struct socket *sock, memcpy(msg->msg_name, skb->cb, msg->msg_namelen); } - DBG("freeing sock %p, skbuff %p\n", sk, skb); + /* assign the flags that have been recorded in raw_rcv() */ + msg->msg_flags |= *(raw_flags(skb)); + skb_free_datagram(sk, skb); return size; } -static void raw_rcv(struct sk_buff *skb, void *data) -{ - struct sock *sk = (struct sock*)data; - struct sockaddr_can *addr; - int error; +static const struct proto_ops raw_ops = { + .family = PF_CAN, + .release = raw_release, + .bind = raw_bind, + .connect = sock_no_connect, + .socketpair = sock_no_socketpair, + .accept = sock_no_accept, + .getname = raw_getname, + .poll = datagram_poll, + .ioctl = can_ioctl, /* use can_ioctl() from af_can.c */ + .listen = sock_no_listen, + .shutdown = sock_no_shutdown, + .setsockopt = raw_setsockopt, + .getsockopt = raw_getsockopt, + .sendmsg = raw_sendmsg, + .recvmsg = raw_recvmsg, + .mmap = sock_no_mmap, + .sendpage = sock_no_sendpage, +}; - DBG("received skbuff %p, sk %p\n", skb, sk); - DBG_SKB(skb); - if (!canraw_sk(sk)->recv_own_msgs) { - if (*(struct sock **)skb->cb == sk) { /* tx sock reference */ - DBG("trashed own tx msg\n"); - kfree_skb(skb); - return; - } - } +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33) +static struct proto raw_proto __read_mostly = { + .name = "CAN_RAW", + .owner = THIS_MODULE, + .obj_size = sizeof(struct raw_sock), + .init = raw_init, +}; - addr = (struct sockaddr_can *)skb->cb; - memset(addr, 0, sizeof(*addr)); - addr->can_family = AF_CAN; - addr->can_ifindex = skb->dev->ifindex; +static const struct can_proto raw_can_proto = { + .type = SOCK_RAW, + .protocol = CAN_RAW, + .ops = &raw_ops, + .prot = &raw_proto, +}; +#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12) +static struct proto raw_proto __read_mostly = { + .name = "CAN_RAW", + .owner = THIS_MODULE, + .obj_size = sizeof(struct raw_sock), + .init = raw_init, +}; - if ((error = sock_queue_rcv_skb(sk, skb)) < 0) { - DBG("sock_queue_rcv_skb failed: %d\n", error); - DBG("freeing skbuff %p\n", skb); - kfree_skb(skb); - } -} +static struct can_proto raw_can_proto __read_mostly = { + .type = SOCK_RAW, + .protocol = CAN_RAW, + .capability = -1, + .ops = &raw_ops, + .prot = &raw_proto, +}; +#else +static struct can_proto raw_can_proto __read_mostly = { + .type = SOCK_RAW, + .protocol = CAN_RAW, + .capability = -1, + .ops = &raw_ops, + .owner = THIS_MODULE, + .obj_size = sizeof(struct raw_sock), + .init = raw_init, +}; +#endif -static void raw_notifier(unsigned long msg, void *data) +static __init int raw_module_init(void) { - struct sock *sk = (struct sock *)data; + int err; + + printk(banner); - DBG("called for sock %p\n", sk); + err = can_proto_register(&raw_can_proto); + if (err < 0) + printk(KERN_ERR "can: registration of raw protocol failed\n"); - switch (msg) { - case NETDEV_UNREGISTER: - canraw_sk(sk)->ifindex = 0; - canraw_sk(sk)->bound = 0; - /* fallthrough */ - case NETDEV_DOWN: - sk->sk_err = ENETDOWN; - sk->sk_error_report(sk); - break; - } + return err; } +static __exit void raw_module_exit(void) +{ + can_proto_unregister(&raw_can_proto); +} module_init(raw_module_init); module_exit(raw_module_exit);