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