projects/linux·blob master · refs

1140 lines · 26.5 KiB

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