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