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         int error;
 119
 120         if (!ro->recv_own_msgs) {
 121                 /* check the received tx sock reference */
 122                 if (skb->sk == sk) {
 123                         kfree_skb(skb);
 124                         return;
 125                 }
 126         }
 127
 128         /*
 129          *  Put the datagram to the queue so that raw_recvmsg() can
 130          *  get it from there.  We need to pass the interface index to
 131          *  raw_recvmsg().  We pass a whole struct sockaddr_can in skb->cb
 132          *  containing the interface index.
 133          */
 134
 135         BUILD_BUG_ON(sizeof(skb->cb) < sizeof(struct sockaddr_can));
 136         addr = (struct sockaddr_can *)skb->cb;
 137         memset(addr, 0, sizeof(*addr));
 138         addr->can_family  = AF_CAN;
 139         addr->can_ifindex = skb->dev->ifindex;
 140
 141         error = sock_queue_rcv_skb(sk, skb);
 142         if (error < 0)
 143                 kfree_skb(skb);
 144 }
 145
 146 static int raw_enable_filters(struct net_device *dev, struct sock *sk,
 147                               struct can_filter *filter,
 148                               int count)
 149 {
 150         int err = 0;
 151         int i;
 152
 153         for (i = 0; i < count; i++) {
 154                 err = can_rx_register(dev, filter[i].can_id,
 155                                       filter[i].can_mask,
 156                                       raw_rcv, sk, "raw");
 157                 if (err) {
 158                         /* clean up successfully registered filters */
 159                         while (--i >= 0)
 160                                 can_rx_unregister(dev, filter[i].can_id,
 161                                                   filter[i].can_mask,
 162                                                   raw_rcv, sk);
 163                         break;
 164                 }
 165         }
 166
 167         return err;
 168 }
 169
 170 static int raw_enable_errfilter(struct net_device *dev, struct sock *sk,
 171                                 can_err_mask_t err_mask)
 172 {
 173         int err = 0;
 174
 175         if (err_mask)
 176                 err = can_rx_register(dev, 0, err_mask | CAN_ERR_FLAG,
 177                                       raw_rcv, sk, "raw");
 178
 179         return err;
 180 }
 181
 182 static void raw_disable_filters(struct net_device *dev, struct sock *sk,
 183                               struct can_filter *filter,
 184                               int count)
 185 {
 186         int i;
 187
 188         for (i = 0; i < count; i++)
 189                 can_rx_unregister(dev, filter[i].can_id, filter[i].can_mask,
 190                                   raw_rcv, sk);
 191 }
 192
 193 static inline void raw_disable_errfilter(struct net_device *dev,
 194                                          struct sock *sk,
 195                                          can_err_mask_t err_mask)
 196
 197 {
 198         if (err_mask)
 199                 can_rx_unregister(dev, 0, err_mask | CAN_ERR_FLAG,
 200                                   raw_rcv, sk);
 201 }
 202
 203 static inline void raw_disable_allfilters(struct net_device *dev,
 204                                           struct sock *sk)
 205 {
 206         struct raw_sock *ro = raw_sk(sk);
 207
 208         raw_disable_filters(dev, sk, ro->filter, ro->count);
 209         raw_disable_errfilter(dev, sk, ro->err_mask);
 210 }
 211
 212 static int raw_enable_allfilters(struct net_device *dev, struct sock *sk)
 213 {
 214         struct raw_sock *ro = raw_sk(sk);
 215         int err;
 216
 217         err = raw_enable_filters(dev, sk, ro->filter, ro->count);
 218         if (!err) {
 219                 err = raw_enable_errfilter(dev, sk, ro->err_mask);
 220                 if (err)
 221                         raw_disable_filters(dev, sk, ro->filter, ro->count);
 222         }
 223
 224         return err;
 225 }
 226
 227 static int raw_notifier(struct notifier_block *nb,
 228                         unsigned long msg, void *data)
 229 {
 230         struct net_device *dev = (struct net_device *)data;
 231         struct raw_sock *ro = container_of(nb, struct raw_sock, notifier);
 232 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12)
 233         struct sock *sk = &ro->sk;
 234 #else
 235         struct sock *sk = ro->sk;
 236 #endif
 237
 238 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
 239         if (dev->nd_net != &init_net)
 240                 return NOTIFY_DONE;
 241 #endif
 242
 243         if (dev->type != ARPHRD_CAN)
 244                 return NOTIFY_DONE;
 245
 246         if (ro->ifindex != dev->ifindex)
 247                 return NOTIFY_DONE;
 248
 249         switch (msg) {
 250
 251         case NETDEV_UNREGISTER:
 252                 lock_sock(sk);
 253                 /* remove current filters & unregister */
 254                 if (ro->bound)
 255                         raw_disable_allfilters(dev, sk);
 256
 257                 if (ro->count > 1)
 258                         kfree(ro->filter);
 259
 260                 ro->ifindex = 0;
 261                 ro->bound   = 0;
 262                 ro->count   = 0;
 263                 release_sock(sk);
 264
 265                 sk->sk_err = ENODEV;
 266                 if (!sock_flag(sk, SOCK_DEAD))
 267                         sk->sk_error_report(sk);
 268                 break;
 269
 270         case NETDEV_DOWN:
 271                 sk->sk_err = ENETDOWN;
 272                 if (!sock_flag(sk, SOCK_DEAD))
 273                         sk->sk_error_report(sk);
 274                 break;
 275         }
 276
 277         return NOTIFY_DONE;
 278 }
 279
 280 static int raw_init(struct sock *sk)
 281 {
 282         struct raw_sock *ro = raw_sk(sk);
 283
 284 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,12)
 285         ro->sk               = sk;
 286 #endif
 287         ro->bound            = 0;
 288         ro->ifindex          = 0;
 289
 290         /* set default filter to single entry dfilter */
 291         ro->dfilter.can_id   = 0;
 292         ro->dfilter.can_mask = MASK_ALL;
 293         ro->filter           = &ro->dfilter;
 294         ro->count            = 1;
 295
 296         /* set default loopback behaviour */
 297         ro->loopback         = 1;
 298         ro->recv_own_msgs    = 0;
 299
 300         /* set notifier */
 301         ro->notifier.notifier_call = raw_notifier;
 302
 303         register_netdevice_notifier(&ro->notifier);
 304
 305         return 0;
 306 }
 307
 308 static int raw_release(struct socket *sock)
 309 {
 310         struct sock *sk = sock->sk;
 311         struct raw_sock *ro = raw_sk(sk);
 312
 313         unregister_netdevice_notifier(&ro->notifier);
 314
 315         lock_sock(sk);
 316
 317         /* remove current filters & unregister */
 318         if (ro->bound) {
 319                 if (ro->ifindex) {
 320                         struct net_device *dev;
 321
 322                         dev = dev_get_by_index(&init_net, ro->ifindex);
 323                         if (dev) {
 324                                 raw_disable_allfilters(dev, sk);
 325                                 dev_put(dev);
 326                         }
 327                 } else
 328                         raw_disable_allfilters(NULL, sk);
 329         }
 330
 331         if (ro->count > 1)
 332                 kfree(ro->filter);
 333
 334         ro->ifindex = 0;
 335         ro->bound   = 0;
 336         ro->count   = 0;
 337
 338         release_sock(sk);
 339         sock_put(sk);
 340
 341         return 0;
 342 }
 343
 344 static int raw_bind(struct socket *sock, struct sockaddr *uaddr, int len)
 345 {
 346         struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
 347         struct sock *sk = sock->sk;
 348         struct raw_sock *ro = raw_sk(sk);
 349         int ifindex;
 350         int err = 0;
 351         int notify_enetdown = 0;
 352
 353         if (len < sizeof(*addr))
 354                 return -EINVAL;
 355
 356         lock_sock(sk);
 357
 358         if (ro->bound && addr->can_ifindex == ro->ifindex)
 359                 goto out;
 360
 361         if (addr->can_ifindex) {
 362                 struct net_device *dev;
 363
 364                 dev = dev_get_by_index(&init_net, addr->can_ifindex);
 365                 if (!dev) {
 366                         err = -ENODEV;
 367                         goto out;
 368                 }
 369                 if (dev->type != ARPHRD_CAN) {
 370                         dev_put(dev);
 371                         err = -ENODEV;
 372                         goto out;
 373                 }
 374                 if (!(dev->flags & IFF_UP))
 375                         notify_enetdown = 1;
 376
 377                 ifindex = dev->ifindex;
 378
 379                 /* filters set by default/setsockopt */
 380                 err = raw_enable_allfilters(dev, sk);
 381                 dev_put(dev);
 382
 383         } else {
 384                 ifindex = 0;
 385
 386                 /* filters set by default/setsockopt */
 387                 err = raw_enable_allfilters(NULL, sk);
 388         }
 389
 390         if (!err) {
 391                 if (ro->bound) {
 392                         /* unregister old filters */
 393                         if (ro->ifindex) {
 394                                 struct net_device *dev;
 395
 396                                 dev = dev_get_by_index(&init_net, ro->ifindex);
 397                                 if (dev) {
 398                                         raw_disable_allfilters(dev, sk);
 399                                         dev_put(dev);
 400                                 }
 401                         } else
 402                                 raw_disable_allfilters(NULL, sk);
 403                 }
 404                 ro->ifindex = ifindex;
 405                 ro->bound = 1;
 406         }
 407
 408  out:
 409         release_sock(sk);
 410
 411         if (notify_enetdown) {
 412                 sk->sk_err = ENETDOWN;
 413                 if (!sock_flag(sk, SOCK_DEAD))
 414                         sk->sk_error_report(sk);
 415         }
 416
 417         return err;
 418 }
 419
 420 static int raw_getname(struct socket *sock, struct sockaddr *uaddr,
 421                        int *len, int peer)
 422 {
 423         struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
 424         struct sock *sk = sock->sk;
 425         struct raw_sock *ro = raw_sk(sk);
 426
 427         if (peer)
 428                 return -EOPNOTSUPP;
 429
 430         addr->can_family  = AF_CAN;
 431         addr->can_ifindex = ro->ifindex;
 432
 433         *len = sizeof(*addr);
 434
 435         return 0;
 436 }
 437
 438 static int raw_setsockopt(struct socket *sock, int level, int optname,
 439                           char __user *optval, int optlen)
 440 {
 441         struct sock *sk = sock->sk;
 442         struct raw_sock *ro = raw_sk(sk);
 443         struct can_filter *filter = NULL;  /* dyn. alloc'ed filters */
 444         struct can_filter sfilter;         /* single filter */
 445         struct net_device *dev = NULL;
 446         can_err_mask_t err_mask = 0;
 447         int count = 0;
 448         int err = 0;
 449
 450         if (level != SOL_CAN_RAW)
 451                 return -EINVAL;
 452         if (optlen < 0)
 453                 return -EINVAL;
 454
 455         switch (optname) {
 456
 457         case CAN_RAW_FILTER:
 458                 if (optlen % sizeof(struct can_filter) != 0)
 459                         return -EINVAL;
 460
 461                 count = optlen / sizeof(struct can_filter);
 462
 463                 if (count > 1) {
 464                         /* filter does not fit into dfilter => alloc space */
 465                         filter = kmalloc(optlen, GFP_KERNEL);
 466                         if (!filter)
 467                                 return -ENOMEM;
 468
 469                         err = copy_from_user(filter, optval, optlen);
 470                         if (err) {
 471                                 kfree(filter);
 472                                 return err;
 473                         }
 474                 } else if (count == 1) {
 475                         err = copy_from_user(&sfilter, optval, optlen);
 476                         if (err)
 477                                 return err;
 478                 }
 479
 480                 lock_sock(sk);
 481
 482                 if (ro->bound && ro->ifindex)
 483                         dev = dev_get_by_index(&init_net, ro->ifindex);
 484
 485                 if (ro->bound) {
 486                         /* (try to) register the new filters */
 487                         if (count == 1)
 488                                 err = raw_enable_filters(dev, sk, &sfilter, 1);
 489                         else
 490                                 err = raw_enable_filters(dev, sk, filter,
 491                                                          count);
 492                         if (err) {
 493                                 if (count > 1)
 494                                         kfree(filter);
 495
 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                 err = copy_from_user(&err_mask, optval, optlen);
 529                 if (err)
 530                         return err;
 531
 532                 err_mask &= CAN_ERR_MASK;
 533
 534                 lock_sock(sk);
 535
 536                 if (ro->bound && ro->ifindex)
 537                         dev = dev_get_by_index(&init_net, ro->ifindex);
 538
 539                 /* remove current error mask */
 540                 if (ro->bound) {
 541                         /* (try to) register the new err_mask */
 542                         err = raw_enable_errfilter(dev, sk, err_mask);
 543
 544                         if (err)
 545                                 goto out_err;
 546
 547                         /* remove old err_mask registration */
 548                         raw_disable_errfilter(dev, sk, ro->err_mask);
 549                 }
 550
 551                 /* link new err_mask to the socket */
 552                 ro->err_mask = err_mask;
 553
 554  out_err:
 555                 if (dev)
 556                         dev_put(dev);
 557
 558                 release_sock(sk);
 559
 560                 break;
 561
 562         case CAN_RAW_LOOPBACK:
 563                 if (optlen != sizeof(ro->loopback))
 564                         return -EINVAL;
 565
 566                 err = copy_from_user(&ro->loopback, optval, optlen);
 567
 568                 break;
 569
 570         case CAN_RAW_RECV_OWN_MSGS:
 571                 if (optlen != sizeof(ro->recv_own_msgs))
 572                         return -EINVAL;
 573
 574                 err = copy_from_user(&ro->recv_own_msgs, optval, optlen);
 575
 576                 break;
 577
 578         default:
 579                 return -ENOPROTOOPT;
 580         }
 581         return err;
 582 }
 583
 584 static int raw_getsockopt(struct socket *sock, int level, int optname,
 585                           char __user *optval, int __user *optlen)
 586 {
 587         struct sock *sk = sock->sk;
 588         struct raw_sock *ro = raw_sk(sk);
 589         int len;
 590         void *val;
 591         int err = 0;
 592
 593         if (level != SOL_CAN_RAW)
 594                 return -EINVAL;
 595         if (get_user(len, optlen))
 596                 return -EFAULT;
 597         if (len < 0)
 598                 return -EINVAL;
 599
 600         switch (optname) {
 601
 602         case CAN_RAW_FILTER:
 603                 lock_sock(sk);
 604                 if (ro->count > 0) {
 605                         int fsize = ro->count * sizeof(struct can_filter);
 606                         if (len > fsize)
 607                                 len = fsize;
 608                         err = copy_to_user(optval, ro->filter, len);
 609                 } else
 610                         len = 0;
 611                 release_sock(sk);
 612
 613                 if (!err)
 614                         err = put_user(len, optlen);
 615                 return err;
 616
 617         case CAN_RAW_ERR_FILTER:
 618                 if (len > sizeof(can_err_mask_t))
 619                         len = sizeof(can_err_mask_t);
 620                 val = &ro->err_mask;
 621                 break;
 622
 623         case CAN_RAW_LOOPBACK:
 624                 if (len > sizeof(int))
 625                         len = sizeof(int);
 626                 val = &ro->loopback;
 627                 break;
 628
 629         case CAN_RAW_RECV_OWN_MSGS:
 630                 if (len > sizeof(int))
 631                         len = sizeof(int);
 632                 val = &ro->recv_own_msgs;
 633                 break;
 634
 635         default:
 636                 return -ENOPROTOOPT;
 637         }
 638
 639         if (put_user(len, optlen))
 640                 return -EFAULT;
 641         if (copy_to_user(optval, val, len))
 642                 return -EFAULT;
 643         return 0;
 644 }
 645
 646 static int raw_sendmsg(struct kiocb *iocb, struct socket *sock,
 647                        struct msghdr *msg, size_t size)
 648 {
 649         struct sock *sk = sock->sk;
 650         struct raw_sock *ro = raw_sk(sk);
 651         struct sk_buff *skb;
 652         struct net_device *dev;
 653         int ifindex;
 654         int err;
 655
 656         if (msg->msg_name) {
 657                 struct sockaddr_can *addr =
 658                         (struct sockaddr_can *)msg->msg_name;
 659
 660                 if (addr->can_family != AF_CAN)
 661                         return -EINVAL;
 662
 663                 ifindex = addr->can_ifindex;
 664         } else
 665                 ifindex = ro->ifindex;
 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 error = 0;
 703         int noblock;
 704
 705         noblock =  flags & MSG_DONTWAIT;
 706         flags   &= ~MSG_DONTWAIT;
 707
 708         skb = skb_recv_datagram(sk, flags, noblock, &error);
 709         if (!skb)
 710                 return error;
 711
 712         if (size < skb->len)
 713                 msg->msg_flags |= MSG_TRUNC;
 714         else
 715                 size = skb->len;
 716
 717         error = memcpy_toiovec(msg->msg_iov, skb->data, size);
 718         if (error < 0) {
 719                 skb_free_datagram(sk, skb);
 720                 return error;
 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);