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