raw.c

   1// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
   2/* raw.c - Raw sockets for protocol family CAN
   3 *
   4 * Copyright (c) 2002-2007 Volkswagen Group Electronic Research
   5 * All rights reserved.
   6 *
   7 * Redistribution and use in source and binary forms, with or without
   8 * modification, are permitted provided that the following conditions
   9 * are met:
  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.
  18 *
  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.
  23 *
  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.
  26 *
  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
  38 * DAMAGE.
  39 *
  40 */
  41
  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/can-ml.h>
  53#include <linux/can/core.h>
  54#include <linux/can/skb.h>
  55#include <linux/can/raw.h>
  56#include <net/sock.h>
  57#include <net/net_namespace.h>
  58
  59MODULE_DESCRIPTION("PF_CAN raw protocol");
  60MODULE_LICENSE("Dual BSD/GPL");
  61MODULE_AUTHOR("Urs Thuermann <urs.thuermann@volkswagen.de>");
  62MODULE_ALIAS("can-proto-1");
  63
  64#define RAW_MIN_NAMELEN CAN_REQUIRED_SIZE(struct sockaddr_can, can_ifindex)
  65
  66#define MASK_ALL 0
  67
  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.
  75 */
  76
  77struct uniqframe {
  78	const struct sk_buff *skb;
  79	int skbcnt;
  80	unsigned int join_rx_count;
  81};
  82
  83struct raw_sock {
  84	struct sock sk;
  85	struct net_device *dev;
  86	netdevice_tracker dev_tracker;
  87	struct list_head notifier;
  88	int ifindex;
  89	unsigned int bound:1;
  90	unsigned int loopback:1;
  91	unsigned int recv_own_msgs:1;
  92	unsigned int fd_frames:1;
  93	unsigned int xl_frames:1;
  94	unsigned int join_filters:1;
  95	struct can_raw_vcid_options raw_vcid_opts;
  96	canid_t tx_vcid_shifted;
  97	canid_t rx_vcid_shifted;
  98	canid_t rx_vcid_mask_shifted;
  99	can_err_mask_t err_mask;
 100	int count;                 /* number of active filters */
 101	struct can_filter dfilter; /* default/single filter */
 102	struct can_filter *filter; /* pointer to filter(s) */
 103	struct uniqframe __percpu *uniq;
 104};
 105
 106static LIST_HEAD(raw_notifier_list);
 107static DEFINE_SPINLOCK(raw_notifier_lock);
 108static struct raw_sock *raw_busy_notifier;
 109
 110/* Return pointer to store the extra msg flags for raw_recvmsg().
 111 * We use the space of one unsigned int beyond the 'struct sockaddr_can'
 112 * in skb->cb.
 113 */
 114static inline unsigned int *raw_flags(struct sk_buff *skb)
 115{
 116	sock_skb_cb_check_size(sizeof(struct sockaddr_can) +
 117			       sizeof(unsigned int));
 118
 119	/* return pointer after struct sockaddr_can */
 120	return (unsigned int *)(&((struct sockaddr_can *)skb->cb)[1]);
 121}
 122
 123static inline struct raw_sock *raw_sk(const struct sock *sk)
 124{
 125	return (struct raw_sock *)sk;
 126}
 127
 128static void raw_rcv(struct sk_buff *oskb, void *data)
 129{
 130	struct sock *sk = (struct sock *)data;
 131	struct raw_sock *ro = raw_sk(sk);
 132	enum skb_drop_reason reason;
 133	struct sockaddr_can *addr;
 134	struct sk_buff *skb;
 135	unsigned int *pflags;
 136
 137	/* check the received tx sock reference */
 138	if (!ro->recv_own_msgs && oskb->sk == sk)
 139		return;
 140
 141	/* make sure to not pass oversized frames to the socket */
 142	if (!ro->fd_frames && can_is_canfd_skb(oskb))
 143		return;
 144
 145	if (can_is_canxl_skb(oskb)) {
 146		struct canxl_frame *cxl = (struct canxl_frame *)oskb->data;
 147
 148		/* make sure to not pass oversized frames to the socket */
 149		if (!ro->xl_frames)
 150			return;
 151
 152		/* filter CAN XL VCID content */
 153		if (ro->raw_vcid_opts.flags & CAN_RAW_XL_VCID_RX_FILTER) {
 154			/* apply VCID filter if user enabled the filter */
 155			if ((cxl->prio & ro->rx_vcid_mask_shifted) !=
 156			    (ro->rx_vcid_shifted & ro->rx_vcid_mask_shifted))
 157				return;
 158		} else {
 159			/* no filter => do not forward VCID tagged frames */
 160			if (cxl->prio & CANXL_VCID_MASK)
 161				return;
 162		}
 163	}
 164
 165	/* eliminate multiple filter matches for the same skb */
 166	if (this_cpu_ptr(ro->uniq)->skb == oskb &&
 167	    this_cpu_ptr(ro->uniq)->skbcnt == can_skb_prv(oskb)->skbcnt) {
 168		if (!ro->join_filters)
 169			return;
 170
 171		this_cpu_inc(ro->uniq->join_rx_count);
 172		/* drop frame until all enabled filters matched */
 173		if (this_cpu_ptr(ro->uniq)->join_rx_count < ro->count)
 174			return;
 175	} else {
 176		this_cpu_ptr(ro->uniq)->skb = oskb;
 177		this_cpu_ptr(ro->uniq)->skbcnt = can_skb_prv(oskb)->skbcnt;
 178		this_cpu_ptr(ro->uniq)->join_rx_count = 1;
 179		/* drop first frame to check all enabled filters? */
 180		if (ro->join_filters && ro->count > 1)
 181			return;
 182	}
 183
 184	/* clone the given skb to be able to enqueue it into the rcv queue */
 185	skb = skb_clone(oskb, GFP_ATOMIC);
 186	if (!skb)
 187		return;
 188
 189	/* Put the datagram to the queue so that raw_recvmsg() can get
 190	 * it from there. We need to pass the interface index to
 191	 * raw_recvmsg(). We pass a whole struct sockaddr_can in
 192	 * skb->cb containing the interface index.
 193	 */
 194
 195	sock_skb_cb_check_size(sizeof(struct sockaddr_can));
 196	addr = (struct sockaddr_can *)skb->cb;
 197	memset(addr, 0, sizeof(*addr));
 198	addr->can_family = AF_CAN;
 199	addr->can_ifindex = skb->dev->ifindex;
 200
 201	/* add CAN specific message flags for raw_recvmsg() */
 202	pflags = raw_flags(skb);
 203	*pflags = 0;
 204	if (oskb->sk)
 205		*pflags |= MSG_DONTROUTE;
 206	if (oskb->sk == sk)
 207		*pflags |= MSG_CONFIRM;
 208
 209	if (sock_queue_rcv_skb_reason(sk, skb, &reason) < 0)
 210		sk_skb_reason_drop(sk, skb, reason);
 211}
 212
 213static int raw_enable_filters(struct net *net, struct net_device *dev,
 214			      struct sock *sk, struct can_filter *filter,
 215			      int count)
 216{
 217	int err = 0;
 218	int i;
 219
 220	for (i = 0; i < count; i++) {
 221		err = can_rx_register(net, dev, filter[i].can_id,
 222				      filter[i].can_mask,
 223				      raw_rcv, sk, "raw", sk);
 224		if (err) {
 225			/* clean up successfully registered filters */
 226			while (--i >= 0)
 227				can_rx_unregister(net, dev, filter[i].can_id,
 228						  filter[i].can_mask,
 229						  raw_rcv, sk);
 230			break;
 231		}
 232	}
 233
 234	return err;
 235}
 236
 237static int raw_enable_errfilter(struct net *net, struct net_device *dev,
 238				struct sock *sk, can_err_mask_t err_mask)
 239{
 240	int err = 0;
 241
 242	if (err_mask)
 243		err = can_rx_register(net, dev, 0, err_mask | CAN_ERR_FLAG,
 244				      raw_rcv, sk, "raw", sk);
 245
 246	return err;
 247}
 248
 249static void raw_disable_filters(struct net *net, struct net_device *dev,
 250				struct sock *sk, struct can_filter *filter,
 251				int count)
 252{
 253	int i;
 254
 255	for (i = 0; i < count; i++)
 256		can_rx_unregister(net, dev, filter[i].can_id,
 257				  filter[i].can_mask, raw_rcv, sk);
 258}
 259
 260static inline void raw_disable_errfilter(struct net *net,
 261					 struct net_device *dev,
 262					 struct sock *sk,
 263					 can_err_mask_t err_mask)
 264
 265{
 266	if (err_mask)
 267		can_rx_unregister(net, dev, 0, err_mask | CAN_ERR_FLAG,
 268				  raw_rcv, sk);
 269}
 270
 271static inline void raw_disable_allfilters(struct net *net,
 272					  struct net_device *dev,
 273					  struct sock *sk)
 274{
 275	struct raw_sock *ro = raw_sk(sk);
 276
 277	raw_disable_filters(net, dev, sk, ro->filter, ro->count);
 278	raw_disable_errfilter(net, dev, sk, ro->err_mask);
 279}
 280
 281static int raw_enable_allfilters(struct net *net, struct net_device *dev,
 282				 struct sock *sk)
 283{
 284	struct raw_sock *ro = raw_sk(sk);
 285	int err;
 286
 287	err = raw_enable_filters(net, dev, sk, ro->filter, ro->count);
 288	if (!err) {
 289		err = raw_enable_errfilter(net, dev, sk, ro->err_mask);
 290		if (err)
 291			raw_disable_filters(net, dev, sk, ro->filter,
 292					    ro->count);
 293	}
 294
 295	return err;
 296}
 297
 298static void raw_notify(struct raw_sock *ro, unsigned long msg,
 299		       struct net_device *dev)
 300{
 301	struct sock *sk = &ro->sk;
 302
 303	if (!net_eq(dev_net(dev), sock_net(sk)))
 304		return;
 305
 306	if (ro->dev != dev)
 307		return;
 308
 309	switch (msg) {
 310	case NETDEV_UNREGISTER:
 311		lock_sock(sk);
 312		/* remove current filters & unregister */
 313		if (ro->bound) {
 314			raw_disable_allfilters(dev_net(dev), dev, sk);
 315			netdev_put(dev, &ro->dev_tracker);
 316		}
 317
 318		if (ro->count > 1)
 319			kfree(ro->filter);
 320
 321		ro->ifindex = 0;
 322		ro->bound = 0;
 323		ro->dev = NULL;
 324		ro->count = 0;
 325		release_sock(sk);
 326
 327		sk->sk_err = ENODEV;
 328		if (!sock_flag(sk, SOCK_DEAD))
 329			sk_error_report(sk);
 330		break;
 331
 332	case NETDEV_DOWN:
 333		sk->sk_err = ENETDOWN;
 334		if (!sock_flag(sk, SOCK_DEAD))
 335			sk_error_report(sk);
 336		break;
 337	}
 338}
 339
 340static int raw_notifier(struct notifier_block *nb, unsigned long msg,
 341			void *ptr)
 342{
 343	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 344
 345	if (dev->type != ARPHRD_CAN)
 346		return NOTIFY_DONE;
 347	if (msg != NETDEV_UNREGISTER && msg != NETDEV_DOWN)
 348		return NOTIFY_DONE;
 349	if (unlikely(raw_busy_notifier)) /* Check for reentrant bug. */
 350		return NOTIFY_DONE;
 351
 352	spin_lock(&raw_notifier_lock);
 353	list_for_each_entry(raw_busy_notifier, &raw_notifier_list, notifier) {
 354		spin_unlock(&raw_notifier_lock);
 355		raw_notify(raw_busy_notifier, msg, dev);
 356		spin_lock(&raw_notifier_lock);
 357	}
 358	raw_busy_notifier = NULL;
 359	spin_unlock(&raw_notifier_lock);
 360	return NOTIFY_DONE;
 361}
 362
 363static void raw_sock_destruct(struct sock *sk)
 364{
 365	struct raw_sock *ro = raw_sk(sk);
 366
 367	free_percpu(ro->uniq);
 368	can_sock_destruct(sk);
 369}
 370
 371static int raw_init(struct sock *sk)
 372{
 373	struct raw_sock *ro = raw_sk(sk);
 374
 375	ro->bound            = 0;
 376	ro->ifindex          = 0;
 377	ro->dev              = NULL;
 378
 379	/* set default filter to single entry dfilter */
 380	ro->dfilter.can_id   = 0;
 381	ro->dfilter.can_mask = MASK_ALL;
 382	ro->filter           = &ro->dfilter;
 383	ro->count            = 1;
 384
 385	/* set default loopback behaviour */
 386	ro->loopback         = 1;
 387	ro->recv_own_msgs    = 0;
 388	ro->fd_frames        = 0;
 389	ro->xl_frames        = 0;
 390	ro->join_filters     = 0;
 391
 392	/* alloc_percpu provides zero'ed memory */
 393	ro->uniq = alloc_percpu(struct uniqframe);
 394	if (unlikely(!ro->uniq))
 395		return -ENOMEM;
 396
 397	sk->sk_destruct = raw_sock_destruct;
 398
 399	/* set notifier */
 400	spin_lock(&raw_notifier_lock);
 401	list_add_tail(&ro->notifier, &raw_notifier_list);
 402	spin_unlock(&raw_notifier_lock);
 403
 404	return 0;
 405}
 406
 407static int raw_release(struct socket *sock)
 408{
 409	struct sock *sk = sock->sk;
 410	struct raw_sock *ro;
 411	struct net *net;
 412
 413	if (!sk)
 414		return 0;
 415
 416	ro = raw_sk(sk);
 417	net = sock_net(sk);
 418
 419	spin_lock(&raw_notifier_lock);
 420	while (raw_busy_notifier == ro) {
 421		spin_unlock(&raw_notifier_lock);
 422		schedule_timeout_uninterruptible(1);
 423		spin_lock(&raw_notifier_lock);
 424	}
 425	list_del(&ro->notifier);
 426	spin_unlock(&raw_notifier_lock);
 427
 428	rtnl_lock();
 429	lock_sock(sk);
 430
 431	/* remove current filters & unregister */
 432	if (ro->bound) {
 433		if (ro->dev) {
 434			raw_disable_allfilters(dev_net(ro->dev), ro->dev, sk);
 435			netdev_put(ro->dev, &ro->dev_tracker);
 436		} else {
 437			raw_disable_allfilters(net, NULL, sk);
 438		}
 439	}
 440
 441	if (ro->count > 1)
 442		kfree(ro->filter);
 443
 444	ro->ifindex = 0;
 445	ro->bound = 0;
 446	ro->dev = NULL;
 447	ro->count = 0;
 448
 449	sock_orphan(sk);
 450	sock->sk = NULL;
 451
 452	release_sock(sk);
 453	rtnl_unlock();
 454
 455	sock_prot_inuse_add(net, sk->sk_prot, -1);
 456	sock_put(sk);
 457
 458	return 0;
 459}
 460
 461static int raw_bind(struct socket *sock, struct sockaddr_unsized *uaddr, int len)
 462{
 463	struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
 464	struct sock *sk = sock->sk;
 465	struct raw_sock *ro = raw_sk(sk);
 466	struct net_device *dev = NULL;
 467	int ifindex;
 468	int err = 0;
 469	int notify_enetdown = 0;
 470
 471	if (len < RAW_MIN_NAMELEN)
 472		return -EINVAL;
 473	if (addr->can_family != AF_CAN)
 474		return -EINVAL;
 475
 476	rtnl_lock();
 477	lock_sock(sk);
 478
 479	if (ro->bound && addr->can_ifindex == ro->ifindex)
 480		goto out;
 481
 482	if (addr->can_ifindex) {
 483		dev = dev_get_by_index(sock_net(sk), addr->can_ifindex);
 484		if (!dev) {
 485			err = -ENODEV;
 486			goto out;
 487		}
 488		if (dev->type != ARPHRD_CAN) {
 489			err = -ENODEV;
 490			goto out_put_dev;
 491		}
 492
 493		if (!(dev->flags & IFF_UP))
 494			notify_enetdown = 1;
 495
 496		ifindex = dev->ifindex;
 497
 498		/* filters set by default/setsockopt */
 499		err = raw_enable_allfilters(sock_net(sk), dev, sk);
 500		if (err)
 501			goto out_put_dev;
 502
 503	} else {
 504		ifindex = 0;
 505
 506		/* filters set by default/setsockopt */
 507		err = raw_enable_allfilters(sock_net(sk), NULL, sk);
 508	}
 509
 510	if (!err) {
 511		if (ro->bound) {
 512			/* unregister old filters */
 513			if (ro->dev) {
 514				raw_disable_allfilters(dev_net(ro->dev),
 515						       ro->dev, sk);
 516				/* drop reference to old ro->dev */
 517				netdev_put(ro->dev, &ro->dev_tracker);
 518			} else {
 519				raw_disable_allfilters(sock_net(sk), NULL, sk);
 520			}
 521		}
 522		ro->ifindex = ifindex;
 523		ro->bound = 1;
 524		/* bind() ok -> hold a reference for new ro->dev */
 525		ro->dev = dev;
 526		if (ro->dev)
 527			netdev_hold(ro->dev, &ro->dev_tracker, GFP_KERNEL);
 528	}
 529
 530out_put_dev:
 531	/* remove potential reference from dev_get_by_index() */
 532	dev_put(dev);
 533out:
 534	release_sock(sk);
 535	rtnl_unlock();
 536
 537	if (notify_enetdown) {
 538		sk->sk_err = ENETDOWN;
 539		if (!sock_flag(sk, SOCK_DEAD))
 540			sk_error_report(sk);
 541	}
 542
 543	return err;
 544}
 545
 546static int raw_getname(struct socket *sock, struct sockaddr *uaddr,
 547		       int peer)
 548{
 549	struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
 550	struct sock *sk = sock->sk;
 551	struct raw_sock *ro = raw_sk(sk);
 552
 553	if (peer)
 554		return -EOPNOTSUPP;
 555
 556	memset(addr, 0, RAW_MIN_NAMELEN);
 557	addr->can_family  = AF_CAN;
 558	addr->can_ifindex = ro->ifindex;
 559
 560	return RAW_MIN_NAMELEN;
 561}
 562
 563static int raw_setsockopt(struct socket *sock, int level, int optname,
 564			  sockptr_t optval, unsigned int optlen)
 565{
 566	struct sock *sk = sock->sk;
 567	struct raw_sock *ro = raw_sk(sk);
 568	struct can_filter *filter = NULL;  /* dyn. alloc'ed filters */
 569	struct can_filter sfilter;         /* single filter */
 570	struct net_device *dev = NULL;
 571	can_err_mask_t err_mask = 0;
 572	int count = 0;
 573	int flag;
 574	int err = 0;
 575
 576	if (level != SOL_CAN_RAW)
 577		return -EINVAL;
 578
 579	switch (optname) {
 580	case CAN_RAW_FILTER:
 581		if (optlen % sizeof(struct can_filter) != 0)
 582			return -EINVAL;
 583
 584		if (optlen > CAN_RAW_FILTER_MAX * sizeof(struct can_filter))
 585			return -EINVAL;
 586
 587		count = optlen / sizeof(struct can_filter);
 588
 589		if (count > 1) {
 590			/* filter does not fit into dfilter => alloc space */
 591			filter = memdup_sockptr(optval, optlen);
 592			if (IS_ERR(filter))
 593				return PTR_ERR(filter);
 594		} else if (count == 1) {
 595			if (copy_from_sockptr(&sfilter, optval, sizeof(sfilter)))
 596				return -EFAULT;
 597		}
 598
 599		rtnl_lock();
 600		lock_sock(sk);
 601
 602		dev = ro->dev;
 603		if (ro->bound && dev) {
 604			if (dev->reg_state != NETREG_REGISTERED) {
 605				if (count > 1)
 606					kfree(filter);
 607				err = -ENODEV;
 608				goto out_fil;
 609			}
 610		}
 611
 612		if (ro->bound) {
 613			/* (try to) register the new filters */
 614			if (count == 1)
 615				err = raw_enable_filters(sock_net(sk), dev, sk,
 616							 &sfilter, 1);
 617			else
 618				err = raw_enable_filters(sock_net(sk), dev, sk,
 619							 filter, count);
 620			if (err) {
 621				if (count > 1)
 622					kfree(filter);
 623				goto out_fil;
 624			}
 625
 626			/* remove old filter registrations */
 627			raw_disable_filters(sock_net(sk), dev, sk, ro->filter,
 628					    ro->count);
 629		}
 630
 631		/* remove old filter space */
 632		if (ro->count > 1)
 633			kfree(ro->filter);
 634
 635		/* link new filters to the socket */
 636		if (count == 1) {
 637			/* copy filter data for single filter */
 638			ro->dfilter = sfilter;
 639			filter = &ro->dfilter;
 640		}
 641		ro->filter = filter;
 642		ro->count  = count;
 643
 644 out_fil:
 645		release_sock(sk);
 646		rtnl_unlock();
 647
 648		break;
 649
 650	case CAN_RAW_ERR_FILTER:
 651		if (optlen != sizeof(err_mask))
 652			return -EINVAL;
 653
 654		if (copy_from_sockptr(&err_mask, optval, optlen))
 655			return -EFAULT;
 656
 657		err_mask &= CAN_ERR_MASK;
 658
 659		rtnl_lock();
 660		lock_sock(sk);
 661
 662		dev = ro->dev;
 663		if (ro->bound && dev) {
 664			if (dev->reg_state != NETREG_REGISTERED) {
 665				err = -ENODEV;
 666				goto out_err;
 667			}
 668		}
 669
 670		/* remove current error mask */
 671		if (ro->bound) {
 672			/* (try to) register the new err_mask */
 673			err = raw_enable_errfilter(sock_net(sk), dev, sk,
 674						   err_mask);
 675
 676			if (err)
 677				goto out_err;
 678
 679			/* remove old err_mask registration */
 680			raw_disable_errfilter(sock_net(sk), dev, sk,
 681					      ro->err_mask);
 682		}
 683
 684		/* link new err_mask to the socket */
 685		ro->err_mask = err_mask;
 686
 687 out_err:
 688		release_sock(sk);
 689		rtnl_unlock();
 690
 691		break;
 692
 693	case CAN_RAW_LOOPBACK:
 694		if (optlen != sizeof(flag))
 695			return -EINVAL;
 696
 697		if (copy_from_sockptr(&flag, optval, optlen))
 698			return -EFAULT;
 699
 700		ro->loopback = !!flag;
 701		break;
 702
 703	case CAN_RAW_RECV_OWN_MSGS:
 704		if (optlen != sizeof(flag))
 705			return -EINVAL;
 706
 707		if (copy_from_sockptr(&flag, optval, optlen))
 708			return -EFAULT;
 709
 710		ro->recv_own_msgs = !!flag;
 711		break;
 712
 713	case CAN_RAW_FD_FRAMES:
 714		if (optlen != sizeof(flag))
 715			return -EINVAL;
 716
 717		if (copy_from_sockptr(&flag, optval, optlen))
 718			return -EFAULT;
 719
 720		/* Enabling CAN XL includes CAN FD */
 721		if (ro->xl_frames && !flag)
 722			return -EINVAL;
 723
 724		ro->fd_frames = !!flag;
 725		break;
 726
 727	case CAN_RAW_XL_FRAMES:
 728		if (optlen != sizeof(flag))
 729			return -EINVAL;
 730
 731		if (copy_from_sockptr(&flag, optval, optlen))
 732			return -EFAULT;
 733
 734		ro->xl_frames = !!flag;
 735
 736		/* Enabling CAN XL includes CAN FD */
 737		if (ro->xl_frames)
 738			ro->fd_frames = ro->xl_frames;
 739		break;
 740
 741	case CAN_RAW_XL_VCID_OPTS:
 742		if (optlen != sizeof(ro->raw_vcid_opts))
 743			return -EINVAL;
 744
 745		if (copy_from_sockptr(&ro->raw_vcid_opts, optval, optlen))
 746			return -EFAULT;
 747
 748		/* prepare 32 bit values for handling in hot path */
 749		ro->tx_vcid_shifted = ro->raw_vcid_opts.tx_vcid << CANXL_VCID_OFFSET;
 750		ro->rx_vcid_shifted = ro->raw_vcid_opts.rx_vcid << CANXL_VCID_OFFSET;
 751		ro->rx_vcid_mask_shifted = ro->raw_vcid_opts.rx_vcid_mask << CANXL_VCID_OFFSET;
 752		break;
 753
 754	case CAN_RAW_JOIN_FILTERS:
 755		if (optlen != sizeof(flag))
 756			return -EINVAL;
 757
 758		if (copy_from_sockptr(&flag, optval, optlen))
 759			return -EFAULT;
 760
 761		ro->join_filters = !!flag;
 762		break;
 763
 764	default:
 765		return -ENOPROTOOPT;
 766	}
 767	return err;
 768}
 769
 770static int raw_getsockopt(struct socket *sock, int level, int optname,
 771			  char __user *optval, int __user *optlen)
 772{
 773	struct sock *sk = sock->sk;
 774	struct raw_sock *ro = raw_sk(sk);
 775	int flag;
 776	int len;
 777	void *val;
 778
 779	if (level != SOL_CAN_RAW)
 780		return -EINVAL;
 781	if (get_user(len, optlen))
 782		return -EFAULT;
 783	if (len < 0)
 784		return -EINVAL;
 785
 786	switch (optname) {
 787	case CAN_RAW_FILTER: {
 788		int err = 0;
 789
 790		lock_sock(sk);
 791		if (ro->count > 0) {
 792			int fsize = ro->count * sizeof(struct can_filter);
 793
 794			/* user space buffer to small for filter list? */
 795			if (len < fsize) {
 796				/* return -ERANGE and needed space in optlen */
 797				err = -ERANGE;
 798				if (put_user(fsize, optlen))
 799					err = -EFAULT;
 800			} else {
 801				if (len > fsize)
 802					len = fsize;
 803				if (copy_to_user(optval, ro->filter, len))
 804					err = -EFAULT;
 805			}
 806		} else {
 807			len = 0;
 808		}
 809		release_sock(sk);
 810
 811		if (!err)
 812			err = put_user(len, optlen);
 813		return err;
 814	}
 815	case CAN_RAW_ERR_FILTER:
 816		if (len > sizeof(can_err_mask_t))
 817			len = sizeof(can_err_mask_t);
 818		val = &ro->err_mask;
 819		break;
 820
 821	case CAN_RAW_LOOPBACK:
 822		if (len > sizeof(int))
 823			len = sizeof(int);
 824		flag = ro->loopback;
 825		val = &flag;
 826		break;
 827
 828	case CAN_RAW_RECV_OWN_MSGS:
 829		if (len > sizeof(int))
 830			len = sizeof(int);
 831		flag = ro->recv_own_msgs;
 832		val = &flag;
 833		break;
 834
 835	case CAN_RAW_FD_FRAMES:
 836		if (len > sizeof(int))
 837			len = sizeof(int);
 838		flag = ro->fd_frames;
 839		val = &flag;
 840		break;
 841
 842	case CAN_RAW_XL_FRAMES:
 843		if (len > sizeof(int))
 844			len = sizeof(int);
 845		flag = ro->xl_frames;
 846		val = &flag;
 847		break;
 848
 849	case CAN_RAW_XL_VCID_OPTS: {
 850		int err = 0;
 851
 852		/* user space buffer to small for VCID opts? */
 853		if (len < sizeof(ro->raw_vcid_opts)) {
 854			/* return -ERANGE and needed space in optlen */
 855			err = -ERANGE;
 856			if (put_user(sizeof(ro->raw_vcid_opts), optlen))
 857				err = -EFAULT;
 858		} else {
 859			if (len > sizeof(ro->raw_vcid_opts))
 860				len = sizeof(ro->raw_vcid_opts);
 861			if (copy_to_user(optval, &ro->raw_vcid_opts, len))
 862				err = -EFAULT;
 863		}
 864		if (!err)
 865			err = put_user(len, optlen);
 866		return err;
 867	}
 868	case CAN_RAW_JOIN_FILTERS:
 869		if (len > sizeof(int))
 870			len = sizeof(int);
 871		flag = ro->join_filters;
 872		val = &flag;
 873		break;
 874
 875	default:
 876		return -ENOPROTOOPT;
 877	}
 878
 879	if (put_user(len, optlen))
 880		return -EFAULT;
 881	if (copy_to_user(optval, val, len))
 882		return -EFAULT;
 883	return 0;
 884}
 885
 886static void raw_put_canxl_vcid(struct raw_sock *ro, struct sk_buff *skb)
 887{
 888	struct canxl_frame *cxl = (struct canxl_frame *)skb->data;
 889
 890	/* sanitize non CAN XL bits */
 891	cxl->prio &= (CANXL_PRIO_MASK | CANXL_VCID_MASK);
 892
 893	/* clear VCID in CAN XL frame if pass through is disabled */
 894	if (!(ro->raw_vcid_opts.flags & CAN_RAW_XL_VCID_TX_PASS))
 895		cxl->prio &= CANXL_PRIO_MASK;
 896
 897	/* set VCID in CAN XL frame if enabled */
 898	if (ro->raw_vcid_opts.flags & CAN_RAW_XL_VCID_TX_SET) {
 899		cxl->prio &= CANXL_PRIO_MASK;
 900		cxl->prio |= ro->tx_vcid_shifted;
 901	}
 902}
 903
 904static unsigned int raw_check_txframe(struct raw_sock *ro, struct sk_buff *skb,
 905				      struct net_device *dev)
 906{
 907	/* Classical CAN */
 908	if (can_is_can_skb(skb) && can_cap_enabled(dev, CAN_CAP_CC))
 909		return CAN_MTU;
 910
 911	/* CAN FD */
 912	if (ro->fd_frames && can_is_canfd_skb(skb) &&
 913	    can_cap_enabled(dev, CAN_CAP_FD))
 914		return CANFD_MTU;
 915
 916	/* CAN XL */
 917	if (ro->xl_frames && can_is_canxl_skb(skb) &&
 918	    can_cap_enabled(dev, CAN_CAP_XL))
 919		return CANXL_MTU;
 920
 921	return 0;
 922}
 923
 924static int raw_sendmsg(struct socket *sock, struct msghdr *msg, size_t size)
 925{
 926	struct sock *sk = sock->sk;
 927	struct raw_sock *ro = raw_sk(sk);
 928	struct sockcm_cookie sockc;
 929	struct sk_buff *skb;
 930	struct net_device *dev;
 931	unsigned int txmtu;
 932	int ifindex;
 933	int err = -EINVAL;
 934
 935	/* check for valid CAN frame sizes */
 936	if (size < CANXL_HDR_SIZE + CANXL_MIN_DLEN || size > CANXL_MTU)
 937		return -EINVAL;
 938
 939	if (msg->msg_name) {
 940		DECLARE_SOCKADDR(struct sockaddr_can *, addr, msg->msg_name);
 941
 942		if (msg->msg_namelen < RAW_MIN_NAMELEN)
 943			return -EINVAL;
 944
 945		if (addr->can_family != AF_CAN)
 946			return -EINVAL;
 947
 948		ifindex = addr->can_ifindex;
 949	} else {
 950		ifindex = ro->ifindex;
 951	}
 952
 953	dev = dev_get_by_index(sock_net(sk), ifindex);
 954	if (!dev)
 955		return -ENXIO;
 956
 957	/* no sending on a CAN device in read-only mode */
 958	if (can_cap_enabled(dev, CAN_CAP_RO)) {
 959		err = -EACCES;
 960		goto put_dev;
 961	}
 962
 963	skb = sock_alloc_send_skb(sk, size + sizeof(struct can_skb_priv),
 964				  msg->msg_flags & MSG_DONTWAIT, &err);
 965	if (!skb)
 966		goto put_dev;
 967
 968	can_skb_reserve(skb);
 969	can_skb_prv(skb)->ifindex = dev->ifindex;
 970	can_skb_prv(skb)->skbcnt = 0;
 971
 972	/* fill the skb before testing for valid CAN frames */
 973	err = memcpy_from_msg(skb_put(skb, size), msg, size);
 974	if (err < 0)
 975		goto free_skb;
 976
 977	err = -EINVAL;
 978
 979	/* check for valid CAN (CC/FD/XL) frame content */
 980	txmtu = raw_check_txframe(ro, skb, dev);
 981	if (!txmtu)
 982		goto free_skb;
 983
 984	/* only CANXL: clear/forward/set VCID value */
 985	if (txmtu == CANXL_MTU)
 986		raw_put_canxl_vcid(ro, skb);
 987
 988	sockcm_init(&sockc, sk);
 989	if (msg->msg_controllen) {
 990		err = sock_cmsg_send(sk, msg, &sockc);
 991		if (unlikely(err))
 992			goto free_skb;
 993	}
 994
 995	skb->dev = dev;
 996	skb->priority = sockc.priority;
 997	skb->mark = sockc.mark;
 998	skb->tstamp = sockc.transmit_time;
 999
1000	skb_setup_tx_timestamp(skb, &sockc);
1001
1002	err = can_send(skb, ro->loopback);
1003
1004	dev_put(dev);
1005
1006	if (err)
1007		goto send_failed;
1008
1009	return size;
1010
1011free_skb:
1012	kfree_skb(skb);
1013put_dev:
1014	dev_put(dev);
1015send_failed:
1016	return err;
1017}
1018
1019static int raw_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
1020		       int flags)
1021{
1022	struct sock *sk = sock->sk;
1023	struct sk_buff *skb;
1024	int err = 0;
1025
1026	if (flags & MSG_ERRQUEUE)
1027		return sock_recv_errqueue(sk, msg, size,
1028					  SOL_CAN_RAW, SCM_CAN_RAW_ERRQUEUE);
1029
1030	skb = skb_recv_datagram(sk, flags, &err);
1031	if (!skb)
1032		return err;
1033
1034	if (size < skb->len)
1035		msg->msg_flags |= MSG_TRUNC;
1036	else
1037		size = skb->len;
1038
1039	err = memcpy_to_msg(msg, skb->data, size);
1040	if (err < 0) {
1041		skb_free_datagram(sk, skb);
1042		return err;
1043	}
1044
1045	sock_recv_cmsgs(msg, sk, skb);
1046
1047	if (msg->msg_name) {
1048		__sockaddr_check_size(RAW_MIN_NAMELEN);
1049		msg->msg_namelen = RAW_MIN_NAMELEN;
1050		memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
1051	}
1052
1053	/* assign the flags that have been recorded in raw_rcv() */
1054	msg->msg_flags |= *(raw_flags(skb));
1055
1056	skb_free_datagram(sk, skb);
1057
1058	return size;
1059}
1060
1061static int raw_sock_no_ioctlcmd(struct socket *sock, unsigned int cmd,
1062				unsigned long arg)
1063{
1064	/* no ioctls for socket layer -> hand it down to NIC layer */
1065	return -ENOIOCTLCMD;
1066}
1067
1068static const struct proto_ops raw_ops = {
1069	.family        = PF_CAN,
1070	.release       = raw_release,
1071	.bind          = raw_bind,
1072	.connect       = sock_no_connect,
1073	.socketpair    = sock_no_socketpair,
1074	.accept        = sock_no_accept,
1075	.getname       = raw_getname,
1076	.poll          = datagram_poll,
1077	.ioctl         = raw_sock_no_ioctlcmd,
1078	.gettstamp     = sock_gettstamp,
1079	.listen        = sock_no_listen,
1080	.shutdown      = sock_no_shutdown,
1081	.setsockopt    = raw_setsockopt,
1082	.getsockopt    = raw_getsockopt,
1083	.sendmsg       = raw_sendmsg,
1084	.recvmsg       = raw_recvmsg,
1085	.mmap          = sock_no_mmap,
1086};
1087
1088static struct proto raw_proto __read_mostly = {
1089	.name       = "CAN_RAW",
1090	.owner      = THIS_MODULE,
1091	.obj_size   = sizeof(struct raw_sock),
1092	.init       = raw_init,
1093};
1094
1095static const struct can_proto raw_can_proto = {
1096	.type       = SOCK_RAW,
1097	.protocol   = CAN_RAW,
1098	.ops        = &raw_ops,
1099	.prot       = &raw_proto,
1100};
1101
1102static struct notifier_block canraw_notifier = {
1103	.notifier_call = raw_notifier
1104};
1105
1106static __init int raw_module_init(void)
1107{
1108	int err;
1109
1110	pr_info("can: raw protocol\n");
1111
1112	err = register_netdevice_notifier(&canraw_notifier);
1113	if (err)
1114		return err;
1115
1116	err = can_proto_register(&raw_can_proto);
1117	if (err < 0) {
1118		pr_err("can: registration of raw protocol failed\n");
1119		goto register_proto_failed;
1120	}
1121
1122	return 0;
1123
1124register_proto_failed:
1125	unregister_netdevice_notifier(&canraw_notifier);
1126	return err;
1127}
1128
1129static __exit void raw_module_exit(void)
1130{
1131	can_proto_unregister(&raw_can_proto);
1132	unregister_netdevice_notifier(&canraw_notifier);
1133}
1134
1135module_init(raw_module_init);
1136module_exit(raw_module_exit);