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