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