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 <llcf@volkswagen.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 <net/sock.h>
  53
  54 #include <linux/can/af_can.h>
  55 #include <linux/can/raw.h>
  56
  57 #include "version.h"
  58
  59 RCSID("$Id$");
  60
  61
  62 #define NAME "RAW sockets for LLCF"
  63 #define IDENT "raw"
  64 static __initdata const char banner[] = BANNER(NAME);
  65
  66 MODULE_DESCRIPTION(NAME);
  67 MODULE_LICENSE("Dual BSD/GPL");
  68 MODULE_AUTHOR("Urs Thuermann <urs.thuermann@volkswagen.de>");
  69
  70 #ifdef DEBUG
  71 static int debug = 0;
  72 module_param(debug, int, S_IRUGO);
  73 #define DBG(args...)       (debug & 1 ? \
  74                                (printk(KERN_DEBUG "RAW %s: ", __func__), \
  75                                 printk(args)) : 0)
  76 #define DBG_SKB(skb)       (debug & 4 ? can_debug_skb(skb) : 0)
  77 #else
  78 #define DBG(args...)
  79 #define DBG_SKB(skb)
  80 #endif
  81
  82 static int raw_release(struct socket *sock);
  83 static int raw_bind   (struct socket *sock, struct sockaddr *uaddr, int len);
  84 static int raw_getname(struct socket *sock, struct sockaddr *uaddr,
  85                        int *len, int peer);
  86 static unsigned int raw_poll(struct file *file, struct socket *sock,
  87                              poll_table *wait);
  88 static int raw_setsockopt(struct socket *sock, int level, int optname,
  89                           char *optval, int optlen);
  90 static int raw_getsockopt(struct socket *sock, int level, int optname,
  91                           char *optval, int *optlen);
  92 static int raw_sendmsg(struct kiocb *iocb, struct socket *sock,
  93                        struct msghdr *msg, size_t size);
  94 static int raw_recvmsg(struct kiocb *iocb, struct socket *sock,
  95                        struct msghdr *msg, size_t size, int flags);
  96 static void raw_rcv(struct sk_buff *skb, void *data);
  97 static void raw_notifier(unsigned long msg, void *data);
  98
  99 static void raw_add_filters(struct net_device *dev, struct sock *sk);
 100 static void raw_remove_filters(struct net_device *dev, struct sock *sk);
 101
 102
 103 static struct proto_ops raw_ops = {
 104     .family        = PF_CAN,
 105     .release       = raw_release,
 106     .bind          = raw_bind,
 107     .connect       = sock_no_connect,
 108     .socketpair    = sock_no_socketpair,
 109     .accept        = sock_no_accept,
 110     .getname       = raw_getname,
 111     .poll          = raw_poll,
 112     .ioctl         = 0,
 113     .listen        = sock_no_listen,
 114     .shutdown      = sock_no_shutdown,
 115     .setsockopt    = raw_setsockopt,
 116     .getsockopt    = raw_getsockopt,
 117     .sendmsg       = raw_sendmsg,
 118     .recvmsg       = raw_recvmsg,
 119     .mmap          = sock_no_mmap,
 120     .sendpage      = sock_no_sendpage,
 121 };
 122
 123
 124 struct raw_opt {
 125     int bound;
 126     int ifindex;
 127     int count;
 128     struct can_filter *filter;
 129 };
 130
 131 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,13)
 132
 133 struct raw_sock {
 134     struct sock    sk;
 135     struct raw_opt opt;
 136 };
 137
 138 #define canraw_sk(sk) (&((struct raw_sock *)(sk))->opt)
 139
 140 static struct proto raw_proto = {
 141     .name     = "CAN_RAW",
 142     .owner    = THIS_MODULE,
 143     .obj_size = sizeof(struct raw_sock),
 144 };
 145
 146 static struct can_proto raw_can_proto = {
 147     .ops  = &raw_ops,
 148     .prot = &raw_proto,
 149 };
 150
 151 #else
 152
 153 #define canraw_sk(sk) ((struct raw_opt *)(sk)->sk_protinfo)
 154
 155 static struct can_proto raw_can_proto = {
 156     .ops      = &raw_ops,
 157     .owner    = THIS_MODULE,
 158     .obj_size = sizeof(struct raw_opt),
 159 };
 160
 161 #endif
 162
 163
 164 static __init int raw_init(void)
 165 {
 166     printk(banner);
 167
 168     can_proto_register(CAN_RAW, &raw_can_proto);
 169     return 0;
 170 }
 171
 172 static __exit void raw_exit(void)
 173 {
 174     can_proto_unregister(CAN_RAW);
 175 }
 176
 177 static int raw_release(struct socket *sock)
 178 {
 179     struct sock *sk = sock->sk;
 180     struct net_device *dev = NULL;
 181
 182     DBG("socket %p, sk %p, refcnt %d\n", sock, sk,
 183         atomic_read(&sk->sk_refcnt));
 184
 185     if (canraw_sk(sk)->bound && canraw_sk(sk)->ifindex)
 186         dev = dev_get_by_index(canraw_sk(sk)->ifindex);
 187
 188     /* remove current filters & unregister */
 189     if (canraw_sk(sk)->count > 0) {
 190         if (canraw_sk(sk)->bound)
 191             raw_remove_filters(dev, sk);
 192         kfree(canraw_sk(sk)->filter);
 193     } else if (canraw_sk(sk)->bound)
 194         can_rx_unregister(dev, 0, 0, raw_rcv, sk);
 195
 196     if (dev) {
 197         can_dev_unregister(dev, raw_notifier, sk);
 198         dev_put(dev);
 199     }
 200
 201     sock_put(sk);
 202
 203     return 0;
 204 }
 205
 206 static int raw_bind(struct socket *sock, struct sockaddr *uaddr, int len)
 207 {
 208     struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
 209     struct sock *sk = sock->sk;
 210     struct net_device *dev;
 211
 212     DBG("socket %p to device %d\n", sock, addr->can_ifindex);
 213
 214     if (len < sizeof(*addr))
 215         return -EINVAL;
 216
 217     if (canraw_sk(sk)->bound) {
 218 #if 1
 219         return -EOPNOTSUPP;
 220 #else
 221         /* remove current bindings */
 222         if (canraw_sk(sk)->ifindex) {
 223             dev = dev_get_by_index(canraw_sk(sk)->ifindex);
 224             ;  /* remove notifier */
 225         } else
 226             dev = NULL;
 227         if (canraw_sk(sk)->count > 0) {
 228             raw_remove_filters(sk);
 229         } else {
 230             can_rx_unregister(dev, 0, 0, raw_rcv, sk);
 231         }
 232         if (dev)
 233             dev_put(dev);
 234         canraw_sk(sk)->bound = 0;
 235 #endif
 236     }
 237
 238     if (addr->can_ifindex) {
 239         dev = dev_get_by_index(addr->can_ifindex);
 240         if (!dev) {
 241             DBG("could not find device %d\n", addr->can_ifindex);
 242             return -ENODEV;
 243         }
 244         if (!(dev->flags & IFF_UP)) {
 245             sk->sk_err = ENETDOWN;
 246             sk->sk_error_report(sk);
 247             goto out;
 248         }
 249         can_dev_register(dev, raw_notifier, sk);
 250     } else
 251         dev = NULL;
 252
 253     canraw_sk(sk)->ifindex = addr->can_ifindex;
 254
 255     if (canraw_sk(sk)->count > 0)   /* filters set by setsockopt */
 256         raw_add_filters(dev, sk);
 257     else
 258         can_rx_register(dev, 0, 0, raw_rcv, sk, IDENT);
 259
 260     canraw_sk(sk)->bound = 1;
 261
 262  out:
 263     if (dev)
 264         dev_put(dev);
 265
 266     return 0;
 267 }
 268
 269 static int raw_getname(struct socket *sock, struct sockaddr *uaddr,
 270                        int *len, int peer)
 271 {
 272     struct sockaddr_can *addr = (struct sockaddr_can *)uaddr;
 273     struct sock *sk = sock->sk;
 274
 275     if (peer)
 276         return -EOPNOTSUPP;
 277
 278     addr->can_family  = AF_CAN;
 279     addr->can_ifindex = canraw_sk(sk)->ifindex;
 280     *len = sizeof(*addr);
 281
 282     return 0;
 283 }
 284
 285 static unsigned int raw_poll(struct file *file, struct socket *sock,
 286                              poll_table *wait)
 287 {
 288     unsigned int mask = 0;
 289
 290     DBG("socket %p\n", sock);
 291
 292     mask = datagram_poll(file, sock, wait);
 293     return mask;
 294 }
 295
 296 static int raw_setsockopt(struct socket *sock, int level, int optname,
 297                           char *optval, int optlen)
 298 {
 299     struct sock *sk = sock->sk;
 300     struct can_filter *filter = NULL;
 301     struct net_device *dev = NULL;
 302     int count = 0;
 303     int err;
 304
 305     if (level != SOL_CAN_RAW)
 306         return -EINVAL;
 307
 308     switch (optname) {
 309     case CAN_RAW_FILTER:
 310         if (optlen) {
 311             if (optlen % sizeof(struct can_filter) != 0)
 312                 return -EINVAL;
 313             if (!(filter = kmalloc(optlen, GFP_KERNEL)))
 314                 return -ENOMEM;
 315             if (err = copy_from_user(filter, optval, optlen)) {
 316                 kfree(filter);
 317                 return err;
 318             }
 319             count = optlen / sizeof(struct can_filter);
 320         }
 321
 322         if (canraw_sk(sk)->bound && canraw_sk(sk)->ifindex)
 323             dev = dev_get_by_index(canraw_sk(sk)->ifindex);
 324
 325         /* remove current filters & unregister */
 326         if (canraw_sk(sk)->count > 0) {
 327
 328             if (canraw_sk(sk)->bound)
 329                 raw_remove_filters(dev, sk);
 330
 331             kfree(canraw_sk(sk)->filter);
 332             canraw_sk(sk)->count = 0;
 333             canraw_sk(sk)->filter = NULL;
 334         } else if (canraw_sk(sk)->bound)
 335             can_rx_unregister(dev, 0, 0, raw_rcv, sk);
 336
 337         /* add new filters & register */
 338         if (optlen) {
 339             canraw_sk(sk)->filter = filter;
 340             canraw_sk(sk)->count  = count;
 341             if (canraw_sk(sk)->bound)
 342                 raw_add_filters(dev, sk);
 343         } else if (canraw_sk(sk)->bound)
 344             can_rx_register(dev, 0, 0, raw_rcv, sk, IDENT);
 345
 346         if (dev)
 347             dev_put(dev);
 348
 349         break;
 350
 351     default:
 352         return -ENOPROTOOPT;
 353     }
 354     return 0;
 355 }
 356
 357 static int raw_getsockopt(struct socket *sock, int level, int optname,
 358                           char *optval, int *optlen)
 359 {
 360     struct sock *sk = sock->sk;
 361     struct can_filter *filter = canraw_sk(sk)->filter;
 362     int len;
 363
 364     if (level != SOL_CAN_RAW)
 365         return -EINVAL;
 366
 367     switch (optname) {
 368     case CAN_RAW_FILTER:
 369         if (get_user(len, optlen))
 370             return -EFAULT;
 371
 372         if (filter) {
 373             int filter_size = canraw_sk(sk)->count * sizeof(struct can_filter);
 374             if (len < filter_size)
 375                 return -EINVAL;
 376             if (len > filter_size)
 377                 len = filter_size;
 378             if (copy_to_user(optval, filter, len))
 379                 return -EFAULT;
 380         } else
 381             len = 0;
 382         if (put_user(len, optlen))
 383             return -EFAULT;
 384         break;
 385
 386     default:
 387         return -ENOPROTOOPT;
 388     }
 389     return 0;
 390 }
 391
 392 static void raw_add_filters(struct net_device *dev, struct sock *sk)
 393 {
 394     struct can_filter *filter = canraw_sk(sk)->filter;
 395     int i;
 396
 397     for (i = 0; i < canraw_sk(sk)->count; i++) {
 398         can_rx_register(dev, filter[i].can_id, filter[i].can_mask,
 399                         raw_rcv, sk, IDENT);
 400         DBG("filter can_id %08X, can_mask %08X%s, sk %p\n",
 401             filter[i].can_id, filter[i].can_mask,
 402             filter[i].can_id & CAN_INV_FILTER ? " (inv)" : "", sk);
 403     }
 404 }
 405
 406 static void raw_remove_filters(struct net_device *dev, struct sock *sk)
 407 {
 408     struct can_filter *filter = canraw_sk(sk)->filter;
 409     int i;
 410
 411     for (i = 0; i < canraw_sk(sk)->count; i++) {
 412         can_rx_unregister(dev, filter[i].can_id, filter[i].can_mask,
 413                           raw_rcv, sk);
 414         DBG("filter can_id %08X, can_mask %08X%s, sk %p\n",
 415             filter[i].can_id, filter[i].can_mask,
 416             filter[i].can_id & CAN_INV_FILTER ? " (inv)" : "", sk);
 417     }
 418 }
 419
 420 static int raw_sendmsg(struct kiocb *iocb, struct socket *sock,
 421                        struct msghdr *msg, size_t size)
 422 {
 423     struct sock *sk = sock->sk;
 424     struct sk_buff *skb;
 425     struct net_device *dev;
 426     int ifindex;
 427     int err;
 428
 429     DBG("socket %p, sk %p\n", sock, sk);
 430
 431     if (msg->msg_name) {
 432         struct sockaddr_can *addr = (struct sockaddr_can *)msg->msg_name;
 433         if (addr->can_family != AF_CAN)
 434             return -EINVAL;
 435         ifindex = addr->can_ifindex;
 436     } else
 437         ifindex = canraw_sk(sk)->ifindex;
 438
 439     if (!(dev = dev_get_by_index(ifindex))) {
 440         DBG("device %d not found\n", ifindex);
 441         return -ENXIO;
 442     }
 443
 444     skb = alloc_skb(size, GFP_KERNEL);
 445     if ((err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size)) < 0) {
 446         kfree_skb(skb);
 447         return err;
 448     }
 449     skb->dev = dev;
 450
 451     DBG("sending skbuff to interface %d\n", ifindex);
 452     DBG_SKB(skb);
 453
 454     err = can_send(skb);
 455
 456     dev_put(dev);
 457
 458     if (err)
 459         return err;
 460
 461     return size;
 462 }
 463
 464 static int raw_recvmsg(struct kiocb *iocb, struct socket *sock,
 465                        struct msghdr *msg, size_t size, int flags)
 466 {
 467     struct sock *sk = sock->sk;
 468     struct sk_buff *skb;
 469     int error = 0;
 470     int noblock;
 471
 472     DBG("socket %p, sk %p\n", sock, sk);
 473
 474     noblock =  flags & MSG_DONTWAIT;
 475     flags   &= ~MSG_DONTWAIT;
 476     if (!(skb = skb_recv_datagram(sk, flags, noblock, &error))) {
 477         return error;
 478     }
 479
 480     DBG("delivering skbuff %p\n", skb);
 481     DBG_SKB(skb);
 482
 483     if (size < skb->len)
 484         msg->msg_flags |= MSG_TRUNC;
 485     else
 486         size = skb->len;
 487     if ((error = memcpy_toiovec(msg->msg_iov, skb->data, size)) < 0) {
 488         skb_free_datagram(sk, skb);
 489         return error;
 490     }
 491
 492     sock_recv_timestamp(msg, sk, skb);
 493
 494     if (msg->msg_name) {
 495         msg->msg_namelen = sizeof(struct sockaddr_can);
 496         memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
 497     }
 498
 499     DBG("freeing sock %p, skbuff %p\n", sk, skb);
 500     skb_free_datagram(sk, skb);
 501
 502     return size;
 503 }
 504
 505 static void raw_rcv(struct sk_buff *skb, void *data)
 506 {
 507     struct sock *sk = (struct sock*)data;
 508     struct sockaddr_can *addr;
 509     int error;
 510
 511     DBG("received skbuff %p, sk %p\n", skb, sk);
 512     DBG_SKB(skb);
 513
 514     addr = (struct sockaddr_can *)skb->cb;
 515     memset(addr, 0, sizeof(*addr));
 516     addr->can_family  = AF_CAN;
 517     addr->can_ifindex = skb->dev->ifindex;
 518
 519     if ((error = sock_queue_rcv_skb(sk, skb)) < 0) {
 520         DBG("sock_queue_rcv_skb failed: %d\n", error);
 521         DBG("freeing skbuff %p\n", skb);
 522         kfree_skb(skb);
 523     }
 524 }
 525
 526 static void raw_notifier(unsigned long msg, void *data)
 527 {
 528     struct sock *sk = (struct sock *)data;
 529
 530     DBG("called for sock %p\n", sk);
 531
 532     switch (msg) {
 533     case NETDEV_UNREGISTER:
 534         canraw_sk(sk)->ifindex = 0;
 535         /* fallthrough */
 536     case NETDEV_DOWN:
 537         sk->sk_err = ENETDOWN;
 538         sk->sk_error_report(sk);
 539         break;
 540     }
 541 }
 542
 543
 544 module_init(raw_init);
 545 module_exit(raw_exit);