sys/net/bpf.c

   1 /*
   2  * Copyright (c) 1990, 1991, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * This code is derived from the Stanford/CMU enet packet filter,
   6  * (net/enet.c) distributed as part of 4.3BSD, and code contributed
   7  * to Berkeley by Steven McCanne and Van Jacobson both of Lawrence
   8  * Berkeley Laboratory.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. All advertising materials mentioning features or use of this software
  19  *    must display the following acknowledgement:
  20  *      This product includes software developed by the University of
  21  *      California, Berkeley and its contributors.
  22  * 4. Neither the name of the University nor the names of its contributors
  23  *    may be used to endorse or promote products derived from this software
  24  *    without specific prior written permission.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  36  * SUCH DAMAGE.
  37  *
  38  *      @(#)bpf.c       8.2 (Berkeley) 3/28/94
  39  *
  40  * $Id: bpf.c,v 1.42 1998/10/04 17:20:22 alex Exp $
  41  */
  42
  43 #include "bpfilter.h"
  44
  45 #if NBPFILTER > 0
  46
  47 #ifndef __GNUC__
  48 #define inline
  49 #else
  50 #define inline __inline
  51 #endif
  52
  53 #include <sys/param.h>
  54 #include <sys/systm.h>
  55 #include <sys/conf.h>
  56 #include <sys/malloc.h>
  57 #include <sys/mbuf.h>
  58 #include <sys/time.h>
  59 #include <sys/proc.h>
  60 #include <sys/signalvar.h>
  61 #include <sys/filio.h>
  62 #include <sys/sockio.h>
  63 #include <sys/ttycom.h>
  64
  65 #if defined(sparc) && BSD < 199103
  66 #include <sys/stream.h>
  67 #endif
  68 #include <sys/poll.h>
  69
  70 #include <sys/socket.h>
  71 #include <sys/vnode.h>
  72
  73 #include <net/if.h>
  74 #include <net/bpf.h>
  75 #include <net/bpfdesc.h>
  76
  77 #include <netinet/in.h>
  78 #include <netinet/if_ether.h>
  79 #include <sys/kernel.h>
  80 #include <sys/sysctl.h>
  81
  82 #include "opt_devfs.h"
  83
  84 #ifdef DEVFS
  85 #include <sys/devfsext.h>
  86 #endif /*DEVFS*/
  87
  88
  89 /*
  90  * Older BSDs don't have kernel malloc.
  91  */
  92 #if BSD < 199103
  93 extern bcopy();
  94 static caddr_t bpf_alloc();
  95 #include <net/bpf_compat.h>
  96 #define BPF_BUFSIZE (MCLBYTES-8)
  97 #define UIOMOVE(cp, len, code, uio) uiomove(cp, len, code, uio)
  98 #else
  99 #define BPF_BUFSIZE 4096
 100 #define UIOMOVE(cp, len, code, uio) uiomove(cp, len, uio)
 101 #endif
 102
 103 #define PRINET  26                      /* interruptible */
 104
 105 /*
 106  * The default read buffer size is patchable.
 107  */
 108 static int bpf_bufsize = BPF_BUFSIZE;
 109 SYSCTL_INT(_debug, OID_AUTO, bpf_bufsize, CTLFLAG_RW,
 110         &bpf_bufsize, 0, "");
 111
 112 /*
 113  *  bpf_iflist is the list of interfaces; each corresponds to an ifnet
 114  *  bpf_dtab holds the descriptors, indexed by minor device #
 115  */
 116 static struct bpf_if    *bpf_iflist;
 117 static struct bpf_d     bpf_dtab[NBPFILTER];
 118 static int              bpf_dtab_init;
 119
 120 static int      bpf_allocbufs __P((struct bpf_d *));
 121 static void     bpf_attachd __P((struct bpf_d *d, struct bpf_if *bp));
 122 static void     bpf_detachd __P((struct bpf_d *d));
 123 static void     bpf_freed __P((struct bpf_d *));
 124 static void     bpf_ifname __P((struct ifnet *, struct ifreq *));
 125 static void     bpf_mcopy __P((const void *, void *, size_t));
 126 static int      bpf_movein __P((struct uio *, int,
 127                     struct mbuf **, struct sockaddr *, int *));
 128 static int      bpf_setif __P((struct bpf_d *, struct ifreq *));
 129 static inline void
 130                 bpf_wakeup __P((struct bpf_d *));
 131 static void     catchpacket __P((struct bpf_d *, u_char *, u_int,
 132                     u_int, void (*)(const void *, void *, size_t)));
 133 static void     reset_d __P((struct bpf_d *));
 134 static int       bpf_setf __P((struct bpf_d *, struct bpf_program *));
 135
 136 static  d_open_t        bpfopen;
 137 static  d_close_t       bpfclose;
 138 static  d_read_t        bpfread;
 139 static  d_write_t       bpfwrite;
 140 static  d_ioctl_t       bpfioctl;
 141 static  d_poll_t        bpfpoll;
 142
 143 #define CDEV_MAJOR 23
 144 static struct cdevsw bpf_cdevsw =
 145         { bpfopen,      bpfclose,       bpfread,        bpfwrite,       /*23*/
 146           bpfioctl,     nostop,         nullreset,      nodevtotty,/* bpf */
 147           bpfpoll,      nommap,         NULL,   "bpf",  NULL,   -1 };
 148
 149
 150 static int
 151 bpf_movein(uio, linktype, mp, sockp, datlen)
 152         register struct uio *uio;
 153         int linktype, *datlen;
 154         register struct mbuf **mp;
 155         register struct sockaddr *sockp;
 156 {
 157         struct mbuf *m;
 158         int error;
 159         int len;
 160         int hlen;
 161
 162         /*
 163          * Build a sockaddr based on the data link layer type.
 164          * We do this at this level because the ethernet header
 165          * is copied directly into the data field of the sockaddr.
 166          * In the case of SLIP, there is no header and the packet
 167          * is forwarded as is.
 168          * Also, we are careful to leave room at the front of the mbuf
 169          * for the link level header.
 170          */
 171         switch (linktype) {
 172
 173         case DLT_SLIP:
 174                 sockp->sa_family = AF_INET;
 175                 hlen = 0;
 176                 break;
 177
 178         case DLT_EN10MB:
 179                 sockp->sa_family = AF_UNSPEC;
 180                 /* XXX Would MAXLINKHDR be better? */
 181                 hlen = sizeof(struct ether_header);
 182                 break;
 183
 184         case DLT_FDDI:
 185 #if defined(__FreeBSD__) || defined(__bsdi__)
 186                 sockp->sa_family = AF_IMPLINK;
 187                 hlen = 0;
 188 #else
 189                 sockp->sa_family = AF_UNSPEC;
 190                 /* XXX 4(FORMAC)+6(dst)+6(src)+3(LLC)+5(SNAP) */
 191                 hlen = 24;
 192 #endif
 193                 break;
 194
 195         case DLT_RAW:
 196         case DLT_NULL:
 197                 sockp->sa_family = AF_UNSPEC;
 198                 hlen = 0;
 199                 break;
 200
 201 #ifdef __FreeBSD__
 202         case DLT_ATM_RFC1483:
 203                 /*
 204                  * en atm driver requires 4-byte atm pseudo header.
 205                  * though it isn't standard, vpi:vci needs to be
 206                  * specified anyway.
 207                  */
 208                 sockp->sa_family = AF_UNSPEC;
 209                 hlen = 12;      /* XXX 4(ATM_PH) + 3(LLC) + 5(SNAP) */
 210                 break;
 211 #endif
 212
 213         default:
 214                 return (EIO);
 215         }
 216
 217         len = uio->uio_resid;
 218         *datlen = len - hlen;
 219         if ((unsigned)len > MCLBYTES)
 220                 return (EIO);
 221
 222         MGETHDR(m, M_WAIT, MT_DATA);
 223         if (m == 0)
 224                 return (ENOBUFS);
 225         if (len > MHLEN) {
 226 #if BSD >= 199103
 227                 MCLGET(m, M_WAIT);
 228                 if ((m->m_flags & M_EXT) == 0) {
 229 #else
 230                 MCLGET(m);
 231                 if (m->m_len != MCLBYTES) {
 232 #endif
 233                         error = ENOBUFS;
 234                         goto bad;
 235                 }
 236         }
 237         m->m_pkthdr.len = m->m_len = len;
 238         m->m_pkthdr.rcvif = NULL;
 239         *mp = m;
 240         /*
 241          * Make room for link header.
 242          */
 243         if (hlen != 0) {
 244                 m->m_pkthdr.len -= hlen;
 245                 m->m_len -= hlen;
 246 #if BSD >= 199103
 247                 m->m_data += hlen; /* XXX */
 248 #else
 249                 m->m_off += hlen;
 250 #endif
 251                 error = UIOMOVE((caddr_t)sockp->sa_data, hlen, UIO_WRITE, uio);
 252                 if (error)
 253                         goto bad;
 254         }
 255         error = UIOMOVE(mtod(m, caddr_t), len - hlen, UIO_WRITE, uio);
 256         if (!error)
 257                 return (0);
 258  bad:
 259         m_freem(m);
 260         return (error);
 261 }
 262
 263 /*
 264  * Attach file to the bpf interface, i.e. make d listen on bp.
 265  * Must be called at splimp.
 266  */
 267 static void
 268 bpf_attachd(d, bp)
 269         struct bpf_d *d;
 270         struct bpf_if *bp;
 271 {
 272         /*
 273          * Point d at bp, and add d to the interface's list of listeners.
 274          * Finally, point the driver's bpf cookie at the interface so
 275          * it will divert packets to bpf.
 276          */
 277         d->bd_bif = bp;
 278         d->bd_next = bp->bif_dlist;
 279         bp->bif_dlist = d;
 280
 281         bp->bif_ifp->if_bpf = bp;
 282 }
 283
 284 /*
 285  * Detach a file from its interface.
 286  */
 287 static void
 288 bpf_detachd(d)
 289         struct bpf_d *d;
 290 {
 291         struct bpf_d **p;
 292         struct bpf_if *bp;
 293
 294         bp = d->bd_bif;
 295         /*
 296          * Check if this descriptor had requested promiscuous mode.
 297          * If so, turn it off.
 298          */
 299         if (d->bd_promisc) {
 300                 d->bd_promisc = 0;
 301                 if (ifpromisc(bp->bif_ifp, 0))
 302                         /*
 303                          * Something is really wrong if we were able to put
 304                          * the driver into promiscuous mode, but can't
 305                          * take it out.
 306                          */
 307                         panic("bpf: ifpromisc failed");
 308         }
 309         /* Remove d from the interface's descriptor list. */
 310         p = &bp->bif_dlist;
 311         while (*p != d) {
 312                 p = &(*p)->bd_next;
 313                 if (*p == 0)
 314                         panic("bpf_detachd: descriptor not in list");
 315         }
 316         *p = (*p)->bd_next;
 317         if (bp->bif_dlist == 0)
 318                 /*
 319                  * Let the driver know that there are no more listeners.
 320                  */
 321                 d->bd_bif->bif_ifp->if_bpf = 0;
 322         d->bd_bif = 0;
 323 }
 324
 325
 326 /*
 327  * Mark a descriptor free by making it point to itself.
 328  * This is probably cheaper than marking with a constant since
 329  * the address should be in a register anyway.
 330  */
 331 #define D_ISFREE(d) ((d) == (d)->bd_next)
 332 #define D_MARKFREE(d) ((d)->bd_next = (d))
 333 #define D_MARKUSED(d) ((d)->bd_next = 0)
 334
 335 /*
 336  * Open ethernet device.  Returns ENXIO for illegal minor device number,
 337  * EBUSY if file is open by another process.
 338  */
 339 /* ARGSUSED */
 340 static  int
 341 bpfopen(dev, flags, fmt, p)
 342         dev_t dev;
 343         int flags;
 344         int fmt;
 345         struct proc *p;
 346 {
 347         register struct bpf_d *d;
 348
 349         if (minor(dev) >= NBPFILTER)
 350                 return (ENXIO);
 351         /*
 352          * Each minor can be opened by only one process.  If the requested
 353          * minor is in use, return EBUSY.
 354          */
 355         d = &bpf_dtab[minor(dev)];
 356         if (!D_ISFREE(d))
 357                 return (EBUSY);
 358
 359         /* Mark "free" and do most initialization. */
 360         bzero((char *)d, sizeof(*d));
 361         d->bd_bufsize = bpf_bufsize;
 362         d->bd_sig = SIGIO;
 363
 364         return (0);
 365 }
 366
 367 /*
 368  * Close the descriptor by detaching it from its interface,
 369  * deallocating its buffers, and marking it free.
 370  */
 371 /* ARGSUSED */
 372 static  int
 373 bpfclose(dev, flags, fmt, p)
 374         dev_t dev;
 375         int flags;
 376         int fmt;
 377         struct proc *p;
 378 {
 379         register struct bpf_d *d = &bpf_dtab[minor(dev)];
 380         register int s;
 381
 382         s = splimp();
 383         if (d->bd_bif)
 384                 bpf_detachd(d);
 385         splx(s);
 386         bpf_freed(d);
 387
 388         return (0);
 389 }
 390
 391 /*
 392  * Support for SunOS, which does not have tsleep.
 393  */
 394 #if BSD < 199103
 395 static
 396 bpf_timeout(arg)
 397         caddr_t arg;
 398 {
 399         struct bpf_d *d = (struct bpf_d *)arg;
 400         d->bd_timedout = 1;
 401         wakeup(arg);
 402 }
 403
 404 #define BPF_SLEEP(chan, pri, s, t) bpf_sleep((struct bpf_d *)chan)
 405
 406 int
 407 bpf_sleep(d)
 408         register struct bpf_d *d;
 409 {
 410         register int rto = d->bd_rtout;
 411         register int st;
 412
 413         if (rto != 0) {
 414                 d->bd_timedout = 0;
 415                 timeout(bpf_timeout, (caddr_t)d, rto);
 416         }
 417         st = sleep((caddr_t)d, PRINET|PCATCH);
 418         if (rto != 0) {
 419                 if (d->bd_timedout == 0)
 420                         untimeout(bpf_timeout, (caddr_t)d);
 421                 else if (st == 0)
 422                         return EWOULDBLOCK;
 423         }
 424         return (st != 0) ? EINTR : 0;
 425 }
 426 #else
 427 #define BPF_SLEEP tsleep
 428 #endif
 429
 430 /*
 431  * Rotate the packet buffers in descriptor d.  Move the store buffer
 432  * into the hold slot, and the free buffer into the store slot.
 433  * Zero the length of the new store buffer.
 434  */
 435 #define ROTATE_BUFFERS(d) \
 436         (d)->bd_hbuf = (d)->bd_sbuf; \
 437         (d)->bd_hlen = (d)->bd_slen; \
 438         (d)->bd_sbuf = (d)->bd_fbuf; \
 439         (d)->bd_slen = 0; \
 440         (d)->bd_fbuf = 0;
 441 /*
 442  *  bpfread - read next chunk of packets from buffers
 443  */
 444 static  int
 445 bpfread(dev, uio, ioflag)
 446         dev_t dev;
 447         register struct uio *uio;
 448         int ioflag;
 449 {
 450         register struct bpf_d *d = &bpf_dtab[minor(dev)];
 451         int error;
 452         int s;
 453
 454         /*
 455          * Restrict application to use a buffer the same size as
 456          * as kernel buffers.
 457          */
 458         if (uio->uio_resid != d->bd_bufsize)
 459                 return (EINVAL);
 460
 461         s = splimp();
 462         /*
 463          * If the hold buffer is empty, then do a timed sleep, which
 464          * ends when the timeout expires or when enough packets
 465          * have arrived to fill the store buffer.
 466          */
 467         while (d->bd_hbuf == 0) {
 468                 if (d->bd_immediate && d->bd_slen != 0) {
 469                         /*
 470                          * A packet(s) either arrived since the previous
 471                          * read or arrived while we were asleep.
 472                          * Rotate the buffers and return what's here.
 473                          */
 474                         ROTATE_BUFFERS(d);
 475                         break;
 476                 }
 477                 if (ioflag & IO_NDELAY)
 478                         error = EWOULDBLOCK;
 479                 else
 480                         error = BPF_SLEEP((caddr_t)d, PRINET|PCATCH, "bpf",
 481                                           d->bd_rtout);
 482                 if (error == EINTR || error == ERESTART) {
 483                         splx(s);
 484                         return (error);
 485                 }
 486                 if (error == EWOULDBLOCK) {
 487                         /*
 488                          * On a timeout, return what's in the buffer,
 489                          * which may be nothing.  If there is something
 490                          * in the store buffer, we can rotate the buffers.
 491                          */
 492                         if (d->bd_hbuf)
 493                                 /*
 494                                  * We filled up the buffer in between
 495                                  * getting the timeout and arriving
 496                                  * here, so we don't need to rotate.
 497                                  */
 498                                 break;
 499
 500                         if (d->bd_slen == 0) {
 501                                 splx(s);
 502                                 return (0);
 503                         }
 504                         ROTATE_BUFFERS(d);
 505                         break;
 506                 }
 507         }
 508         /*
 509          * At this point, we know we have something in the hold slot.
 510          */
 511         splx(s);
 512
 513         /*
 514          * Move data from hold buffer into user space.
 515          * We know the entire buffer is transferred since
 516          * we checked above that the read buffer is bpf_bufsize bytes.
 517          */
 518         error = UIOMOVE(d->bd_hbuf, d->bd_hlen, UIO_READ, uio);
 519
 520         s = splimp();
 521         d->bd_fbuf = d->bd_hbuf;
 522         d->bd_hbuf = 0;
 523         d->bd_hlen = 0;
 524         splx(s);
 525
 526         return (error);
 527 }
 528
 529
 530 /*
 531  * If there are processes sleeping on this descriptor, wake them up.
 532  */
 533 static inline void
 534 bpf_wakeup(d)
 535         register struct bpf_d *d;
 536 {
 537         struct proc *p;
 538
 539         wakeup((caddr_t)d);
 540         if (d->bd_async && d->bd_sig)
 541                 if (d->bd_pgid > 0)
 542                         gsignal (d->bd_pgid, d->bd_sig);
 543                 else if (p = pfind (-d->bd_pgid))
 544                         psignal (p, d->bd_sig);
 545
 546 #if BSD >= 199103
 547         selwakeup(&d->bd_sel);
 548         /* XXX */
 549         d->bd_sel.si_pid = 0;
 550 #else
 551         if (d->bd_selproc) {
 552                 selwakeup(d->bd_selproc, (int)d->bd_selcoll);
 553                 d->bd_selcoll = 0;
 554                 d->bd_selproc = 0;
 555         }
 556 #endif
 557 }
 558
 559 static  int
 560 bpfwrite(dev, uio, ioflag)
 561         dev_t dev;
 562         struct uio *uio;
 563         int ioflag;
 564 {
 565         register struct bpf_d *d = &bpf_dtab[minor(dev)];
 566         struct ifnet *ifp;
 567         struct mbuf *m;
 568         int error, s;
 569         static struct sockaddr dst;
 570         int datlen;
 571
 572         if (d->bd_bif == 0)
 573                 return (ENXIO);
 574
 575         ifp = d->bd_bif->bif_ifp;
 576
 577         if (uio->uio_resid == 0)
 578                 return (0);
 579
 580         error = bpf_movein(uio, (int)d->bd_bif->bif_dlt, &m, &dst, &datlen);
 581         if (error)
 582                 return (error);
 583
 584         if (datlen > ifp->if_mtu)
 585                 return (EMSGSIZE);
 586
 587         s = splnet();
 588 #if BSD >= 199103
 589         error = (*ifp->if_output)(ifp, m, &dst, (struct rtentry *)0);
 590 #else
 591         error = (*ifp->if_output)(ifp, m, &dst);
 592 #endif
 593         splx(s);
 594         /*
 595          * The driver frees the mbuf.
 596          */
 597         return (error);
 598 }
 599
 600 /*
 601  * Reset a descriptor by flushing its packet buffer and clearing the
 602  * receive and drop counts.  Should be called at splimp.
 603  */
 604 static void
 605 reset_d(d)
 606         struct bpf_d *d;
 607 {
 608         if (d->bd_hbuf) {
 609                 /* Free the hold buffer. */
 610                 d->bd_fbuf = d->bd_hbuf;
 611                 d->bd_hbuf = 0;
 612         }
 613         d->bd_slen = 0;
 614         d->bd_hlen = 0;
 615         d->bd_rcount = 0;
 616         d->bd_dcount = 0;
 617 }
 618
 619 /*
 620  *  FIONREAD            Check for read packet available.
 621  *  SIOCGIFADDR         Get interface address - convenient hook to driver.
 622  *  BIOCGBLEN           Get buffer len [for read()].
 623  *  BIOCSETF            Set ethernet read filter.
 624  *  BIOCFLUSH           Flush read packet buffer.
 625  *  BIOCPROMISC         Put interface into promiscuous mode.
 626  *  BIOCGDLT            Get link layer type.
 627  *  BIOCGETIF           Get interface name.
 628  *  BIOCSETIF           Set interface.
 629  *  BIOCSRTIMEOUT       Set read timeout.
 630  *  BIOCGRTIMEOUT       Get read timeout.
 631  *  BIOCGSTATS          Get packet stats.
 632  *  BIOCIMMEDIATE       Set immediate mode.
 633  *  BIOCVERSION         Get filter language version.
 634  */
 635 /* ARGSUSED */
 636 static  int
 637 bpfioctl(dev, cmd, addr, flags, p)
 638         dev_t dev;
 639         u_long cmd;
 640         caddr_t addr;
 641         int flags;
 642         struct proc *p;
 643 {
 644         register struct bpf_d *d = &bpf_dtab[minor(dev)];
 645         int s, error = 0;
 646
 647         switch (cmd) {
 648
 649         default:
 650                 error = EINVAL;
 651                 break;
 652
 653         /*
 654          * Check for read packet available.
 655          */
 656         case FIONREAD:
 657                 {
 658                         int n;
 659
 660                         s = splimp();
 661                         n = d->bd_slen;
 662                         if (d->bd_hbuf)
 663                                 n += d->bd_hlen;
 664                         splx(s);
 665
 666                         *(int *)addr = n;
 667                         break;
 668                 }
 669
 670         case SIOCGIFADDR:
 671                 {
 672                         struct ifnet *ifp;
 673
 674                         if (d->bd_bif == 0)
 675                                 error = EINVAL;
 676                         else {
 677                                 ifp = d->bd_bif->bif_ifp;
 678                                 error = (*ifp->if_ioctl)(ifp, cmd, addr);
 679                         }
 680                         break;
 681                 }
 682
 683         /*
 684          * Get buffer len [for read()].
 685          */
 686         case BIOCGBLEN:
 687                 *(u_int *)addr = d->bd_bufsize;
 688                 break;
 689
 690         /*
 691          * Set buffer length.
 692          */
 693         case BIOCSBLEN:
 694 #if BSD < 199103
 695                 error = EINVAL;
 696 #else
 697                 if (d->bd_bif != 0)
 698                         error = EINVAL;
 699                 else {
 700                         register u_int size = *(u_int *)addr;
 701
 702                         if (size > BPF_MAXBUFSIZE)
 703                                 *(u_int *)addr = size = BPF_MAXBUFSIZE;
 704                         else if (size < BPF_MINBUFSIZE)
 705                                 *(u_int *)addr = size = BPF_MINBUFSIZE;
 706                         d->bd_bufsize = size;
 707                 }
 708 #endif
 709                 break;
 710
 711         /*
 712          * Set link layer read filter.
 713          */
 714         case BIOCSETF:
 715                 error = bpf_setf(d, (struct bpf_program *)addr);
 716                 break;
 717
 718         /*
 719          * Flush read packet buffer.
 720          */
 721         case BIOCFLUSH:
 722                 s = splimp();
 723                 reset_d(d);
 724                 splx(s);
 725                 break;
 726
 727         /*
 728          * Put interface into promiscuous mode.
 729          */
 730         case BIOCPROMISC:
 731                 if (d->bd_bif == 0) {
 732                         /*
 733                          * No interface attached yet.
 734                          */
 735                         error = EINVAL;
 736                         break;
 737                 }
 738                 s = splimp();
 739                 if (d->bd_promisc == 0) {
 740                         error = ifpromisc(d->bd_bif->bif_ifp, 1);
 741                         if (error == 0)
 742                                 d->bd_promisc = 1;
 743                 }
 744                 splx(s);
 745                 break;
 746
 747         /*
 748          * Get device parameters.
 749          */
 750         case BIOCGDLT:
 751                 if (d->bd_bif == 0)
 752                         error = EINVAL;
 753                 else
 754                         *(u_int *)addr = d->bd_bif->bif_dlt;
 755                 break;
 756
 757         /*
 758          * Set interface name.
 759          */
 760         case BIOCGETIF:
 761                 if (d->bd_bif == 0)
 762                         error = EINVAL;
 763                 else
 764                         bpf_ifname(d->bd_bif->bif_ifp, (struct ifreq *)addr);
 765                 break;
 766
 767         /*
 768          * Set interface.
 769          */
 770         case BIOCSETIF:
 771                 error = bpf_setif(d, (struct ifreq *)addr);
 772                 break;
 773
 774         /*
 775          * Set read timeout.
 776          */
 777         case BIOCSRTIMEOUT:
 778                 {
 779                         struct timeval *tv = (struct timeval *)addr;
 780
 781                         d->bd_rtout = tv->tv_sec * hz + tv->tv_usec / tick;
 782                         if (d->bd_rtout == 0 && tv->tv_usec != 0)
 783                                 d->bd_rtout = 1;
 784                         break;
 785                 }
 786
 787         /*
 788          * Get read timeout.
 789          */
 790         case BIOCGRTIMEOUT:
 791                 {
 792                         struct timeval *tv = (struct timeval *)addr;
 793                         u_long msec = d->bd_rtout;
 794
 795                         msec *= tick / 1000;
 796                         tv->tv_sec = msec / 1000;
 797                         tv->tv_usec = msec % 1000;
 798                         break;
 799                 }
 800
 801         /*
 802          * Get packet stats.
 803          */
 804         case BIOCGSTATS:
 805                 {
 806                         struct bpf_stat *bs = (struct bpf_stat *)addr;
 807
 808                         bs->bs_recv = d->bd_rcount;
 809                         bs->bs_drop = d->bd_dcount;
 810                         break;
 811                 }
 812
 813         /*
 814          * Set immediate mode.
 815          */
 816         case BIOCIMMEDIATE:
 817                 d->bd_immediate = *(u_int *)addr;
 818                 break;
 819
 820         case BIOCVERSION:
 821                 {
 822                         struct bpf_version *bv = (struct bpf_version *)addr;
 823
 824                         bv->bv_major = BPF_MAJOR_VERSION;
 825                         bv->bv_minor = BPF_MINOR_VERSION;
 826                         break;
 827                 }
 828
 829         case FIONBIO:           /* Non-blocking I/O */
 830                 break;
 831
 832         case FIOASYNC:          /* Send signal on receive packets */
 833                 d->bd_async = *(int *)addr;
 834                 break;
 835
 836 /* N.B.  ioctl (FIOSETOWN) and fcntl (F_SETOWN) both end up doing the
 837    equivalent of a TIOCSPGRP and hence end up here.  *However* TIOCSPGRP's arg
 838    is a process group if it's positive and a process id if it's negative.  This
 839    is exactly the opposite of what the other two functions want!  Therefore
 840    there is code in ioctl and fcntl to negate the arg before calling here. */
 841
 842         case TIOCSPGRP:         /* Process or group to send signals to */
 843                 d->bd_pgid = *(int *)addr;
 844                 break;
 845
 846         case TIOCGPGRP:
 847                 *(int *)addr = d->bd_pgid;
 848                 break;
 849
 850         case BIOCSRSIG:         /* Set receive signal */
 851                 {
 852                         u_int sig;
 853
 854                         sig = *(u_int *)addr;
 855
 856                         if (sig >= NSIG)
 857                                 error = EINVAL;
 858                         else
 859                                 d->bd_sig = sig;
 860                         break;
 861                 }
 862         case BIOCGRSIG:
 863                 *(u_int *)addr = d->bd_sig;
 864                 break;
 865         }
 866         return (error);
 867 }
 868
 869 /*
 870  * Set d's packet filter program to fp.  If this file already has a filter,
 871  * free it and replace it.  Returns EINVAL for bogus requests.
 872  */
 873 static int
 874 bpf_setf(d, fp)
 875         struct bpf_d *d;
 876         struct bpf_program *fp;
 877 {
 878         struct bpf_insn *fcode, *old;
 879         u_int flen, size;
 880         int s;
 881
 882         old = d->bd_filter;
 883         if (fp->bf_insns == 0) {
 884                 if (fp->bf_len != 0)
 885                         return (EINVAL);
 886                 s = splimp();
 887                 d->bd_filter = 0;
 888                 reset_d(d);
 889                 splx(s);
 890                 if (old != 0)
 891                         free((caddr_t)old, M_DEVBUF);
 892                 return (0);
 893         }
 894         flen = fp->bf_len;
 895         if (flen > BPF_MAXINSNS)
 896                 return (EINVAL);
 897
 898         size = flen * sizeof(*fp->bf_insns);
 899         fcode = (struct bpf_insn *)malloc(size, M_DEVBUF, M_WAITOK);
 900         if (copyin((caddr_t)fp->bf_insns, (caddr_t)fcode, size) == 0 &&
 901             bpf_validate(fcode, (int)flen)) {
 902                 s = splimp();
 903                 d->bd_filter = fcode;
 904                 reset_d(d);
 905                 splx(s);
 906                 if (old != 0)
 907                         free((caddr_t)old, M_DEVBUF);
 908
 909                 return (0);
 910         }
 911         free((caddr_t)fcode, M_DEVBUF);
 912         return (EINVAL);
 913 }
 914
 915 /*
 916  * Detach a file from its current interface (if attached at all) and attach
 917  * to the interface indicated by the name stored in ifr.
 918  * Return an errno or 0.
 919  */
 920 static int
 921 bpf_setif(d, ifr)
 922         struct bpf_d *d;
 923         struct ifreq *ifr;
 924 {
 925         struct bpf_if *bp;
 926         int s, error;
 927         struct ifnet *theywant;
 928
 929         theywant = ifunit(ifr->ifr_name);
 930         if (theywant == 0)
 931                 return ENXIO;
 932
 933         /*
 934          * Look through attached interfaces for the named one.
 935          */
 936         for (bp = bpf_iflist; bp != 0; bp = bp->bif_next) {
 937                 struct ifnet *ifp = bp->bif_ifp;
 938
 939                 if (ifp == 0 || ifp != theywant)
 940                         continue;
 941                 /*
 942                  * We found the requested interface.
 943                  * If it's not up, return an error.
 944                  * Allocate the packet buffers if we need to.
 945                  * If we're already attached to requested interface,
 946                  * just flush the buffer.
 947                  */
 948                 if ((ifp->if_flags & IFF_UP) == 0)
 949                         return (ENETDOWN);
 950
 951                 if (d->bd_sbuf == 0) {
 952                         error = bpf_allocbufs(d);
 953                         if (error != 0)
 954                                 return (error);
 955                 }
 956                 s = splimp();
 957                 if (bp != d->bd_bif) {
 958                         if (d->bd_bif)
 959                                 /*
 960                                  * Detach if attached to something else.
 961                                  */
 962                                 bpf_detachd(d);
 963
 964                         bpf_attachd(d, bp);
 965                 }
 966                 reset_d(d);
 967                 splx(s);
 968                 return (0);
 969         }
 970         /* Not found. */
 971         return (ENXIO);
 972 }
 973
 974 /*
 975  * Convert an interface name plus unit number of an ifp to a single
 976  * name which is returned in the ifr.
 977  */
 978 static void
 979 bpf_ifname(ifp, ifr)
 980         struct ifnet *ifp;
 981         struct ifreq *ifr;
 982 {
 983         char *s = ifp->if_name;
 984         char *d = ifr->ifr_name;
 985
 986         while (*d++ = *s++)
 987                 continue;
 988         d--; /* back to the null */
 989         /* XXX Assume that unit number is less than 10. */
 990         *d++ = ifp->if_unit + '0';
 991         *d = '\0';
 992 }
 993
 994 /*
 995  * Support for select() and poll() system calls
 996  *
 997  * Return true iff the specific operation will not block indefinitely.
 998  * Otherwise, return false but make a note that a selwakeup() must be done.
 999  */
1000 int
1001 bpfpoll(dev, events, p)
1002         register dev_t dev;
1003         int events;
1004         struct proc *p;
1005 {
1006         register struct bpf_d *d;
1007         register int s;
1008         int revents = 0;
1009
1010         /*
1011          * An imitation of the FIONREAD ioctl code.
1012          */
1013         d = &bpf_dtab[minor(dev)];
1014
1015         s = splimp();
1016         if (events & (POLLIN | POLLRDNORM))
1017                 if (d->bd_hlen != 0 || (d->bd_immediate && d->bd_slen != 0))
1018                         revents |= events & (POLLIN | POLLRDNORM);
1019                 else
1020                         selrecord(p, &d->bd_sel);
1021
1022         splx(s);
1023         return (revents);
1024 }
1025
1026 /*
1027  * Incoming linkage from device drivers.  Process the packet pkt, of length
1028  * pktlen, which is stored in a contiguous buffer.  The packet is parsed
1029  * by each process' filter, and if accepted, stashed into the corresponding
1030  * buffer.
1031  */
1032 void
1033 bpf_tap(ifp, pkt, pktlen)
1034         struct ifnet *ifp;
1035         register u_char *pkt;
1036         register u_int pktlen;
1037 {
1038         struct bpf_if *bp;
1039         register struct bpf_d *d;
1040         register u_int slen;
1041         /*
1042          * Note that the ipl does not have to be raised at this point.
1043          * The only problem that could arise here is that if two different
1044          * interfaces shared any data.  This is not the case.
1045          */
1046         bp = ifp->if_bpf;
1047         for (d = bp->bif_dlist; d != 0; d = d->bd_next) {
1048                 ++d->bd_rcount;
1049                 slen = bpf_filter(d->bd_filter, pkt, pktlen, pktlen);
1050                 if (slen != 0)
1051                         catchpacket(d, pkt, pktlen, slen, bcopy);
1052         }
1053 }
1054
1055 /*
1056  * Copy data from an mbuf chain into a buffer.  This code is derived
1057  * from m_copydata in sys/uipc_mbuf.c.
1058  */
1059 static void
1060 bpf_mcopy(src_arg, dst_arg, len)
1061         const void *src_arg;
1062         void *dst_arg;
1063         register size_t len;
1064 {
1065         register const struct mbuf *m;
1066         register u_int count;
1067         u_char *dst;
1068
1069         m = src_arg;
1070         dst = dst_arg;
1071         while (len > 0) {
1072                 if (m == 0)
1073                         panic("bpf_mcopy");
1074                 count = min(m->m_len, len);
1075                 bcopy(mtod(m, void *), dst, count);
1076                 m = m->m_next;
1077                 dst += count;
1078                 len -= count;
1079         }
1080 }
1081
1082 /*
1083  * Incoming linkage from device drivers, when packet is in an mbuf chain.
1084  */
1085 void
1086 bpf_mtap(ifp, m)
1087         struct ifnet *ifp;
1088         struct mbuf *m;
1089 {
1090         struct bpf_if *bp = ifp->if_bpf;
1091         struct bpf_d *d;
1092         u_int pktlen, slen;
1093         struct mbuf *m0;
1094
1095         pktlen = 0;
1096         for (m0 = m; m0 != 0; m0 = m0->m_next)
1097                 pktlen += m0->m_len;
1098
1099         for (d = bp->bif_dlist; d != 0; d = d->bd_next) {
1100                 ++d->bd_rcount;
1101                 slen = bpf_filter(d->bd_filter, (u_char *)m, pktlen, 0);
1102                 if (slen != 0)
1103                         catchpacket(d, (u_char *)m, pktlen, slen, bpf_mcopy);
1104         }
1105 }
1106
1107 /*
1108  * Move the packet data from interface memory (pkt) into the
1109  * store buffer.  Return 1 if it's time to wakeup a listener (buffer full),
1110  * otherwise 0.  "copy" is the routine called to do the actual data
1111  * transfer.  bcopy is passed in to copy contiguous chunks, while
1112  * bpf_mcopy is passed in to copy mbuf chains.  In the latter case,
1113  * pkt is really an mbuf.
1114  */
1115 static void
1116 catchpacket(d, pkt, pktlen, snaplen, cpfn)
1117         register struct bpf_d *d;
1118         register u_char *pkt;
1119         register u_int pktlen, snaplen;
1120         register void (*cpfn) __P((const void *, void *, size_t));
1121 {
1122         register struct bpf_hdr *hp;
1123         register int totlen, curlen;
1124         register int hdrlen = d->bd_bif->bif_hdrlen;
1125         /*
1126          * Figure out how many bytes to move.  If the packet is
1127          * greater or equal to the snapshot length, transfer that
1128          * much.  Otherwise, transfer the whole packet (unless
1129          * we hit the buffer size limit).
1130          */
1131         totlen = hdrlen + min(snaplen, pktlen);
1132         if (totlen > d->bd_bufsize)
1133                 totlen = d->bd_bufsize;
1134
1135         /*
1136          * Round up the end of the previous packet to the next longword.
1137          */
1138         curlen = BPF_WORDALIGN(d->bd_slen);
1139         if (curlen + totlen > d->bd_bufsize) {
1140                 /*
1141                  * This packet will overflow the storage buffer.
1142                  * Rotate the buffers if we can, then wakeup any
1143                  * pending reads.
1144                  */
1145                 if (d->bd_fbuf == 0) {
1146                         /*
1147                          * We haven't completed the previous read yet,
1148                          * so drop the packet.
1149                          */
1150                         ++d->bd_dcount;
1151                         return;
1152                 }
1153                 ROTATE_BUFFERS(d);
1154                 bpf_wakeup(d);
1155                 curlen = 0;
1156         }
1157         else if (d->bd_immediate)
1158                 /*
1159                  * Immediate mode is set.  A packet arrived so any
1160                  * reads should be woken up.
1161                  */
1162                 bpf_wakeup(d);
1163
1164         /*
1165          * Append the bpf header.
1166          */
1167         hp = (struct bpf_hdr *)(d->bd_sbuf + curlen);
1168 #if BSD >= 199103
1169         microtime(&hp->bh_tstamp);
1170 #elif defined(sun)
1171         uniqtime(&hp->bh_tstamp);
1172 #else
1173         hp->bh_tstamp = time;
1174 #endif
1175         hp->bh_datalen = pktlen;
1176         hp->bh_hdrlen = hdrlen;
1177         /*
1178          * Copy the packet data into the store buffer and update its length.
1179          */
1180         (*cpfn)(pkt, (u_char *)hp + hdrlen, (hp->bh_caplen = totlen - hdrlen));
1181         d->bd_slen = curlen + totlen;
1182 }
1183
1184 /*
1185  * Initialize all nonzero fields of a descriptor.
1186  */
1187 static int
1188 bpf_allocbufs(d)
1189         register struct bpf_d *d;
1190 {
1191         d->bd_fbuf = (caddr_t)malloc(d->bd_bufsize, M_DEVBUF, M_WAITOK);
1192         if (d->bd_fbuf == 0)
1193                 return (ENOBUFS);
1194
1195         d->bd_sbuf = (caddr_t)malloc(d->bd_bufsize, M_DEVBUF, M_WAITOK);
1196         if (d->bd_sbuf == 0) {
1197                 free(d->bd_fbuf, M_DEVBUF);
1198                 return (ENOBUFS);
1199         }
1200         d->bd_slen = 0;
1201         d->bd_hlen = 0;
1202         return (0);
1203 }
1204
1205 /*
1206  * Free buffers currently in use by a descriptor.
1207  * Called on close.
1208  */
1209 static void
1210 bpf_freed(d)
1211         register struct bpf_d *d;
1212 {
1213         /*
1214          * We don't need to lock out interrupts since this descriptor has
1215          * been detached from its interface and it yet hasn't been marked
1216          * free.
1217          */
1218         if (d->bd_sbuf != 0) {
1219                 free(d->bd_sbuf, M_DEVBUF);
1220                 if (d->bd_hbuf != 0)
1221                         free(d->bd_hbuf, M_DEVBUF);
1222                 if (d->bd_fbuf != 0)
1223                         free(d->bd_fbuf, M_DEVBUF);
1224         }
1225         if (d->bd_filter)
1226                 free((caddr_t)d->bd_filter, M_DEVBUF);
1227
1228         D_MARKFREE(d);
1229 }
1230
1231 /*
1232  * Attach an interface to bpf.  driverp is a pointer to a (struct bpf_if *)
1233  * in the driver's softc; dlt is the link layer type; hdrlen is the fixed
1234  * size of the link header (variable length headers not yet supported).
1235  */
1236 void
1237 bpfattach(ifp, dlt, hdrlen)
1238         struct ifnet *ifp;
1239         u_int dlt, hdrlen;
1240 {
1241         struct bpf_if *bp;
1242         int i;
1243         bp = (struct bpf_if *)malloc(sizeof(*bp), M_DEVBUF, M_DONTWAIT);
1244         if (bp == 0)
1245                 panic("bpfattach");
1246
1247         bp->bif_dlist = 0;
1248         bp->bif_ifp = ifp;
1249         bp->bif_dlt = dlt;
1250
1251         bp->bif_next = bpf_iflist;
1252         bpf_iflist = bp;
1253
1254         bp->bif_ifp->if_bpf = 0;
1255
1256         /*
1257          * Compute the length of the bpf header.  This is not necessarily
1258          * equal to SIZEOF_BPF_HDR because we want to insert spacing such
1259          * that the network layer header begins on a longword boundary (for
1260          * performance reasons and to alleviate alignment restrictions).
1261          */
1262         bp->bif_hdrlen = BPF_WORDALIGN(hdrlen + SIZEOF_BPF_HDR) - hdrlen;
1263
1264         /*
1265          * Mark all the descriptors free if this hasn't been done.
1266          */
1267         if (!bpf_dtab_init) {
1268                 for (i = 0; i < NBPFILTER; ++i)
1269                         D_MARKFREE(&bpf_dtab[i]);
1270                 bpf_dtab_init = 1;
1271         }
1272
1273         if (bootverbose)
1274                 printf("bpf: %s%d attached\n", ifp->if_name, ifp->if_unit);
1275 }
1276
1277 #ifdef DEVFS
1278 static  void *bpf_devfs_token[NBPFILTER];
1279 #endif
1280
1281 static  int bpf_devsw_installed;
1282
1283 static void bpf_drvinit __P((void *unused));
1284 static void
1285 bpf_drvinit(unused)
1286         void *unused;
1287 {
1288         dev_t dev;
1289 #ifdef DEVFS
1290         int i;
1291 #endif
1292
1293         if( ! bpf_devsw_installed ) {
1294                 dev = makedev(CDEV_MAJOR, 0);
1295                 cdevsw_add(&dev,&bpf_cdevsw, NULL);
1296                 bpf_devsw_installed = 1;
1297 #ifdef DEVFS
1298
1299                 for ( i = 0 ; i < NBPFILTER ; i++ ) {
1300                         bpf_devfs_token[i] =
1301                                 devfs_add_devswf(&bpf_cdevsw, i, DV_CHR, 0, 0,
1302                                                  0600, "bpf%d", i);
1303                 }
1304 #endif
1305         }
1306 }
1307
1308 SYSINIT(bpfdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,bpf_drvinit,NULL)
1309
1310 #endif