patch-series/net-2.6.25/03-can-raw-proto.diff

   1 DESC
   2 CAN: Add raw protocol
   3 EDESC
   4 This patch adds the CAN raw protocol.
   5
   6 Signed-off-by: Oliver Hartkopp <oliver.hartkopp@volkswagen.de>
   7 Signed-off-by: Urs Thuermann <urs.thuermann@volkswagen.de>
   8
   9 ---
  10  include/linux/can/raw.h |   31 +
  11  net/can/Kconfig         |   11
  12  net/can/Makefile        |    3
  13  net/can/raw.c           |  763 ++++++++++++++++++++++++++++++++++++++++++++++++
  14  4 files changed, 808 insertions(+)
  15
  16 Index: net-2.6.25/include/linux/can/raw.h
  17 ===================================================================
  18 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
  19 +++ net-2.6.25/include/linux/can/raw.h  2007-11-16 14:40:14.000000000 +0100
  20 @@ -0,0 +1,31 @@
  21 +/*
  22 + * linux/can/raw.h
  23 + *
  24 + * Definitions for raw CAN sockets
  25 + *
  26 + * Authors: Oliver Hartkopp <oliver.hartkopp@volkswagen.de>
  27 + *          Urs Thuermann   <urs.thuermann@volkswagen.de>
  28 + * Copyright (c) 2002-2007 Volkswagen Group Electronic Research
  29 + * All rights reserved.
  30 + *
  31 + * Send feedback to <socketcan-users@lists.berlios.de>
  32 + *
  33 + */
  34 +
  35 +#ifndef CAN_RAW_H
  36 +#define CAN_RAW_H
  37 +
  38 +#include <linux/can.h>
  39 +
  40 +#define SOL_CAN_RAW (SOL_CAN_BASE + CAN_RAW)
  41 +
  42 +/* for socket options affecting the socket (not the global system) */
  43 +
  44 +enum {
  45 +       CAN_RAW_FILTER = 1,     /* set 0 .. n can_filter(s)          */
  46 +       CAN_RAW_ERR_FILTER,     /* set filter for error frames       */
  47 +       CAN_RAW_LOOPBACK,       /* local loopback (default:on)       */
  48 +       CAN_RAW_RECV_OWN_MSGS   /* receive my own msgs (default:off) */
  49 +};
  50 +
  51 +#endif
  52 Index: net-2.6.25/net/can/Kconfig
  53 ===================================================================
  54 --- net-2.6.25.orig/net/can/Kconfig     2007-11-16 14:34:20.000000000 +0100
  55 +++ net-2.6.25/net/can/Kconfig  2007-11-16 14:42:30.000000000 +0100
  56 @@ -15,3 +15,14 @@
  57
  58           If you want CAN support you should say Y here and also to the
  59           specific driver for your controller(s) below.
  60 +
  61 +config CAN_RAW
  62 +       tristate "Raw CAN Protocol (raw access with CAN-ID filtering)"
  63 +       depends on CAN
  64 +       default N
  65 +       ---help---
  66 +         The raw CAN protocol option offers access to the CAN bus via
  67 +         the BSD socket API. You probably want to use the raw socket in
  68 +         most cases where no higher level protocol is being used. The raw
  69 +         socket has several filter options e.g. ID masking / error frames.
  70 +         To receive/send raw CAN messages, use AF_CAN with protocol CAN_RAW.
  71 Index: net-2.6.25/net/can/Makefile
  72 ===================================================================
  73 --- net-2.6.25.orig/net/can/Makefile    2007-11-16 14:25:56.000000000 +0100
  74 +++ net-2.6.25/net/can/Makefile 2007-11-16 14:40:14.000000000 +0100
  75 @@ -4,3 +4,6 @@
  76
  77  obj-$(CONFIG_CAN)      += can.o
  78  can-objs               := af_can.o proc.o
  79 +
  80 +obj-$(CONFIG_CAN_RAW)  += can-raw.o
  81 +can-raw-objs           := raw.o
  82 Index: net-2.6.25/net/can/raw.c
  83 ===================================================================
  84 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
  85 +++ net-2.6.25/net/can/raw.c    2007-11-16 14:43:29.000000000 +0100
  86 @@ -0,0 +1,763 @@
  87 +/*
  88 + * raw.c - Raw sockets for protocol family CAN
  89 + *
  90 + * Copyright (c) 2002-2007 Volkswagen Group Electronic Research
  91 + * All rights reserved.
  92 + *
  93 + * Redistribution and use in source and binary forms, with or without
  94 + * modification, are permitted provided that the following conditions
  95 + * are met:
  96 + * 1. Redistributions of source code must retain the above copyright
  97 + *    notice, this list of conditions and the following disclaimer.
  98 + * 2. Redistributions in binary form must reproduce the above copyright
  99 + *    notice, this list of conditions and the following disclaimer in the
 100 + *    documentation and/or other materials provided with the distribution.
 101 + * 3. Neither the name of Volkswagen nor the names of its contributors
 102 + *    may be used to endorse or promote products derived from this software
 103 + *    without specific prior written permission.
 104 + *
 105 + * Alternatively, provided that this notice is retained in full, this
 106 + * software may be distributed under the terms of the GNU General
 107 + * Public License ("GPL") version 2, in which case the provisions of the
 108 + * GPL apply INSTEAD OF those given above.
 109 + *
 110 + * The provided data structures and external interfaces from this code
 111 + * are not restricted to be used by modules with a GPL compatible license.
 112 + *
 113 + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 114 + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 115 + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 116 + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 117 + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 118 + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 119 + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 120 + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 121 + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 122 + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 123 + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 124 + * DAMAGE.
 125 + *
 126 + * Send feedback to <socketcan-users@lists.berlios.de>
 127 + *
 128 + */
 129 +
 130 +#include <linux/module.h>
 131 +#include <linux/init.h>
 132 +#include <linux/uio.h>
 133 +#include <linux/net.h>
 134 +#include <linux/netdevice.h>
 135 +#include <linux/socket.h>
 136 +#include <linux/if_arp.h>
 137 +#include <linux/skbuff.h>
 138 +#include <linux/can.h>
 139 +#include <linux/can/core.h>
 140 +#include <linux/can/raw.h>
 141 +#include <net/sock.h>
 142 +#include <net/net_namespace.h>
 143 +
 144 +#define CAN_RAW_VERSION CAN_VERSION
 145 +static __initdata const char banner[] =
 146 +       KERN_INFO "can: raw protocol (rev " CAN_RAW_VERSION ")\n";
 147 +
 148 +MODULE_DESCRIPTION("PF_CAN raw protocol");
 149 +MODULE_LICENSE("Dual BSD/GPL");
 150 +MODULE_AUTHOR("Urs Thuermann <urs.thuermann@volkswagen.de>");
 151 +
 152 +#define MASK_ALL 0
 153 +
 154 +/*
 155 + * A raw socket has a list of can_filters attached to it, each receiving
 156 + * the CAN frames matching that filter.  If the filter list is empty,
 157 + * no CAN frames will be received by the socket.  The default after
 158 + * opening the socket, is to have one filter which receives all frames.
 159 + * The filter list is allocated dynamically with the exception of the
 160 + * list containing only one item.  This common case is optimized by
 161 + * storing the single filter in dfilter, to avoid using dynamic memory.
 162 + */
 163 +
 164 +struct raw_sock {
 165 +       struct sock sk;
 166 +       int bound;
 167 +       int ifindex;
 168 +       struct notifier_block notifier;
 169 +       int loopback;
 170 +       int recv_own_msgs;
 171 +       int count;                 /* number of active filters */
 172 +       struct can_filter dfilter; /* default/single filter */
 173 +       struct can_filter *filter; /* pointer to filter(s) */
 174 +       can_err_mask_t err_mask;
 175 +};
 176 +
 177 +static inline struct raw_sock *raw_sk(const struct sock *sk)
 178 +{
 179 +       return (struct raw_sock *)sk;
 180 +}
 181 +
 182 +static void raw_rcv(struct sk_buff *skb, void *data)
 183 +{
 184 +       struct sock *sk = (struct sock *)data;
 185 +       struct raw_sock *ro = raw_sk(sk);
 186 +       struct sockaddr_can *addr;
 187 +       int error;
 188 +
 189 +       if (!ro->recv_own_msgs) {
 190 +               /* check the received tx sock reference */
 191 +               if (skb->sk == sk) {
 192 +                       kfree_skb(skb);
 193 +                       return;
 194 +               }
 195 +       }
 196 +
 197 +       /*
 198 +        *  Put the datagram to the queue so that raw_recvmsg() can
 199 +        *  get it from there.  We need to pass the interface index to
 200 +        *  raw_recvmsg().  We pass a whole struct sockaddr_can in skb->cb
 201 +        *  containing the interface index.
 202 +        */
 203 +
 204 +       BUILD_BUG_ON(sizeof(skb->cb) < sizeof(struct sockaddr_can));
 205 +       addr = (struct sockaddr_can *)skb->cb;
 206 +       memset(addr, 0, sizeof(*addr));
 207 +       addr->can_family  = AF_CAN;
 208 +       addr->can_ifindex = skb->dev->ifindex;
 209 +
 210 +       error = sock_queue_rcv_skb(sk, skb);
 211 +       if (error < 0)
 212 +               kfree_skb(skb);
 213 +}
 214 +
 215 +static int raw_enable_filters(struct net_device *dev, struct sock *sk,
 216 +                             struct can_filter *filter,
 217 +                             int count)
 218 +{
 219 +       int err = 0;
 220 +       int i;
 221 +
 222 +       for (i = 0; i < count; i++) {
 223 +               err = can_rx_register(dev, filter[i].can_id,
 224 +                                     filter[i].can_mask,
 225 +                                     raw_rcv, sk, "raw");
 226 +               if (err) {
 227 +                       /* clean up successfully registered filters */
 228 +                       while (--i >= 0)
 229 +                               can_rx_unregister(dev, filter[i].can_id,
 230 +                                                 filter[i].can_mask,
 231 +                                                 raw_rcv, sk);
 232 +                       break;
 233 +               }
 234 +       }
 235 +
 236 +       return err;
 237 +}
 238 +
 239 +static int raw_enable_errfilter(struct net_device *dev, struct sock *sk,
 240 +                               can_err_mask_t err_mask)
 241 +{
 242 +       int err = 0;
 243 +
 244 +       if (err_mask)
 245 +               err = can_rx_register(dev, 0, err_mask | CAN_ERR_FLAG,
 246 +                                     raw_rcv, sk, "raw");
 247 +
 248 +       return err;
 249 +}
 250 +
 251 +static void raw_disable_filters(struct net_device *dev, struct sock *sk,
 252 +                             struct can_filter *filter,
 253 +                             int count)
 254 +{
 255 +       int i;
 256 +
 257 +       for (i = 0; i < count; i++)
 258 +               can_rx_unregister(dev, filter[i].can_id, filter[i].can_mask,
 259 +                                 raw_rcv, sk);
 260 +}
 261 +
 262 +static inline void raw_disable_errfilter(struct net_device *dev,
 263 +                                        struct sock *sk,
 264 +                                        can_err_mask_t err_mask)
 265 +
 266 +{
 267 +       if (err_mask)
 268 +               can_rx_unregister(dev, 0, err_mask | CAN_ERR_FLAG,
 269 +                                 raw_rcv, sk);
 270 +}
 271 +
 272 +static inline void raw_disable_allfilters(struct net_device *dev,
 273 +                                         struct sock *sk)
 274 +{
 275 +       struct raw_sock *ro = raw_sk(sk);
 276 +
 277 +       raw_disable_filters(dev, sk, ro->filter, ro->count);
 278 +       raw_disable_errfilter(dev, sk, ro->err_mask);
 279 +}
 280 +
 281 +static int raw_enable_allfilters(struct net_device *dev, struct sock *sk)
 282 +{
 283 +       struct raw_sock *ro = raw_sk(sk);
 284 +       int err;
 285 +
 286 +       err = raw_enable_filters(dev, sk, ro->filter, ro->count);
 287 +       if (!err) {
 288 +               err = raw_enable_errfilter(dev, sk, ro->err_mask);
 289 +               if (err)
 290 +                       raw_disable_filters(dev, sk, ro->filter, ro->count);
 291 +       }
 292 +
 293 +       return err;
 294 +}
 295 +
 296 +static int raw_notifier(struct notifier_block *nb,
 297 +                       unsigned long msg, void *data)
 298 +{
 299 +       struct net_device *dev = (struct net_device *)data;
 300 +       struct raw_sock *ro = container_of(nb, struct raw_sock, notifier);
 301 +       struct sock *sk = &ro->sk;
 302 +
 303 +       if (dev->nd_net != &init_net)
 304 +               return NOTIFY_DONE;
 305 +
 306 +       if (dev->type != ARPHRD_CAN)
 307 +               return NOTIFY_DONE;
 308 +
 309 +       if (ro->ifindex != dev->ifindex)
 310 +               return NOTIFY_DONE;
 311 +
 312 +       switch (msg) {
 313 +
 314 +       case NETDEV_UNREGISTER:
 315 +               lock_sock(sk);
 316 +               /* remove current filters & unregister */
 317 +               if (ro->bound)
 318 +                       raw_disable_allfilters(dev, sk);
 319 +
 320 +               if (ro->count > 1)
 321 +                       kfree(ro->filter);
 322 +
 323 +               ro->ifindex = 0;
 324 +               ro->bound   = 0;
 325 +               ro->count   = 0;
 326 +               release_sock(sk);
 327 +
 328 +               sk->sk_err = ENODEV;
 329 +               if (!sock_flag(sk, SOCK_DEAD))
 330 +                       sk->sk_error_report(sk);
 331 +               break;
 332 +
 333 +       case NETDEV_DOWN:
 334 +               sk->sk_err = ENETDOWN;
 335 +               if (!sock_flag(sk, SOCK_DEAD))
 336 +                       sk->sk_error_report(sk);
 337 +               break;
 338 +       }
 339 +
 340 +       return NOTIFY_DONE;
 341 +}
 342 +
 343 +static int raw_init(struct sock *sk)
 344 +{
 345 +       struct raw_sock *ro = raw_sk(sk);
 346 +
 347 +       ro->bound            = 0;
 348 +       ro->ifindex          = 0;
 349 +
 350 +       /* set default filter to single entry dfilter */
 351 +       ro->dfilter.can_id   = 0;
 352 +       ro->dfilter.can_mask = MASK_ALL;
 353 +       ro->filter           = &ro->dfilter;
 354 +       ro->count            = 1;
 355 +
 356 +       /* set default loopback behaviour */
 357 +       ro->loopback         = 1;
 358 +       ro->recv_own_msgs    = 0;
 359 +
 360 +       /* set notifier */
 361 +       ro->notifier.notifier_call = raw_notifier;
 362 +
 363 +       register_netdevice_notifier(&ro->notifier);
 364 +
 365 +       return 0;
 366 +}
 367 +
 368 +static int raw_release(struct socket *sock)
 369 +{
 370 +       struct sock *sk = sock->sk;
 371 +       struct raw_sock *ro = raw_sk(sk);
 372 +
 373 +       unregister_netdevice_notifier(&ro->notifier);
 374 +
 375 +       lock_sock(sk);
 376 +
 377 +       /* remove current filters & unregister */
 378 +       if (ro->bound) {
 379 +               if (ro->ifindex) {
 380 +                       struct net_device *dev;
 381 +
 382 +                       dev = dev_get_by_index(&init_net, ro->ifindex);
 383 +                       if (dev) {
 384 +                               raw_disable_allfilters(dev, sk);
 385 +                               dev_put(dev);
 386 +                       }
 387 +               } else
 388 +                       raw_disable_allfilters(NULL, sk);
 389 +       }
 390 +
 391 +       if (ro->count > 1)
 392 +               kfree(ro->filter);
 393 +
 394 +       ro->ifindex = 0;
 395 +       ro->bound   = 0;
 396 +       ro->count   = 0;
 397 +
 398 +       release_sock(sk);
 399 +       sock_put(sk);
 400 +
 401 +       return 0;
 402 +}
 403 +
 404 +static int raw_bind(struct socket *sock, struct sockaddr *uaddr, int len)
 405 +{
 406 +       struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
 407 +       struct sock *sk = sock->sk;
 408 +       struct raw_sock *ro = raw_sk(sk);
 409 +       int ifindex;
 410 +       int err = 0;
 411 +       int notify_enetdown = 0;
 412 +
 413 +       if (len < sizeof(*addr))
 414 +               return -EINVAL;
 415 +
 416 +       lock_sock(sk);
 417 +
 418 +       if (ro->bound && addr->can_ifindex == ro->ifindex)
 419 +               goto out;
 420 +
 421 +       if (addr->can_ifindex) {
 422 +               struct net_device *dev;
 423 +
 424 +               dev = dev_get_by_index(&init_net, addr->can_ifindex);
 425 +               if (!dev) {
 426 +                       err = -ENODEV;
 427 +                       goto out;
 428 +               }
 429 +               if (dev->type != ARPHRD_CAN) {
 430 +                       dev_put(dev);
 431 +                       err = -ENODEV;
 432 +                       goto out;
 433 +               }
 434 +               if (!(dev->flags & IFF_UP))
 435 +                       notify_enetdown = 1;
 436 +
 437 +               ifindex = dev->ifindex;
 438 +
 439 +               /* filters set by default/setsockopt */
 440 +               err = raw_enable_allfilters(dev, sk);
 441 +               dev_put(dev);
 442 +
 443 +       } else {
 444 +               ifindex = 0;
 445 +
 446 +               /* filters set by default/setsockopt */
 447 +               err = raw_enable_allfilters(NULL, sk);
 448 +       }
 449 +
 450 +       if (!err) {
 451 +               if (ro->bound) {
 452 +                       /* unregister old filters */
 453 +                       if (ro->ifindex) {
 454 +                               struct net_device *dev;
 455 +
 456 +                               dev = dev_get_by_index(&init_net, ro->ifindex);
 457 +                               if (dev) {
 458 +                                       raw_disable_allfilters(dev, sk);
 459 +                                       dev_put(dev);
 460 +                               }
 461 +                       } else
 462 +                               raw_disable_allfilters(NULL, sk);
 463 +               }
 464 +               ro->ifindex = ifindex;
 465 +               ro->bound = 1;
 466 +       }
 467 +
 468 + out:
 469 +       release_sock(sk);
 470 +
 471 +       if (notify_enetdown) {
 472 +               sk->sk_err = ENETDOWN;
 473 +               if (!sock_flag(sk, SOCK_DEAD))
 474 +                       sk->sk_error_report(sk);
 475 +       }
 476 +
 477 +       return err;
 478 +}
 479 +
 480 +static int raw_getname(struct socket *sock, struct sockaddr *uaddr,
 481 +                      int *len, int peer)
 482 +{
 483 +       struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
 484 +       struct sock *sk = sock->sk;
 485 +       struct raw_sock *ro = raw_sk(sk);
 486 +
 487 +       if (peer)
 488 +               return -EOPNOTSUPP;
 489 +
 490 +       addr->can_family  = AF_CAN;
 491 +       addr->can_ifindex = ro->ifindex;
 492 +
 493 +       *len = sizeof(*addr);
 494 +
 495 +       return 0;
 496 +}
 497 +
 498 +static int raw_setsockopt(struct socket *sock, int level, int optname,
 499 +                         char __user *optval, int optlen)
 500 +{
 501 +       struct sock *sk = sock->sk;
 502 +       struct raw_sock *ro = raw_sk(sk);
 503 +       struct can_filter *filter = NULL;  /* dyn. alloc'ed filters */
 504 +       struct can_filter sfilter;         /* single filter */
 505 +       struct net_device *dev = NULL;
 506 +       can_err_mask_t err_mask = 0;
 507 +       int count = 0;
 508 +       int err = 0;
 509 +
 510 +       if (level != SOL_CAN_RAW)
 511 +               return -EINVAL;
 512 +       if (optlen < 0)
 513 +               return -EINVAL;
 514 +
 515 +       switch (optname) {
 516 +
 517 +       case CAN_RAW_FILTER:
 518 +               if (optlen % sizeof(struct can_filter) != 0)
 519 +                       return -EINVAL;
 520 +
 521 +               count = optlen / sizeof(struct can_filter);
 522 +
 523 +               if (count > 1) {
 524 +                       /* filter does not fit into dfilter => alloc space */
 525 +                       filter = kmalloc(optlen, GFP_KERNEL);
 526 +                       if (!filter)
 527 +                               return -ENOMEM;
 528 +
 529 +                       err = copy_from_user(filter, optval, optlen);
 530 +                       if (err) {
 531 +                               kfree(filter);
 532 +                               return err;
 533 +                       }
 534 +               } else if (count == 1) {
 535 +                       err = copy_from_user(&sfilter, optval, optlen);
 536 +                       if (err)
 537 +                               return err;
 538 +               }
 539 +
 540 +               lock_sock(sk);
 541 +
 542 +               if (ro->bound && ro->ifindex)
 543 +                       dev = dev_get_by_index(&init_net, ro->ifindex);
 544 +
 545 +               if (ro->bound) {
 546 +                       /* (try to) register the new filters */
 547 +                       if (count == 1)
 548 +                               err = raw_enable_filters(dev, sk, &sfilter, 1);
 549 +                       else
 550 +                               err = raw_enable_filters(dev, sk, filter,
 551 +                                                        count);
 552 +                       if (err) {
 553 +                               if (count > 1)
 554 +                                       kfree(filter);
 555 +
 556 +                               goto out_fil;
 557 +                       }
 558 +
 559 +                       /* remove old filter registrations */
 560 +                       raw_disable_filters(dev, sk, ro->filter, ro->count);
 561 +               }
 562 +
 563 +               /* remove old filter space */
 564 +               if (ro->count > 1)
 565 +                       kfree(ro->filter);
 566 +
 567 +               /* link new filters to the socket */
 568 +               if (count == 1) {
 569 +                       /* copy filter data for single filter */
 570 +                       ro->dfilter = sfilter;
 571 +                       filter = &ro->dfilter;
 572 +               }
 573 +               ro->filter = filter;
 574 +               ro->count  = count;
 575 +
 576 + out_fil:
 577 +               if (dev)
 578 +                       dev_put(dev);
 579 +
 580 +               release_sock(sk);
 581 +
 582 +               break;
 583 +
 584 +       case CAN_RAW_ERR_FILTER:
 585 +               if (optlen != sizeof(err_mask))
 586 +                       return -EINVAL;
 587 +
 588 +               err = copy_from_user(&err_mask, optval, optlen);
 589 +               if (err)
 590 +                       return err;
 591 +
 592 +               err_mask &= CAN_ERR_MASK;
 593 +
 594 +               lock_sock(sk);
 595 +
 596 +               if (ro->bound && ro->ifindex)
 597 +                       dev = dev_get_by_index(&init_net, ro->ifindex);
 598 +
 599 +               /* remove current error mask */
 600 +               if (ro->bound) {
 601 +                       /* (try to) register the new err_mask */
 602 +                       err = raw_enable_errfilter(dev, sk, err_mask);
 603 +
 604 +                       if (err)
 605 +                               goto out_err;
 606 +
 607 +                       /* remove old err_mask registration */
 608 +                       raw_disable_errfilter(dev, sk, ro->err_mask);
 609 +               }
 610 +
 611 +               /* link new err_mask to the socket */
 612 +               ro->err_mask = err_mask;
 613 +
 614 + out_err:
 615 +               if (dev)
 616 +                       dev_put(dev);
 617 +
 618 +               release_sock(sk);
 619 +
 620 +               break;
 621 +
 622 +       case CAN_RAW_LOOPBACK:
 623 +               if (optlen != sizeof(ro->loopback))
 624 +                       return -EINVAL;
 625 +
 626 +               err = copy_from_user(&ro->loopback, optval, optlen);
 627 +
 628 +               break;
 629 +
 630 +       case CAN_RAW_RECV_OWN_MSGS:
 631 +               if (optlen != sizeof(ro->recv_own_msgs))
 632 +                       return -EINVAL;
 633 +
 634 +               err = copy_from_user(&ro->recv_own_msgs, optval, optlen);
 635 +
 636 +               break;
 637 +
 638 +       default:
 639 +               return -ENOPROTOOPT;
 640 +       }
 641 +       return err;
 642 +}
 643 +
 644 +static int raw_getsockopt(struct socket *sock, int level, int optname,
 645 +                         char __user *optval, int __user *optlen)
 646 +{
 647 +       struct sock *sk = sock->sk;
 648 +       struct raw_sock *ro = raw_sk(sk);
 649 +       int len;
 650 +       void *val;
 651 +       int err = 0;
 652 +
 653 +       if (level != SOL_CAN_RAW)
 654 +               return -EINVAL;
 655 +       if (get_user(len, optlen))
 656 +               return -EFAULT;
 657 +       if (len < 0)
 658 +               return -EINVAL;
 659 +
 660 +       switch (optname) {
 661 +
 662 +       case CAN_RAW_FILTER:
 663 +               lock_sock(sk);
 664 +               if (ro->count > 0) {
 665 +                       int fsize = ro->count * sizeof(struct can_filter);
 666 +                       if (len > fsize)
 667 +                               len = fsize;
 668 +                       err = copy_to_user(optval, ro->filter, len);
 669 +               } else
 670 +                       len = 0;
 671 +               release_sock(sk);
 672 +
 673 +               if (!err)
 674 +                       err = put_user(len, optlen);
 675 +               return err;
 676 +
 677 +       case CAN_RAW_ERR_FILTER:
 678 +               if (len > sizeof(can_err_mask_t))
 679 +                       len = sizeof(can_err_mask_t);
 680 +               val = &ro->err_mask;
 681 +               break;
 682 +
 683 +       case CAN_RAW_LOOPBACK:
 684 +               if (len > sizeof(int))
 685 +                       len = sizeof(int);
 686 +               val = &ro->loopback;
 687 +               break;
 688 +
 689 +       case CAN_RAW_RECV_OWN_MSGS:
 690 +               if (len > sizeof(int))
 691 +                       len = sizeof(int);
 692 +               val = &ro->recv_own_msgs;
 693 +               break;
 694 +
 695 +       default:
 696 +               return -ENOPROTOOPT;
 697 +       }
 698 +
 699 +       if (put_user(len, optlen))
 700 +               return -EFAULT;
 701 +       if (copy_to_user(optval, val, len))
 702 +               return -EFAULT;
 703 +       return 0;
 704 +}
 705 +
 706 +static int raw_sendmsg(struct kiocb *iocb, struct socket *sock,
 707 +                      struct msghdr *msg, size_t size)
 708 +{
 709 +       struct sock *sk = sock->sk;
 710 +       struct raw_sock *ro = raw_sk(sk);
 711 +       struct sk_buff *skb;
 712 +       struct net_device *dev;
 713 +       int ifindex;
 714 +       int err;
 715 +
 716 +       if (msg->msg_name) {
 717 +               struct sockaddr_can *addr =
 718 +                       (struct sockaddr_can *)msg->msg_name;
 719 +
 720 +               if (addr->can_family != AF_CAN)
 721 +                       return -EINVAL;
 722 +
 723 +               ifindex = addr->can_ifindex;
 724 +       } else
 725 +               ifindex = ro->ifindex;
 726 +
 727 +       dev = dev_get_by_index(&init_net, ifindex);
 728 +       if (!dev)
 729 +               return -ENXIO;
 730 +
 731 +       skb = sock_alloc_send_skb(sk, size, msg->msg_flags & MSG_DONTWAIT,
 732 +                                 &err);
 733 +       if (!skb) {
 734 +               dev_put(dev);
 735 +               return err;
 736 +       }
 737 +
 738 +       err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
 739 +       if (err < 0) {
 740 +               kfree_skb(skb);
 741 +               dev_put(dev);
 742 +               return err;
 743 +       }
 744 +       skb->dev = dev;
 745 +       skb->sk  = sk;
 746 +
 747 +       err = can_send(skb, ro->loopback);
 748 +
 749 +       dev_put(dev);
 750 +
 751 +       if (err)
 752 +               return err;
 753 +
 754 +       return size;
 755 +}
 756 +
 757 +static int raw_recvmsg(struct kiocb *iocb, struct socket *sock,
 758 +                      struct msghdr *msg, size_t size, int flags)
 759 +{
 760 +       struct sock *sk = sock->sk;
 761 +       struct sk_buff *skb;
 762 +       int error = 0;
 763 +       int noblock;
 764 +
 765 +       noblock =  flags & MSG_DONTWAIT;
 766 +       flags   &= ~MSG_DONTWAIT;
 767 +
 768 +       skb = skb_recv_datagram(sk, flags, noblock, &error);
 769 +       if (!skb)
 770 +               return error;
 771 +
 772 +       if (size < skb->len)
 773 +               msg->msg_flags |= MSG_TRUNC;
 774 +       else
 775 +               size = skb->len;
 776 +
 777 +       error = memcpy_toiovec(msg->msg_iov, skb->data, size);
 778 +       if (error < 0) {
 779 +               skb_free_datagram(sk, skb);
 780 +               return error;
 781 +       }
 782 +
 783 +       sock_recv_timestamp(msg, sk, skb);
 784 +
 785 +       if (msg->msg_name) {
 786 +               msg->msg_namelen = sizeof(struct sockaddr_can);
 787 +               memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
 788 +       }
 789 +
 790 +       skb_free_datagram(sk, skb);
 791 +
 792 +       return size;
 793 +}
 794 +
 795 +static struct proto_ops raw_ops __read_mostly = {
 796 +       .family        = PF_CAN,
 797 +       .release       = raw_release,
 798 +       .bind          = raw_bind,
 799 +       .connect       = sock_no_connect,
 800 +       .socketpair    = sock_no_socketpair,
 801 +       .accept        = sock_no_accept,
 802 +       .getname       = raw_getname,
 803 +       .poll          = datagram_poll,
 804 +       .ioctl         = NULL,          /* use can_ioctl() from af_can.c */
 805 +       .listen        = sock_no_listen,
 806 +       .shutdown      = sock_no_shutdown,
 807 +       .setsockopt    = raw_setsockopt,
 808 +       .getsockopt    = raw_getsockopt,
 809 +       .sendmsg       = raw_sendmsg,
 810 +       .recvmsg       = raw_recvmsg,
 811 +       .mmap          = sock_no_mmap,
 812 +       .sendpage      = sock_no_sendpage,
 813 +};
 814 +
 815 +static struct proto raw_proto __read_mostly = {
 816 +       .name       = "CAN_RAW",
 817 +       .owner      = THIS_MODULE,
 818 +       .obj_size   = sizeof(struct raw_sock),
 819 +       .init       = raw_init,
 820 +};
 821 +
 822 +static struct can_proto raw_can_proto __read_mostly = {
 823 +       .type       = SOCK_RAW,
 824 +       .protocol   = CAN_RAW,
 825 +       .capability = -1,
 826 +       .ops        = &raw_ops,
 827 +       .prot       = &raw_proto,
 828 +};
 829 +
 830 +static __init int raw_module_init(void)
 831 +{
 832 +       int err;
 833 +
 834 +       printk(banner);
 835 +
 836 +       err = can_proto_register(&raw_can_proto);
 837 +       if (err < 0)
 838 +               printk(KERN_ERR "can: registration of raw protocol failed\n");
 839 +
 840 +       return err;
 841 +}
 842 +
 843 +static __exit void raw_module_exit(void)
 844 +{
 845 +       can_proto_unregister(&raw_can_proto);
 846 +}
 847 +
 848 +module_init(raw_module_init);
 849 +module_exit(raw_module_exit);