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