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