1136 lines · 26.4 KB · C
RawDownload
// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)/* raw.c - Raw sockets for protocol family CAN * * 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 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. * 3. Neither the name of Volkswagen nor the names of its contributors *    may be used to endorse or promote products derived from this software *    without specific prior written permission. * * 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, 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. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * */ #include <linux/module.h>#include <linux/init.h>#include <linux/uio.h>#include <linux/net.h>#include <linux/slab.h>#include <linux/netdevice.h>#include <linux/socket.h>#include <linux/if_arp.h>#include <linux/skbuff.h>#include <linux/can.h>#include <linux/can/can-ml.h>#include <linux/can/core.h>#include <linux/can/skb.h>#include <linux/can/raw.h>#include <net/can.h>#include <net/sock.h>#include <net/net_namespace.h> MODULE_DESCRIPTION("PF_CAN raw protocol");MODULE_LICENSE("Dual BSD/GPL");MODULE_AUTHOR("Urs Thuermann <urs.thuermann@volkswagen.de>");MODULE_ALIAS("can-proto-1"); #define RAW_MIN_NAMELEN CAN_REQUIRED_SIZE(struct sockaddr_can, can_ifindex) #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 uniqframe {	const struct sk_buff *skb;	u32 hash;	unsigned int join_rx_count;}; struct raw_sock {	struct sock sk;	struct net_device *dev;	netdevice_tracker dev_tracker;	struct list_head notifier;	int ifindex;	unsigned int bound:1;	unsigned int loopback:1;	unsigned int recv_own_msgs:1;	unsigned int fd_frames:1;	unsigned int xl_frames:1;	unsigned int join_filters:1;	struct can_raw_vcid_options raw_vcid_opts;	canid_t tx_vcid_shifted;	canid_t rx_vcid_shifted;	canid_t rx_vcid_mask_shifted;	can_err_mask_t err_mask;	int count;                 /* number of active filters */	struct can_filter dfilter; /* default/single filter */	struct can_filter *filter; /* pointer to filter(s) */	struct uniqframe __percpu *uniq;}; static LIST_HEAD(raw_notifier_list);static DEFINE_SPINLOCK(raw_notifier_lock);static struct raw_sock *raw_busy_notifier; /* 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){	sock_skb_cb_check_size(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){	return (struct raw_sock *)sk;} static void raw_rcv(struct sk_buff *oskb, void *data){	struct sock *sk = (struct sock *)data;	struct raw_sock *ro = raw_sk(sk);	enum skb_drop_reason reason;	struct sockaddr_can *addr;	struct sk_buff *skb;	unsigned int *pflags; 	/* check the received tx sock reference */	if (!ro->recv_own_msgs && oskb->sk == sk)		return; 	/* make sure to not pass oversized frames to the socket */	if (!ro->fd_frames && can_is_canfd_skb(oskb))		return; 	if (can_is_canxl_skb(oskb)) {		struct canxl_frame *cxl = (struct canxl_frame *)oskb->data; 		/* make sure to not pass oversized frames to the socket */		if (!ro->xl_frames)			return; 		/* filter CAN XL VCID content */		if (ro->raw_vcid_opts.flags & CAN_RAW_XL_VCID_RX_FILTER) {			/* apply VCID filter if user enabled the filter */			if ((cxl->prio & ro->rx_vcid_mask_shifted) !=			    (ro->rx_vcid_shifted & ro->rx_vcid_mask_shifted))				return;		} else {			/* no filter => do not forward VCID tagged frames */			if (cxl->prio & CANXL_VCID_MASK)				return;		}	} 	/* eliminate multiple filter matches for the same skb */	if (this_cpu_ptr(ro->uniq)->skb == oskb &&	    this_cpu_ptr(ro->uniq)->hash == oskb->hash) {		if (!ro->join_filters)			return; 		this_cpu_inc(ro->uniq->join_rx_count);		/* drop frame until all enabled filters matched */		if (this_cpu_ptr(ro->uniq)->join_rx_count < ro->count)			return;	} else {		this_cpu_ptr(ro->uniq)->skb = oskb;		this_cpu_ptr(ro->uniq)->hash = oskb->hash;		this_cpu_ptr(ro->uniq)->join_rx_count = 1;		/* drop first frame to check all enabled filters? */		if (ro->join_filters && ro->count > 1)			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.	 */ 	sock_skb_cb_check_size(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; 	/* 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; 	reason = sock_queue_rcv_skb_reason(sk, skb);	if (reason)		sk_skb_reason_drop(sk, skb, reason);} static int raw_enable_filters(struct net *net, struct net_device *dev,			      struct sock *sk, struct can_filter *filter,			      int count){	int err = 0;	int i; 	for (i = 0; i < count; i++) {		err = can_rx_register(net, dev, filter[i].can_id,				      filter[i].can_mask,				      raw_rcv, sk, "raw", sk);		if (err) {			/* clean up successfully registered filters */			while (--i >= 0)				can_rx_unregister(net, dev, filter[i].can_id,						  filter[i].can_mask,						  raw_rcv, sk);			break;		}	} 	return err;} static int raw_enable_errfilter(struct net *net, struct net_device *dev,				struct sock *sk, can_err_mask_t err_mask){	int err = 0; 	if (err_mask)		err = can_rx_register(net, dev, 0, err_mask | CAN_ERR_FLAG,				      raw_rcv, sk, "raw", sk); 	return err;} static void raw_disable_filters(struct net *net, struct net_device *dev,				struct sock *sk, struct can_filter *filter,				int count){	int i; 	for (i = 0; i < count; i++)		can_rx_unregister(net, dev, filter[i].can_id,				  filter[i].can_mask, raw_rcv, sk);} static inline void raw_disable_errfilter(struct net *net,					 struct net_device *dev,					 struct sock *sk,					 can_err_mask_t err_mask) {	if (err_mask)		can_rx_unregister(net, dev, 0, err_mask | CAN_ERR_FLAG,				  raw_rcv, sk);} static inline void raw_disable_allfilters(struct net *net,					  struct net_device *dev,					  struct sock *sk){	struct raw_sock *ro = raw_sk(sk); 	raw_disable_filters(net, dev, sk, ro->filter, ro->count);	raw_disable_errfilter(net, dev, sk, ro->err_mask);} static int raw_enable_allfilters(struct net *net, struct net_device *dev,				 struct sock *sk){	struct raw_sock *ro = raw_sk(sk);	int err; 	err = raw_enable_filters(net, dev, sk, ro->filter, ro->count);	if (!err) {		err = raw_enable_errfilter(net, dev, sk, ro->err_mask);		if (err)			raw_disable_filters(net, dev, sk, ro->filter,					    ro->count);	} 	return err;} static void raw_notify(struct raw_sock *ro, unsigned long msg,		       struct net_device *dev){	struct sock *sk = &ro->sk; 	if (!net_eq(dev_net(dev), sock_net(sk)))		return; 	if (ro->dev != dev)		return; 	switch (msg) {	case NETDEV_UNREGISTER:		lock_sock(sk);		/* remove current filters & unregister */		if (ro->bound) {			raw_disable_allfilters(dev_net(dev), dev, sk);			netdev_put(dev, &ro->dev_tracker);		} 		if (ro->count > 1)			kfree(ro->filter); 		ro->ifindex = 0;		ro->bound = 0;		ro->dev = NULL;		ro->count = 0;		release_sock(sk); 		sk->sk_err = ENODEV;		if (!sock_flag(sk, SOCK_DEAD))			sk_error_report(sk);		break; 	case NETDEV_DOWN:		sk->sk_err = ENETDOWN;		if (!sock_flag(sk, SOCK_DEAD))			sk_error_report(sk);		break;	}} static int raw_notifier(struct notifier_block *nb, unsigned long msg,			void *ptr){	struct net_device *dev = netdev_notifier_info_to_dev(ptr); 	if (dev->type != ARPHRD_CAN)		return NOTIFY_DONE;	if (msg != NETDEV_UNREGISTER && msg != NETDEV_DOWN)		return NOTIFY_DONE;	if (unlikely(raw_busy_notifier)) /* Check for reentrant bug. */		return NOTIFY_DONE; 	spin_lock(&raw_notifier_lock);	list_for_each_entry(raw_busy_notifier, &raw_notifier_list, notifier) {		spin_unlock(&raw_notifier_lock);		raw_notify(raw_busy_notifier, msg, dev);		spin_lock(&raw_notifier_lock);	}	raw_busy_notifier = NULL;	spin_unlock(&raw_notifier_lock);	return NOTIFY_DONE;} static void raw_sock_destruct(struct sock *sk){	struct raw_sock *ro = raw_sk(sk); 	free_percpu(ro->uniq);	can_sock_destruct(sk);} static int raw_init(struct sock *sk){	struct raw_sock *ro = raw_sk(sk); 	ro->bound            = 0;	ro->ifindex          = 0;	ro->dev              = NULL; 	/* set default filter to single entry dfilter */	ro->dfilter.can_id   = 0;	ro->dfilter.can_mask = MASK_ALL;	ro->filter           = &ro->dfilter;	ro->count            = 1; 	/* set default loopback behaviour */	ro->loopback         = 1;	ro->recv_own_msgs    = 0;	ro->fd_frames        = 0;	ro->xl_frames        = 0;	ro->join_filters     = 0; 	/* alloc_percpu provides zero'ed memory */	ro->uniq = alloc_percpu(struct uniqframe);	if (unlikely(!ro->uniq))		return -ENOMEM; 	sk->sk_destruct = raw_sock_destruct; 	/* set notifier */	spin_lock(&raw_notifier_lock);	list_add_tail(&ro->notifier, &raw_notifier_list);	spin_unlock(&raw_notifier_lock); 	return 0;} static int raw_release(struct socket *sock){	struct sock *sk = sock->sk;	struct raw_sock *ro;	struct net *net; 	if (!sk)		return 0; 	ro = raw_sk(sk);	net = sock_net(sk); 	spin_lock(&raw_notifier_lock);	while (raw_busy_notifier == ro) {		spin_unlock(&raw_notifier_lock);		schedule_timeout_uninterruptible(1);		spin_lock(&raw_notifier_lock);	}	list_del(&ro->notifier);	spin_unlock(&raw_notifier_lock); 	rtnl_lock();	lock_sock(sk); 	/* remove current filters & unregister */	if (ro->bound) {		if (ro->dev) {			raw_disable_allfilters(dev_net(ro->dev), ro->dev, sk);			netdev_put(ro->dev, &ro->dev_tracker);		} else {			raw_disable_allfilters(net, NULL, sk);		}	} 	if (ro->count > 1)		kfree(ro->filter); 	ro->ifindex = 0;	ro->bound = 0;	ro->dev = NULL;	ro->count = 0; 	sock_orphan(sk);	sock->sk = NULL; 	release_sock(sk);	rtnl_unlock(); 	sock_prot_inuse_add(net, sk->sk_prot, -1);	sock_put(sk); 	return 0;} static int raw_bind(struct socket *sock, struct sockaddr_unsized *uaddr, int len){	struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;	struct sock *sk = sock->sk;	struct raw_sock *ro = raw_sk(sk);	struct net_device *dev = NULL;	int ifindex;	int err = 0;	int notify_enetdown = 0; 	if (len < RAW_MIN_NAMELEN)		return -EINVAL;	if (addr->can_family != AF_CAN)		return -EINVAL; 	rtnl_lock();	lock_sock(sk); 	if (ro->bound && addr->can_ifindex == ro->ifindex)		goto out; 	if (addr->can_ifindex) {		dev = dev_get_by_index(sock_net(sk), addr->can_ifindex);		if (!dev) {			err = -ENODEV;			goto out;		}		if (dev->type != ARPHRD_CAN) {			err = -ENODEV;			goto out_put_dev;		} 		if (!(dev->flags & IFF_UP))			notify_enetdown = 1; 		ifindex = dev->ifindex; 		/* filters set by default/setsockopt */

Lines 1–500 of 1136.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t