X-Git-Url: http://rtime.felk.cvut.cz/gitweb/socketcan-devel.git/blobdiff_plain/bc99196be46864dde7bbc681ac572ce227113259..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 5361b5c..b874bce 100644 --- a/kernel/2.6/net/can/raw.c +++ b/kernel/2.6/net/can/raw.c @@ -8,8 +8,7 @@ * 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. @@ -45,39 +44,34 @@ #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 /* for RCSID. Removed by mkpatch script */ +#include /* for RCSID. Removed by mkpatch script */ RCSID("$Id$"); -#define IDENT "raw" #define CAN_RAW_VERSION CAN_VERSION static __initdata const char banner[] = - KERN_INFO "can: raw protocol # rev " CAN_RAW_VERSION "\n"; + KERN_INFO "can: raw protocol (rev " CAN_RAW_VERSION ")\n"; MODULE_DESCRIPTION("PF_CAN raw protocol"); MODULE_LICENSE("Dual BSD/GPL"); MODULE_AUTHOR("Urs Thuermann "); - -#ifdef CONFIG_CAN_DEBUG_CORE -static int debug = 0; -module_param(debug, int, S_IRUGO); -MODULE_PARM_DESC(debug, "debug print mask: 1:debug, 2:frames, 4:skbs"); -#endif - -#ifdef CONFIG_CAN_RAW_USER -#define RAW_CAP (-1) -#else -#define RAW_CAP CAP_NET_RAW -#endif +MODULE_ALIAS("can-proto-1"); #define MASK_ALL 0 @@ -91,125 +85,232 @@ MODULE_PARM_DESC(debug, "debug print mask: 1:debug, 2:frames, 4:skbs"); * 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 */ struct can_filter *filter; /* pointer to filter(s) */ can_err_mask_t err_mask; - spinlock_t lock; }; -#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12) -struct raw_sock { - struct sock sk; - struct raw_opt opt; -}; - -static inline struct raw_opt *raw_sk(const struct sock *sk) -{ - return &((struct raw_sock *)sk)->opt; -} -#else -static inline struct raw_opt *raw_sk(const struct sock *sk) +/* + * 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) { - return (struct raw_opt *)sk->sk_protinfo; + 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]); } -#endif -static void raw_notifier(unsigned long msg, void *data) +static inline struct raw_sock *raw_sk(const struct sock *sk) { - struct sock *sk = (struct sock *)data; - struct raw_opt *ro = raw_sk(sk); - - DBG("called for sock %p\n", sk); - - switch (msg) { - - case NETDEV_UNREGISTER: - spin_lock(&ro->lock); - ro->ifindex = 0; - ro->bound = 0; - spin_unlock(&ro->lock); - /* fallthrough */ - case NETDEV_DOWN: - sk->sk_err = ENETDOWN; - if (!sock_flag(sk, SOCK_DEAD)) - sk->sk_error_report(sk); - break; - } +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12) + return (struct raw_sock *)sk; +#else + return (struct raw_sock *)sk->sk_protinfo; +#endif } -static void raw_rcv(struct sk_buff *skb, void *data) +static void raw_rcv(struct sk_buff *oskb, void *data) { - struct sock *sk = (struct sock*)data; - struct raw_opt *ro = raw_sk(sk); + struct sock *sk = (struct sock *)data; + struct raw_sock *ro = raw_sk(sk); struct sockaddr_can *addr; - int error; + struct sk_buff *skb; + unsigned int *pflags; - DBG("received skbuff %p, sk %p\n", skb, sk); - DBG_SKB(skb); + /* check the received tx sock reference */ + if (!ro->recv_own_msgs && oskb->sk == sk) + return; - if (!ro->recv_own_msgs) { - /* check the received tx sock reference */ - if (*(struct sock **)skb->cb == sk) { - DBG("trashed own tx msg\n"); - kfree_skb(skb); - return; - } - } + /* clone the given skb to be able to enqueue it into the rcv queue */ + skb = skb_clone(oskb, GFP_ATOMIC); + if (!skb) + return; + + /* + * 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. + */ + 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; - error = sock_queue_rcv_skb(sk, skb); - if (error < 0) { - DBG("sock_queue_rcv_skb failed: %d\n", error); - DBG("freeing skbuff %p\n", skb); + /* 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; + + if (sock_queue_rcv_skb(sk, skb) < 0) kfree_skb(skb); - } } -static void raw_add_filters(struct net_device *dev, struct sock *sk) +static int raw_enable_filters(struct net_device *dev, struct sock *sk, + struct can_filter *filter, int count) { - struct raw_opt *ro = raw_sk(sk); - struct can_filter *filter = ro->filter; + int err = 0; int i; - for (i = 0; i < ro->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); + 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; + } } + + return err; +} + +static int raw_enable_errfilter(struct net_device *dev, struct sock *sk, + can_err_mask_t err_mask) +{ + int err = 0; + + if (err_mask) + err = can_rx_register(dev, 0, err_mask | CAN_ERR_FLAG, + raw_rcv, sk, "raw"); + + return err; } -static void raw_remove_filters(struct net_device *dev, struct sock *sk) +static void raw_disable_filters(struct net_device *dev, struct sock *sk, + struct can_filter *filter, int count) { - struct raw_opt *ro = raw_sk(sk); - struct can_filter *filter = ro->filter; int i; - for (i = 0; i < ro->count; i++) { + for (i = 0; i < 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); +} + +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) { - struct raw_opt *ro = raw_sk(sk); + 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 */ ro->dfilter.can_id = 0; @@ -221,7 +322,10 @@ static int raw_init(struct sock *sk) ro->loopback = 1; ro->recv_own_msgs = 0; - spin_lock_init(&ro->lock); + /* set notifier */ + ro->notifier.notifier_call = raw_notifier; + + register_netdevice_notifier(&ro->notifier); return 0; } @@ -229,34 +333,42 @@ static int raw_init(struct sock *sk) static int raw_release(struct socket *sock) { struct sock *sk = sock->sk; - struct raw_opt *ro = raw_sk(sk); - struct net_device *dev = NULL; + struct raw_sock *ro; + + if (!sk) + return 0; - DBG("socket %p, sk %p, refcnt %d\n", sock, sk, - atomic_read(&sk->sk_refcnt)); + ro = raw_sk(sk); - spin_lock(&ro->lock); - if (ro->bound && ro->ifindex) - dev = dev_get_by_index(ro->ifindex); - spin_unlock(&ro->lock); + unregister_netdevice_notifier(&ro->notifier); + + lock_sock(sk); /* remove current filters & unregister */ - if (ro->bound) - raw_remove_filters(dev, sk); + 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); - /* remove current error mask */ - if (ro->err_mask && ro->bound) - can_rx_unregister(dev, 0, ro->err_mask | CAN_ERR_FLAG, - raw_rcv, sk); + ro->ifindex = 0; + ro->bound = 0; + ro->count = 0; - if (dev) { - can_dev_unregister(dev, raw_notifier, sk); - dev_put(dev); - } + sock_orphan(sk); + sock->sk = NULL; + release_sock(sk); sock_put(sk); return 0; @@ -266,82 +378,73 @@ 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 raw_opt *ro = raw_sk(sk); - struct net_device *dev; + struct raw_sock *ro = raw_sk(sk); + int ifindex; int err = 0; - - DBG("socket %p to device %d\n", sock, addr->can_ifindex); + int notify_enetdown = 0; if (len < sizeof(*addr)) return -EINVAL; lock_sock(sk); - spin_lock(&ro->lock); - - if (ro->bound) { - /* remove current bindings / notifier */ - if (ro->ifindex) { - dev = dev_get_by_index(ro->ifindex); - if (!dev) { - DBG("could not find device %d\n", - addr->can_ifindex); - err = -ENODEV; - goto out; - } - if (!(dev->flags & IFF_UP)) { - sk->sk_err = ENETDOWN; - if (!sock_flag(sk, SOCK_DEAD)) - 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); - if (dev) - dev_put(dev); - - ro->bound = 0; - } + 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); err = -ENODEV; goto out; } - if (!(dev->flags & IFF_UP)) { - sk->sk_err = ENETDOWN; - if (!sock_flag(sk, SOCK_DEAD)) - 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; - ro->ifindex = addr->can_ifindex; + ifindex = dev->ifindex; - /* filters set by default/setsockopt */ - raw_add_filters(dev, sk); + /* filters set by default/setsockopt */ + err = raw_enable_allfilters(dev, sk); + dev_put(dev); + } else { + ifindex = 0; - /* error frame filter set by setsockopt */ - if (ro->err_mask) - can_rx_register(dev, 0, ro->err_mask | CAN_ERR_FLAG, - raw_rcv, sk, IDENT); + /* filters set by default/setsockopt */ + err = raw_enable_allfilters(NULL, sk); + } - ro->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: - spin_unlock(&ro->lock); release_sock(sk); - if (dev) - dev_put(dev); + if (notify_enetdown) { + sk->sk_err = ENETDOWN; + if (!sock_flag(sk, SOCK_DEAD)) + sk->sk_error_report(sk); + } return err; } @@ -351,40 +454,35 @@ 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_opt *ro = raw_sk(sk); + struct raw_sock *ro = raw_sk(sk); if (peer) return -EOPNOTSUPP; addr->can_family = AF_CAN; 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 raw_opt *ro = raw_sk(sk); + 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; @@ -405,43 +503,51 @@ static int raw_setsockopt(struct socket *sock, int level, int optname, if (!filter) return -ENOMEM; - err = copy_from_user(filter, optval, optlen); - if (err) { + if (copy_from_user(filter, optval, optlen)) { kfree(filter); - return err; + return -EFAULT; } } else if (count == 1) { - err = copy_from_user(&sfilter, optval, optlen); - if (err) - return err; + if (copy_from_user(&sfilter, optval, sizeof(sfilter))) + return -EFAULT; } lock_sock(sk); - spin_lock(&ro->lock); if (ro->bound && ro->ifindex) - dev = dev_get_by_index(ro->ifindex); - spin_unlock(&ro->lock); + 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 (ro->bound) - raw_remove_filters(dev, sk); + /* remove old filter registrations */ + raw_disable_filters(dev, sk, ro->filter, ro->count); + } + /* 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; } - - /* add new filters & register */ ro->filter = filter; ro->count = count; - if (ro->bound) - raw_add_filters(dev, sk); + out_fil: if (dev) dev_put(dev); @@ -453,38 +559,45 @@ static int raw_setsockopt(struct socket *sock, int level, int optname, if (optlen != sizeof(err_mask)) return -EINVAL; - err = copy_from_user(&err_mask, optval, optlen); - if (err) - return err; + if (copy_from_user(&err_mask, optval, optlen)) + return -EFAULT; err_mask &= CAN_ERR_MASK; + lock_sock(sk); + if (ro->bound && ro->ifindex) - dev = dev_get_by_index(ro->ifindex); + dev = dev_get_by_index(&init_net, ro->ifindex); /* remove current error mask */ - if (ro->err_mask && ro->bound) - can_rx_unregister(dev, 0, ro->err_mask | CAN_ERR_FLAG, - raw_rcv, sk); + 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); + } - /* add new error mask */ + /* link new err_mask to the socket */ ro->err_mask = err_mask; - if (ro->err_mask && ro->bound) - can_rx_register(dev, 0, ro->err_mask | CAN_ERR_FLAG, - raw_rcv, sk, IDENT); + out_err: if (dev) dev_put(dev); + release_sock(sk); + break; case CAN_RAW_LOOPBACK: if (optlen != sizeof(ro->loopback)) return -EINVAL; - err = copy_from_user(&ro->loopback, optval, optlen); - if (err) - return err; + if (copy_from_user(&ro->loopback, optval, optlen)) + return -EFAULT; break; @@ -492,27 +605,25 @@ static int raw_setsockopt(struct socket *sock, int level, int optname, if (optlen != sizeof(ro->recv_own_msgs)) return -EINVAL; - err = copy_from_user(&ro->recv_own_msgs, optval, optlen); - if (err) - return err; + 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 raw_opt *ro = raw_sk(sk); - struct can_filter *filter = ro->filter; - int count = ro->count; + struct raw_sock *ro = raw_sk(sk); int len; - void *val = NULL; + void *val; + int err = 0; if (level != SOL_CAN_RAW) return -EINVAL; @@ -524,14 +635,20 @@ static int raw_getsockopt(struct socket *sock, int level, int optname, switch (optname) { case CAN_RAW_FILTER: - if (count && filter) { - int filter_size = count * sizeof(struct can_filter); - if (len > filter_size) - len = filter_size; - val = 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; - break; + release_sock(sk); + + if (!err) + err = put_user(len, optlen); + return err; case CAN_RAW_ERR_FILTER: if (len > sizeof(can_err_mask_t)) @@ -566,18 +683,19 @@ static int raw_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t size) { struct sock *sk = sock->sk; - struct raw_opt *ro = raw_sk(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; + if (msg->msg_namelen < sizeof(*addr)) + return -EINVAL; + if (addr->can_family != AF_CAN) return -EINVAL; @@ -585,38 +703,39 @@ static int raw_sendmsg(struct kiocb *iocb, struct socket *sock, } else ifindex = ro->ifindex; - dev = dev_get_by_index(ifindex); - if (!dev) { - DBG("device %d not found\n", ifindex); + if (size != sizeof(struct can_frame)) + return -EINVAL; + + dev = dev_get_by_index(&init_net, ifindex); + if (!dev) return -ENXIO; - } - skb = alloc_skb(size, GFP_KERNEL); - if (!skb) { - dev_put(dev); - return -ENOMEM; - } + 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) { - kfree_skb(skb); - dev_put(dev); - return err; - } + 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, 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, @@ -624,30 +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; - skb = skb_recv_datagram(sk, flags, noblock, &error); + skb = skb_recv_datagram(sk, flags, noblock, &err); if (!skb) - return error; - - DBG("delivering skbuff %p\n", skb); - DBG_SKB(skb); + return err; if (size < skb->len) msg->msg_flags |= MSG_TRUNC; else size = skb->len; - error = memcpy_toiovec(msg->msg_iov, skb->data, size); - if (error < 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); @@ -657,13 +771,15 @@ 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 struct proto_ops raw_ops = { +static const struct proto_ops raw_ops = { .family = PF_CAN, .release = raw_release, .bind = raw_bind, @@ -671,8 +787,8 @@ static struct proto_ops raw_ops = { .socketpair = sock_no_socketpair, .accept = sock_no_accept, .getname = raw_getname, - .poll = raw_poll, - .ioctl = NULL, /* use can_ioctl() from af_can.c */ + .poll = datagram_poll, + .ioctl = can_ioctl, /* use can_ioctl() from af_can.c */ .listen = sock_no_listen, .shutdown = sock_no_shutdown, .setsockopt = raw_setsockopt, @@ -683,39 +799,59 @@ static struct proto_ops raw_ops = { .sendpage = sock_no_sendpage, }; -#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12) -static struct proto raw_proto = { + +#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, +}; + +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, }; -static struct can_proto raw_can_proto = { +static struct can_proto raw_can_proto __read_mostly = { .type = SOCK_RAW, .protocol = CAN_RAW, - .capability = RAW_CAP, + .capability = -1, .ops = &raw_ops, .prot = &raw_proto, }; #else -static struct can_proto raw_can_proto = { +static struct can_proto raw_can_proto __read_mostly = { .type = SOCK_RAW, .protocol = CAN_RAW, - .capability = RAW_CAP, + .capability = -1, .ops = &raw_ops, .owner = THIS_MODULE, - .obj_size = sizeof(struct raw_opt), + .obj_size = sizeof(struct raw_sock), .init = raw_init, }; #endif static __init int raw_module_init(void) { + int err; + printk(banner); - can_proto_register(&raw_can_proto); - return 0; + err = can_proto_register(&raw_can_proto); + if (err < 0) + printk(KERN_ERR "can: registration of raw protocol failed\n"); + + return err; } static __exit void raw_module_exit(void)