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