kernel/2.6/net/can/raw.c

   1 /*
   2  * raw.c
   3  *
   4  * Copyright (c) 2002-2005 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/config.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/raw.h>
  58 #include <linux/can/version.h>
  59
  60 #include "af_can.h"
  61
  62
  63 RCSID("$Id$");
  64
  65 #define NAME "RAW sockets for LLCF"
  66 #define IDENT "raw"
  67 static __initdata const char banner[] = BANNER(NAME);
  68
  69 MODULE_DESCRIPTION(NAME);
  70 MODULE_LICENSE("Dual BSD/GPL");
  71 MODULE_AUTHOR("Urs Thuermann <urs.thuermann@volkswagen.de>");
  72
  73 #ifdef CONFIG_CAN_DEBUG_CORE
  74 static int debug = 0;
  75 module_param(debug, int, S_IRUGO);
  76 #define DBG(args...)       (debug & 1 ? \
  77                                (printk(KERN_DEBUG "RAW %s: ", __func__), \
  78                                 printk(args)) : 0)
  79 #define DBG_SKB(skb)       (debug & 4 ? can_debug_skb(skb) : 0)
  80 #else
  81 #define DBG(args...)
  82 #define DBG_SKB(skb)
  83 #endif
  84
  85 static int raw_init(struct sock *sk);
  86 static int raw_release(struct socket *sock);
  87 static int raw_bind   (struct socket *sock, struct sockaddr *uaddr, int len);
  88 static int raw_getname(struct socket *sock, struct sockaddr *uaddr,
  89                        int *len, int peer);
  90 static unsigned int raw_poll(struct file *file, struct socket *sock,
  91                              poll_table *wait);
  92 static int raw_setsockopt(struct socket *sock, int level, int optname,
  93                           char __user *optval, int optlen);
  94 static int raw_getsockopt(struct socket *sock, int level, int optname,
  95                           char __user *optval, int __user *optlen);
  96 static int raw_sendmsg(struct kiocb *iocb, struct socket *sock,
  97                        struct msghdr *msg, size_t size);
  98 static int raw_recvmsg(struct kiocb *iocb, struct socket *sock,
  99                        struct msghdr *msg, size_t size, int flags);
 100 static void raw_rcv(struct sk_buff *skb, void *data);
 101 static void raw_notifier(unsigned long msg, void *data);
 102
 103 static void raw_add_filters(struct net_device *dev, struct sock *sk);
 104 static void raw_remove_filters(struct net_device *dev, struct sock *sk);
 105
 106
 107 static struct proto_ops raw_ops = {
 108         .family        = PF_CAN,
 109         .release       = raw_release,
 110         .bind          = raw_bind,
 111         .connect       = sock_no_connect,
 112         .socketpair    = sock_no_socketpair,
 113         .accept        = sock_no_accept,
 114         .getname       = raw_getname,
 115         .poll          = raw_poll,
 116         .ioctl         = NULL,          /* use can_ioctl() from af_can.c */
 117         .listen        = sock_no_listen,
 118         .shutdown      = sock_no_shutdown,
 119         .setsockopt    = raw_setsockopt,
 120         .getsockopt    = raw_getsockopt,
 121         .sendmsg       = raw_sendmsg,
 122         .recvmsg       = raw_recvmsg,
 123         .mmap          = sock_no_mmap,
 124         .sendpage      = sock_no_sendpage,
 125 };
 126
 127
 128 /* A raw socket has a list of can_filters attached to it, each receiving
 129    the CAN frames matching that filter.  If the filter list is empty,
 130    no CAN frames will be received by the socket.  The default after
 131    opening the socket, is to have one filter which receives all frames.
 132    The filter list is allocated dynamically with the exception of the
 133    list containing only one item.  This common case is optimized by
 134    storing the single filter in dfilter, to avoid using dynamic memory.
 135 */
 136
 137 struct raw_opt {
 138         int bound;
 139         int ifindex;
 140         int loopback;
 141         int recv_own_msgs;
 142         int count;                 /* number of active filters */
 143         struct can_filter dfilter; /* default/single filter */
 144         struct can_filter *filter; /* pointer to filter(s) */
 145         can_err_mask_t err_mask;
 146 };
 147
 148 #ifdef CONFIG_CAN_RAW_USER
 149 #define RAW_CAP (-1)
 150 #else
 151 #define RAW_CAP CAP_NET_RAW
 152 #endif
 153
 154 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,13)
 155
 156 struct raw_sock {
 157         struct sock    sk;
 158         struct raw_opt opt;
 159 };
 160
 161 #define canraw_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
 178 #else
 179
 180 #define canraw_sk(sk) ((struct raw_opt *)(sk)->sk_protinfo)
 181
 182 static struct can_proto raw_can_proto = {
 183         .type       = SOCK_RAW,
 184         .protocol   = CAN_RAW,
 185         .capability = RAW_CAP,
 186         .ops        = &raw_ops,
 187         .owner      = THIS_MODULE,
 188         .obj_size   = sizeof(struct raw_opt),
 189         .init       = raw_init,
 190 };
 191
 192 #endif
 193
 194 #define MASK_ALL 0
 195
 196 static __init int raw_module_init(void)
 197 {
 198         printk(banner);
 199
 200         can_proto_register(&raw_can_proto);
 201         return 0;
 202 }
 203
 204 static __exit void raw_module_exit(void)
 205 {
 206         can_proto_unregister(&raw_can_proto);
 207 }
 208
 209 static int raw_init(struct sock *sk)
 210 {
 211         canraw_sk(sk)->bound            = 0;
 212
 213         /* set default filter to single entry dfilter */
 214         canraw_sk(sk)->dfilter.can_id   = 0;
 215         canraw_sk(sk)->dfilter.can_mask = MASK_ALL;
 216         canraw_sk(sk)->filter           = &canraw_sk(sk)->dfilter;
 217         canraw_sk(sk)->count            = 1;
 218
 219         /* set default loopback behaviour */
 220         canraw_sk(sk)->loopback         = 1;
 221         canraw_sk(sk)->recv_own_msgs    = 0;
 222
 223         return 0;
 224 }
 225
 226 static int raw_release(struct socket *sock)
 227 {
 228         struct sock *sk = sock->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 (canraw_sk(sk)->bound && canraw_sk(sk)->ifindex)
 235                 dev = dev_get_by_index(canraw_sk(sk)->ifindex);
 236
 237         /* remove current filters & unregister */
 238         if (canraw_sk(sk)->bound)
 239                 raw_remove_filters(dev, sk);
 240         if (canraw_sk(sk)->count > 1)
 241                 kfree(canraw_sk(sk)->filter);
 242
 243         /* remove current error mask */
 244         if (canraw_sk(sk)->err_mask && canraw_sk(sk)->bound)
 245                 can_rx_unregister(dev, 0, canraw_sk(sk)->err_mask | CAN_ERR_FLAG, raw_rcv, sk);
 246
 247         if (dev) {
 248                 can_dev_unregister(dev, raw_notifier, sk);
 249                 dev_put(dev);
 250         }
 251
 252         sock_put(sk);
 253
 254         return 0;
 255 }
 256
 257 static int raw_bind(struct socket *sock, struct sockaddr *uaddr, int len)
 258 {
 259         struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
 260         struct sock *sk = sock->sk;
 261         struct net_device *dev;
 262
 263         DBG("socket %p to device %d\n", sock, addr->can_ifindex);
 264
 265         if (len < sizeof(*addr))
 266                 return -EINVAL;
 267
 268         if (canraw_sk(sk)->bound) {
 269 #if 1
 270                 return -EINVAL;
 271 #else
 272                 /* remove current bindings / notifier */
 273                 if (canraw_sk(sk)->ifindex) {
 274                         dev = dev_get_by_index(canraw_sk(sk)->ifindex);
 275                         if (!dev) {
 276                                 DBG("could not find device %d\n",
 277                                     addr->can_ifindex);
 278                                 return -ENODEV;
 279                         }
 280                         if (!(dev->flags & IFF_UP)) {
 281                                 sk->sk_err = ENETDOWN;
 282                                 sk->sk_error_report(sk);
 283                                 goto out;
 284                         }
 285                         can_dev_unregister(dev, raw_notifier, sk);
 286                 } else
 287                         dev = NULL;
 288
 289                 /* unregister current filters for this device */
 290                 raw_remove_filters(dev, sk);
 291
 292                 if (dev)
 293                         dev_put(dev);
 294
 295                 canraw_sk(sk)->bound = 0;
 296 #endif
 297         }
 298
 299         if (addr->can_ifindex) {
 300                 dev = dev_get_by_index(addr->can_ifindex);
 301                 if (!dev) {
 302                         DBG("could not find device %d\n", addr->can_ifindex);
 303                         return -ENODEV;
 304                 }
 305                 if (!(dev->flags & IFF_UP)) {
 306                         sk->sk_err = ENETDOWN;
 307                         sk->sk_error_report(sk);
 308                         goto out;
 309                 }
 310                 can_dev_register(dev, raw_notifier, sk);
 311         } else
 312                 dev = NULL;
 313
 314         canraw_sk(sk)->ifindex = addr->can_ifindex;
 315
 316         raw_add_filters(dev, sk); /* filters set by default/setsockopt */
 317
 318         if (canraw_sk(sk)->err_mask) /* error frame filter set by setsockopt */
 319                 can_rx_register(dev, 0, canraw_sk(sk)->err_mask | CAN_ERR_FLAG, raw_rcv, sk, IDENT);
 320
 321         canraw_sk(sk)->bound = 1;
 322
 323  out:
 324         if (dev)
 325                 dev_put(dev);
 326
 327         return 0;
 328 }
 329
 330 static int raw_getname(struct socket *sock, struct sockaddr *uaddr,
 331                        int *len, int peer)
 332 {
 333         struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
 334         struct sock *sk = sock->sk;
 335
 336         if (peer)
 337                 return -EOPNOTSUPP;
 338
 339         addr->can_family  = AF_CAN;
 340         addr->can_ifindex = canraw_sk(sk)->ifindex;
 341         *len = sizeof(*addr);
 342
 343         return 0;
 344 }
 345
 346 static unsigned int raw_poll(struct file *file, struct socket *sock,
 347                              poll_table *wait)
 348 {
 349         unsigned int mask = 0;
 350
 351         DBG("socket %p\n", sock);
 352
 353         mask = datagram_poll(file, sock, wait);
 354         return mask;
 355 }
 356
 357 static int raw_setsockopt(struct socket *sock, int level, int optname,
 358                           char __user *optval, int optlen)
 359 {
 360         struct sock *sk = sock->sk;
 361         struct can_filter *filter = NULL;  /* dyn. alloc'ed filters */
 362         struct can_filter sfilter;         /* single filter */
 363         struct net_device *dev = NULL;
 364         can_err_mask_t err_mask = 0;
 365         int count = 0;
 366         int err;
 367
 368         if (level != SOL_CAN_RAW)
 369                 return -EINVAL;
 370
 371         switch (optname) {
 372         case CAN_RAW_FILTER:
 373                 if (optlen % sizeof(struct can_filter) != 0)
 374                         return -EINVAL;
 375
 376                 count = optlen / sizeof(struct can_filter);
 377
 378                 if (count > 1) { /* does not fit into dfilter */
 379                         if (!(filter = kmalloc(optlen, GFP_KERNEL)))
 380                                 return -ENOMEM;
 381                         if ((err = copy_from_user(filter, optval, optlen))) {
 382                                 kfree(filter);
 383                                 return err;
 384                         }
 385                 } else if (count == 1) {
 386                         if ((err = copy_from_user(&sfilter, optval, optlen)))
 387                                 return err;
 388                 }
 389
 390                 if (canraw_sk(sk)->bound && canraw_sk(sk)->ifindex)
 391                         dev = dev_get_by_index(canraw_sk(sk)->ifindex);
 392
 393                 /* remove current filters & unregister */
 394                 if (canraw_sk(sk)->bound)
 395                         raw_remove_filters(dev, sk);
 396                 if (canraw_sk(sk)->count > 1)
 397                         kfree(canraw_sk(sk)->filter);
 398
 399                 if (count == 1) { /* copy data for single filter */
 400                         canraw_sk(sk)->dfilter = sfilter;
 401                         filter = &canraw_sk(sk)->dfilter;
 402                 }
 403
 404                 /* add new filters & register */
 405                 canraw_sk(sk)->filter = filter;
 406                 canraw_sk(sk)->count  = count;
 407                 if (canraw_sk(sk)->bound)
 408                         raw_add_filters(dev, sk);
 409
 410                 if (dev)
 411                         dev_put(dev);
 412
 413                 break;
 414
 415         case CAN_RAW_ERR_FILTER:
 416                 if (optlen != sizeof(err_mask))
 417                         return -EINVAL;
 418                 if ((err = copy_from_user(&err_mask, optval, optlen)))
 419                         return err;
 420
 421                 err_mask &= CAN_ERR_MASK;
 422
 423                 if (canraw_sk(sk)->bound && canraw_sk(sk)->ifindex)
 424                         dev = dev_get_by_index(canraw_sk(sk)->ifindex);
 425
 426                 /* remove current error mask */
 427                 if (canraw_sk(sk)->err_mask && canraw_sk(sk)->bound)
 428                         can_rx_unregister(dev, 0, canraw_sk(sk)->err_mask | CAN_ERR_FLAG, raw_rcv, sk);
 429
 430                 /* add new error mask */
 431                 canraw_sk(sk)->err_mask = err_mask;
 432                 if (canraw_sk(sk)->err_mask && canraw_sk(sk)->bound)
 433                         can_rx_register(dev, 0, canraw_sk(sk)->err_mask | CAN_ERR_FLAG, raw_rcv, sk, IDENT);
 434
 435                 if (dev)
 436                         dev_put(dev);
 437
 438                 break;
 439
 440         case CAN_RAW_LOOPBACK:
 441                 if (optlen != sizeof(canraw_sk(sk)->loopback))
 442                         return -EINVAL;
 443                 if ((err = copy_from_user(&canraw_sk(sk)->loopback, optval, optlen)))
 444                         return err;
 445                 break;
 446
 447         case CAN_RAW_RECV_OWN_MSGS:
 448                 if (optlen != sizeof(canraw_sk(sk)->recv_own_msgs))
 449                         return -EINVAL;
 450                 if ((err = copy_from_user(&canraw_sk(sk)->recv_own_msgs, optval, optlen)))
 451                         return err;
 452                 break;
 453
 454         default:
 455                 return -ENOPROTOOPT;
 456         }
 457         return 0;
 458 }
 459
 460 static int raw_getsockopt(struct socket *sock, int level, int optname,
 461                           char __user *optval, int __user *optlen)
 462 {
 463         struct sock *sk = sock->sk;
 464         struct can_filter *filter = canraw_sk(sk)->filter;
 465         int count = canraw_sk(sk)->count;
 466         int len;
 467
 468         if (level != SOL_CAN_RAW)
 469                 return -EINVAL;
 470
 471         switch (optname) {
 472         case CAN_RAW_FILTER:
 473                 if (get_user(len, optlen))
 474                         return -EFAULT;
 475
 476                 if (count && filter) {
 477                         int filter_size = count * sizeof(struct can_filter);
 478                         if (len < filter_size)
 479                                 return -EINVAL;
 480                         if (len > filter_size)
 481                                 len = filter_size;
 482                         if (copy_to_user(optval, filter, len))
 483                                 return -EFAULT;
 484                 } else
 485                         len = 0;
 486
 487                 if (put_user(len, optlen))
 488                         return -EFAULT;
 489
 490                 break;
 491
 492         case CAN_RAW_ERR_FILTER:
 493                 if (get_user(len, optlen))
 494                         return -EFAULT;
 495
 496                 if (len < sizeof(can_err_mask_t))
 497                         return -EINVAL;
 498
 499                 if (len > sizeof(can_err_mask_t))
 500                         len = sizeof(can_err_mask_t);
 501
 502                 if (copy_to_user(optval, &canraw_sk(sk)->err_mask, len))
 503                         return -EFAULT;
 504
 505                 if (put_user(len, optlen))
 506                         return -EFAULT;
 507
 508                 break;
 509
 510         case CAN_RAW_LOOPBACK:
 511                 if (get_user(len, optlen))
 512                         return -EFAULT;
 513
 514                 if (len < sizeof(int))
 515                         return -EINVAL;
 516
 517                 if (len > sizeof(int))
 518                         len = sizeof(int);
 519
 520                 if (copy_to_user(optval, &canraw_sk(sk)->loopback, len))
 521                         return -EFAULT;
 522
 523                 if (put_user(len, optlen))
 524                         return -EFAULT;
 525
 526                 break;
 527
 528         case CAN_RAW_RECV_OWN_MSGS:
 529                 if (get_user(len, optlen))
 530                         return -EFAULT;
 531
 532                 if (len < sizeof(int))
 533                         return -EINVAL;
 534
 535                 if (len > sizeof(int))
 536                         len = sizeof(int);
 537
 538                 if (copy_to_user(optval, &canraw_sk(sk)->recv_own_msgs, len))
 539                         return -EFAULT;
 540
 541                 if (put_user(len, optlen))
 542                         return -EFAULT;
 543
 544                 break;
 545
 546         default:
 547                 return -ENOPROTOOPT;
 548         }
 549         return 0;
 550 }
 551
 552 static void raw_add_filters(struct net_device *dev, struct sock *sk)
 553 {
 554         struct can_filter *filter = canraw_sk(sk)->filter;
 555         int i;
 556
 557         for (i = 0; i < canraw_sk(sk)->count; i++) {
 558                 can_rx_register(dev, filter[i].can_id, filter[i].can_mask,
 559                                 raw_rcv, sk, IDENT);
 560                 DBG("filter can_id %08X, can_mask %08X%s, sk %p\n",
 561                     filter[i].can_id, filter[i].can_mask,
 562                     filter[i].can_id & CAN_INV_FILTER ? " (inv)" : "", sk);
 563         }
 564 }
 565
 566 static void raw_remove_filters(struct net_device *dev, struct sock *sk)
 567 {
 568         struct can_filter *filter = canraw_sk(sk)->filter;
 569         int i;
 570
 571         for (i = 0; i < canraw_sk(sk)->count; i++) {
 572                 can_rx_unregister(dev, filter[i].can_id, filter[i].can_mask,
 573                                   raw_rcv, sk);
 574                 DBG("filter can_id %08X, can_mask %08X%s, sk %p\n",
 575                     filter[i].can_id, filter[i].can_mask,
 576                     filter[i].can_id & CAN_INV_FILTER ? " (inv)" : "", sk);
 577         }
 578 }
 579
 580 static int raw_sendmsg(struct kiocb *iocb, struct socket *sock,
 581                        struct msghdr *msg, size_t size)
 582 {
 583         struct sock *sk = sock->sk;
 584         struct sk_buff *skb;
 585         struct net_device *dev;
 586         int ifindex;
 587         int err;
 588
 589         DBG("socket %p, sk %p\n", sock, sk);
 590
 591         if (msg->msg_name) {
 592                 struct sockaddr_can *addr = (struct sockaddr_can *)msg->msg_name;
 593                 if (addr->can_family != AF_CAN)
 594                         return -EINVAL;
 595                 ifindex = addr->can_ifindex;
 596         } else
 597                 ifindex = canraw_sk(sk)->ifindex;
 598
 599         if (!(dev = dev_get_by_index(ifindex))) {
 600                 DBG("device %d not found\n", ifindex);
 601                 return -ENXIO;
 602         }
 603
 604         if (!(skb = alloc_skb(size, GFP_KERNEL))) {
 605                 dev_put(dev);
 606                 return -ENOMEM;
 607         }
 608
 609         if ((err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size)) < 0) {
 610                 kfree_skb(skb);
 611                 dev_put(dev);
 612                 return err;
 613         }
 614         skb->dev = dev;
 615         skb->sk  = sk;
 616
 617         DBG("sending skbuff to interface %d\n", ifindex);
 618         DBG_SKB(skb);
 619
 620         err = can_send(skb, canraw_sk(sk)->loopback);
 621
 622         dev_put(dev);
 623
 624         if (err)
 625                 return err;
 626
 627         return size;
 628 }
 629
 630 static int raw_recvmsg(struct kiocb *iocb, struct socket *sock,
 631                        struct msghdr *msg, size_t size, int flags)
 632 {
 633         struct sock *sk = sock->sk;
 634         struct sk_buff *skb;
 635         int error = 0;
 636         int noblock;
 637
 638         DBG("socket %p, sk %p\n", sock, sk);
 639
 640         noblock =  flags & MSG_DONTWAIT;
 641         flags   &= ~MSG_DONTWAIT;
 642
 643         if (!(skb = skb_recv_datagram(sk, flags, noblock, &error)))
 644                 return error;
 645
 646         DBG("delivering skbuff %p\n", skb);
 647         DBG_SKB(skb);
 648
 649         if (size < skb->len)
 650                 msg->msg_flags |= MSG_TRUNC;
 651         else
 652                 size = skb->len;
 653
 654         if ((error = memcpy_toiovec(msg->msg_iov, skb->data, size)) < 0) {
 655                 skb_free_datagram(sk, skb);
 656                 return error;
 657         }
 658
 659         sock_recv_timestamp(msg, sk, skb);
 660
 661         if (msg->msg_name) {
 662                 msg->msg_namelen = sizeof(struct sockaddr_can);
 663                 memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
 664         }
 665
 666         DBG("freeing sock %p, skbuff %p\n", sk, skb);
 667         skb_free_datagram(sk, skb);
 668
 669         return size;
 670 }
 671
 672 static void raw_rcv(struct sk_buff *skb, void *data)
 673 {
 674         struct sock *sk = (struct sock*)data;
 675         struct sockaddr_can *addr;
 676         int error;
 677
 678         DBG("received skbuff %p, sk %p\n", skb, sk);
 679         DBG_SKB(skb);
 680
 681         if (!canraw_sk(sk)->recv_own_msgs) {
 682                 if (*(struct sock **)skb->cb == sk) { /* tx sock reference */
 683                         DBG("trashed own tx msg\n");
 684                         kfree_skb(skb);
 685                         return;
 686                 }
 687         }
 688
 689         addr = (struct sockaddr_can *)skb->cb;
 690         memset(addr, 0, sizeof(*addr));
 691         addr->can_family  = AF_CAN;
 692         addr->can_ifindex = skb->dev->ifindex;
 693
 694         if ((error = sock_queue_rcv_skb(sk, skb)) < 0) {
 695                 DBG("sock_queue_rcv_skb failed: %d\n", error);
 696                 DBG("freeing skbuff %p\n", skb);
 697                 kfree_skb(skb);
 698         }
 699 }
 700
 701 static void raw_notifier(unsigned long msg, void *data)
 702 {
 703         struct sock *sk = (struct sock *)data;
 704
 705         DBG("called for sock %p\n", sk);
 706
 707         switch (msg) {
 708         case NETDEV_UNREGISTER:
 709                 canraw_sk(sk)->ifindex = 0;
 710                 canraw_sk(sk)->bound   = 0;
 711                 /* fallthrough */
 712         case NETDEV_DOWN:
 713                 sk->sk_err = ENETDOWN;
 714                 if (!sock_flag(sk, SOCK_DEAD))
 715                         sk->sk_error_report(sk);
 716                 break;
 717         }
 718 }
 719
 720
 721 module_init(raw_module_init);
 722 module_exit(raw_module_exit);