~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/can/raw.c

Version: ~ [ linux-6.2-rc3 ] ~ [ linux-6.1.5 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.87 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.162 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.228 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.269 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.302 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp