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