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