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 102 if (!ro->recv_own_msgs) { 103 /* check the received tx sock reference */ 104 if (skb->sk == sk) { 105 kfree_skb(skb); 106 return; 107 } 108 } 109 110 /* 111 * Put the datagram to the queue so that raw_recvmsg() can 112 * get it from there. We need to pass the interface index to 113 * raw_recvmsg(). We pass a whole struct sockaddr_can in skb->cb 114 * containing the interface index. 115 */ 116 117 BUILD_BUG_ON(sizeof(skb->cb) < sizeof(struct sockaddr_can)); 118 addr = (struct sockaddr_can *)skb->cb; 119 memset(addr, 0, sizeof(*addr)); 120 addr->can_family = AF_CAN; 121 addr->can_ifindex = skb->dev->ifindex; 122 123 if (sock_queue_rcv_skb(sk, skb) < 0) 124 kfree_skb(skb); 125 } 126 127 static int raw_enable_filters(struct net_device *dev, struct sock *sk, 128 struct can_filter *filter, int count) 129 { 130 int err = 0; 131 int i; 132 133 for (i = 0; i < count; i++) { 134 err = can_rx_register(dev, filter[i].can_id, 135 filter[i].can_mask, 136 raw_rcv, sk, "raw"); 137 if (err) { 138 /* clean up successfully registered filters */ 139 while (--i >= 0) 140 can_rx_unregister(dev, filter[i].can_id, 141 filter[i].can_mask, 142 raw_rcv, sk); 143 break; 144 } 145 } 146 147 return err; 148 } 149 150 static int raw_enable_errfilter(struct net_device *dev, struct sock *sk, 151 can_err_mask_t err_mask) 152 { 153 int err = 0; 154 155 if (err_mask) 156 err = can_rx_register(dev, 0, err_mask | CAN_ERR_FLAG, 157 raw_rcv, sk, "raw"); 158 159 return err; 160 } 161 162 static void raw_disable_filters(struct net_device *dev, struct sock *sk, 163 struct can_filter *filter, int count) 164 { 165 int i; 166 167 for (i = 0; i < count; i++) 168 can_rx_unregister(dev, filter[i].can_id, filter[i].can_mask, 169 raw_rcv, sk); 170 } 171 172 static inline void raw_disable_errfilter(struct net_device *dev, 173 struct sock *sk, 174 can_err_mask_t err_mask) 175 176 { 177 if (err_mask) 178 can_rx_unregister(dev, 0, err_mask | CAN_ERR_FLAG, 179 raw_rcv, sk); 180 } 181 182 static inline void raw_disable_allfilters(struct net_device *dev, 183 struct sock *sk) 184 { 185 struct raw_sock *ro = raw_sk(sk); 186 187 raw_disable_filters(dev, sk, ro->filter, ro->count); 188 raw_disable_errfilter(dev, sk, ro->err_mask); 189 } 190 191 static int raw_enable_allfilters(struct net_device *dev, struct sock *sk) 192 { 193 struct raw_sock *ro = raw_sk(sk); 194 int err; 195 196 err = raw_enable_filters(dev, sk, ro->filter, ro->count); 197 if (!err) { 198 err = raw_enable_errfilter(dev, sk, ro->err_mask); 199 if (err) 200 raw_disable_filters(dev, sk, ro->filter, ro->count); 201 } 202 203 return err; 204 } 205 206 static int raw_notifier(struct notifier_block *nb, 207 unsigned long msg, void *data) 208 { 209 struct net_device *dev = (struct net_device *)data; 210 struct raw_sock *ro = container_of(nb, struct raw_sock, notifier); 211 struct sock *sk = &ro->sk; 212 213 if (!net_eq(dev_net(dev), &init_net)) 214 return NOTIFY_DONE; 215 216 if (dev->type != ARPHRD_CAN) 217 return NOTIFY_DONE; 218 219 if (ro->ifindex != dev->ifindex) 220 return NOTIFY_DONE; 221 222 switch (msg) { 223 224 case NETDEV_UNREGISTER: 225 lock_sock(sk); 226 /* remove current filters & unregister */ 227 if (ro->bound) 228 raw_disable_allfilters(dev, sk); 229 230 if (ro->count > 1) 231 kfree(ro->filter); 232 233 ro->ifindex = 0; 234 ro->bound = 0; 235 ro->count = 0; 236 release_sock(sk); 237 238 sk->sk_err = ENODEV; 239 if (!sock_flag(sk, SOCK_DEAD)) 240 sk->sk_error_report(sk); 241 break; 242 243 case NETDEV_DOWN: 244 sk->sk_err = ENETDOWN; 245 if (!sock_flag(sk, SOCK_DEAD)) 246 sk->sk_error_report(sk); 247 break; 248 } 249 250 return NOTIFY_DONE; 251 } 252 253 static int raw_init(struct sock *sk) 254 { 255 struct raw_sock *ro = raw_sk(sk); 256 257 ro->bound = 0; 258 ro->ifindex = 0; 259 260 /* set default filter to single entry dfilter */ 261 ro->dfilter.can_id = 0; 262 ro->dfilter.can_mask = MASK_ALL; 263 ro->filter = &ro->dfilter; 264 ro->count = 1; 265 266 /* set default loopback behaviour */ 267 ro->loopback = 1; 268 ro->recv_own_msgs = 0; 269 270 /* set notifier */ 271 ro->notifier.notifier_call = raw_notifier; 272 273 register_netdevice_notifier(&ro->notifier); 274 275 return 0; 276 } 277 278 static int raw_release(struct socket *sock) 279 { 280 struct sock *sk = sock->sk; 281 struct raw_sock *ro = raw_sk(sk); 282 283 unregister_netdevice_notifier(&ro->notifier); 284 285 lock_sock(sk); 286 287 /* remove current filters & unregister */ 288 if (ro->bound) { 289 if (ro->ifindex) { 290 struct net_device *dev; 291 292 dev = dev_get_by_index(&init_net, ro->ifindex); 293 if (dev) { 294 raw_disable_allfilters(dev, sk); 295 dev_put(dev); 296 } 297 } else 298 raw_disable_allfilters(NULL, sk); 299 } 300 301 if (ro->count > 1) 302 kfree(ro->filter); 303 304 ro->ifindex = 0; 305 ro->bound = 0; 306 ro->count = 0; 307 308 release_sock(sk); 309 sock_put(sk); 310 311 return 0; 312 } 313 314 static int raw_bind(struct socket *sock, struct sockaddr *uaddr, int len) 315 { 316 struct sockaddr_can *addr = (struct sockaddr_can *)uaddr; 317 struct sock *sk = sock->sk; 318 struct raw_sock *ro = raw_sk(sk); 319 int ifindex; 320 int err = 0; 321 int notify_enetdown = 0; 322 323 if (len < sizeof(*addr)) 324 return -EINVAL; 325 326 lock_sock(sk); 327 328 if (ro->bound && addr->can_ifindex == ro->ifindex) 329 goto out; 330 331 if (addr->can_ifindex) { 332 struct net_device *dev; 333 334 dev = dev_get_by_index(&init_net, addr->can_ifindex); 335 if (!dev) { 336 err = -ENODEV; 337 goto out; 338 } 339 if (dev->type != ARPHRD_CAN) { 340 dev_put(dev); 341 err = -ENODEV; 342 goto out; 343 } 344 if (!(dev->flags & IFF_UP)) 345 notify_enetdown = 1; 346 347 ifindex = dev->ifindex; 348 349 /* filters set by default/setsockopt */ 350 err = raw_enable_allfilters(dev, sk); 351 dev_put(dev); 352 } else { 353 ifindex = 0; 354 355 /* filters set by default/setsockopt */ 356 err = raw_enable_allfilters(NULL, sk); 357 } 358 359 if (!err) { 360 if (ro->bound) { 361 /* unregister old filters */ 362 if (ro->ifindex) { 363 struct net_device *dev; 364 365 dev = dev_get_by_index(&init_net, ro->ifindex); 366 if (dev) { 367 raw_disable_allfilters(dev, sk); 368 dev_put(dev); 369 } 370 } else 371 raw_disable_allfilters(NULL, sk); 372 } 373 ro->ifindex = ifindex; 374 ro->bound = 1; 375 } 376 377 out: 378 release_sock(sk); 379 380 if (notify_enetdown) { 381 sk->sk_err = ENETDOWN; 382 if (!sock_flag(sk, SOCK_DEAD)) 383 sk->sk_error_report(sk); 384 } 385 386 return err; 387 } 388 389 static int raw_getname(struct socket *sock, struct sockaddr *uaddr, 390 int *len, int peer) 391 { 392 struct sockaddr_can *addr = (struct sockaddr_can *)uaddr; 393 struct sock *sk = sock->sk; 394 struct raw_sock *ro = raw_sk(sk); 395 396 if (peer) 397 return -EOPNOTSUPP; 398 399 addr->can_family = AF_CAN; 400 addr->can_ifindex = ro->ifindex; 401 402 *len = sizeof(*addr); 403 404 return 0; 405 } 406 407 static int raw_setsockopt(struct socket *sock, int level, int optname, 408 char __user *optval, int optlen) 409 { 410 struct sock *sk = sock->sk; 411 struct raw_sock *ro = raw_sk(sk); 412 struct can_filter *filter = NULL; /* dyn. alloc'ed filters */ 413 struct can_filter sfilter; /* single filter */ 414 struct net_device *dev = NULL; 415 can_err_mask_t err_mask = 0; 416 int count = 0; 417 int err = 0; 418 419 if (level != SOL_CAN_RAW) 420 return -EINVAL; 421 if (optlen < 0) 422 return -EINVAL; 423 424 switch (optname) { 425 426 case CAN_RAW_FILTER: 427 if (optlen % sizeof(struct can_filter) != 0) 428 return -EINVAL; 429 430 count = optlen / sizeof(struct can_filter); 431 432 if (count > 1) { 433 /* filter does not fit into dfilter => alloc space */ 434 filter = kmalloc(optlen, GFP_KERNEL); 435 if (!filter) 436 return -ENOMEM; 437 438 if (copy_from_user(filter, optval, optlen)) { 439 kfree(filter); 440 return -EFAULT; 441 } 442 } else if (count == 1) { 443 if (copy_from_user(&sfilter, optval, optlen)) 444 return -EFAULT; 445 } 446 447 lock_sock(sk); 448 449 if (ro->bound && ro->ifindex) 450 dev = dev_get_by_index(&init_net, ro->ifindex); 451 452 if (ro->bound) { 453 /* (try to) register the new filters */ 454 if (count == 1) 455 err = raw_enable_filters(dev, sk, &sfilter, 1); 456 else 457 err = raw_enable_filters(dev, sk, filter, 458 count); 459 if (err) { 460 if (count > 1) 461 kfree(filter); 462 goto out_fil; 463 } 464 465 /* remove old filter registrations */ 466 raw_disable_filters(dev, sk, ro->filter, ro->count); 467 } 468 469 /* remove old filter space */ 470 if (ro->count > 1) 471 kfree(ro->filter); 472 473 /* link new filters to the socket */ 474 if (count == 1) { 475 /* copy filter data for single filter */ 476 ro->dfilter = sfilter; 477 filter = &ro->dfilter; 478 } 479 ro->filter = filter; 480 ro->count = count; 481 482 out_fil: 483 if (dev) 484 dev_put(dev); 485 486 release_sock(sk); 487 488 break; 489 490 case CAN_RAW_ERR_FILTER: 491 if (optlen != sizeof(err_mask)) 492 return -EINVAL; 493 494 if (copy_from_user(&err_mask, optval, optlen)) 495 return -EFAULT; 496 497 err_mask &= CAN_ERR_MASK; 498 499 lock_sock(sk); 500 501 if (ro->bound && ro->ifindex) 502 dev = dev_get_by_index(&init_net, ro->ifindex); 503 504 /* remove current error mask */ 505 if (ro->bound) { 506 /* (try to) register the new err_mask */ 507 err = raw_enable_errfilter(dev, sk, err_mask); 508 509 if (err) 510 goto out_err; 511 512 /* remove old err_mask registration */ 513 raw_disable_errfilter(dev, sk, ro->err_mask); 514 } 515 516 /* link new err_mask to the socket */ 517 ro->err_mask = err_mask; 518 519 out_err: 520 if (dev) 521 dev_put(dev); 522 523 release_sock(sk); 524 525 break; 526 527 case CAN_RAW_LOOPBACK: 528 if (optlen != sizeof(ro->loopback)) 529 return -EINVAL; 530 531 if (copy_from_user(&ro->loopback, optval, optlen)) 532 return -EFAULT; 533 534 break; 535 536 case CAN_RAW_RECV_OWN_MSGS: 537 if (optlen != sizeof(ro->recv_own_msgs)) 538 return -EINVAL; 539 540 if (copy_from_user(&ro->recv_own_msgs, optval, optlen)) 541 return -EFAULT; 542 543 break; 544 545 default: 546 return -ENOPROTOOPT; 547 } 548 return err; 549 } 550 551 static int raw_getsockopt(struct socket *sock, int level, int optname, 552 char __user *optval, int __user *optlen) 553 { 554 struct sock *sk = sock->sk; 555 struct raw_sock *ro = raw_sk(sk); 556 int len; 557 void *val; 558 int err = 0; 559 560 if (level != SOL_CAN_RAW) 561 return -EINVAL; 562 if (get_user(len, optlen)) 563 return -EFAULT; 564 if (len < 0) 565 return -EINVAL; 566 567 switch (optname) { 568 569 case CAN_RAW_FILTER: 570 lock_sock(sk); 571 if (ro->count > 0) { 572 int fsize = ro->count * sizeof(struct can_filter); 573 if (len > fsize) 574 len = fsize; 575 if (copy_to_user(optval, ro->filter, len)) 576 err = -EFAULT; 577 } else 578 len = 0; 579 release_sock(sk); 580 581 if (!err) 582 err = put_user(len, optlen); 583 return err; 584 585 case CAN_RAW_ERR_FILTER: 586 if (len > sizeof(can_err_mask_t)) 587 len = sizeof(can_err_mask_t); 588 val = &ro->err_mask; 589 break; 590 591 case CAN_RAW_LOOPBACK: 592 if (len > sizeof(int)) 593 len = sizeof(int); 594 val = &ro->loopback; 595 break; 596 597 case CAN_RAW_RECV_OWN_MSGS: 598 if (len > sizeof(int)) 599 len = sizeof(int); 600 val = &ro->recv_own_msgs; 601 break; 602 603 default: 604 return -ENOPROTOOPT; 605 } 606 607 if (put_user(len, optlen)) 608 return -EFAULT; 609 if (copy_to_user(optval, val, len)) 610 return -EFAULT; 611 return 0; 612 } 613 614 static int raw_sendmsg(struct kiocb *iocb, struct socket *sock, 615 struct msghdr *msg, size_t size) 616 { 617 struct sock *sk = sock->sk; 618 struct raw_sock *ro = raw_sk(sk); 619 struct sk_buff *skb; 620 struct net_device *dev; 621 int ifindex; 622 int err; 623 624 if (msg->msg_name) { 625 struct sockaddr_can *addr = 626 (struct sockaddr_can *)msg->msg_name; 627 628 if (addr->can_family != AF_CAN) 629 return -EINVAL; 630 631 ifindex = addr->can_ifindex; 632 } else 633 ifindex = ro->ifindex; 634 635 if (size != sizeof(struct can_frame)) 636 return -EINVAL; 637 638 dev = dev_get_by_index(&init_net, ifindex); 639 if (!dev) 640 return -ENXIO; 641 642 skb = sock_alloc_send_skb(sk, size, msg->msg_flags & MSG_DONTWAIT, 643 &err); 644 if (!skb) { 645 dev_put(dev); 646 return err; 647 } 648 649 err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size); 650 if (err < 0) { 651 kfree_skb(skb); 652 dev_put(dev); 653 return err; 654 } 655 skb->dev = dev; 656 skb->sk = sk; 657 658 err = can_send(skb, ro->loopback); 659 660 dev_put(dev); 661 662 if (err) 663 return err; 664 665 return size; 666 } 667 668 static int raw_recvmsg(struct kiocb *iocb, struct socket *sock, 669 struct msghdr *msg, size_t size, int flags) 670 { 671 struct sock *sk = sock->sk; 672 struct sk_buff *skb; 673 int err = 0; 674 int noblock; 675 676 noblock = flags & MSG_DONTWAIT; 677 flags &= ~MSG_DONTWAIT; 678 679 skb = skb_recv_datagram(sk, flags, noblock, &err); 680 if (!skb) 681 return err; 682 683 if (size < skb->len) 684 msg->msg_flags |= MSG_TRUNC; 685 else 686 size = skb->len; 687 688 err = memcpy_toiovec(msg->msg_iov, skb->data, size); 689 if (err < 0) { 690 skb_free_datagram(sk, skb); 691 return err; 692 } 693 694 sock_recv_timestamp(msg, sk, skb); 695 696 if (msg->msg_name) { 697 msg->msg_namelen = sizeof(struct sockaddr_can); 698 memcpy(msg->msg_name, skb->cb, msg->msg_namelen); 699 } 700 701 skb_free_datagram(sk, skb); 702 703 return size; 704 } 705 706 static struct proto_ops raw_ops __read_mostly = { 707 .family = PF_CAN, 708 .release = raw_release, 709 .bind = raw_bind, 710 .connect = sock_no_connect, 711 .socketpair = sock_no_socketpair, 712 .accept = sock_no_accept, 713 .getname = raw_getname, 714 .poll = datagram_poll, 715 .ioctl = NULL, /* use can_ioctl() from af_can.c */ 716 .listen = sock_no_listen, 717 .shutdown = sock_no_shutdown, 718 .setsockopt = raw_setsockopt, 719 .getsockopt = raw_getsockopt, 720 .sendmsg = raw_sendmsg, 721 .recvmsg = raw_recvmsg, 722 .mmap = sock_no_mmap, 723 .sendpage = sock_no_sendpage, 724 }; 725 726 static struct proto raw_proto __read_mostly = { 727 .name = "CAN_RAW", 728 .owner = THIS_MODULE, 729 .obj_size = sizeof(struct raw_sock), 730 .init = raw_init, 731 }; 732 733 static struct can_proto raw_can_proto __read_mostly = { 734 .type = SOCK_RAW, 735 .protocol = CAN_RAW, 736 .capability = -1, 737 .ops = &raw_ops, 738 .prot = &raw_proto, 739 }; 740 741 static __init int raw_module_init(void) 742 { 743 int err; 744 745 printk(banner); 746 747 err = can_proto_register(&raw_can_proto); 748 if (err < 0) 749 printk(KERN_ERR "can: registration of raw protocol failed\n"); 750 751 return err; 752 } 753 754 static __exit void raw_module_exit(void) 755 { 756 can_proto_unregister(&raw_can_proto); 757 } 758 759 module_init(raw_module_init); 760 module_exit(raw_module_exit); 761