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
60 MODULE_DESCRIPTION("PF_CAN raw protocol");
61 MODULE_LICENSE("Dual BSD/GPL");
62 MODULE_AUTHOR("Urs Thuermann <urs.thuermann@volkswagen.de>");
63 MODULE_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
78 struct uniqframe {
79 const struct sk_buff *skb;
80 u32 hash;
81 unsigned int join_rx_count;
82 };
83
84 struct 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
107 static LIST_HEAD(raw_notifier_list);
108 static DEFINE_SPINLOCK(raw_notifier_lock);
109 static 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 */
raw_flags(struct sk_buff * skb)115 static 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
raw_sk(const struct sock * sk)124 static inline struct raw_sock *raw_sk(const struct sock *sk)
125 {
126 return (struct raw_sock *)sk;
127 }
128
raw_rcv(struct sk_buff * oskb,void * data)129 static 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 unsigned int *pflags;
137
138 /* check the received tx sock reference */
139 if (!ro->recv_own_msgs && oskb->sk == sk)
140 return;
141
142 /* make sure to not pass oversized frames to the socket */
143 if (!ro->fd_frames && can_is_canfd_skb(oskb))
144 return;
145
146 if (can_is_canxl_skb(oskb)) {
147 struct canxl_frame *cxl = (struct canxl_frame *)oskb->data;
148
149 /* make sure to not pass oversized frames to the socket */
150 if (!ro->xl_frames)
151 return;
152
153 /* filter CAN XL VCID content */
154 if (ro->raw_vcid_opts.flags & CAN_RAW_XL_VCID_RX_FILTER) {
155 /* apply VCID filter if user enabled the filter */
156 if ((cxl->prio & ro->rx_vcid_mask_shifted) !=
157 (ro->rx_vcid_shifted & ro->rx_vcid_mask_shifted))
158 return;
159 } else {
160 /* no filter => do not forward VCID tagged frames */
161 if (cxl->prio & CANXL_VCID_MASK)
162 return;
163 }
164 }
165
166 /* eliminate multiple filter matches for the same skb */
167 if (this_cpu_ptr(ro->uniq)->skb == oskb &&
168 this_cpu_ptr(ro->uniq)->hash == oskb->hash) {
169 if (!ro->join_filters)
170 return;
171
172 this_cpu_inc(ro->uniq->join_rx_count);
173 /* drop frame until all enabled filters matched */
174 if (this_cpu_ptr(ro->uniq)->join_rx_count < ro->count)
175 return;
176 } else {
177 this_cpu_ptr(ro->uniq)->skb = oskb;
178 this_cpu_ptr(ro->uniq)->hash = oskb->hash;
179 this_cpu_ptr(ro->uniq)->join_rx_count = 1;
180 /* drop first frame to check all enabled filters? */
181 if (ro->join_filters && ro->count > 1)
182 return;
183 }
184
185 /* clone the given skb to be able to enqueue it into the rcv queue */
186 skb = skb_clone(oskb, GFP_ATOMIC);
187 if (!skb)
188 return;
189
190 /* Put the datagram to the queue so that raw_recvmsg() can get
191 * it from there. We need to pass the interface index to
192 * raw_recvmsg(). We pass a whole struct sockaddr_can in
193 * skb->cb containing the interface index.
194 */
195
196 sock_skb_cb_check_size(sizeof(struct sockaddr_can));
197 addr = (struct sockaddr_can *)skb->cb;
198 memset(addr, 0, sizeof(*addr));
199 addr->can_family = AF_CAN;
200 addr->can_ifindex = skb->dev->ifindex;
201
202 /* add CAN specific message flags for raw_recvmsg() */
203 pflags = raw_flags(skb);
204 *pflags = 0;
205 if (oskb->sk)
206 *pflags |= MSG_DONTROUTE;
207 if (oskb->sk == sk)
208 *pflags |= MSG_CONFIRM;
209
210 reason = sock_queue_rcv_skb_reason(sk, skb);
211 if (reason)
212 sk_skb_reason_drop(sk, skb, reason);
213 }
214
raw_enable_filters(struct net * net,struct net_device * dev,struct sock * sk,struct can_filter * filter,int count)215 static int raw_enable_filters(struct net *net, struct net_device *dev,
216 struct sock *sk, struct can_filter *filter,
217 int count)
218 {
219 int err = 0;
220 int i;
221
222 for (i = 0; i < count; i++) {
223 err = can_rx_register(net, dev, filter[i].can_id,
224 filter[i].can_mask,
225 raw_rcv, sk, "raw", sk);
226 if (err) {
227 /* clean up successfully registered filters */
228 while (--i >= 0)
229 can_rx_unregister(net, dev, filter[i].can_id,
230 filter[i].can_mask,
231 raw_rcv, sk);
232 break;
233 }
234 }
235
236 return err;
237 }
238
raw_enable_errfilter(struct net * net,struct net_device * dev,struct sock * sk,can_err_mask_t err_mask)239 static int raw_enable_errfilter(struct net *net, struct net_device *dev,
240 struct sock *sk, can_err_mask_t err_mask)
241 {
242 int err = 0;
243
244 if (err_mask)
245 err = can_rx_register(net, dev, 0, err_mask | CAN_ERR_FLAG,
246 raw_rcv, sk, "raw", sk);
247
248 return err;
249 }
250
raw_disable_filters(struct net * net,struct net_device * dev,struct sock * sk,struct can_filter * filter,int count)251 static void raw_disable_filters(struct net *net, struct net_device *dev,
252 struct sock *sk, struct can_filter *filter,
253 int count)
254 {
255 int i;
256
257 for (i = 0; i < count; i++)
258 can_rx_unregister(net, dev, filter[i].can_id,
259 filter[i].can_mask, raw_rcv, sk);
260 }
261
raw_disable_errfilter(struct net * net,struct net_device * dev,struct sock * sk,can_err_mask_t err_mask)262 static inline void raw_disable_errfilter(struct net *net,
263 struct net_device *dev,
264 struct sock *sk,
265 can_err_mask_t err_mask)
266
267 {
268 if (err_mask)
269 can_rx_unregister(net, dev, 0, err_mask | CAN_ERR_FLAG,
270 raw_rcv, sk);
271 }
272
raw_disable_allfilters(struct net * net,struct net_device * dev,struct sock * sk)273 static inline void raw_disable_allfilters(struct net *net,
274 struct net_device *dev,
275 struct sock *sk)
276 {
277 struct raw_sock *ro = raw_sk(sk);
278
279 raw_disable_filters(net, dev, sk, ro->filter, ro->count);
280 raw_disable_errfilter(net, dev, sk, ro->err_mask);
281 }
282
raw_enable_allfilters(struct net * net,struct net_device * dev,struct sock * sk)283 static int raw_enable_allfilters(struct net *net, struct net_device *dev,
284 struct sock *sk)
285 {
286 struct raw_sock *ro = raw_sk(sk);
287 int err;
288
289 err = raw_enable_filters(net, dev, sk, ro->filter, ro->count);
290 if (!err) {
291 err = raw_enable_errfilter(net, dev, sk, ro->err_mask);
292 if (err)
293 raw_disable_filters(net, dev, sk, ro->filter,
294 ro->count);
295 }
296
297 return err;
298 }
299
raw_notify(struct raw_sock * ro,unsigned long msg,struct net_device * dev)300 static void raw_notify(struct raw_sock *ro, unsigned long msg,
301 struct net_device *dev)
302 {
303 struct sock *sk = &ro->sk;
304
305 if (!net_eq(dev_net(dev), sock_net(sk)))
306 return;
307
308 if (ro->dev != dev)
309 return;
310
311 switch (msg) {
312 case NETDEV_UNREGISTER:
313 lock_sock(sk);
314 /* remove current filters & unregister */
315 if (ro->bound) {
316 raw_disable_allfilters(dev_net(dev), dev, sk);
317 netdev_put(dev, &ro->dev_tracker);
318 }
319
320 if (ro->count > 1)
321 kfree(ro->filter);
322
323 ro->ifindex = 0;
324 ro->bound = 0;
325 ro->dev = NULL;
326 ro->count = 0;
327 release_sock(sk);
328
329 sk->sk_err = ENODEV;
330 if (!sock_flag(sk, SOCK_DEAD))
331 sk_error_report(sk);
332 break;
333
334 case NETDEV_DOWN:
335 sk->sk_err = ENETDOWN;
336 if (!sock_flag(sk, SOCK_DEAD))
337 sk_error_report(sk);
338 break;
339 }
340 }
341
raw_notifier(struct notifier_block * nb,unsigned long msg,void * ptr)342 static int raw_notifier(struct notifier_block *nb, unsigned long msg,
343 void *ptr)
344 {
345 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
346
347 if (dev->type != ARPHRD_CAN)
348 return NOTIFY_DONE;
349 if (msg != NETDEV_UNREGISTER && msg != NETDEV_DOWN)
350 return NOTIFY_DONE;
351 if (unlikely(raw_busy_notifier)) /* Check for reentrant bug. */
352 return NOTIFY_DONE;
353
354 spin_lock(&raw_notifier_lock);
355 list_for_each_entry(raw_busy_notifier, &raw_notifier_list, notifier) {
356 spin_unlock(&raw_notifier_lock);
357 raw_notify(raw_busy_notifier, msg, dev);
358 spin_lock(&raw_notifier_lock);
359 }
360 raw_busy_notifier = NULL;
361 spin_unlock(&raw_notifier_lock);
362 return NOTIFY_DONE;
363 }
364
raw_sock_destruct(struct sock * sk)365 static void raw_sock_destruct(struct sock *sk)
366 {
367 struct raw_sock *ro = raw_sk(sk);
368
369 free_percpu(ro->uniq);
370 can_sock_destruct(sk);
371 }
372
raw_init(struct sock * sk)373 static int raw_init(struct sock *sk)
374 {
375 struct raw_sock *ro = raw_sk(sk);
376
377 ro->bound = 0;
378 ro->ifindex = 0;
379 ro->dev = NULL;
380
381 /* set default filter to single entry dfilter */
382 ro->dfilter.can_id = 0;
383 ro->dfilter.can_mask = MASK_ALL;
384 ro->filter = &ro->dfilter;
385 ro->count = 1;
386
387 /* set default loopback behaviour */
388 ro->loopback = 1;
389 ro->recv_own_msgs = 0;
390 ro->fd_frames = 0;
391 ro->xl_frames = 0;
392 ro->join_filters = 0;
393
394 /* alloc_percpu provides zero'ed memory */
395 ro->uniq = alloc_percpu(struct uniqframe);
396 if (unlikely(!ro->uniq))
397 return -ENOMEM;
398
399 sk->sk_destruct = raw_sock_destruct;
400
401 /* set notifier */
402 spin_lock(&raw_notifier_lock);
403 list_add_tail(&ro->notifier, &raw_notifier_list);
404 spin_unlock(&raw_notifier_lock);
405
406 return 0;
407 }
408
raw_release(struct socket * sock)409 static int raw_release(struct socket *sock)
410 {
411 struct sock *sk = sock->sk;
412 struct raw_sock *ro;
413 struct net *net;
414
415 if (!sk)
416 return 0;
417
418 ro = raw_sk(sk);
419 net = sock_net(sk);
420
421 spin_lock(&raw_notifier_lock);
422 while (raw_busy_notifier == ro) {
423 spin_unlock(&raw_notifier_lock);
424 schedule_timeout_uninterruptible(1);
425 spin_lock(&raw_notifier_lock);
426 }
427 list_del(&ro->notifier);
428 spin_unlock(&raw_notifier_lock);
429
430 rtnl_lock();
431 lock_sock(sk);
432
433 /* remove current filters & unregister */
434 if (ro->bound) {
435 if (ro->dev) {
436 raw_disable_allfilters(dev_net(ro->dev), ro->dev, sk);
437 netdev_put(ro->dev, &ro->dev_tracker);
438 } else {
439 raw_disable_allfilters(net, NULL, sk);
440 }
441 }
442
443 if (ro->count > 1)
444 kfree(ro->filter);
445
446 ro->ifindex = 0;
447 ro->bound = 0;
448 ro->dev = NULL;
449 ro->count = 0;
450
451 sock_orphan(sk);
452 sock->sk = NULL;
453
454 release_sock(sk);
455 rtnl_unlock();
456
457 sock_prot_inuse_add(net, sk->sk_prot, -1);
458 sock_put(sk);
459
460 return 0;
461 }
462
raw_bind(struct socket * sock,struct sockaddr_unsized * uaddr,int len)463 static int raw_bind(struct socket *sock, struct sockaddr_unsized *uaddr, int len)
464 {
465 struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
466 struct sock *sk = sock->sk;
467 struct raw_sock *ro = raw_sk(sk);
468 struct net_device *dev = NULL;
469 int ifindex;
470 int err = 0;
471 int notify_enetdown = 0;
472
473 if (len < RAW_MIN_NAMELEN)
474 return -EINVAL;
475 if (addr->can_family != AF_CAN)
476 return -EINVAL;
477
478 rtnl_lock();
479 lock_sock(sk);
480
481 if (ro->bound && addr->can_ifindex == ro->ifindex)
482 goto out;
483
484 if (addr->can_ifindex) {
485 dev = dev_get_by_index(sock_net(sk), addr->can_ifindex);
486 if (!dev) {
487 err = -ENODEV;
488 goto out;
489 }
490 if (dev->type != ARPHRD_CAN) {
491 err = -ENODEV;
492 goto out_put_dev;
493 }
494
495 if (!(dev->flags & IFF_UP))
496 notify_enetdown = 1;
497
498 ifindex = dev->ifindex;
499
500 /* filters set by default/setsockopt */
501 err = raw_enable_allfilters(sock_net(sk), dev, sk);
502 if (err)
503 goto out_put_dev;
504
505 } else {
506 ifindex = 0;
507
508 /* filters set by default/setsockopt */
509 err = raw_enable_allfilters(sock_net(sk), NULL, sk);
510 }
511
512 if (!err) {
513 if (ro->bound) {
514 /* unregister old filters */
515 if (ro->dev) {
516 raw_disable_allfilters(dev_net(ro->dev),
517 ro->dev, sk);
518 /* drop reference to old ro->dev */
519 netdev_put(ro->dev, &ro->dev_tracker);
520 } else {
521 raw_disable_allfilters(sock_net(sk), NULL, sk);
522 }
523 }
524 ro->ifindex = ifindex;
525 ro->bound = 1;
526 /* bind() ok -> hold a reference for new ro->dev */
527 ro->dev = dev;
528 if (ro->dev)
529 netdev_hold(ro->dev, &ro->dev_tracker, GFP_KERNEL);
530 }
531
532 out_put_dev:
533 /* remove potential reference from dev_get_by_index() */
534 dev_put(dev);
535 out:
536 release_sock(sk);
537 rtnl_unlock();
538
539 if (notify_enetdown) {
540 sk->sk_err = ENETDOWN;
541 if (!sock_flag(sk, SOCK_DEAD))
542 sk_error_report(sk);
543 }
544
545 return err;
546 }
547
raw_getname(struct socket * sock,struct sockaddr * uaddr,int peer)548 static int raw_getname(struct socket *sock, struct sockaddr *uaddr,
549 int peer)
550 {
551 struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
552 struct sock *sk = sock->sk;
553 struct raw_sock *ro = raw_sk(sk);
554
555 if (peer)
556 return -EOPNOTSUPP;
557
558 memset(addr, 0, RAW_MIN_NAMELEN);
559 addr->can_family = AF_CAN;
560 addr->can_ifindex = ro->ifindex;
561
562 return RAW_MIN_NAMELEN;
563 }
564
raw_setsockopt_locked(struct socket * sock,int optname,sockptr_t optval,unsigned int optlen)565 static int raw_setsockopt_locked(struct socket *sock, int optname,
566 sockptr_t optval, unsigned int optlen)
567 {
568 struct sock *sk = sock->sk;
569 struct raw_sock *ro = raw_sk(sk);
570 struct can_filter *filter = NULL; /* dyn. alloc'ed filters */
571 struct can_filter sfilter; /* single filter */
572 struct net_device *dev = NULL;
573 can_err_mask_t err_mask = 0;
574 int count = 0;
575 int flag;
576 int err = 0;
577
578 switch (optname) {
579 case CAN_RAW_FILTER:
580 if (optlen % sizeof(struct can_filter) != 0)
581 return -EINVAL;
582
583 if (optlen > CAN_RAW_FILTER_MAX * sizeof(struct can_filter))
584 return -EINVAL;
585
586 count = optlen / sizeof(struct can_filter);
587
588 if (count > 1) {
589 /* filter does not fit into dfilter => alloc space */
590 filter = memdup_sockptr(optval, optlen);
591 if (IS_ERR(filter))
592 return PTR_ERR(filter);
593 } else if (count == 1) {
594 if (copy_from_sockptr(&sfilter, optval, sizeof(sfilter)))
595 return -EFAULT;
596 }
597
598 dev = ro->dev;
599 if (ro->bound && dev && dev->reg_state != NETREG_REGISTERED) {
600 if (count > 1)
601 kfree(filter);
602 return -ENODEV;
603 }
604
605 if (ro->bound) {
606 /* (try to) register the new filters */
607 if (count == 1)
608 err = raw_enable_filters(sock_net(sk), dev, sk,
609 &sfilter, 1);
610 else
611 err = raw_enable_filters(sock_net(sk), dev, sk,
612 filter, count);
613 if (err) {
614 if (count > 1)
615 kfree(filter);
616 return err;
617 }
618
619 /* remove old filter registrations */
620 raw_disable_filters(sock_net(sk), dev, sk, ro->filter,
621 ro->count);
622 }
623
624 /* remove old filter space */
625 if (ro->count > 1)
626 kfree(ro->filter);
627
628 /* link new filters to the socket */
629 if (count == 1) {
630 /* copy filter data for single filter */
631 ro->dfilter = sfilter;
632 filter = &ro->dfilter;
633 }
634 ro->filter = filter;
635 ro->count = count;
636 break;
637
638 case CAN_RAW_ERR_FILTER:
639 if (optlen != sizeof(err_mask))
640 return -EINVAL;
641
642 if (copy_from_sockptr(&err_mask, optval, optlen))
643 return -EFAULT;
644
645 err_mask &= CAN_ERR_MASK;
646
647 dev = ro->dev;
648 if (ro->bound && dev && dev->reg_state != NETREG_REGISTERED)
649 return -ENODEV;
650
651 /* remove current error mask */
652 if (ro->bound) {
653 /* (try to) register the new err_mask */
654 err = raw_enable_errfilter(sock_net(sk), dev, sk,
655 err_mask);
656
657 if (err)
658 return err;
659
660 /* remove old err_mask registration */
661 raw_disable_errfilter(sock_net(sk), dev, sk,
662 ro->err_mask);
663 }
664
665 /* link new err_mask to the socket */
666 ro->err_mask = err_mask;
667 break;
668
669 case CAN_RAW_LOOPBACK:
670 if (optlen != sizeof(flag))
671 return -EINVAL;
672
673 if (copy_from_sockptr(&flag, optval, optlen))
674 return -EFAULT;
675
676 ro->loopback = !!flag;
677 break;
678
679 case CAN_RAW_RECV_OWN_MSGS:
680 if (optlen != sizeof(flag))
681 return -EINVAL;
682
683 if (copy_from_sockptr(&flag, optval, optlen))
684 return -EFAULT;
685
686 ro->recv_own_msgs = !!flag;
687 break;
688
689 case CAN_RAW_FD_FRAMES:
690 if (optlen != sizeof(flag))
691 return -EINVAL;
692
693 if (copy_from_sockptr(&flag, optval, optlen))
694 return -EFAULT;
695
696 /* Enabling CAN XL includes CAN FD */
697 if (ro->xl_frames && !flag)
698 return -EINVAL;
699
700 ro->fd_frames = !!flag;
701 break;
702
703 case CAN_RAW_XL_FRAMES:
704 if (optlen != sizeof(flag))
705 return -EINVAL;
706
707 if (copy_from_sockptr(&flag, optval, optlen))
708 return -EFAULT;
709
710 ro->xl_frames = !!flag;
711
712 /* Enabling CAN XL includes CAN FD */
713 if (ro->xl_frames)
714 ro->fd_frames = ro->xl_frames;
715 break;
716
717 case CAN_RAW_XL_VCID_OPTS:
718 if (optlen != sizeof(ro->raw_vcid_opts))
719 return -EINVAL;
720
721 if (copy_from_sockptr(&ro->raw_vcid_opts, optval, optlen))
722 return -EFAULT;
723
724 /* prepare 32 bit values for handling in hot path */
725 ro->tx_vcid_shifted = ro->raw_vcid_opts.tx_vcid << CANXL_VCID_OFFSET;
726 ro->rx_vcid_shifted = ro->raw_vcid_opts.rx_vcid << CANXL_VCID_OFFSET;
727 ro->rx_vcid_mask_shifted = ro->raw_vcid_opts.rx_vcid_mask << CANXL_VCID_OFFSET;
728 break;
729
730 case CAN_RAW_JOIN_FILTERS:
731 if (optlen != sizeof(flag))
732 return -EINVAL;
733
734 if (copy_from_sockptr(&flag, optval, optlen))
735 return -EFAULT;
736
737 ro->join_filters = !!flag;
738 break;
739
740 default:
741 return -ENOPROTOOPT;
742 }
743 return err;
744 }
745
raw_setsockopt(struct socket * sock,int level,int optname,sockptr_t optval,unsigned int optlen)746 static int raw_setsockopt(struct socket *sock, int level, int optname,
747 sockptr_t optval, unsigned int optlen)
748 {
749 struct sock *sk = sock->sk;
750 int err;
751
752 if (level != SOL_CAN_RAW)
753 return -EINVAL;
754
755 rtnl_lock();
756 lock_sock(sk);
757
758 err = raw_setsockopt_locked(sock, optname, optval, optlen);
759
760 release_sock(sk);
761 rtnl_unlock();
762
763 return err;
764 }
765
raw_getsockopt(struct socket * sock,int level,int optname,sockopt_t * opt)766 static int raw_getsockopt(struct socket *sock, int level, int optname,
767 sockopt_t *opt)
768 {
769 struct sock *sk = sock->sk;
770 struct raw_sock *ro = raw_sk(sk);
771 int flag;
772 int len;
773 void *val;
774
775 if (level != SOL_CAN_RAW)
776 return -EINVAL;
777 len = opt->optlen;
778 if (len < 0)
779 return -EINVAL;
780
781 switch (optname) {
782 case CAN_RAW_FILTER: {
783 int err = 0;
784
785 lock_sock(sk);
786 if (ro->count > 0) {
787 int fsize = ro->count * sizeof(struct can_filter);
788
789 /* user space buffer to small for filter list? */
790 if (len < fsize) {
791 /* return -ERANGE and needed space in optlen */
792 err = -ERANGE;
793 opt->optlen = fsize;
794 } else {
795 if (len > fsize)
796 len = fsize;
797 if (copy_to_iter(ro->filter, len,
798 &opt->iter_out) != len)
799 err = -EFAULT;
800 }
801 } else {
802 len = 0;
803 }
804 release_sock(sk);
805
806 if (!err)
807 opt->optlen = len;
808 return err;
809 }
810 case CAN_RAW_ERR_FILTER:
811 if (len > sizeof(can_err_mask_t))
812 len = sizeof(can_err_mask_t);
813 val = &ro->err_mask;
814 break;
815
816 case CAN_RAW_LOOPBACK:
817 if (len > sizeof(int))
818 len = sizeof(int);
819 flag = ro->loopback;
820 val = &flag;
821 break;
822
823 case CAN_RAW_RECV_OWN_MSGS:
824 if (len > sizeof(int))
825 len = sizeof(int);
826 flag = ro->recv_own_msgs;
827 val = &flag;
828 break;
829
830 case CAN_RAW_FD_FRAMES:
831 if (len > sizeof(int))
832 len = sizeof(int);
833 flag = ro->fd_frames;
834 val = &flag;
835 break;
836
837 case CAN_RAW_XL_FRAMES:
838 if (len > sizeof(int))
839 len = sizeof(int);
840 flag = ro->xl_frames;
841 val = &flag;
842 break;
843
844 case CAN_RAW_XL_VCID_OPTS: {
845 int err = 0;
846
847 /* user space buffer to small for VCID opts? */
848 if (len < sizeof(ro->raw_vcid_opts)) {
849 /* return -ERANGE and needed space in optlen */
850 err = -ERANGE;
851 opt->optlen = sizeof(ro->raw_vcid_opts);
852 } else {
853 if (len > sizeof(ro->raw_vcid_opts))
854 len = sizeof(ro->raw_vcid_opts);
855 if (copy_to_iter(&ro->raw_vcid_opts, len,
856 &opt->iter_out) != len)
857 err = -EFAULT;
858 }
859 if (!err)
860 opt->optlen = len;
861 return err;
862 }
863 case CAN_RAW_JOIN_FILTERS:
864 if (len > sizeof(int))
865 len = sizeof(int);
866 flag = ro->join_filters;
867 val = &flag;
868 break;
869
870 default:
871 return -ENOPROTOOPT;
872 }
873
874 opt->optlen = len;
875 if (copy_to_iter(val, len, &opt->iter_out) != len)
876 return -EFAULT;
877 return 0;
878 }
879
raw_put_canxl_vcid(struct raw_sock * ro,struct sk_buff * skb)880 static void raw_put_canxl_vcid(struct raw_sock *ro, struct sk_buff *skb)
881 {
882 struct canxl_frame *cxl = (struct canxl_frame *)skb->data;
883
884 /* sanitize non CAN XL bits */
885 cxl->prio &= (CANXL_PRIO_MASK | CANXL_VCID_MASK);
886
887 /* clear VCID in CAN XL frame if pass through is disabled */
888 if (!(ro->raw_vcid_opts.flags & CAN_RAW_XL_VCID_TX_PASS))
889 cxl->prio &= CANXL_PRIO_MASK;
890
891 /* set VCID in CAN XL frame if enabled */
892 if (ro->raw_vcid_opts.flags & CAN_RAW_XL_VCID_TX_SET) {
893 cxl->prio &= CANXL_PRIO_MASK;
894 cxl->prio |= ro->tx_vcid_shifted;
895 }
896 }
897
raw_check_txframe(struct raw_sock * ro,struct sk_buff * skb,struct net_device * dev)898 static unsigned int raw_check_txframe(struct raw_sock *ro, struct sk_buff *skb,
899 struct net_device *dev)
900 {
901 /* Classical CAN */
902 if (can_is_can_skb(skb) && can_cap_enabled(dev, CAN_CAP_CC))
903 return CAN_MTU;
904
905 /* CAN FD */
906 if (ro->fd_frames && can_is_canfd_skb(skb) &&
907 can_cap_enabled(dev, CAN_CAP_FD))
908 return CANFD_MTU;
909
910 /* CAN XL */
911 if (ro->xl_frames && can_is_canxl_skb(skb) &&
912 can_cap_enabled(dev, CAN_CAP_XL))
913 return CANXL_MTU;
914
915 return 0;
916 }
917
raw_sendmsg(struct socket * sock,struct msghdr * msg,size_t size)918 static int raw_sendmsg(struct socket *sock, struct msghdr *msg, size_t size)
919 {
920 struct sock *sk = sock->sk;
921 struct raw_sock *ro = raw_sk(sk);
922 struct sockcm_cookie sockc;
923 struct sk_buff *skb;
924 struct can_skb_ext *csx;
925 struct net_device *dev;
926 unsigned int txmtu;
927 int ifindex;
928 int err = -EINVAL;
929
930 /* check for valid CAN frame sizes */
931 if (size < CANXL_HDR_SIZE + CANXL_MIN_DLEN || size > CANXL_MTU)
932 return -EINVAL;
933
934 if (msg->msg_name) {
935 DECLARE_SOCKADDR(struct sockaddr_can *, addr, msg->msg_name);
936
937 if (msg->msg_namelen < RAW_MIN_NAMELEN)
938 return -EINVAL;
939
940 if (addr->can_family != AF_CAN)
941 return -EINVAL;
942
943 ifindex = addr->can_ifindex;
944 } else {
945 ifindex = ro->ifindex;
946 }
947
948 dev = dev_get_by_index(sock_net(sk), ifindex);
949 if (!dev)
950 return -ENXIO;
951
952 /* no sending on a CAN device in read-only mode */
953 if (can_cap_enabled(dev, CAN_CAP_RO)) {
954 err = -EACCES;
955 goto put_dev;
956 }
957
958 skb = sock_alloc_send_skb(sk, size, msg->msg_flags & MSG_DONTWAIT,
959 &err);
960 if (!skb)
961 goto put_dev;
962
963 csx = can_skb_ext_add(skb);
964 if (!csx) {
965 kfree_skb(skb);
966 err = -ENOMEM;
967 goto put_dev;
968 }
969
970 csx->can_iif = dev->ifindex;
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
1011 free_skb:
1012 kfree_skb(skb);
1013 put_dev:
1014 dev_put(dev);
1015 send_failed:
1016 return err;
1017 }
1018
raw_recvmsg(struct socket * sock,struct msghdr * msg,size_t size,int flags)1019 static 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
raw_sock_no_ioctlcmd(struct socket * sock,unsigned int cmd,unsigned long arg)1061 static 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
1068 static 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_iter = raw_getsockopt,
1083 .sendmsg = raw_sendmsg,
1084 .recvmsg = raw_recvmsg,
1085 .mmap = sock_no_mmap,
1086 };
1087
1088 static 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
1095 static 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
1102 static struct notifier_block canraw_notifier = {
1103 .notifier_call = raw_notifier
1104 };
1105
raw_module_init(void)1106 static __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
1124 register_proto_failed:
1125 unregister_netdevice_notifier(&canraw_notifier);
1126 return err;
1127 }
1128
raw_module_exit(void)1129 static __exit void raw_module_exit(void)
1130 {
1131 can_proto_unregister(&raw_can_proto);
1132 unregister_netdevice_notifier(&canraw_notifier);
1133 }
1134
1135 module_init(raw_module_init);
1136 module_exit(raw_module_exit);
1137