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, the following disclaimer and
  12  *    the referenced file 'COPYING'.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. Neither the name of Volkswagen nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * Alternatively, provided that this notice is retained in full, this
  21  * software may be distributed under the terms of the GNU General
  22  * Public License ("GPL") version 2 as distributed in the 'COPYING'
  23  * file from the main directory of the linux kernel source.
  24  *
  25  * The provided data structures and external interfaces from this code
  26  * are not restricted to be used by modules with a GPL compatible license.
  27  *
  28  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  29  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  30  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  31  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  32  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  33  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  34  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  35  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  36  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  37  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  38  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  39  * DAMAGE.
  40  *
  41  * Send feedback to <socketcan-users@lists.berlios.de>
  42  *
  43  */
  44
  45 #include <linux/autoconf.h>
  46 #include <linux/module.h>
  47 #include <linux/version.h>
  48 #include <linux/init.h>
  49 #include <linux/net.h>
  50 #include <linux/netdevice.h>
  51 #include <linux/uio.h>
  52 #include <linux/poll.h>
  53 #include <net/sock.h>
  54
  55 #include <linux/can.h>
  56 #include <linux/can/error.h>
  57 #include <linux/can/core.h>
  58 #include <linux/can/raw.h>
  59 #include <linux/can/version.h>
  60
  61 RCSID("$Id$");
  62
  63 #define IDENT "raw"
  64 static __initdata const char banner[] =
  65         KERN_INFO "CAN: raw socket protocol " CAN_VERSION "\n";
  66
  67 MODULE_DESCRIPTION("PF_CAN raw sockets");
  68 MODULE_LICENSE("Dual BSD/GPL");
  69 MODULE_AUTHOR("Urs Thuermann <urs.thuermann@volkswagen.de>");
  70
  71 #ifdef CONFIG_CAN_DEBUG_CORE
  72 static int debug = 0;
  73 module_param(debug, int, S_IRUGO);
  74 #define DBG(args...)       (debug & 1 ? \
  75                                (printk(KERN_DEBUG "RAW %s: ", __func__), \
  76                                 printk(args)) : 0)
  77 #define DBG_SKB(skb)       (debug & 4 ? can_debug_skb(skb) : 0)
  78 #else
  79 #define DBG(args...)
  80 #define DBG_SKB(skb)
  81 #endif
  82
  83 static int raw_init(struct sock *sk);
  84 static int raw_release(struct socket *sock);
  85 static int raw_bind   (struct socket *sock, struct sockaddr *uaddr, int len);
  86 static int raw_getname(struct socket *sock, struct sockaddr *uaddr,
  87                        int *len, int peer);
  88 static unsigned int raw_poll(struct file *file, struct socket *sock,
  89                              poll_table *wait);
  90 static int raw_setsockopt(struct socket *sock, int level, int optname,
  91                           char __user *optval, int optlen);
  92 static int raw_getsockopt(struct socket *sock, int level, int optname,
  93                           char __user *optval, int __user *optlen);
  94 static int raw_sendmsg(struct kiocb *iocb, struct socket *sock,
  95                        struct msghdr *msg, size_t size);
  96 static int raw_recvmsg(struct kiocb *iocb, struct socket *sock,
  97                        struct msghdr *msg, size_t size, int flags);
  98 static void raw_rcv(struct sk_buff *skb, void *data);
  99 static void raw_notifier(unsigned long msg, void *data);
 100
 101 static void raw_add_filters(struct net_device *dev, struct sock *sk);
 102 static void raw_remove_filters(struct net_device *dev, struct sock *sk);
 103
 104
 105 static struct proto_ops raw_ops = {
 106         .family        = PF_CAN,
 107         .release       = raw_release,
 108         .bind          = raw_bind,
 109         .connect       = sock_no_connect,
 110         .socketpair    = sock_no_socketpair,
 111         .accept        = sock_no_accept,
 112         .getname       = raw_getname,
 113         .poll          = raw_poll,
 114         .ioctl         = NULL,          /* use can_ioctl() from af_can.c */
 115         .listen        = sock_no_listen,
 116         .shutdown      = sock_no_shutdown,
 117         .setsockopt    = raw_setsockopt,
 118         .getsockopt    = raw_getsockopt,
 119         .sendmsg       = raw_sendmsg,
 120         .recvmsg       = raw_recvmsg,
 121         .mmap          = sock_no_mmap,
 122         .sendpage      = sock_no_sendpage,
 123 };
 124
 125
 126 /*
 127  * A raw socket has a list of can_filters attached to it, each receiving
 128  * the CAN frames matching that filter.  If the filter list is empty,
 129  * no CAN frames will be received by the socket.  The default after
 130  * opening the socket, is to have one filter which receives all frames.
 131  * The filter list is allocated dynamically with the exception of the
 132  * list containing only one item.  This common case is optimized by
 133  * storing the single filter in dfilter, to avoid using dynamic memory.
 134  */
 135
 136 struct raw_opt {
 137         int bound;
 138         int ifindex;
 139         int loopback;
 140         int recv_own_msgs;
 141         int count;                 /* number of active filters */
 142         struct can_filter dfilter; /* default/single filter */
 143         struct can_filter *filter; /* pointer to filter(s) */
 144         can_err_mask_t err_mask;
 145 };
 146
 147 #ifdef CONFIG_CAN_RAW_USER
 148 #define RAW_CAP (-1)
 149 #else
 150 #define RAW_CAP CAP_NET_RAW
 151 #endif
 152
 153 #undef CAN_RAW_SUPPORT_REBIND /* allow bind on already bound socket */
 154
 155 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,13)
 156 struct raw_sock {
 157         struct sock    sk;
 158         struct raw_opt opt;
 159 };
 160
 161 #define raw_sk(sk) (&((struct raw_sock *)(sk))->opt)
 162
 163 static struct proto raw_proto = {
 164         .name       = "CAN_RAW",
 165         .owner      = THIS_MODULE,
 166         .obj_size   = sizeof(struct raw_sock),
 167         .init       = raw_init,
 168 };
 169
 170 static struct can_proto raw_can_proto = {
 171         .type       = SOCK_RAW,
 172         .protocol   = CAN_RAW,
 173         .capability = RAW_CAP,
 174         .ops        = &raw_ops,
 175         .prot       = &raw_proto,
 176 };
 177 #else
 178 #define raw_sk(sk) ((struct raw_opt *)(sk)->sk_protinfo)
 179
 180 static struct can_proto raw_can_proto = {
 181         .type       = SOCK_RAW,
 182         .protocol   = CAN_RAW,
 183         .capability = RAW_CAP,
 184         .ops        = &raw_ops,
 185         .owner      = THIS_MODULE,
 186         .obj_size   = sizeof(struct raw_opt),
 187         .init       = raw_init,
 188 };
 189 #endif
 190
 191 #define MASK_ALL 0
 192
 193 static __init int raw_module_init(void)
 194 {
 195         printk(banner);
 196
 197         can_proto_register(&raw_can_proto);
 198         return 0;
 199 }
 200
 201 static __exit void raw_module_exit(void)
 202 {
 203         can_proto_unregister(&raw_can_proto);
 204 }
 205
 206 static int raw_init(struct sock *sk)
 207 {
 208         struct raw_opt *ro = raw_sk(sk);
 209
 210         ro->bound            = 0;
 211
 212         /* set default filter to single entry dfilter */
 213         ro->dfilter.can_id   = 0;
 214         ro->dfilter.can_mask = MASK_ALL;
 215         ro->filter           = &ro->dfilter;
 216         ro->count            = 1;
 217
 218         /* set default loopback behaviour */
 219         ro->loopback         = 1;
 220         ro->recv_own_msgs    = 0;
 221
 222         return 0;
 223 }
 224
 225 static int raw_release(struct socket *sock)
 226 {
 227         struct sock *sk = sock->sk;
 228         struct raw_opt *ro = raw_sk(sk);
 229         struct net_device *dev = NULL;
 230
 231         DBG("socket %p, sk %p, refcnt %d\n", sock, sk,
 232             atomic_read(&sk->sk_refcnt));
 233
 234         if (ro->bound && ro->ifindex)
 235                 dev = dev_get_by_index(ro->ifindex);
 236
 237         /* remove current filters & unregister */
 238         if (ro->bound)
 239                 raw_remove_filters(dev, sk);
 240
 241         if (ro->count > 1)
 242                 kfree(ro->filter);
 243
 244         /* remove current error mask */
 245         if (ro->err_mask && ro->bound)
 246                 can_rx_unregister(dev, 0, ro->err_mask | CAN_ERR_FLAG,
 247                                   raw_rcv, sk);
 248
 249         if (dev) {
 250                 can_dev_unregister(dev, raw_notifier, sk);
 251                 dev_put(dev);
 252         }
 253
 254         sock_put(sk);
 255
 256         return 0;
 257 }
 258
 259 static int raw_bind(struct socket *sock, struct sockaddr *uaddr, int len)
 260 {
 261         struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
 262         struct sock *sk = sock->sk;
 263         struct raw_opt *ro = raw_sk(sk);
 264         struct net_device *dev;
 265
 266         DBG("socket %p to device %d\n", sock, addr->can_ifindex);
 267
 268         if (len < sizeof(*addr))
 269                 return -EINVAL;
 270
 271         if (ro->bound) {
 272 #ifdef CAN_RAW_SUPPORT_REBIND
 273                 /* remove current bindings / notifier */
 274                 if (ro->ifindex) {
 275                         dev = dev_get_by_index(ro->ifindex);
 276                         if (!dev) {
 277                                 DBG("could not find device %d\n",
 278                                     addr->can_ifindex);
 279                                 return -ENODEV;
 280                         }
 281                         if (!(dev->flags & IFF_UP)) {
 282                                 sk->sk_err = ENETDOWN;
 283                                 if (!sock_flag(sk, SOCK_DEAD))
 284                                         sk->sk_error_report(sk);
 285                                 goto out;
 286                         }
 287                         can_dev_unregister(dev, raw_notifier, sk);
 288                 } else
 289                         dev = NULL;
 290
 291                 /* unregister current filters for this device */
 292                 raw_remove_filters(dev, sk);
 293
 294                 if (dev)
 295                         dev_put(dev);
 296
 297                 ro->bound = 0;
 298 #else
 299                 return -EINVAL;
 300 #endif
 301         }
 302
 303         if (addr->can_ifindex) {
 304                 dev = dev_get_by_index(addr->can_ifindex);
 305                 if (!dev) {
 306                         DBG("could not find device %d\n", addr->can_ifindex);
 307                         return -ENODEV;
 308                 }
 309                 if (!(dev->flags & IFF_UP)) {
 310                         sk->sk_err = ENETDOWN;
 311                         if (!sock_flag(sk, SOCK_DEAD))
 312                                 sk->sk_error_report(sk);
 313                         goto out;
 314                 }
 315                 can_dev_register(dev, raw_notifier, sk);
 316         } else
 317                 dev = NULL;
 318
 319         ro->ifindex = addr->can_ifindex;
 320
 321         /* filters set by default/setsockopt */
 322         raw_add_filters(dev, sk);
 323
 324         /* error frame filter set by setsockopt */
 325         if (ro->err_mask)
 326                 can_rx_register(dev, 0, ro->err_mask | CAN_ERR_FLAG,
 327                                 raw_rcv, sk, IDENT);
 328
 329         ro->bound = 1;
 330
 331  out:
 332         if (dev)
 333                 dev_put(dev);
 334
 335         return 0;
 336 }
 337
 338 static int raw_getname(struct socket *sock, struct sockaddr *uaddr,
 339                        int *len, int peer)
 340 {
 341         struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
 342         struct sock *sk = sock->sk;
 343         struct raw_opt *ro = raw_sk(sk);
 344
 345         if (peer)
 346                 return -EOPNOTSUPP;
 347
 348         addr->can_family  = AF_CAN;
 349         addr->can_ifindex = ro->ifindex;
 350         *len = sizeof(*addr);
 351
 352         return 0;
 353 }
 354
 355 static unsigned int raw_poll(struct file *file, struct socket *sock,
 356                              poll_table *wait)
 357 {
 358         unsigned int mask = 0;
 359
 360         DBG("socket %p\n", sock);
 361
 362         mask = datagram_poll(file, sock, wait);
 363         return mask;
 364 }
 365
 366 static int raw_setsockopt(struct socket *sock, int level, int optname,
 367                           char __user *optval, int optlen)
 368 {
 369         struct sock *sk = sock->sk;
 370         struct raw_opt *ro = raw_sk(sk);
 371         struct can_filter *filter = NULL;  /* dyn. alloc'ed filters */
 372         struct can_filter sfilter;         /* single filter */
 373         struct net_device *dev = NULL;
 374         can_err_mask_t err_mask = 0;
 375         int count = 0;
 376         int err;
 377
 378         if (level != SOL_CAN_RAW)
 379                 return -EINVAL;
 380
 381         switch (optname) {
 382         case CAN_RAW_FILTER:
 383                 if (optlen % sizeof(struct can_filter) != 0)
 384                         return -EINVAL;
 385
 386                 count = optlen / sizeof(struct can_filter);
 387
 388                 if (count > 1) {
 389                         /* filter does not fit into dfilter => alloc space */
 390                         filter = kmalloc(optlen, GFP_KERNEL);
 391                         if (!filter)
 392                                 return -ENOMEM;
 393
 394                         err = copy_from_user(filter, optval, optlen);
 395                         if (err) {
 396                                 kfree(filter);
 397                                 return err;
 398                         }
 399                 } else if (count == 1) {
 400                         err = copy_from_user(&sfilter, optval, optlen);
 401                         if (err)
 402                                 return err;
 403                 }
 404
 405                 if (ro->bound && ro->ifindex)
 406                         dev = dev_get_by_index(ro->ifindex);
 407
 408                 /* remove current filters & unregister */
 409                 if (ro->bound)
 410                         raw_remove_filters(dev, sk);
 411
 412                 if (ro->count > 1)
 413                         kfree(ro->filter);
 414
 415                 if (count == 1) {
 416                         /* copy filter data for single filter */
 417                         ro->dfilter = sfilter;
 418                         filter = &ro->dfilter;
 419                 }
 420
 421                 /* add new filters & register */
 422                 ro->filter = filter;
 423                 ro->count  = count;
 424                 if (ro->bound)
 425                         raw_add_filters(dev, sk);
 426
 427                 if (dev)
 428                         dev_put(dev);
 429
 430                 break;
 431
 432         case CAN_RAW_ERR_FILTER:
 433                 if (optlen != sizeof(err_mask))
 434                         return -EINVAL;
 435
 436                 err = copy_from_user(&err_mask, optval, optlen);
 437                 if (err)
 438                         return err;
 439
 440                 err_mask &= CAN_ERR_MASK;
 441
 442                 if (ro->bound && ro->ifindex)
 443                         dev = dev_get_by_index(ro->ifindex);
 444
 445                 /* remove current error mask */
 446                 if (ro->err_mask && ro->bound)
 447                         can_rx_unregister(dev, 0, ro->err_mask | CAN_ERR_FLAG,
 448                                           raw_rcv, sk);
 449
 450                 /* add new error mask */
 451                 ro->err_mask = err_mask;
 452                 if (ro->err_mask && ro->bound)
 453                         can_rx_register(dev, 0, ro->err_mask | CAN_ERR_FLAG,
 454                                         raw_rcv, sk, IDENT);
 455
 456                 if (dev)
 457                         dev_put(dev);
 458
 459                 break;
 460
 461         case CAN_RAW_LOOPBACK:
 462                 if (optlen != sizeof(ro->loopback))
 463                         return -EINVAL;
 464
 465                 err = copy_from_user(&ro->loopback, optval, optlen);
 466                 if (err)
 467                         return err;
 468
 469                 break;
 470
 471         case CAN_RAW_RECV_OWN_MSGS:
 472                 if (optlen != sizeof(ro->recv_own_msgs))
 473                         return -EINVAL;
 474
 475                 err = copy_from_user(&ro->recv_own_msgs, optval, optlen);
 476                 if (err)
 477                         return err;
 478
 479                 break;
 480
 481         default:
 482                 return -ENOPROTOOPT;
 483         }
 484         return 0;
 485 }
 486
 487 static int raw_getsockopt(struct socket *sock, int level, int optname,
 488                           char __user *optval, int __user *optlen)
 489 {
 490         struct sock *sk = sock->sk;
 491         struct raw_opt *ro = raw_sk(sk);
 492         struct can_filter *filter = ro->filter;
 493         int count = ro->count;
 494         int len;
 495
 496         if (level != SOL_CAN_RAW)
 497                 return -EINVAL;
 498
 499         switch (optname) {
 500         case CAN_RAW_FILTER:
 501                 if (get_user(len, optlen))
 502                         return -EFAULT;
 503
 504                 if (count && filter) {
 505                         int filter_size = count * sizeof(struct can_filter);
 506                         if (len < filter_size)
 507                                 return -EINVAL;
 508                         if (len > filter_size)
 509                                 len = filter_size;
 510                         if (copy_to_user(optval, filter, len))
 511                                 return -EFAULT;
 512                 } else
 513                         len = 0;
 514
 515                 if (put_user(len, optlen))
 516                         return -EFAULT;
 517
 518                 break;
 519
 520         case CAN_RAW_ERR_FILTER:
 521                 if (get_user(len, optlen))
 522                         return -EFAULT;
 523
 524                 if (len < sizeof(can_err_mask_t))
 525                         return -EINVAL;
 526
 527                 if (len > sizeof(can_err_mask_t))
 528                         len = sizeof(can_err_mask_t);
 529
 530                 if (copy_to_user(optval, &ro->err_mask, len))
 531                         return -EFAULT;
 532
 533                 if (put_user(len, optlen))
 534                         return -EFAULT;
 535
 536                 break;
 537
 538         case CAN_RAW_LOOPBACK:
 539                 if (get_user(len, optlen))
 540                         return -EFAULT;
 541
 542                 if (len < sizeof(int))
 543                         return -EINVAL;
 544
 545                 if (len > sizeof(int))
 546                         len = sizeof(int);
 547
 548                 if (copy_to_user(optval, &ro->loopback, len))
 549                         return -EFAULT;
 550
 551                 if (put_user(len, optlen))
 552                         return -EFAULT;
 553
 554                 break;
 555
 556         case CAN_RAW_RECV_OWN_MSGS:
 557                 if (get_user(len, optlen))
 558                         return -EFAULT;
 559
 560                 if (len < sizeof(int))
 561                         return -EINVAL;
 562
 563                 if (len > sizeof(int))
 564                         len = sizeof(int);
 565
 566                 if (copy_to_user(optval, &ro->recv_own_msgs, len))
 567                         return -EFAULT;
 568
 569                 if (put_user(len, optlen))
 570                         return -EFAULT;
 571
 572                 break;
 573
 574         default:
 575                 return -ENOPROTOOPT;
 576         }
 577         return 0;
 578 }
 579
 580 static void raw_add_filters(struct net_device *dev, struct sock *sk)
 581 {
 582         struct raw_opt *ro = raw_sk(sk);
 583         struct can_filter *filter = ro->filter;
 584         int i;
 585
 586         for (i = 0; i < ro->count; i++) {
 587                 can_rx_register(dev, filter[i].can_id, filter[i].can_mask,
 588                                 raw_rcv, sk, IDENT);
 589                 DBG("filter can_id %08X, can_mask %08X%s, sk %p\n",
 590                     filter[i].can_id, filter[i].can_mask,
 591                     filter[i].can_id & CAN_INV_FILTER ? " (inv)" : "", sk);
 592         }
 593 }
 594
 595 static void raw_remove_filters(struct net_device *dev, struct sock *sk)
 596 {
 597         struct raw_opt *ro = raw_sk(sk);
 598         struct can_filter *filter = ro->filter;
 599         int i;
 600
 601         for (i = 0; i < ro->count; i++) {
 602                 can_rx_unregister(dev, filter[i].can_id, filter[i].can_mask,
 603                                   raw_rcv, sk);
 604                 DBG("filter can_id %08X, can_mask %08X%s, sk %p\n",
 605                     filter[i].can_id, filter[i].can_mask,
 606                     filter[i].can_id & CAN_INV_FILTER ? " (inv)" : "", sk);
 607         }
 608 }
 609
 610 static int raw_sendmsg(struct kiocb *iocb, struct socket *sock,
 611                        struct msghdr *msg, size_t size)
 612 {
 613         struct sock *sk = sock->sk;
 614         struct raw_opt *ro = raw_sk(sk);
 615         struct sk_buff *skb;
 616         struct net_device *dev;
 617         int ifindex;
 618         int err;
 619
 620         DBG("socket %p, sk %p\n", sock, sk);
 621
 622         if (msg->msg_name) {
 623                 struct sockaddr_can *addr =
 624                         (struct sockaddr_can *)msg->msg_name;
 625
 626                 if (addr->can_family != AF_CAN)
 627                         return -EINVAL;
 628
 629                 ifindex = addr->can_ifindex;
 630         } else
 631                 ifindex = ro->ifindex;
 632
 633         dev = dev_get_by_index(ifindex);
 634         if (!dev) {
 635                 DBG("device %d not found\n", ifindex);
 636                 return -ENXIO;
 637         }
 638
 639         skb = alloc_skb(size, GFP_KERNEL);
 640         if (!skb) {
 641                 dev_put(dev);
 642                 return -ENOMEM;
 643         }
 644
 645         err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
 646         if (err < 0) {
 647                 kfree_skb(skb);
 648                 dev_put(dev);
 649                 return err;
 650         }
 651         skb->dev = dev;
 652         skb->sk  = sk;
 653
 654         DBG("sending skbuff to interface %d\n", ifindex);
 655         DBG_SKB(skb);
 656
 657         err = can_send(skb, ro->loopback);
 658
 659         dev_put(dev);
 660
 661         if (err)
 662                 return err;
 663
 664         return size;
 665 }
 666
 667 static int raw_recvmsg(struct kiocb *iocb, struct socket *sock,
 668                        struct msghdr *msg, size_t size, int flags)
 669 {
 670         struct sock *sk = sock->sk;
 671         struct sk_buff *skb;
 672         int error = 0;
 673         int noblock;
 674
 675         DBG("socket %p, sk %p\n", sock, sk);
 676
 677         noblock =  flags & MSG_DONTWAIT;
 678         flags   &= ~MSG_DONTWAIT;
 679
 680         skb = skb_recv_datagram(sk, flags, noblock, &error);
 681         if (!skb)
 682                 return error;
 683
 684         DBG("delivering skbuff %p\n", skb);
 685         DBG_SKB(skb);
 686
 687         if (size < skb->len)
 688                 msg->msg_flags |= MSG_TRUNC;
 689         else
 690                 size = skb->len;
 691
 692         error = memcpy_toiovec(msg->msg_iov, skb->data, size);
 693         if (error < 0) {
 694                 skb_free_datagram(sk, skb);
 695                 return error;
 696         }
 697
 698         sock_recv_timestamp(msg, sk, skb);
 699
 700         if (msg->msg_name) {
 701                 msg->msg_namelen = sizeof(struct sockaddr_can);
 702                 memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
 703         }
 704
 705         DBG("freeing sock %p, skbuff %p\n", sk, skb);
 706         skb_free_datagram(sk, skb);
 707
 708         return size;
 709 }
 710
 711 static void raw_rcv(struct sk_buff *skb, void *data)
 712 {
 713         struct sock *sk = (struct sock*)data;
 714         struct raw_opt *ro = raw_sk(sk);
 715         struct sockaddr_can *addr;
 716         int error;
 717
 718         DBG("received skbuff %p, sk %p\n", skb, sk);
 719         DBG_SKB(skb);
 720
 721         if (!ro->recv_own_msgs) {
 722                 /* check the received tx sock reference */
 723                 if (*(struct sock **)skb->cb == sk) {
 724                         DBG("trashed own tx msg\n");
 725                         kfree_skb(skb);
 726                         return;
 727                 }
 728         }
 729
 730         addr = (struct sockaddr_can *)skb->cb;
 731         memset(addr, 0, sizeof(*addr));
 732         addr->can_family  = AF_CAN;
 733         addr->can_ifindex = skb->dev->ifindex;
 734
 735         error = sock_queue_rcv_skb(sk, skb);
 736         if (error < 0) {
 737                 DBG("sock_queue_rcv_skb failed: %d\n", error);
 738                 DBG("freeing skbuff %p\n", skb);
 739                 kfree_skb(skb);
 740         }
 741 }
 742
 743 static void raw_notifier(unsigned long msg, void *data)
 744 {
 745         struct sock *sk = (struct sock *)data;
 746         struct raw_opt *ro = raw_sk(sk);
 747
 748         DBG("called for sock %p\n", sk);
 749
 750         switch (msg) {
 751         case NETDEV_UNREGISTER:
 752                 ro->ifindex = 0;
 753                 ro->bound   = 0;
 754                 /* fallthrough */
 755         case NETDEV_DOWN:
 756                 sk->sk_err = ENETDOWN;
 757                 if (!sock_flag(sk, SOCK_DEAD))
 758                         sk->sk_error_report(sk);
 759                 break;
 760         }
 761 }
 762
 763
 764 module_init(raw_module_init);
 765 module_exit(raw_module_exit);