can: add missing socket check in can/raw release
[linux-2.6.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  * Send feedback to <socketcan-users@lists.berlios.de>
41  *
42  */
43
44 #include <linux/module.h>
45 #include <linux/init.h>
46 #include <linux/uio.h>
47 #include <linux/net.h>
48 #include <linux/slab.h>
49 #include <linux/netdevice.h>
50 #include <linux/socket.h>
51 #include <linux/if_arp.h>
52 #include <linux/skbuff.h>
53 #include <linux/can.h>
54 #include <linux/can/core.h>
55 #include <linux/can/raw.h>
56 #include <net/sock.h>
57 #include <net/net_namespace.h>
58
59 #define CAN_RAW_VERSION CAN_VERSION
60 static __initdata const char banner[] =
61         KERN_INFO "can: raw protocol (rev " CAN_RAW_VERSION ")\n";
62
63 MODULE_DESCRIPTION("PF_CAN raw protocol");
64 MODULE_LICENSE("Dual BSD/GPL");
65 MODULE_AUTHOR("Urs Thuermann <urs.thuermann@volkswagen.de>");
66 MODULE_ALIAS("can-proto-1");
67
68 #define MASK_ALL 0
69
70 /*
71  * A raw socket has a list of can_filters attached to it, each receiving
72  * the CAN frames matching that filter.  If the filter list is empty,
73  * no CAN frames will be received by the socket.  The default after
74  * opening the socket, is to have one filter which receives all frames.
75  * The filter list is allocated dynamically with the exception of the
76  * list containing only one item.  This common case is optimized by
77  * storing the single filter in dfilter, to avoid using dynamic memory.
78  */
79
80 struct raw_sock {
81         struct sock sk;
82         int bound;
83         int ifindex;
84         struct notifier_block notifier;
85         int loopback;
86         int recv_own_msgs;
87         int count;                 /* number of active filters */
88         struct can_filter dfilter; /* default/single filter */
89         struct can_filter *filter; /* pointer to filter(s) */
90         can_err_mask_t err_mask;
91 };
92
93 /*
94  * Return pointer to store the extra msg flags for raw_recvmsg().
95  * We use the space of one unsigned int beyond the 'struct sockaddr_can'
96  * in skb->cb.
97  */
98 static inline unsigned int *raw_flags(struct sk_buff *skb)
99 {
100         BUILD_BUG_ON(sizeof(skb->cb) <= (sizeof(struct sockaddr_can) +
101                                          sizeof(unsigned int)));
102
103         /* return pointer after struct sockaddr_can */
104         return (unsigned int *)(&((struct sockaddr_can *)skb->cb)[1]);
105 }
106
107 static inline struct raw_sock *raw_sk(const struct sock *sk)
108 {
109         return (struct raw_sock *)sk;
110 }
111
112 static void raw_rcv(struct sk_buff *oskb, void *data)
113 {
114         struct sock *sk = (struct sock *)data;
115         struct raw_sock *ro = raw_sk(sk);
116         struct sockaddr_can *addr;
117         struct sk_buff *skb;
118         unsigned int *pflags;
119
120         /* check the received tx sock reference */
121         if (!ro->recv_own_msgs && oskb->sk == sk)
122                 return;
123
124         /* clone the given skb to be able to enqueue it into the rcv queue */
125         skb = skb_clone(oskb, GFP_ATOMIC);
126         if (!skb)
127                 return;
128
129         /*
130          *  Put the datagram to the queue so that raw_recvmsg() can
131          *  get it from there.  We need to pass the interface index to
132          *  raw_recvmsg().  We pass a whole struct sockaddr_can in skb->cb
133          *  containing the interface index.
134          */
135
136         BUILD_BUG_ON(sizeof(skb->cb) < sizeof(struct sockaddr_can));
137         addr = (struct sockaddr_can *)skb->cb;
138         memset(addr, 0, sizeof(*addr));
139         addr->can_family  = AF_CAN;
140         addr->can_ifindex = skb->dev->ifindex;
141
142         /* add CAN specific message flags for raw_recvmsg() */
143         pflags = raw_flags(skb);
144         *pflags = 0;
145         if (oskb->sk)
146                 *pflags |= MSG_DONTROUTE;
147         if (oskb->sk == sk)
148                 *pflags |= MSG_CONFIRM;
149
150         if (sock_queue_rcv_skb(sk, skb) < 0)
151                 kfree_skb(skb);
152 }
153
154 static int raw_enable_filters(struct net_device *dev, struct sock *sk,
155                               struct can_filter *filter, int count)
156 {
157         int err = 0;
158         int i;
159
160         for (i = 0; i < count; i++) {
161                 err = can_rx_register(dev, filter[i].can_id,
162                                       filter[i].can_mask,
163                                       raw_rcv, sk, "raw");
164                 if (err) {
165                         /* clean up successfully registered filters */
166                         while (--i >= 0)
167                                 can_rx_unregister(dev, filter[i].can_id,
168                                                   filter[i].can_mask,
169                                                   raw_rcv, sk);
170                         break;
171                 }
172         }
173
174         return err;
175 }
176
177 static int raw_enable_errfilter(struct net_device *dev, struct sock *sk,
178                                 can_err_mask_t err_mask)
179 {
180         int err = 0;
181
182         if (err_mask)
183                 err = can_rx_register(dev, 0, err_mask | CAN_ERR_FLAG,
184                                       raw_rcv, sk, "raw");
185
186         return err;
187 }
188
189 static void raw_disable_filters(struct net_device *dev, struct sock *sk,
190                               struct can_filter *filter, int count)
191 {
192         int i;
193
194         for (i = 0; i < count; i++)
195                 can_rx_unregister(dev, filter[i].can_id, filter[i].can_mask,
196                                   raw_rcv, sk);
197 }
198
199 static inline void raw_disable_errfilter(struct net_device *dev,
200                                          struct sock *sk,
201                                          can_err_mask_t err_mask)
202
203 {
204         if (err_mask)
205                 can_rx_unregister(dev, 0, err_mask | CAN_ERR_FLAG,
206                                   raw_rcv, sk);
207 }
208
209 static inline void raw_disable_allfilters(struct net_device *dev,
210                                           struct sock *sk)
211 {
212         struct raw_sock *ro = raw_sk(sk);
213
214         raw_disable_filters(dev, sk, ro->filter, ro->count);
215         raw_disable_errfilter(dev, sk, ro->err_mask);
216 }
217
218 static int raw_enable_allfilters(struct net_device *dev, struct sock *sk)
219 {
220         struct raw_sock *ro = raw_sk(sk);
221         int err;
222
223         err = raw_enable_filters(dev, sk, ro->filter, ro->count);
224         if (!err) {
225                 err = raw_enable_errfilter(dev, sk, ro->err_mask);
226                 if (err)
227                         raw_disable_filters(dev, sk, ro->filter, ro->count);
228         }
229
230         return err;
231 }
232
233 static int raw_notifier(struct notifier_block *nb,
234                         unsigned long msg, void *data)
235 {
236         struct net_device *dev = (struct net_device *)data;
237         struct raw_sock *ro = container_of(nb, struct raw_sock, notifier);
238         struct sock *sk = &ro->sk;
239
240         if (!net_eq(dev_net(dev), &init_net))
241                 return NOTIFY_DONE;
242
243         if (dev->type != ARPHRD_CAN)
244                 return NOTIFY_DONE;
245
246         if (ro->ifindex != dev->ifindex)
247                 return NOTIFY_DONE;
248
249         switch (msg) {
250
251         case NETDEV_UNREGISTER:
252                 lock_sock(sk);
253                 /* remove current filters & unregister */
254                 if (ro->bound)
255                         raw_disable_allfilters(dev, sk);
256
257                 if (ro->count > 1)
258                         kfree(ro->filter);
259
260                 ro->ifindex = 0;
261                 ro->bound   = 0;
262                 ro->count   = 0;
263                 release_sock(sk);
264
265                 sk->sk_err = ENODEV;
266                 if (!sock_flag(sk, SOCK_DEAD))
267                         sk->sk_error_report(sk);
268                 break;
269
270         case NETDEV_DOWN:
271                 sk->sk_err = ENETDOWN;
272                 if (!sock_flag(sk, SOCK_DEAD))
273                         sk->sk_error_report(sk);
274                 break;
275         }
276
277         return NOTIFY_DONE;
278 }
279
280 static int raw_init(struct sock *sk)
281 {
282         struct raw_sock *ro = raw_sk(sk);
283
284         ro->bound            = 0;
285         ro->ifindex          = 0;
286
287         /* set default filter to single entry dfilter */
288         ro->dfilter.can_id   = 0;
289         ro->dfilter.can_mask = MASK_ALL;
290         ro->filter           = &ro->dfilter;
291         ro->count            = 1;
292
293         /* set default loopback behaviour */
294         ro->loopback         = 1;
295         ro->recv_own_msgs    = 0;
296
297         /* set notifier */
298         ro->notifier.notifier_call = raw_notifier;
299
300         register_netdevice_notifier(&ro->notifier);
301
302         return 0;
303 }
304
305 static int raw_release(struct socket *sock)
306 {
307         struct sock *sk = sock->sk;
308         struct raw_sock *ro;
309
310         if (!sk)
311                 return 0;
312
313         ro = raw_sk(sk);
314
315         unregister_netdevice_notifier(&ro->notifier);
316
317         lock_sock(sk);
318
319         /* remove current filters & unregister */
320         if (ro->bound) {
321                 if (ro->ifindex) {
322                         struct net_device *dev;
323
324                         dev = dev_get_by_index(&init_net, ro->ifindex);
325                         if (dev) {
326                                 raw_disable_allfilters(dev, sk);
327                                 dev_put(dev);
328                         }
329                 } else
330                         raw_disable_allfilters(NULL, sk);
331         }
332
333         if (ro->count > 1)
334                 kfree(ro->filter);
335
336         ro->ifindex = 0;
337         ro->bound   = 0;
338         ro->count   = 0;
339
340         sock_orphan(sk);
341         sock->sk = NULL;
342
343         release_sock(sk);
344         sock_put(sk);
345
346         return 0;
347 }
348
349 static int raw_bind(struct socket *sock, struct sockaddr *uaddr, int len)
350 {
351         struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
352         struct sock *sk = sock->sk;
353         struct raw_sock *ro = raw_sk(sk);
354         int ifindex;
355         int err = 0;
356         int notify_enetdown = 0;
357
358         if (len < sizeof(*addr))
359                 return -EINVAL;
360
361         lock_sock(sk);
362
363         if (ro->bound && addr->can_ifindex == ro->ifindex)
364                 goto out;
365
366         if (addr->can_ifindex) {
367                 struct net_device *dev;
368
369                 dev = dev_get_by_index(&init_net, addr->can_ifindex);
370                 if (!dev) {
371                         err = -ENODEV;
372                         goto out;
373                 }
374                 if (dev->type != ARPHRD_CAN) {
375                         dev_put(dev);
376                         err = -ENODEV;
377                         goto out;
378                 }
379                 if (!(dev->flags & IFF_UP))
380                         notify_enetdown = 1;
381
382                 ifindex = dev->ifindex;
383
384                 /* filters set by default/setsockopt */
385                 err = raw_enable_allfilters(dev, sk);
386                 dev_put(dev);
387         } else {
388                 ifindex = 0;
389
390                 /* filters set by default/setsockopt */
391                 err = raw_enable_allfilters(NULL, sk);
392         }
393
394         if (!err) {
395                 if (ro->bound) {
396                         /* unregister old filters */
397                         if (ro->ifindex) {
398                                 struct net_device *dev;
399
400                                 dev = dev_get_by_index(&init_net, ro->ifindex);
401                                 if (dev) {
402                                         raw_disable_allfilters(dev, sk);
403                                         dev_put(dev);
404                                 }
405                         } else
406                                 raw_disable_allfilters(NULL, sk);
407                 }
408                 ro->ifindex = ifindex;
409                 ro->bound = 1;
410         }
411
412  out:
413         release_sock(sk);
414
415         if (notify_enetdown) {
416                 sk->sk_err = ENETDOWN;
417                 if (!sock_flag(sk, SOCK_DEAD))
418                         sk->sk_error_report(sk);
419         }
420
421         return err;
422 }
423
424 static int raw_getname(struct socket *sock, struct sockaddr *uaddr,
425                        int *len, int peer)
426 {
427         struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
428         struct sock *sk = sock->sk;
429         struct raw_sock *ro = raw_sk(sk);
430
431         if (peer)
432                 return -EOPNOTSUPP;
433
434         memset(addr, 0, sizeof(*addr));
435         addr->can_family  = AF_CAN;
436         addr->can_ifindex = ro->ifindex;
437
438         *len = sizeof(*addr);
439
440         return 0;
441 }
442
443 static int raw_setsockopt(struct socket *sock, int level, int optname,
444                           char __user *optval, unsigned int optlen)
445 {
446         struct sock *sk = sock->sk;
447         struct raw_sock *ro = raw_sk(sk);
448         struct can_filter *filter = NULL;  /* dyn. alloc'ed filters */
449         struct can_filter sfilter;         /* single filter */
450         struct net_device *dev = NULL;
451         can_err_mask_t err_mask = 0;
452         int count = 0;
453         int err = 0;
454
455         if (level != SOL_CAN_RAW)
456                 return -EINVAL;
457
458         switch (optname) {
459
460         case CAN_RAW_FILTER:
461                 if (optlen % sizeof(struct can_filter) != 0)
462                         return -EINVAL;
463
464                 count = optlen / sizeof(struct can_filter);
465
466                 if (count > 1) {
467                         /* filter does not fit into dfilter => alloc space */
468                         filter = memdup_user(optval, optlen);
469                         if (IS_ERR(filter))
470                                 return PTR_ERR(filter);
471                 } else if (count == 1) {
472                         if (copy_from_user(&sfilter, optval, sizeof(sfilter)))
473                                 return -EFAULT;
474                 }
475
476                 lock_sock(sk);
477
478                 if (ro->bound && ro->ifindex)
479                         dev = dev_get_by_index(&init_net, ro->ifindex);
480
481                 if (ro->bound) {
482                         /* (try to) register the new filters */
483                         if (count == 1)
484                                 err = raw_enable_filters(dev, sk, &sfilter, 1);
485                         else
486                                 err = raw_enable_filters(dev, sk, filter,
487                                                          count);
488                         if (err) {
489                                 if (count > 1)
490                                         kfree(filter);
491                                 goto out_fil;
492                         }
493
494                         /* remove old filter registrations */
495                         raw_disable_filters(dev, sk, ro->filter, ro->count);
496                 }
497
498                 /* remove old filter space */
499                 if (ro->count > 1)
500                         kfree(ro->filter);
501
502                 /* link new filters to the socket */
503                 if (count == 1) {
504                         /* copy filter data for single filter */
505                         ro->dfilter = sfilter;
506                         filter = &ro->dfilter;
507                 }
508                 ro->filter = filter;
509                 ro->count  = count;
510
511  out_fil:
512                 if (dev)
513                         dev_put(dev);
514
515                 release_sock(sk);
516
517                 break;
518
519         case CAN_RAW_ERR_FILTER:
520                 if (optlen != sizeof(err_mask))
521                         return -EINVAL;
522
523                 if (copy_from_user(&err_mask, optval, optlen))
524                         return -EFAULT;
525
526                 err_mask &= CAN_ERR_MASK;
527
528                 lock_sock(sk);
529
530                 if (ro->bound && ro->ifindex)
531                         dev = dev_get_by_index(&init_net, ro->ifindex);
532
533                 /* remove current error mask */
534                 if (ro->bound) {
535                         /* (try to) register the new err_mask */
536                         err = raw_enable_errfilter(dev, sk, err_mask);
537
538                         if (err)
539                                 goto out_err;
540
541                         /* remove old err_mask registration */
542                         raw_disable_errfilter(dev, sk, ro->err_mask);
543                 }
544
545                 /* link new err_mask to the socket */
546                 ro->err_mask = err_mask;
547
548  out_err:
549                 if (dev)
550                         dev_put(dev);
551
552                 release_sock(sk);
553
554                 break;
555
556         case CAN_RAW_LOOPBACK:
557                 if (optlen != sizeof(ro->loopback))
558                         return -EINVAL;
559
560                 if (copy_from_user(&ro->loopback, optval, optlen))
561                         return -EFAULT;
562
563                 break;
564
565         case CAN_RAW_RECV_OWN_MSGS:
566                 if (optlen != sizeof(ro->recv_own_msgs))
567                         return -EINVAL;
568
569                 if (copy_from_user(&ro->recv_own_msgs, optval, optlen))
570                         return -EFAULT;
571
572                 break;
573
574         default:
575                 return -ENOPROTOOPT;
576         }
577         return err;
578 }
579
580 static int raw_getsockopt(struct socket *sock, int level, int optname,
581                           char __user *optval, int __user *optlen)
582 {
583         struct sock *sk = sock->sk;
584         struct raw_sock *ro = raw_sk(sk);
585         int len;
586         void *val;
587         int err = 0;
588
589         if (level != SOL_CAN_RAW)
590                 return -EINVAL;
591         if (get_user(len, optlen))
592                 return -EFAULT;
593         if (len < 0)
594                 return -EINVAL;
595
596         switch (optname) {
597
598         case CAN_RAW_FILTER:
599                 lock_sock(sk);
600                 if (ro->count > 0) {
601                         int fsize = ro->count * sizeof(struct can_filter);
602                         if (len > fsize)
603                                 len = fsize;
604                         if (copy_to_user(optval, ro->filter, len))
605                                 err = -EFAULT;
606                 } else
607                         len = 0;
608                 release_sock(sk);
609
610                 if (!err)
611                         err = put_user(len, optlen);
612                 return err;
613
614         case CAN_RAW_ERR_FILTER:
615                 if (len > sizeof(can_err_mask_t))
616                         len = sizeof(can_err_mask_t);
617                 val = &ro->err_mask;
618                 break;
619
620         case CAN_RAW_LOOPBACK:
621                 if (len > sizeof(int))
622                         len = sizeof(int);
623                 val = &ro->loopback;
624                 break;
625
626         case CAN_RAW_RECV_OWN_MSGS:
627                 if (len > sizeof(int))
628                         len = sizeof(int);
629                 val = &ro->recv_own_msgs;
630                 break;
631
632         default:
633                 return -ENOPROTOOPT;
634         }
635
636         if (put_user(len, optlen))
637                 return -EFAULT;
638         if (copy_to_user(optval, val, len))
639                 return -EFAULT;
640         return 0;
641 }
642
643 static int raw_sendmsg(struct kiocb *iocb, struct socket *sock,
644                        struct msghdr *msg, size_t size)
645 {
646         struct sock *sk = sock->sk;
647         struct raw_sock *ro = raw_sk(sk);
648         struct sk_buff *skb;
649         struct net_device *dev;
650         int ifindex;
651         int err;
652
653         if (msg->msg_name) {
654                 struct sockaddr_can *addr =
655                         (struct sockaddr_can *)msg->msg_name;
656
657                 if (msg->msg_namelen < sizeof(*addr))
658                         return -EINVAL;
659
660                 if (addr->can_family != AF_CAN)
661                         return -EINVAL;
662
663                 ifindex = addr->can_ifindex;
664         } else
665                 ifindex = ro->ifindex;
666
667         if (size != sizeof(struct can_frame))
668                 return -EINVAL;
669
670         dev = dev_get_by_index(&init_net, ifindex);
671         if (!dev)
672                 return -ENXIO;
673
674         skb = sock_alloc_send_skb(sk, size, msg->msg_flags & MSG_DONTWAIT,
675                                   &err);
676         if (!skb)
677                 goto put_dev;
678
679         err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
680         if (err < 0)
681                 goto free_skb;
682         err = sock_tx_timestamp(sk, &skb_shinfo(skb)->tx_flags);
683         if (err < 0)
684                 goto free_skb;
685
686         /* to be able to check the received tx sock reference in raw_rcv() */
687         skb_shinfo(skb)->tx_flags |= SKBTX_DRV_NEEDS_SK_REF;
688
689         skb->dev = dev;
690         skb->sk  = sk;
691
692         err = can_send(skb, ro->loopback);
693
694         dev_put(dev);
695
696         if (err)
697                 goto send_failed;
698
699         return size;
700
701 free_skb:
702         kfree_skb(skb);
703 put_dev:
704         dev_put(dev);
705 send_failed:
706         return err;
707 }
708
709 static int raw_recvmsg(struct kiocb *iocb, struct socket *sock,
710                        struct msghdr *msg, size_t size, int flags)
711 {
712         struct sock *sk = sock->sk;
713         struct sk_buff *skb;
714         int err = 0;
715         int noblock;
716
717         noblock =  flags & MSG_DONTWAIT;
718         flags   &= ~MSG_DONTWAIT;
719
720         skb = skb_recv_datagram(sk, flags, noblock, &err);
721         if (!skb)
722                 return err;
723
724         if (size < skb->len)
725                 msg->msg_flags |= MSG_TRUNC;
726         else
727                 size = skb->len;
728
729         err = memcpy_toiovec(msg->msg_iov, skb->data, size);
730         if (err < 0) {
731                 skb_free_datagram(sk, skb);
732                 return err;
733         }
734
735         sock_recv_ts_and_drops(msg, sk, skb);
736
737         if (msg->msg_name) {
738                 msg->msg_namelen = sizeof(struct sockaddr_can);
739                 memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
740         }
741
742         /* assign the flags that have been recorded in raw_rcv() */
743         msg->msg_flags |= *(raw_flags(skb));
744
745         skb_free_datagram(sk, skb);
746
747         return size;
748 }
749
750 static const struct proto_ops raw_ops = {
751         .family        = PF_CAN,
752         .release       = raw_release,
753         .bind          = raw_bind,
754         .connect       = sock_no_connect,
755         .socketpair    = sock_no_socketpair,
756         .accept        = sock_no_accept,
757         .getname       = raw_getname,
758         .poll          = datagram_poll,
759         .ioctl         = can_ioctl,     /* use can_ioctl() from af_can.c */
760         .listen        = sock_no_listen,
761         .shutdown      = sock_no_shutdown,
762         .setsockopt    = raw_setsockopt,
763         .getsockopt    = raw_getsockopt,
764         .sendmsg       = raw_sendmsg,
765         .recvmsg       = raw_recvmsg,
766         .mmap          = sock_no_mmap,
767         .sendpage      = sock_no_sendpage,
768 };
769
770 static struct proto raw_proto __read_mostly = {
771         .name       = "CAN_RAW",
772         .owner      = THIS_MODULE,
773         .obj_size   = sizeof(struct raw_sock),
774         .init       = raw_init,
775 };
776
777 static struct can_proto raw_can_proto __read_mostly = {
778         .type       = SOCK_RAW,
779         .protocol   = CAN_RAW,
780         .ops        = &raw_ops,
781         .prot       = &raw_proto,
782 };
783
784 static __init int raw_module_init(void)
785 {
786         int err;
787
788         printk(banner);
789
790         err = can_proto_register(&raw_can_proto);
791         if (err < 0)
792                 printk(KERN_ERR "can: registration of raw protocol failed\n");
793
794         return err;
795 }
796
797 static __exit void raw_module_exit(void)
798 {
799         can_proto_unregister(&raw_can_proto);
800 }
801
802 module_init(raw_module_init);
803 module_exit(raw_module_exit);