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