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