can-raw: Fix skb_orphan_try handling
[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 static inline struct raw_sock *raw_sk(const struct sock *sk)
94 {
95         return (struct raw_sock *)sk;
96 }
97
98 static void raw_rcv(struct sk_buff *skb, void *data)
99 {
100         struct sock *sk = (struct sock *)data;
101         struct raw_sock *ro = raw_sk(sk);
102         struct sockaddr_can *addr;
103
104         /* check the received tx sock reference */
105         if (!ro->recv_own_msgs && skb->sk == sk)
106                 return;
107
108         /* clone the given skb to be able to enqueue it into the rcv queue */
109         skb = skb_clone(skb, GFP_ATOMIC);
110         if (!skb)
111                 return;
112
113         /*
114          *  Put the datagram to the queue so that raw_recvmsg() can
115          *  get it from there.  We need to pass the interface index to
116          *  raw_recvmsg().  We pass a whole struct sockaddr_can in skb->cb
117          *  containing the interface index.
118          */
119
120         BUILD_BUG_ON(sizeof(skb->cb) < sizeof(struct sockaddr_can));
121         addr = (struct sockaddr_can *)skb->cb;
122         memset(addr, 0, sizeof(*addr));
123         addr->can_family  = AF_CAN;
124         addr->can_ifindex = skb->dev->ifindex;
125
126         if (sock_queue_rcv_skb(sk, skb) < 0)
127                 kfree_skb(skb);
128 }
129
130 static int raw_enable_filters(struct net_device *dev, struct sock *sk,
131                               struct can_filter *filter, 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, int count)
167 {
168         int i;
169
170         for (i = 0; i < count; i++)
171                 can_rx_unregister(dev, filter[i].can_id, filter[i].can_mask,
172                                   raw_rcv, sk);
173 }
174
175 static inline void raw_disable_errfilter(struct net_device *dev,
176                                          struct sock *sk,
177                                          can_err_mask_t err_mask)
178
179 {
180         if (err_mask)
181                 can_rx_unregister(dev, 0, err_mask | CAN_ERR_FLAG,
182                                   raw_rcv, sk);
183 }
184
185 static inline void raw_disable_allfilters(struct net_device *dev,
186                                           struct sock *sk)
187 {
188         struct raw_sock *ro = raw_sk(sk);
189
190         raw_disable_filters(dev, sk, ro->filter, ro->count);
191         raw_disable_errfilter(dev, sk, ro->err_mask);
192 }
193
194 static int raw_enable_allfilters(struct net_device *dev, struct sock *sk)
195 {
196         struct raw_sock *ro = raw_sk(sk);
197         int err;
198
199         err = raw_enable_filters(dev, sk, ro->filter, ro->count);
200         if (!err) {
201                 err = raw_enable_errfilter(dev, sk, ro->err_mask);
202                 if (err)
203                         raw_disable_filters(dev, sk, ro->filter, ro->count);
204         }
205
206         return err;
207 }
208
209 static int raw_notifier(struct notifier_block *nb,
210                         unsigned long msg, void *data)
211 {
212         struct net_device *dev = (struct net_device *)data;
213         struct raw_sock *ro = container_of(nb, struct raw_sock, notifier);
214         struct sock *sk = &ro->sk;
215
216         if (!net_eq(dev_net(dev), &init_net))
217                 return NOTIFY_DONE;
218
219         if (dev->type != ARPHRD_CAN)
220                 return NOTIFY_DONE;
221
222         if (ro->ifindex != dev->ifindex)
223                 return NOTIFY_DONE;
224
225         switch (msg) {
226
227         case NETDEV_UNREGISTER:
228                 lock_sock(sk);
229                 /* remove current filters & unregister */
230                 if (ro->bound)
231                         raw_disable_allfilters(dev, sk);
232
233                 if (ro->count > 1)
234                         kfree(ro->filter);
235
236                 ro->ifindex = 0;
237                 ro->bound   = 0;
238                 ro->count   = 0;
239                 release_sock(sk);
240
241                 sk->sk_err = ENODEV;
242                 if (!sock_flag(sk, SOCK_DEAD))
243                         sk->sk_error_report(sk);
244                 break;
245
246         case NETDEV_DOWN:
247                 sk->sk_err = ENETDOWN;
248                 if (!sock_flag(sk, SOCK_DEAD))
249                         sk->sk_error_report(sk);
250                 break;
251         }
252
253         return NOTIFY_DONE;
254 }
255
256 static int raw_init(struct sock *sk)
257 {
258         struct raw_sock *ro = raw_sk(sk);
259
260         ro->bound            = 0;
261         ro->ifindex          = 0;
262
263         /* set default filter to single entry dfilter */
264         ro->dfilter.can_id   = 0;
265         ro->dfilter.can_mask = MASK_ALL;
266         ro->filter           = &ro->dfilter;
267         ro->count            = 1;
268
269         /* set default loopback behaviour */
270         ro->loopback         = 1;
271         ro->recv_own_msgs    = 0;
272
273         /* set notifier */
274         ro->notifier.notifier_call = raw_notifier;
275
276         register_netdevice_notifier(&ro->notifier);
277
278         return 0;
279 }
280
281 static int raw_release(struct socket *sock)
282 {
283         struct sock *sk = sock->sk;
284         struct raw_sock *ro = raw_sk(sk);
285
286         unregister_netdevice_notifier(&ro->notifier);
287
288         lock_sock(sk);
289
290         /* remove current filters & unregister */
291         if (ro->bound) {
292                 if (ro->ifindex) {
293                         struct net_device *dev;
294
295                         dev = dev_get_by_index(&init_net, ro->ifindex);
296                         if (dev) {
297                                 raw_disable_allfilters(dev, sk);
298                                 dev_put(dev);
299                         }
300                 } else
301                         raw_disable_allfilters(NULL, sk);
302         }
303
304         if (ro->count > 1)
305                 kfree(ro->filter);
306
307         ro->ifindex = 0;
308         ro->bound   = 0;
309         ro->count   = 0;
310
311         sock_orphan(sk);
312         sock->sk = NULL;
313
314         release_sock(sk);
315         sock_put(sk);
316
317         return 0;
318 }
319
320 static int raw_bind(struct socket *sock, struct sockaddr *uaddr, int len)
321 {
322         struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
323         struct sock *sk = sock->sk;
324         struct raw_sock *ro = raw_sk(sk);
325         int ifindex;
326         int err = 0;
327         int notify_enetdown = 0;
328
329         if (len < sizeof(*addr))
330                 return -EINVAL;
331
332         lock_sock(sk);
333
334         if (ro->bound && addr->can_ifindex == ro->ifindex)
335                 goto out;
336
337         if (addr->can_ifindex) {
338                 struct net_device *dev;
339
340                 dev = dev_get_by_index(&init_net, addr->can_ifindex);
341                 if (!dev) {
342                         err = -ENODEV;
343                         goto out;
344                 }
345                 if (dev->type != ARPHRD_CAN) {
346                         dev_put(dev);
347                         err = -ENODEV;
348                         goto out;
349                 }
350                 if (!(dev->flags & IFF_UP))
351                         notify_enetdown = 1;
352
353                 ifindex = dev->ifindex;
354
355                 /* filters set by default/setsockopt */
356                 err = raw_enable_allfilters(dev, sk);
357                 dev_put(dev);
358         } else {
359                 ifindex = 0;
360
361                 /* filters set by default/setsockopt */
362                 err = raw_enable_allfilters(NULL, sk);
363         }
364
365         if (!err) {
366                 if (ro->bound) {
367                         /* unregister old filters */
368                         if (ro->ifindex) {
369                                 struct net_device *dev;
370
371                                 dev = dev_get_by_index(&init_net, ro->ifindex);
372                                 if (dev) {
373                                         raw_disable_allfilters(dev, sk);
374                                         dev_put(dev);
375                                 }
376                         } else
377                                 raw_disable_allfilters(NULL, sk);
378                 }
379                 ro->ifindex = ifindex;
380                 ro->bound = 1;
381         }
382
383  out:
384         release_sock(sk);
385
386         if (notify_enetdown) {
387                 sk->sk_err = ENETDOWN;
388                 if (!sock_flag(sk, SOCK_DEAD))
389                         sk->sk_error_report(sk);
390         }
391
392         return err;
393 }
394
395 static int raw_getname(struct socket *sock, struct sockaddr *uaddr,
396                        int *len, int peer)
397 {
398         struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
399         struct sock *sk = sock->sk;
400         struct raw_sock *ro = raw_sk(sk);
401
402         if (peer)
403                 return -EOPNOTSUPP;
404
405         memset(addr, 0, sizeof(*addr));
406         addr->can_family  = AF_CAN;
407         addr->can_ifindex = ro->ifindex;
408
409         *len = sizeof(*addr);
410
411         return 0;
412 }
413
414 static int raw_setsockopt(struct socket *sock, int level, int optname,
415                           char __user *optval, unsigned int optlen)
416 {
417         struct sock *sk = sock->sk;
418         struct raw_sock *ro = raw_sk(sk);
419         struct can_filter *filter = NULL;  /* dyn. alloc'ed filters */
420         struct can_filter sfilter;         /* single filter */
421         struct net_device *dev = NULL;
422         can_err_mask_t err_mask = 0;
423         int count = 0;
424         int err = 0;
425
426         if (level != SOL_CAN_RAW)
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 = memdup_user(optval, optlen);
440                         if (IS_ERR(filter))
441                                 return PTR_ERR(filter);
442                 } else if (count == 1) {
443                         if (copy_from_user(&sfilter, optval, sizeof(sfilter)))
444                                 return -EFAULT;
445                 }
446
447                 lock_sock(sk);
448
449                 if (ro->bound && ro->ifindex)
450                         dev = dev_get_by_index(&init_net, ro->ifindex);
451
452                 if (ro->bound) {
453                         /* (try to) register the new filters */
454                         if (count == 1)
455                                 err = raw_enable_filters(dev, sk, &sfilter, 1);
456                         else
457                                 err = raw_enable_filters(dev, sk, filter,
458                                                          count);
459                         if (err) {
460                                 if (count > 1)
461                                         kfree(filter);
462                                 goto out_fil;
463                         }
464
465                         /* remove old filter registrations */
466                         raw_disable_filters(dev, sk, ro->filter, ro->count);
467                 }
468
469                 /* remove old filter space */
470                 if (ro->count > 1)
471                         kfree(ro->filter);
472
473                 /* link new filters to the socket */
474                 if (count == 1) {
475                         /* copy filter data for single filter */
476                         ro->dfilter = sfilter;
477                         filter = &ro->dfilter;
478                 }
479                 ro->filter = filter;
480                 ro->count  = count;
481
482  out_fil:
483                 if (dev)
484                         dev_put(dev);
485
486                 release_sock(sk);
487
488                 break;
489
490         case CAN_RAW_ERR_FILTER:
491                 if (optlen != sizeof(err_mask))
492                         return -EINVAL;
493
494                 if (copy_from_user(&err_mask, optval, optlen))
495                         return -EFAULT;
496
497                 err_mask &= CAN_ERR_MASK;
498
499                 lock_sock(sk);
500
501                 if (ro->bound && ro->ifindex)
502                         dev = dev_get_by_index(&init_net, ro->ifindex);
503
504                 /* remove current error mask */
505                 if (ro->bound) {
506                         /* (try to) register the new err_mask */
507                         err = raw_enable_errfilter(dev, sk, err_mask);
508
509                         if (err)
510                                 goto out_err;
511
512                         /* remove old err_mask registration */
513                         raw_disable_errfilter(dev, sk, ro->err_mask);
514                 }
515
516                 /* link new err_mask to the socket */
517                 ro->err_mask = err_mask;
518
519  out_err:
520                 if (dev)
521                         dev_put(dev);
522
523                 release_sock(sk);
524
525                 break;
526
527         case CAN_RAW_LOOPBACK:
528                 if (optlen != sizeof(ro->loopback))
529                         return -EINVAL;
530
531                 if (copy_from_user(&ro->loopback, optval, optlen))
532                         return -EFAULT;
533
534                 break;
535
536         case CAN_RAW_RECV_OWN_MSGS:
537                 if (optlen != sizeof(ro->recv_own_msgs))
538                         return -EINVAL;
539
540                 if (copy_from_user(&ro->recv_own_msgs, optval, optlen))
541                         return -EFAULT;
542
543                 break;
544
545         default:
546                 return -ENOPROTOOPT;
547         }
548         return err;
549 }
550
551 static int raw_getsockopt(struct socket *sock, int level, int optname,
552                           char __user *optval, int __user *optlen)
553 {
554         struct sock *sk = sock->sk;
555         struct raw_sock *ro = raw_sk(sk);
556         int len;
557         void *val;
558         int err = 0;
559
560         if (level != SOL_CAN_RAW)
561                 return -EINVAL;
562         if (get_user(len, optlen))
563                 return -EFAULT;
564         if (len < 0)
565                 return -EINVAL;
566
567         switch (optname) {
568
569         case CAN_RAW_FILTER:
570                 lock_sock(sk);
571                 if (ro->count > 0) {
572                         int fsize = ro->count * sizeof(struct can_filter);
573                         if (len > fsize)
574                                 len = fsize;
575                         if (copy_to_user(optval, ro->filter, len))
576                                 err = -EFAULT;
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         if (size != sizeof(struct can_frame))
636                 return -EINVAL;
637
638         dev = dev_get_by_index(&init_net, ifindex);
639         if (!dev)
640                 return -ENXIO;
641
642         skb = sock_alloc_send_skb(sk, size, msg->msg_flags & MSG_DONTWAIT,
643                                   &err);
644         if (!skb)
645                 goto put_dev;
646
647         err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
648         if (err < 0)
649                 goto free_skb;
650         err = sock_tx_timestamp(msg, sk, skb_tx(skb));
651         if (err < 0)
652                 goto free_skb;
653
654         /* to be able to check the received tx sock reference in raw_rcv() */
655         skb_tx(skb)->prevent_sk_orphan = 1;
656
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);