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