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