net/packet/af_packet.c

   1 /*
   2  * INET         An implementation of the TCP/IP protocol suite for the LINUX
   3  *              operating system.  INET is implemented using the  BSD Socket
   4  *              interface as the means of communication with the user level.
   5  *
   6  *              PACKET - implements raw packet sockets.
   7  *
   8  * Version:     $Id: af_packet.c,v 1.61 2002/02/08 03:57:19 davem Exp $
   9  *
  10  * Authors:     Ross Biro
  11  *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  12  *              Alan Cox, <gw4pts@gw4pts.ampr.org>
  13  *
  14  * Fixes:
  15  *              Alan Cox        :       verify_area() now used correctly
  16  *              Alan Cox        :       new skbuff lists, look ma no backlogs!
  17  *              Alan Cox        :       tidied skbuff lists.
  18  *              Alan Cox        :       Now uses generic datagram routines I
  19  *                                      added. Also fixed the peek/read crash
  20  *                                      from all old Linux datagram code.
  21  *              Alan Cox        :       Uses the improved datagram code.
  22  *              Alan Cox        :       Added NULL's for socket options.
  23  *              Alan Cox        :       Re-commented the code.
  24  *              Alan Cox        :       Use new kernel side addressing
  25  *              Rob Janssen     :       Correct MTU usage.
  26  *              Dave Platt      :       Counter leaks caused by incorrect
  27  *                                      interrupt locking and some slightly
  28  *                                      dubious gcc output. Can you read
  29  *                                      compiler: it said _VOLATILE_
  30  *      Richard Kooijman        :       Timestamp fixes.
  31  *              Alan Cox        :       New buffers. Use sk->mac.raw.
  32  *              Alan Cox        :       sendmsg/recvmsg support.
  33  *              Alan Cox        :       Protocol setting support
  34  *      Alexey Kuznetsov        :       Untied from IPv4 stack.
  35  *      Cyrus Durgin            :       Fixed kerneld for kmod.
  36  *      Michal Ostrowski        :       Module initialization cleanup.
  37  *         Ulises Alonso        :       Frame number limit removal and
  38  *                                      packet_set_ring memory leak.
  39  *
  40  *              This program is free software; you can redistribute it and/or
  41  *              modify it under the terms of the GNU General Public License
  42  *              as published by the Free Software Foundation; either version
  43  *              2 of the License, or (at your option) any later version.
  44  *
  45  */
  46
  47 #include <linux/config.h>
  48 #include <linux/types.h>
  49 #include <linux/sched.h>
  50 #include <linux/mm.h>
  51 #include <linux/fcntl.h>
  52 #include <linux/socket.h>
  53 #include <linux/in.h>
  54 #include <linux/inet.h>
  55 #include <linux/netdevice.h>
  56 #include <linux/if_packet.h>
  57 #include <linux/wireless.h>
  58 #include <linux/kmod.h>
  59 #include <net/ip.h>
  60 #include <net/protocol.h>
  61 #include <linux/skbuff.h>
  62 #include <net/sock.h>
  63 #include <linux/errno.h>
  64 #include <linux/timer.h>
  65 #include <asm/system.h>
  66 #include <asm/uaccess.h>
  67 #include <asm/ioctls.h>
  68 #include <asm/page.h>
  69 #include <asm/io.h>
  70 #include <linux/proc_fs.h>
  71 #include <linux/seq_file.h>
  72 #include <linux/poll.h>
  73 #include <linux/module.h>
  74 #include <linux/init.h>
  75
  76 #ifdef CONFIG_INET
  77 #include <net/inet_common.h>
  78 #endif
  79
  80 #define CONFIG_SOCK_PACKET      1
  81
  82 /*
  83    Proposed replacement for SIOC{ADD,DEL}MULTI and
  84    IFF_PROMISC, IFF_ALLMULTI flags.
  85
  86    It is more expensive, but I believe,
  87    it is really correct solution: reentereble, safe and fault tolerant.
  88
  89    IFF_PROMISC/IFF_ALLMULTI/SIOC{ADD/DEL}MULTI are faked by keeping
  90    reference count and global flag, so that real status is
  91    (gflag|(count != 0)), so that we can use obsolete faulty interface
  92    not harming clever users.
  93  */
  94 #define CONFIG_PACKET_MULTICAST 1
  95
  96 /*
  97    Assumptions:
  98    - if device has no dev->hard_header routine, it adds and removes ll header
  99      inside itself. In this case ll header is invisible outside of device,
 100      but higher levels still should reserve dev->hard_header_len.
 101      Some devices are enough clever to reallocate skb, when header
 102      will not fit to reserved space (tunnel), another ones are silly
 103      (PPP).
 104    - packet socket receives packets with pulled ll header,
 105      so that SOCK_RAW should push it back.
 106
 107 On receive:
 108 -----------
 109
 110 Incoming, dev->hard_header!=NULL
 111    mac.raw -> ll header
 112    data    -> data
 113
 114 Outgoing, dev->hard_header!=NULL
 115    mac.raw -> ll header
 116    data    -> ll header
 117
 118 Incoming, dev->hard_header==NULL
 119    mac.raw -> UNKNOWN position. It is very likely, that it points to ll header.
 120               PPP makes it, that is wrong, because introduce assymetry
 121               between rx and tx paths.
 122    data    -> data
 123
 124 Outgoing, dev->hard_header==NULL
 125    mac.raw -> data. ll header is still not built!
 126    data    -> data
 127
 128 Resume
 129   If dev->hard_header==NULL we are unlikely to restore sensible ll header.
 130
 131
 132 On transmit:
 133 ------------
 134
 135 dev->hard_header != NULL
 136    mac.raw -> ll header
 137    data    -> ll header
 138
 139 dev->hard_header == NULL (ll header is added by device, we cannot control it)
 140    mac.raw -> data
 141    data -> data
 142
 143    We should set nh.raw on output to correct posistion,
 144    packet classifier depends on it.
 145  */
 146
 147 /* List of all packet sockets. */
 148 static HLIST_HEAD(packet_sklist);
 149 static DEFINE_RWLOCK(packet_sklist_lock);
 150
 151 static atomic_t packet_socks_nr;
 152
 153
 154 /* Private packet socket structures. */
 155
 156 #ifdef CONFIG_PACKET_MULTICAST
 157 struct packet_mclist
 158 {
 159         struct packet_mclist    *next;
 160         int                     ifindex;
 161         int                     count;
 162         unsigned short          type;
 163         unsigned short          alen;
 164         unsigned char           addr[8];
 165 };
 166 #endif
 167 #ifdef CONFIG_PACKET_MMAP
 168 static int packet_set_ring(struct sock *sk, struct tpacket_req *req, int closing);
 169 #endif
 170
 171 static void packet_flush_mclist(struct sock *sk);
 172
 173 struct packet_sock {
 174         /* struct sock has to be the first member of packet_sock */
 175         struct sock             sk;
 176         struct tpacket_stats    stats;
 177 #ifdef CONFIG_PACKET_MMAP
 178         char *                  *pg_vec;
 179         unsigned int            head;
 180         unsigned int            frames_per_block;
 181         unsigned int            frame_size;
 182         unsigned int            frame_max;
 183         int                     copy_thresh;
 184 #endif
 185         struct packet_type      prot_hook;
 186         spinlock_t              bind_lock;
 187         char                    running;        /* prot_hook is attached*/
 188         int                     ifindex;        /* bound device         */
 189         unsigned short          num;
 190 #ifdef CONFIG_PACKET_MULTICAST
 191         struct packet_mclist    *mclist;
 192 #endif
 193 #ifdef CONFIG_PACKET_MMAP
 194         atomic_t                mapped;
 195         unsigned int            pg_vec_order;
 196         unsigned int            pg_vec_pages;
 197         unsigned int            pg_vec_len;
 198 #endif
 199 };
 200
 201 #ifdef CONFIG_PACKET_MMAP
 202
 203 static inline char *packet_lookup_frame(struct packet_sock *po, unsigned int position)
 204 {
 205         unsigned int pg_vec_pos, frame_offset;
 206         char *frame;
 207
 208         pg_vec_pos = position / po->frames_per_block;
 209         frame_offset = position % po->frames_per_block;
 210
 211         frame = po->pg_vec[pg_vec_pos] + (frame_offset * po->frame_size);
 212
 213         return frame;
 214 }
 215 #endif
 216
 217 static inline struct packet_sock *pkt_sk(struct sock *sk)
 218 {
 219         return (struct packet_sock *)sk;
 220 }
 221
 222 static void packet_sock_destruct(struct sock *sk)
 223 {
 224         BUG_TRAP(!atomic_read(&sk->sk_rmem_alloc));
 225         BUG_TRAP(!atomic_read(&sk->sk_wmem_alloc));
 226         BUG_ON(sk->sk_nx_info);
 227         BUG_ON(sk->sk_vx_info);
 228
 229         if (!sock_flag(sk, SOCK_DEAD)) {
 230                 printk("Attempt to release alive packet socket: %p\n", sk);
 231                 return;
 232         }
 233
 234         atomic_dec(&packet_socks_nr);
 235 #ifdef PACKET_REFCNT_DEBUG
 236         printk(KERN_DEBUG "PACKET socket %p is free, %d are alive\n", sk, atomic_read(&packet_socks_nr));
 237 #endif
 238 }
 239
 240
 241 static struct proto_ops packet_ops;
 242
 243 #ifdef CONFIG_SOCK_PACKET
 244 static struct proto_ops packet_ops_spkt;
 245
 246 static int packet_rcv_spkt(struct sk_buff *skb, struct net_device *dev,  struct packet_type *pt)
 247 {
 248         struct sock *sk;
 249         struct sockaddr_pkt *spkt;
 250
 251         /*
 252          *      When we registered the protocol we saved the socket in the data
 253          *      field for just this event.
 254          */
 255
 256         sk = pt->af_packet_priv;
 257
 258         /*
 259          *      Yank back the headers [hope the device set this
 260          *      right or kerboom...]
 261          *
 262          *      Incoming packets have ll header pulled,
 263          *      push it back.
 264          *
 265          *      For outgoing ones skb->data == skb->mac.raw
 266          *      so that this procedure is noop.
 267          */
 268
 269         if (skb->pkt_type == PACKET_LOOPBACK)
 270                 goto out;
 271
 272         if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
 273                 goto oom;
 274
 275         /* drop any routing info */
 276         dst_release(skb->dst);
 277         skb->dst = NULL;
 278
 279         spkt = (struct sockaddr_pkt*)skb->cb;
 280
 281         skb_push(skb, skb->data-skb->mac.raw);
 282
 283         /*
 284          *      The SOCK_PACKET socket receives _all_ frames.
 285          */
 286
 287         spkt->spkt_family = dev->type;
 288         strlcpy(spkt->spkt_device, dev->name, sizeof(spkt->spkt_device));
 289         spkt->spkt_protocol = skb->protocol;
 290
 291         /*
 292          *      Charge the memory to the socket. This is done specifically
 293          *      to prevent sockets using all the memory up.
 294          */
 295
 296         if (sock_queue_rcv_skb(sk,skb) == 0)
 297                 return 0;
 298
 299 out:
 300         kfree_skb(skb);
 301 oom:
 302         return 0;
 303 }
 304
 305
 306 /*
 307  *      Output a raw packet to a device layer. This bypasses all the other
 308  *      protocol layers and you must therefore supply it with a complete frame
 309  */
 310
 311 static int packet_sendmsg_spkt(struct kiocb *iocb, struct socket *sock,
 312                                struct msghdr *msg, size_t len)
 313 {
 314         struct sock *sk = sock->sk;
 315         struct sockaddr_pkt *saddr=(struct sockaddr_pkt *)msg->msg_name;
 316         struct sk_buff *skb;
 317         struct net_device *dev;
 318         unsigned short proto=0;
 319         int err;
 320
 321         /*
 322          *      Get and verify the address.
 323          */
 324
 325         if (saddr)
 326         {
 327                 if (msg->msg_namelen < sizeof(struct sockaddr))
 328                         return(-EINVAL);
 329                 if (msg->msg_namelen==sizeof(struct sockaddr_pkt))
 330                         proto=saddr->spkt_protocol;
 331         }
 332         else
 333                 return(-ENOTCONN);      /* SOCK_PACKET must be sent giving an address */
 334
 335         /*
 336          *      Find the device first to size check it
 337          */
 338
 339         saddr->spkt_device[13] = 0;
 340         dev = dev_get_by_name(saddr->spkt_device);
 341         err = -ENODEV;
 342         if (dev == NULL)
 343                 goto out_unlock;
 344
 345         /*
 346          *      You may not queue a frame bigger than the mtu. This is the lowest level
 347          *      raw protocol and you must do your own fragmentation at this level.
 348          */
 349
 350         err = -EMSGSIZE;
 351         if(len>dev->mtu+dev->hard_header_len)
 352                 goto out_unlock;
 353
 354         err = -ENOBUFS;
 355         skb = sock_wmalloc(sk, len + LL_RESERVED_SPACE(dev), 0, GFP_KERNEL);
 356
 357         /*
 358          *      If the write buffer is full, then tough. At this level the user gets to
 359          *      deal with the problem - do your own algorithmic backoffs. That's far
 360          *      more flexible.
 361          */
 362
 363         if (skb == NULL)
 364                 goto out_unlock;
 365
 366         /*
 367          *      Fill it in
 368          */
 369
 370         /* FIXME: Save some space for broken drivers that write a
 371          * hard header at transmission time by themselves. PPP is the
 372          * notable one here. This should really be fixed at the driver level.
 373          */
 374         skb_reserve(skb, LL_RESERVED_SPACE(dev));
 375         skb->nh.raw = skb->data;
 376
 377         /* Try to align data part correctly */
 378         if (dev->hard_header) {
 379                 skb->data -= dev->hard_header_len;
 380                 skb->tail -= dev->hard_header_len;
 381                 if (len < dev->hard_header_len)
 382                         skb->nh.raw = skb->data;
 383         }
 384
 385         /* Returns -EFAULT on error */
 386         err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
 387         skb->protocol = proto;
 388         skb->dev = dev;
 389         skb->priority = sk->sk_priority;
 390         if (err)
 391                 goto out_free;
 392
 393         err = -ENETDOWN;
 394         if (!(dev->flags & IFF_UP))
 395                 goto out_free;
 396
 397         /*
 398          *      Now send it
 399          */
 400
 401         dev_queue_xmit(skb);
 402         dev_put(dev);
 403         return(len);
 404
 405 out_free:
 406         kfree_skb(skb);
 407 out_unlock:
 408         if (dev)
 409                 dev_put(dev);
 410         return err;
 411 }
 412 #endif
 413
 414 static inline unsigned run_filter(struct sk_buff *skb, struct sock *sk, unsigned res)
 415 {
 416         struct sk_filter *filter;
 417
 418         bh_lock_sock(sk);
 419         filter = sk->sk_filter;
 420         /*
 421          * Our caller already checked that filter != NULL but we need to
 422          * verify that under bh_lock_sock() to be safe
 423          */
 424         if (likely(filter != NULL))
 425                 res = sk_run_filter(skb, filter->insns, filter->len);
 426         bh_unlock_sock(sk);
 427
 428         return res;
 429 }
 430
 431 /*
 432    This function makes lazy skb cloning in hope that most of packets
 433    are discarded by BPF.
 434
 435    Note tricky part: we DO mangle shared skb! skb->data, skb->len
 436    and skb->cb are mangled. It works because (and until) packets
 437    falling here are owned by current CPU. Output packets are cloned
 438    by dev_queue_xmit_nit(), input packets are processed by net_bh
 439    sequencially, so that if we return skb to original state on exit,
 440    we will not harm anyone.
 441  */
 442
 443 static int packet_rcv(struct sk_buff *skb, struct net_device *dev,  struct packet_type *pt)
 444 {
 445         struct sock *sk;
 446         struct sockaddr_ll *sll;
 447         struct packet_sock *po;
 448         u8 * skb_head = skb->data;
 449         int skb_len = skb->len;
 450         unsigned snaplen;
 451
 452         if (skb->pkt_type == PACKET_LOOPBACK)
 453                 goto drop;
 454
 455         sk = pt->af_packet_priv;
 456         po = pkt_sk(sk);
 457
 458 #if defined(CONFIG_VNET) || defined(CONFIG_VNET_MODULE)
 459         if (vnet_active &&
 460             (int) sk->sk_xid > 0 && sk->sk_xid != skb->xid)
 461                 goto drop;
 462 #endif
 463
 464         skb->dev = dev;
 465
 466         if (dev->hard_header) {
 467                 /* The device has an explicit notion of ll header,
 468                    exported to higher levels.
 469
 470                    Otherwise, the device hides datails of it frame
 471                    structure, so that corresponding packet head
 472                    never delivered to user.
 473                  */
 474                 if (sk->sk_type != SOCK_DGRAM)
 475                         skb_push(skb, skb->data - skb->mac.raw);
 476                 else if (skb->pkt_type == PACKET_OUTGOING) {
 477                         /* Special case: outgoing packets have ll header at head */
 478                         skb_pull(skb, skb->nh.raw - skb->data);
 479                 }
 480         }
 481
 482         snaplen = skb->len;
 483
 484         if (sk->sk_filter) {
 485                 unsigned res = run_filter(skb, sk, snaplen);
 486                 if (res == 0)
 487                         goto drop_n_restore;
 488                 if (snaplen > res)
 489                         snaplen = res;
 490         }
 491
 492         if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
 493             (unsigned)sk->sk_rcvbuf)
 494                 goto drop_n_acct;
 495
 496         if (skb_shared(skb)) {
 497                 struct sk_buff *nskb = skb_clone(skb, GFP_ATOMIC);
 498                 if (nskb == NULL)
 499                         goto drop_n_acct;
 500
 501                 if (skb_head != skb->data) {
 502                         skb->data = skb_head;
 503                         skb->len = skb_len;
 504                 }
 505                 kfree_skb(skb);
 506                 skb = nskb;
 507         }
 508
 509         sll = (struct sockaddr_ll*)skb->cb;
 510         sll->sll_family = AF_PACKET;
 511         sll->sll_hatype = dev->type;
 512         sll->sll_protocol = skb->protocol;
 513         sll->sll_pkttype = skb->pkt_type;
 514         sll->sll_ifindex = dev->ifindex;
 515         sll->sll_halen = 0;
 516
 517         if (dev->hard_header_parse)
 518                 sll->sll_halen = dev->hard_header_parse(skb, sll->sll_addr);
 519
 520         if (pskb_trim(skb, snaplen))
 521                 goto drop_n_acct;
 522
 523         skb_set_owner_r(skb, sk);
 524         skb->dev = NULL;
 525         dst_release(skb->dst);
 526         skb->dst = NULL;
 527
 528         spin_lock(&sk->sk_receive_queue.lock);
 529         po->stats.tp_packets++;
 530         __skb_queue_tail(&sk->sk_receive_queue, skb);
 531         spin_unlock(&sk->sk_receive_queue.lock);
 532         sk->sk_data_ready(sk, skb->len);
 533         return 0;
 534
 535 drop_n_acct:
 536         spin_lock(&sk->sk_receive_queue.lock);
 537         po->stats.tp_drops++;
 538         spin_unlock(&sk->sk_receive_queue.lock);
 539
 540 drop_n_restore:
 541         if (skb_head != skb->data && skb_shared(skb)) {
 542                 skb->data = skb_head;
 543                 skb->len = skb_len;
 544         }
 545 drop:
 546         kfree_skb(skb);
 547         return 0;
 548 }
 549
 550 #ifdef CONFIG_PACKET_MMAP
 551 static int tpacket_rcv(struct sk_buff *skb, struct net_device *dev,  struct packet_type *pt)
 552 {
 553         struct sock *sk;
 554         struct packet_sock *po;
 555         struct sockaddr_ll *sll;
 556         struct tpacket_hdr *h;
 557         u8 * skb_head = skb->data;
 558         int skb_len = skb->len;
 559         unsigned snaplen;
 560         unsigned long status = TP_STATUS_LOSING|TP_STATUS_USER;
 561         unsigned short macoff, netoff;
 562         struct sk_buff *copy_skb = NULL;
 563
 564         if (skb->pkt_type == PACKET_LOOPBACK)
 565                 goto drop;
 566
 567         sk = pt->af_packet_priv;
 568         po = pkt_sk(sk);
 569
 570         if (dev->hard_header) {
 571                 if (sk->sk_type != SOCK_DGRAM)
 572                         skb_push(skb, skb->data - skb->mac.raw);
 573                 else if (skb->pkt_type == PACKET_OUTGOING) {
 574                         /* Special case: outgoing packets have ll header at head */
 575                         skb_pull(skb, skb->nh.raw - skb->data);
 576                         if (skb->ip_summed == CHECKSUM_HW)
 577                                 status |= TP_STATUS_CSUMNOTREADY;
 578                 }
 579         }
 580
 581         snaplen = skb->len;
 582
 583         if (sk->sk_filter) {
 584                 unsigned res = run_filter(skb, sk, snaplen);
 585                 if (res == 0)
 586                         goto drop_n_restore;
 587                 if (snaplen > res)
 588                         snaplen = res;
 589         }
 590
 591         if (sk->sk_type == SOCK_DGRAM) {
 592                 macoff = netoff = TPACKET_ALIGN(TPACKET_HDRLEN) + 16;
 593         } else {
 594                 unsigned maclen = skb->nh.raw - skb->data;
 595                 netoff = TPACKET_ALIGN(TPACKET_HDRLEN + (maclen < 16 ? 16 : maclen));
 596                 macoff = netoff - maclen;
 597         }
 598
 599         if (macoff + snaplen > po->frame_size) {
 600                 if (po->copy_thresh &&
 601                     atomic_read(&sk->sk_rmem_alloc) + skb->truesize <
 602                     (unsigned)sk->sk_rcvbuf) {
 603                         if (skb_shared(skb)) {
 604                                 copy_skb = skb_clone(skb, GFP_ATOMIC);
 605                         } else {
 606                                 copy_skb = skb_get(skb);
 607                                 skb_head = skb->data;
 608                         }
 609                         if (copy_skb)
 610                                 skb_set_owner_r(copy_skb, sk);
 611                 }
 612                 snaplen = po->frame_size - macoff;
 613                 if ((int)snaplen < 0)
 614                         snaplen = 0;
 615         }
 616         if (snaplen > skb->len-skb->data_len)
 617                 snaplen = skb->len-skb->data_len;
 618
 619         spin_lock(&sk->sk_receive_queue.lock);
 620         h = (struct tpacket_hdr *)packet_lookup_frame(po, po->head);
 621
 622         if (h->tp_status)
 623                 goto ring_is_full;
 624         po->head = po->head != po->frame_max ? po->head+1 : 0;
 625         po->stats.tp_packets++;
 626         if (copy_skb) {
 627                 status |= TP_STATUS_COPY;
 628                 __skb_queue_tail(&sk->sk_receive_queue, copy_skb);
 629         }
 630         if (!po->stats.tp_drops)
 631                 status &= ~TP_STATUS_LOSING;
 632         spin_unlock(&sk->sk_receive_queue.lock);
 633
 634         memcpy((u8*)h + macoff, skb->data, snaplen);
 635
 636         h->tp_len = skb->len;
 637         h->tp_snaplen = snaplen;
 638         h->tp_mac = macoff;
 639         h->tp_net = netoff;
 640         if (skb->stamp.tv_sec == 0) {
 641                 do_gettimeofday(&skb->stamp);
 642                 sock_enable_timestamp(sk);
 643         }
 644         h->tp_sec = skb->stamp.tv_sec;
 645         h->tp_usec = skb->stamp.tv_usec;
 646
 647         sll = (struct sockaddr_ll*)((u8*)h + TPACKET_ALIGN(sizeof(*h)));
 648         sll->sll_halen = 0;
 649         if (dev->hard_header_parse)
 650                 sll->sll_halen = dev->hard_header_parse(skb, sll->sll_addr);
 651         sll->sll_family = AF_PACKET;
 652         sll->sll_hatype = dev->type;
 653         sll->sll_protocol = skb->protocol;
 654         sll->sll_pkttype = skb->pkt_type;
 655         sll->sll_ifindex = dev->ifindex;
 656
 657         h->tp_status = status;
 658         mb();
 659
 660         {
 661                 struct page *p_start, *p_end;
 662                 u8 *h_end = (u8 *)h + macoff + snaplen - 1;
 663
 664                 p_start = virt_to_page(h);
 665                 p_end = virt_to_page(h_end);
 666                 while (p_start <= p_end) {
 667                         flush_dcache_page(p_start);
 668                         p_start++;
 669                 }
 670         }
 671
 672         sk->sk_data_ready(sk, 0);
 673
 674 drop_n_restore:
 675         if (skb_head != skb->data && skb_shared(skb)) {
 676                 skb->data = skb_head;
 677                 skb->len = skb_len;
 678         }
 679 drop:
 680         kfree_skb(skb);
 681         return 0;
 682
 683 ring_is_full:
 684         po->stats.tp_drops++;
 685         spin_unlock(&sk->sk_receive_queue.lock);
 686
 687         sk->sk_data_ready(sk, 0);
 688         if (copy_skb)
 689                 kfree_skb(copy_skb);
 690         goto drop_n_restore;
 691 }
 692
 693 #endif
 694
 695
 696 static int packet_sendmsg(struct kiocb *iocb, struct socket *sock,
 697                           struct msghdr *msg, size_t len)
 698 {
 699         struct sock *sk = sock->sk;
 700         struct sockaddr_ll *saddr=(struct sockaddr_ll *)msg->msg_name;
 701         struct sk_buff *skb;
 702         struct net_device *dev;
 703         unsigned short proto;
 704         unsigned char *addr;
 705         int ifindex, err, reserve = 0;
 706
 707         /*
 708          *      Get and verify the address.
 709          */
 710
 711         if (saddr == NULL) {
 712                 struct packet_sock *po = pkt_sk(sk);
 713
 714                 ifindex = po->ifindex;
 715                 proto   = po->num;
 716                 addr    = NULL;
 717         } else {
 718                 err = -EINVAL;
 719                 if (msg->msg_namelen < sizeof(struct sockaddr_ll))
 720                         goto out;
 721                 ifindex = saddr->sll_ifindex;
 722                 proto   = saddr->sll_protocol;
 723                 addr    = saddr->sll_addr;
 724         }
 725
 726
 727         dev = dev_get_by_index(ifindex);
 728         err = -ENXIO;
 729         if (dev == NULL)
 730                 goto out_unlock;
 731         if (sock->type == SOCK_RAW)
 732                 reserve = dev->hard_header_len;
 733
 734         err = -EMSGSIZE;
 735         if (len > dev->mtu+reserve)
 736                 goto out_unlock;
 737
 738         skb = sock_alloc_send_skb(sk, len + LL_RESERVED_SPACE(dev),
 739                                 msg->msg_flags & MSG_DONTWAIT, &err);
 740         if (skb==NULL)
 741                 goto out_unlock;
 742
 743         skb_reserve(skb, LL_RESERVED_SPACE(dev));
 744         skb->nh.raw = skb->data;
 745
 746         if (dev->hard_header) {
 747                 int res;
 748                 err = -EINVAL;
 749                 res = dev->hard_header(skb, dev, ntohs(proto), addr, NULL, len);
 750                 if (sock->type != SOCK_DGRAM) {
 751                         skb->tail = skb->data;
 752                         skb->len = 0;
 753                 } else if (res < 0)
 754                         goto out_free;
 755         }
 756
 757         /* Returns -EFAULT on error */
 758         err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
 759         if (err)
 760                 goto out_free;
 761
 762         skb->protocol = proto;
 763         skb->dev = dev;
 764         skb->priority = sk->sk_priority;
 765
 766         err = -ENETDOWN;
 767         if (!(dev->flags & IFF_UP))
 768                 goto out_free;
 769
 770         /*
 771          *      Now send it
 772          */
 773
 774         err = dev_queue_xmit(skb);
 775         if (err > 0 && (err = net_xmit_errno(err)) != 0)
 776                 goto out_unlock;
 777
 778         dev_put(dev);
 779
 780         return(len);
 781
 782 out_free:
 783         kfree_skb(skb);
 784 out_unlock:
 785         if (dev)
 786                 dev_put(dev);
 787 out:
 788         return err;
 789 }
 790
 791 /*
 792  *      Close a PACKET socket. This is fairly simple. We immediately go
 793  *      to 'closed' state and remove our protocol entry in the device list.
 794  */
 795
 796 static int packet_release(struct socket *sock)
 797 {
 798         struct sock *sk = sock->sk;
 799         struct packet_sock *po;
 800
 801         if (!sk)
 802                 return 0;
 803
 804         po = pkt_sk(sk);
 805
 806         write_lock_bh(&packet_sklist_lock);
 807         sk_del_node_init(sk);
 808         write_unlock_bh(&packet_sklist_lock);
 809
 810         /*
 811          *      Unhook packet receive handler.
 812          */
 813
 814         if (po->running) {
 815                 /*
 816                  *      Remove the protocol hook
 817                  */
 818                 dev_remove_pack(&po->prot_hook);
 819                 po->running = 0;
 820                 po->num = 0;
 821                 __sock_put(sk);
 822         }
 823
 824 #ifdef CONFIG_PACKET_MULTICAST
 825         packet_flush_mclist(sk);
 826 #endif
 827
 828 #ifdef CONFIG_PACKET_MMAP
 829         if (po->pg_vec) {
 830                 struct tpacket_req req;
 831                 memset(&req, 0, sizeof(req));
 832                 packet_set_ring(sk, &req, 1);
 833         }
 834 #endif
 835
 836 #warning MEF: figure out whether the following vserver net code is required by PlanetLab
 837 #if 0
 838         clr_vx_info(&sk->sk_vx_info);
 839         clr_nx_info(&sk->sk_nx_info);
 840 #endif
 841
 842         /*
 843          *      Now the socket is dead. No more input will appear.
 844          */
 845
 846         sock_orphan(sk);
 847         sock->sk = NULL;
 848
 849         /* Purge queues */
 850
 851         skb_queue_purge(&sk->sk_receive_queue);
 852
 853         sock_put(sk);
 854         return 0;
 855 }
 856
 857 /*
 858  *      Attach a packet hook.
 859  */
 860
 861 static int packet_do_bind(struct sock *sk, struct net_device *dev, int protocol)
 862 {
 863         struct packet_sock *po = pkt_sk(sk);
 864         /*
 865          *      Detach an existing hook if present.
 866          */
 867
 868         lock_sock(sk);
 869
 870         spin_lock(&po->bind_lock);
 871         if (po->running) {
 872                 __sock_put(sk);
 873                 po->running = 0;
 874                 po->num = 0;
 875                 spin_unlock(&po->bind_lock);
 876                 dev_remove_pack(&po->prot_hook);
 877                 spin_lock(&po->bind_lock);
 878         }
 879
 880         po->num = protocol;
 881         po->prot_hook.type = protocol;
 882         po->prot_hook.dev = dev;
 883
 884         po->ifindex = dev ? dev->ifindex : 0;
 885
 886         if (protocol == 0)
 887                 goto out_unlock;
 888
 889         if (dev) {
 890                 if (dev->flags&IFF_UP) {
 891                         dev_add_pack(&po->prot_hook);
 892                         sock_hold(sk);
 893                         po->running = 1;
 894                 } else {
 895                         sk->sk_err = ENETDOWN;
 896                         if (!sock_flag(sk, SOCK_DEAD))
 897                                 sk->sk_error_report(sk);
 898                 }
 899         } else {
 900                 dev_add_pack(&po->prot_hook);
 901                 sock_hold(sk);
 902                 po->running = 1;
 903         }
 904
 905 out_unlock:
 906         spin_unlock(&po->bind_lock);
 907         release_sock(sk);
 908         return 0;
 909 }
 910
 911 /*
 912  *      Bind a packet socket to a device
 913  */
 914
 915 #ifdef CONFIG_SOCK_PACKET
 916
 917 static int packet_bind_spkt(struct socket *sock, struct sockaddr *uaddr, int addr_len)
 918 {
 919         struct sock *sk=sock->sk;
 920         char name[15];
 921         struct net_device *dev;
 922         int err = -ENODEV;
 923
 924         /*
 925          *      Check legality
 926          */
 927
 928         if(addr_len!=sizeof(struct sockaddr))
 929                 return -EINVAL;
 930         strlcpy(name,uaddr->sa_data,sizeof(name));
 931
 932         dev = dev_get_by_name(name);
 933         if (dev) {
 934                 err = packet_do_bind(sk, dev, pkt_sk(sk)->num);
 935                 dev_put(dev);
 936         }
 937         return err;
 938 }
 939 #endif
 940
 941 static int packet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
 942 {
 943         struct sockaddr_ll *sll = (struct sockaddr_ll*)uaddr;
 944         struct sock *sk=sock->sk;
 945         struct net_device *dev = NULL;
 946         int err;
 947
 948
 949         /*
 950          *      Check legality
 951          */
 952
 953         if (addr_len < sizeof(struct sockaddr_ll))
 954                 return -EINVAL;
 955         if (sll->sll_family != AF_PACKET)
 956                 return -EINVAL;
 957
 958         if (sll->sll_ifindex) {
 959                 err = -ENODEV;
 960                 dev = dev_get_by_index(sll->sll_ifindex);
 961                 if (dev == NULL)
 962                         goto out;
 963         }
 964         err = packet_do_bind(sk, dev, sll->sll_protocol ? : pkt_sk(sk)->num);
 965         if (dev)
 966                 dev_put(dev);
 967
 968 out:
 969         return err;
 970 }
 971
 972 static struct proto packet_proto = {
 973         .name     = "PACKET",
 974         .owner    = THIS_MODULE,
 975         .obj_size = sizeof(struct packet_sock),
 976 };
 977
 978 /*
 979  *      Create a packet of type SOCK_PACKET.
 980  */
 981
 982 static int packet_create(struct socket *sock, int protocol)
 983 {
 984         struct sock *sk;
 985         struct packet_sock *po;
 986         int err;
 987
 988         if (!capable(CAP_NET_RAW))
 989                 return -EPERM;
 990         if (sock->type != SOCK_DGRAM && sock->type != SOCK_RAW
 991 #ifdef CONFIG_SOCK_PACKET
 992             && sock->type != SOCK_PACKET
 993 #endif
 994             )
 995                 return -ESOCKTNOSUPPORT;
 996
 997         sock->state = SS_UNCONNECTED;
 998
 999         err = -ENOBUFS;
1000         sk = sk_alloc(PF_PACKET, GFP_KERNEL, &packet_proto, 1);
1001         if (sk == NULL)
1002                 goto out;
1003
1004         sock->ops = &packet_ops;
1005 #ifdef CONFIG_SOCK_PACKET
1006         if (sock->type == SOCK_PACKET)
1007                 sock->ops = &packet_ops_spkt;
1008 #endif
1009         sock_init_data(sock, sk);
1010
1011         po = pkt_sk(sk);
1012         sk->sk_family = PF_PACKET;
1013         po->num = protocol;
1014
1015         sk->sk_destruct = packet_sock_destruct;
1016         atomic_inc(&packet_socks_nr);
1017
1018 #warning MEF: figure out whether the following vserver net code is required by PlanetLab
1019 #if 0
1020         set_vx_info(&sk->sk_vx_info, current->vx_info);
1021         sk->sk_xid = vx_current_xid();
1022         set_nx_info(&sk->sk_nx_info, current->nx_info);
1023         sk->sk_nid = nx_current_nid();
1024 #endif
1025
1026         /*
1027          *      Attach a protocol block
1028          */
1029
1030         spin_lock_init(&po->bind_lock);
1031         po->prot_hook.func = packet_rcv;
1032 #ifdef CONFIG_SOCK_PACKET
1033         if (sock->type == SOCK_PACKET)
1034                 po->prot_hook.func = packet_rcv_spkt;
1035 #endif
1036         po->prot_hook.af_packet_priv = sk;
1037
1038         if (protocol) {
1039                 po->prot_hook.type = protocol;
1040                 dev_add_pack(&po->prot_hook);
1041                 sock_hold(sk);
1042                 po->running = 1;
1043         }
1044
1045         write_lock_bh(&packet_sklist_lock);
1046         sk_add_node(sk, &packet_sklist);
1047         write_unlock_bh(&packet_sklist_lock);
1048         return(0);
1049 out:
1050         return err;
1051 }
1052
1053 /*
1054  *      Pull a packet from our receive queue and hand it to the user.
1055  *      If necessary we block.
1056  */
1057
1058 static int packet_recvmsg(struct kiocb *iocb, struct socket *sock,
1059                           struct msghdr *msg, size_t len, int flags)
1060 {
1061         struct sock *sk = sock->sk;
1062         struct sk_buff *skb;
1063         int copied, err;
1064
1065         err = -EINVAL;
1066         if (flags & ~(MSG_PEEK|MSG_DONTWAIT|MSG_TRUNC|MSG_CMSG_COMPAT))
1067                 goto out;
1068
1069 #if 0
1070         /* What error should we return now? EUNATTACH? */
1071         if (pkt_sk(sk)->ifindex < 0)
1072                 return -ENODEV;
1073 #endif
1074
1075         /*
1076          *      If the address length field is there to be filled in, we fill
1077          *      it in now.
1078          */
1079
1080         if (sock->type == SOCK_PACKET)
1081                 msg->msg_namelen = sizeof(struct sockaddr_pkt);
1082         else
1083                 msg->msg_namelen = sizeof(struct sockaddr_ll);
1084
1085         /*
1086          *      Call the generic datagram receiver. This handles all sorts
1087          *      of horrible races and re-entrancy so we can forget about it
1088          *      in the protocol layers.
1089          *
1090          *      Now it will return ENETDOWN, if device have just gone down,
1091          *      but then it will block.
1092          */
1093
1094         skb=skb_recv_datagram(sk,flags,flags&MSG_DONTWAIT,&err);
1095
1096         /*
1097          *      An error occurred so return it. Because skb_recv_datagram()
1098          *      handles the blocking we don't see and worry about blocking
1099          *      retries.
1100          */
1101
1102         if(skb==NULL)
1103                 goto out;
1104
1105         /*
1106          *      You lose any data beyond the buffer you gave. If it worries a
1107          *      user program they can ask the device for its MTU anyway.
1108          */
1109
1110         copied = skb->len;
1111         if (copied > len)
1112         {
1113                 copied=len;
1114                 msg->msg_flags|=MSG_TRUNC;
1115         }
1116
1117         err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1118         if (err)
1119                 goto out_free;
1120
1121         sock_recv_timestamp(msg, sk, skb);
1122
1123         if (msg->msg_name)
1124                 memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
1125
1126         /*
1127          *      Free or return the buffer as appropriate. Again this
1128          *      hides all the races and re-entrancy issues from us.
1129          */
1130         err = (flags&MSG_TRUNC) ? skb->len : copied;
1131
1132 out_free:
1133         skb_free_datagram(sk, skb);
1134 out:
1135         return err;
1136 }
1137
1138 #ifdef CONFIG_SOCK_PACKET
1139 static int packet_getname_spkt(struct socket *sock, struct sockaddr *uaddr,
1140                                int *uaddr_len, int peer)
1141 {
1142         struct net_device *dev;
1143         struct sock *sk = sock->sk;
1144
1145         if (peer)
1146                 return -EOPNOTSUPP;
1147
1148         uaddr->sa_family = AF_PACKET;
1149         dev = dev_get_by_index(pkt_sk(sk)->ifindex);
1150         if (dev) {
1151                 strlcpy(uaddr->sa_data, dev->name, 15);
1152                 dev_put(dev);
1153         } else
1154                 memset(uaddr->sa_data, 0, 14);
1155         *uaddr_len = sizeof(*uaddr);
1156
1157         return 0;
1158 }
1159 #endif
1160
1161 static int packet_getname(struct socket *sock, struct sockaddr *uaddr,
1162                           int *uaddr_len, int peer)
1163 {
1164         struct net_device *dev;
1165         struct sock *sk = sock->sk;
1166         struct packet_sock *po = pkt_sk(sk);
1167         struct sockaddr_ll *sll = (struct sockaddr_ll*)uaddr;
1168
1169         if (peer)
1170                 return -EOPNOTSUPP;
1171
1172         sll->sll_family = AF_PACKET;
1173         sll->sll_ifindex = po->ifindex;
1174         sll->sll_protocol = po->num;
1175         dev = dev_get_by_index(po->ifindex);
1176         if (dev) {
1177                 sll->sll_hatype = dev->type;
1178                 sll->sll_halen = dev->addr_len;
1179                 memcpy(sll->sll_addr, dev->dev_addr, dev->addr_len);
1180                 dev_put(dev);
1181         } else {
1182                 sll->sll_hatype = 0;    /* Bad: we have no ARPHRD_UNSPEC */
1183                 sll->sll_halen = 0;
1184         }
1185         *uaddr_len = sizeof(*sll);
1186
1187         return 0;
1188 }
1189
1190 #ifdef CONFIG_PACKET_MULTICAST
1191 static void packet_dev_mc(struct net_device *dev, struct packet_mclist *i, int what)
1192 {
1193         switch (i->type) {
1194         case PACKET_MR_MULTICAST:
1195                 if (what > 0)
1196                         dev_mc_add(dev, i->addr, i->alen, 0);
1197                 else
1198                         dev_mc_delete(dev, i->addr, i->alen, 0);
1199                 break;
1200         case PACKET_MR_PROMISC:
1201                 dev_set_promiscuity(dev, what);
1202                 break;
1203         case PACKET_MR_ALLMULTI:
1204                 dev_set_allmulti(dev, what);
1205                 break;
1206         default:;
1207         }
1208 }
1209
1210 static void packet_dev_mclist(struct net_device *dev, struct packet_mclist *i, int what)
1211 {
1212         for ( ; i; i=i->next) {
1213                 if (i->ifindex == dev->ifindex)
1214                         packet_dev_mc(dev, i, what);
1215         }
1216 }
1217
1218 static int packet_mc_add(struct sock *sk, struct packet_mreq *mreq)
1219 {
1220         struct packet_sock *po = pkt_sk(sk);
1221         struct packet_mclist *ml, *i;
1222         struct net_device *dev;
1223         int err;
1224
1225         rtnl_lock();
1226
1227         err = -ENODEV;
1228         dev = __dev_get_by_index(mreq->mr_ifindex);
1229         if (!dev)
1230                 goto done;
1231
1232         err = -EINVAL;
1233         if (mreq->mr_alen > dev->addr_len)
1234                 goto done;
1235
1236         err = -ENOBUFS;
1237         i = (struct packet_mclist *)kmalloc(sizeof(*i), GFP_KERNEL);
1238         if (i == NULL)
1239                 goto done;
1240
1241         err = 0;
1242         for (ml = po->mclist; ml; ml = ml->next) {
1243                 if (ml->ifindex == mreq->mr_ifindex &&
1244                     ml->type == mreq->mr_type &&
1245                     ml->alen == mreq->mr_alen &&
1246                     memcmp(ml->addr, mreq->mr_address, ml->alen) == 0) {
1247                         ml->count++;
1248                         /* Free the new element ... */
1249                         kfree(i);
1250                         goto done;
1251                 }
1252         }
1253
1254         i->type = mreq->mr_type;
1255         i->ifindex = mreq->mr_ifindex;
1256         i->alen = mreq->mr_alen;
1257         memcpy(i->addr, mreq->mr_address, i->alen);
1258         i->count = 1;
1259         i->next = po->mclist;
1260         po->mclist = i;
1261         packet_dev_mc(dev, i, +1);
1262
1263 done:
1264         rtnl_unlock();
1265         return err;
1266 }
1267
1268 static int packet_mc_drop(struct sock *sk, struct packet_mreq *mreq)
1269 {
1270         struct packet_mclist *ml, **mlp;
1271
1272         rtnl_lock();
1273
1274         for (mlp = &pkt_sk(sk)->mclist; (ml = *mlp) != NULL; mlp = &ml->next) {
1275                 if (ml->ifindex == mreq->mr_ifindex &&
1276                     ml->type == mreq->mr_type &&
1277                     ml->alen == mreq->mr_alen &&
1278                     memcmp(ml->addr, mreq->mr_address, ml->alen) == 0) {
1279                         if (--ml->count == 0) {
1280                                 struct net_device *dev;
1281                                 *mlp = ml->next;
1282                                 dev = dev_get_by_index(ml->ifindex);
1283                                 if (dev) {
1284                                         packet_dev_mc(dev, ml, -1);
1285                                         dev_put(dev);
1286                                 }
1287                                 kfree(ml);
1288                         }
1289                         rtnl_unlock();
1290                         return 0;
1291                 }
1292         }
1293         rtnl_unlock();
1294         return -EADDRNOTAVAIL;
1295 }
1296
1297 static void packet_flush_mclist(struct sock *sk)
1298 {
1299         struct packet_sock *po = pkt_sk(sk);
1300         struct packet_mclist *ml;
1301
1302         if (!po->mclist)
1303                 return;
1304
1305         rtnl_lock();
1306         while ((ml = po->mclist) != NULL) {
1307                 struct net_device *dev;
1308
1309                 po->mclist = ml->next;
1310                 if ((dev = dev_get_by_index(ml->ifindex)) != NULL) {
1311                         packet_dev_mc(dev, ml, -1);
1312                         dev_put(dev);
1313                 }
1314                 kfree(ml);
1315         }
1316         rtnl_unlock();
1317 }
1318 #endif
1319
1320 static int
1321 packet_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen)
1322 {
1323         struct sock *sk = sock->sk;
1324         int ret;
1325
1326         if (level != SOL_PACKET)
1327                 return -ENOPROTOOPT;
1328
1329         switch(optname) {
1330 #ifdef CONFIG_PACKET_MULTICAST
1331         case PACKET_ADD_MEMBERSHIP:
1332         case PACKET_DROP_MEMBERSHIP:
1333         {
1334                 struct packet_mreq mreq;
1335                 if (optlen<sizeof(mreq))
1336                         return -EINVAL;
1337                 if (copy_from_user(&mreq,optval,sizeof(mreq)))
1338                         return -EFAULT;
1339                 if (optname == PACKET_ADD_MEMBERSHIP)
1340                         ret = packet_mc_add(sk, &mreq);
1341                 else
1342                         ret = packet_mc_drop(sk, &mreq);
1343                 return ret;
1344         }
1345 #endif
1346 #ifdef CONFIG_PACKET_MMAP
1347         case PACKET_RX_RING:
1348         {
1349                 struct tpacket_req req;
1350
1351                 if (optlen<sizeof(req))
1352                         return -EINVAL;
1353                 if (copy_from_user(&req,optval,sizeof(req)))
1354                         return -EFAULT;
1355                 return packet_set_ring(sk, &req, 0);
1356         }
1357         case PACKET_COPY_THRESH:
1358         {
1359                 int val;
1360
1361                 if (optlen!=sizeof(val))
1362                         return -EINVAL;
1363                 if (copy_from_user(&val,optval,sizeof(val)))
1364                         return -EFAULT;
1365
1366                 pkt_sk(sk)->copy_thresh = val;
1367                 return 0;
1368         }
1369 #endif
1370         default:
1371                 return -ENOPROTOOPT;
1372         }
1373 }
1374
1375 static int packet_getsockopt(struct socket *sock, int level, int optname,
1376                              char __user *optval, int __user *optlen)
1377 {
1378         int len;
1379         struct sock *sk = sock->sk;
1380         struct packet_sock *po = pkt_sk(sk);
1381
1382         if (level != SOL_PACKET)
1383                 return -ENOPROTOOPT;
1384
1385         if (get_user(len,optlen))
1386                 return -EFAULT;
1387
1388         if (len < 0)
1389                 return -EINVAL;
1390
1391         switch(optname) {
1392         case PACKET_STATISTICS:
1393         {
1394                 struct tpacket_stats st;
1395
1396                 if (len > sizeof(struct tpacket_stats))
1397                         len = sizeof(struct tpacket_stats);
1398                 spin_lock_bh(&sk->sk_receive_queue.lock);
1399                 st = po->stats;
1400                 memset(&po->stats, 0, sizeof(st));
1401                 spin_unlock_bh(&sk->sk_receive_queue.lock);
1402                 st.tp_packets += st.tp_drops;
1403
1404                 if (copy_to_user(optval, &st, len))
1405                         return -EFAULT;
1406                 break;
1407         }
1408         default:
1409                 return -ENOPROTOOPT;
1410         }
1411
1412         if (put_user(len, optlen))
1413                 return -EFAULT;
1414         return 0;
1415 }
1416
1417
1418 static int packet_notifier(struct notifier_block *this, unsigned long msg, void *data)
1419 {
1420         struct sock *sk;
1421         struct hlist_node *node;
1422         struct net_device *dev = (struct net_device*)data;
1423
1424         read_lock(&packet_sklist_lock);
1425         sk_for_each(sk, node, &packet_sklist) {
1426                 struct packet_sock *po = pkt_sk(sk);
1427
1428                 switch (msg) {
1429                 case NETDEV_UNREGISTER:
1430 #ifdef CONFIG_PACKET_MULTICAST
1431                         if (po->mclist)
1432                                 packet_dev_mclist(dev, po->mclist, -1);
1433                         // fallthrough
1434 #endif
1435                 case NETDEV_DOWN:
1436                         if (dev->ifindex == po->ifindex) {
1437                                 spin_lock(&po->bind_lock);
1438                                 if (po->running) {
1439                                         __dev_remove_pack(&po->prot_hook);
1440                                         __sock_put(sk);
1441                                         po->running = 0;
1442                                         sk->sk_err = ENETDOWN;
1443                                         if (!sock_flag(sk, SOCK_DEAD))
1444                                                 sk->sk_error_report(sk);
1445                                 }
1446                                 if (msg == NETDEV_UNREGISTER) {
1447                                         po->ifindex = -1;
1448                                         po->prot_hook.dev = NULL;
1449                                 }
1450                                 spin_unlock(&po->bind_lock);
1451                         }
1452                         break;
1453                 case NETDEV_UP:
1454                         spin_lock(&po->bind_lock);
1455                         if (dev->ifindex == po->ifindex && po->num &&
1456                             !po->running) {
1457                                 dev_add_pack(&po->prot_hook);
1458                                 sock_hold(sk);
1459                                 po->running = 1;
1460                         }
1461                         spin_unlock(&po->bind_lock);
1462                         break;
1463                 }
1464         }
1465         read_unlock(&packet_sklist_lock);
1466         return NOTIFY_DONE;
1467 }
1468
1469
1470 static int packet_ioctl(struct socket *sock, unsigned int cmd,
1471                         unsigned long arg)
1472 {
1473         struct sock *sk = sock->sk;
1474
1475         switch(cmd) {
1476                 case SIOCOUTQ:
1477                 {
1478                         int amount = atomic_read(&sk->sk_wmem_alloc);
1479                         return put_user(amount, (int __user *)arg);
1480                 }
1481                 case SIOCINQ:
1482                 {
1483                         struct sk_buff *skb;
1484                         int amount = 0;
1485
1486                         spin_lock_bh(&sk->sk_receive_queue.lock);
1487                         skb = skb_peek(&sk->sk_receive_queue);
1488                         if (skb)
1489                                 amount = skb->len;
1490                         spin_unlock_bh(&sk->sk_receive_queue.lock);
1491                         return put_user(amount, (int __user *)arg);
1492                 }
1493                 case SIOCGSTAMP:
1494                         return sock_get_timestamp(sk, (struct timeval __user *)arg);
1495
1496 #ifdef CONFIG_INET
1497                 case SIOCADDRT:
1498                 case SIOCDELRT:
1499                 case SIOCDARP:
1500                 case SIOCGARP:
1501                 case SIOCSARP:
1502                 case SIOCGIFADDR:
1503                 case SIOCSIFADDR:
1504                 case SIOCGIFBRDADDR:
1505                 case SIOCSIFBRDADDR:
1506                 case SIOCGIFNETMASK:
1507                 case SIOCSIFNETMASK:
1508                 case SIOCGIFDSTADDR:
1509                 case SIOCSIFDSTADDR:
1510                 case SIOCSIFFLAGS:
1511                         return inet_dgram_ops.ioctl(sock, cmd, arg);
1512 #endif
1513
1514                 default:
1515                         return dev_ioctl(cmd, (void __user *)arg);
1516         }
1517         return 0;
1518 }
1519
1520 #ifndef CONFIG_PACKET_MMAP
1521 #define packet_mmap sock_no_mmap
1522 #define packet_poll datagram_poll
1523 #else
1524
1525 static unsigned int packet_poll(struct file * file, struct socket *sock,
1526                                 poll_table *wait)
1527 {
1528         struct sock *sk = sock->sk;
1529         struct packet_sock *po = pkt_sk(sk);
1530         unsigned int mask = datagram_poll(file, sock, wait);
1531
1532         spin_lock_bh(&sk->sk_receive_queue.lock);
1533         if (po->pg_vec) {
1534                 unsigned last = po->head ? po->head-1 : po->frame_max;
1535                 struct tpacket_hdr *h;
1536
1537                 h = (struct tpacket_hdr *)packet_lookup_frame(po, last);
1538
1539                 if (h->tp_status)
1540                         mask |= POLLIN | POLLRDNORM;
1541         }
1542         spin_unlock_bh(&sk->sk_receive_queue.lock);
1543         return mask;
1544 }
1545
1546
1547 /* Dirty? Well, I still did not learn better way to account
1548  * for user mmaps.
1549  */
1550
1551 static void packet_mm_open(struct vm_area_struct *vma)
1552 {
1553         struct file *file = vma->vm_file;
1554         struct inode *inode = file->f_dentry->d_inode;
1555         struct socket * sock = SOCKET_I(inode);
1556         struct sock *sk = sock->sk;
1557
1558         if (sk)
1559                 atomic_inc(&pkt_sk(sk)->mapped);
1560 }
1561
1562 static void packet_mm_close(struct vm_area_struct *vma)
1563 {
1564         struct file *file = vma->vm_file;
1565         struct inode *inode = file->f_dentry->d_inode;
1566         struct socket * sock = SOCKET_I(inode);
1567         struct sock *sk = sock->sk;
1568
1569         if (sk)
1570                 atomic_dec(&pkt_sk(sk)->mapped);
1571 }
1572
1573 static struct vm_operations_struct packet_mmap_ops = {
1574         .open = packet_mm_open,
1575         .close =packet_mm_close,
1576 };
1577
1578 static inline struct page *pg_vec_endpage(char *one_pg_vec, unsigned int order)
1579 {
1580         return virt_to_page(one_pg_vec + (PAGE_SIZE << order) - 1);
1581 }
1582
1583 static void free_pg_vec(char **pg_vec, unsigned order, unsigned len)
1584 {
1585         int i;
1586
1587         for (i=0; i<len; i++) {
1588                 if (pg_vec[i]) {
1589                         struct page *page, *pend;
1590
1591                         pend = pg_vec_endpage(pg_vec[i], order);
1592                         for (page = virt_to_page(pg_vec[i]); page <= pend; page++)
1593                                 ClearPageReserved(page);
1594                         free_pages((unsigned long)pg_vec[i], order);
1595                 }
1596         }
1597         kfree(pg_vec);
1598 }
1599
1600
1601 static int packet_set_ring(struct sock *sk, struct tpacket_req *req, int closing)
1602 {
1603         char **pg_vec = NULL;
1604         struct packet_sock *po = pkt_sk(sk);
1605         int was_running, num, order = 0;
1606         int err = 0;
1607
1608         if (req->tp_block_nr) {
1609                 int i, l;
1610
1611                 /* Sanity tests and some calculations */
1612
1613                 if (po->pg_vec)
1614                         return -EBUSY;
1615
1616                 if ((int)req->tp_block_size <= 0)
1617                         return -EINVAL;
1618                 if (req->tp_block_size&(PAGE_SIZE-1))
1619                         return -EINVAL;
1620                 if (req->tp_frame_size < TPACKET_HDRLEN)
1621                         return -EINVAL;
1622                 if (req->tp_frame_size&(TPACKET_ALIGNMENT-1))
1623                         return -EINVAL;
1624
1625                 po->frames_per_block = req->tp_block_size/req->tp_frame_size;
1626                 if (po->frames_per_block <= 0)
1627                         return -EINVAL;
1628                 if (po->frames_per_block*req->tp_block_nr != req->tp_frame_nr)
1629                         return -EINVAL;
1630                 /* OK! */
1631
1632                 /* Allocate page vector */
1633                 while ((PAGE_SIZE<<order) < req->tp_block_size)
1634                         order++;
1635
1636                 err = -ENOMEM;
1637
1638                 pg_vec = kmalloc(req->tp_block_nr*sizeof(char *), GFP_KERNEL);
1639                 if (pg_vec == NULL)
1640                         goto out;
1641                 memset(pg_vec, 0, req->tp_block_nr*sizeof(char **));
1642
1643                 for (i=0; i<req->tp_block_nr; i++) {
1644                         struct page *page, *pend;
1645                         pg_vec[i] = (char *)__get_free_pages(GFP_KERNEL, order);
1646                         if (!pg_vec[i])
1647                                 goto out_free_pgvec;
1648
1649                         pend = pg_vec_endpage(pg_vec[i], order);
1650                         for (page = virt_to_page(pg_vec[i]); page <= pend; page++)
1651                                 SetPageReserved(page);
1652                 }
1653                 /* Page vector is allocated */
1654
1655                 l = 0;
1656                 for (i=0; i<req->tp_block_nr; i++) {
1657                         char *ptr = pg_vec[i];
1658                         struct tpacket_hdr *header;
1659                         int k;
1660
1661                         for (k=0; k<po->frames_per_block; k++) {
1662
1663                                 header = (struct tpacket_hdr*)ptr;
1664                                 header->tp_status = TP_STATUS_KERNEL;
1665                                 ptr += req->tp_frame_size;
1666                         }
1667                 }
1668                 /* Done */
1669         } else {
1670                 if (req->tp_frame_nr)
1671                         return -EINVAL;
1672         }
1673
1674         lock_sock(sk);
1675
1676         /* Detach socket from network */
1677         spin_lock(&po->bind_lock);
1678         was_running = po->running;
1679         num = po->num;
1680         if (was_running) {
1681                 __dev_remove_pack(&po->prot_hook);
1682                 po->num = 0;
1683                 po->running = 0;
1684                 __sock_put(sk);
1685         }
1686         spin_unlock(&po->bind_lock);
1687
1688         synchronize_net();
1689
1690         err = -EBUSY;
1691         if (closing || atomic_read(&po->mapped) == 0) {
1692                 err = 0;
1693 #define XC(a, b) ({ __typeof__ ((a)) __t; __t = (a); (a) = (b); __t; })
1694
1695                 spin_lock_bh(&sk->sk_receive_queue.lock);
1696                 pg_vec = XC(po->pg_vec, pg_vec);
1697                 po->frame_max = req->tp_frame_nr-1;
1698                 po->head = 0;
1699                 po->frame_size = req->tp_frame_size;
1700                 spin_unlock_bh(&sk->sk_receive_queue.lock);
1701
1702                 order = XC(po->pg_vec_order, order);
1703                 req->tp_block_nr = XC(po->pg_vec_len, req->tp_block_nr);
1704
1705                 po->pg_vec_pages = req->tp_block_size/PAGE_SIZE;
1706                 po->prot_hook.func = po->pg_vec ? tpacket_rcv : packet_rcv;
1707                 skb_queue_purge(&sk->sk_receive_queue);
1708 #undef XC
1709                 if (atomic_read(&po->mapped))
1710                         printk(KERN_DEBUG "packet_mmap: vma is busy: %d\n", atomic_read(&po->mapped));
1711         }
1712
1713         spin_lock(&po->bind_lock);
1714         if (was_running && !po->running) {
1715                 sock_hold(sk);
1716                 po->running = 1;
1717                 po->num = num;
1718                 dev_add_pack(&po->prot_hook);
1719         }
1720         spin_unlock(&po->bind_lock);
1721
1722         release_sock(sk);
1723
1724 out_free_pgvec:
1725         if (pg_vec)
1726                 free_pg_vec(pg_vec, order, req->tp_block_nr);
1727 out:
1728         return err;
1729 }
1730
1731 static int packet_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
1732 {
1733         struct sock *sk = sock->sk;
1734         struct packet_sock *po = pkt_sk(sk);
1735         unsigned long size;
1736         unsigned long start;
1737         int err = -EINVAL;
1738         int i;
1739
1740         if (vma->vm_pgoff)
1741                 return -EINVAL;
1742
1743         size = vma->vm_end - vma->vm_start;
1744
1745         lock_sock(sk);
1746         if (po->pg_vec == NULL)
1747                 goto out;
1748         if (size != po->pg_vec_len*po->pg_vec_pages*PAGE_SIZE)
1749                 goto out;
1750
1751         atomic_inc(&po->mapped);
1752         start = vma->vm_start;
1753         err = -EAGAIN;
1754         for (i=0; i<po->pg_vec_len; i++) {
1755                 if (remap_pfn_range(vma, start,
1756                                      __pa(po->pg_vec[i]) >> PAGE_SHIFT,
1757                                      po->pg_vec_pages*PAGE_SIZE,
1758                                      vma->vm_page_prot))
1759                         goto out;
1760                 start += po->pg_vec_pages*PAGE_SIZE;
1761         }
1762         vma->vm_ops = &packet_mmap_ops;
1763         err = 0;
1764
1765 out:
1766         release_sock(sk);
1767         return err;
1768 }
1769 #endif
1770
1771
1772 #ifdef CONFIG_SOCK_PACKET
1773 static struct proto_ops packet_ops_spkt = {
1774         .family =       PF_PACKET,
1775         .owner =        THIS_MODULE,
1776         .release =      packet_release,
1777         .bind =         packet_bind_spkt,
1778         .connect =      sock_no_connect,
1779         .socketpair =   sock_no_socketpair,
1780         .accept =       sock_no_accept,
1781         .getname =      packet_getname_spkt,
1782         .poll =         datagram_poll,
1783         .ioctl =        packet_ioctl,
1784         .listen =       sock_no_listen,
1785         .shutdown =     sock_no_shutdown,
1786         .setsockopt =   sock_no_setsockopt,
1787         .getsockopt =   sock_no_getsockopt,
1788         .sendmsg =      packet_sendmsg_spkt,
1789         .recvmsg =      packet_recvmsg,
1790         .mmap =         sock_no_mmap,
1791         .sendpage =     sock_no_sendpage,
1792 };
1793 #endif
1794
1795 static struct proto_ops packet_ops = {
1796         .family =       PF_PACKET,
1797         .owner =        THIS_MODULE,
1798         .release =      packet_release,
1799         .bind =         packet_bind,
1800         .connect =      sock_no_connect,
1801         .socketpair =   sock_no_socketpair,
1802         .accept =       sock_no_accept,
1803         .getname =      packet_getname,
1804         .poll =         packet_poll,
1805         .ioctl =        packet_ioctl,
1806         .listen =       sock_no_listen,
1807         .shutdown =     sock_no_shutdown,
1808         .setsockopt =   packet_setsockopt,
1809         .getsockopt =   packet_getsockopt,
1810         .sendmsg =      packet_sendmsg,
1811         .recvmsg =      packet_recvmsg,
1812         .mmap =         packet_mmap,
1813         .sendpage =     sock_no_sendpage,
1814 };
1815
1816 #if defined(CONFIG_VNET) || defined(CONFIG_VNET_MODULE)
1817 EXPORT_SYMBOL(packet_ops);
1818 struct net_proto_family packet_family_ops;
1819 EXPORT_SYMBOL(packet_family_ops);
1820 #else
1821 static
1822 #endif
1823 struct net_proto_family packet_family_ops = {
1824         .family =       PF_PACKET,
1825         .create =       packet_create,
1826         .owner  =       THIS_MODULE,
1827 };
1828
1829 static struct notifier_block packet_netdev_notifier = {
1830         .notifier_call =packet_notifier,
1831 };
1832
1833 #ifdef CONFIG_PROC_FS
1834 static inline struct sock *packet_seq_idx(loff_t off)
1835 {
1836         struct sock *s;
1837         struct hlist_node *node;
1838
1839         sk_for_each(s, node, &packet_sklist) {
1840                 if (!off--)
1841                         return s;
1842         }
1843         return NULL;
1844 }
1845
1846 static void *packet_seq_start(struct seq_file *seq, loff_t *pos)
1847 {
1848         read_lock(&packet_sklist_lock);
1849         return *pos ? packet_seq_idx(*pos - 1) : SEQ_START_TOKEN;
1850 }
1851
1852 static void *packet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1853 {
1854         ++*pos;
1855         return  (v == SEQ_START_TOKEN)
1856                 ? sk_head(&packet_sklist)
1857                 : sk_next((struct sock*)v) ;
1858 }
1859
1860 static void packet_seq_stop(struct seq_file *seq, void *v)
1861 {
1862         read_unlock(&packet_sklist_lock);
1863 }
1864
1865 static int packet_seq_show(struct seq_file *seq, void *v)
1866 {
1867         if (v == SEQ_START_TOKEN)
1868                 seq_puts(seq, "sk       RefCnt Type Proto  Iface R Rmem   User   Inode\n");
1869         else {
1870                 struct sock *s = v;
1871                 const struct packet_sock *po = pkt_sk(s);
1872
1873                 seq_printf(seq,
1874                            "%p %-6d %-4d %04x   %-5d %1d %-6u %-6u %-6lu\n",
1875                            s,
1876                            atomic_read(&s->sk_refcnt),
1877                            s->sk_type,
1878                            ntohs(po->num),
1879                            po->ifindex,
1880                            po->running,
1881                            atomic_read(&s->sk_rmem_alloc),
1882                            sock_i_uid(s),
1883                            sock_i_ino(s) );
1884         }
1885
1886         return 0;
1887 }
1888
1889 static struct seq_operations packet_seq_ops = {
1890         .start  = packet_seq_start,
1891         .next   = packet_seq_next,
1892         .stop   = packet_seq_stop,
1893         .show   = packet_seq_show,
1894 };
1895
1896 static int packet_seq_open(struct inode *inode, struct file *file)
1897 {
1898         return seq_open(file, &packet_seq_ops);
1899 }
1900
1901 static struct file_operations packet_seq_fops = {
1902         .owner          = THIS_MODULE,
1903         .open           = packet_seq_open,
1904         .read           = seq_read,
1905         .llseek         = seq_lseek,
1906         .release        = seq_release,
1907 };
1908
1909 #endif
1910
1911 static void __exit packet_exit(void)
1912 {
1913         proc_net_remove("packet");
1914         unregister_netdevice_notifier(&packet_netdev_notifier);
1915         sock_unregister(PF_PACKET);
1916         proto_unregister(&packet_proto);
1917 }
1918
1919 static int __init packet_init(void)
1920 {
1921         int rc = proto_register(&packet_proto, 0);
1922
1923         if (rc != 0)
1924                 goto out;
1925
1926         sock_register(&packet_family_ops);
1927         register_netdevice_notifier(&packet_netdev_notifier);
1928         proc_net_fops_create("packet", 0, &packet_seq_fops);
1929 out:
1930         return rc;
1931 }
1932
1933 module_init(packet_init);
1934 module_exit(packet_exit);
1935 MODULE_LICENSE("GPL");
1936 MODULE_ALIAS_NETPROTO(PF_PACKET);