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