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  * $FreeBSD: src/sys/net/bpf.c,v 1.59.2.12 2002/04/14 21:41:48 luigi Exp $
  41  * $DragonFly: src/sys/net/bpf.c,v 1.50 2008/09/23 11:28:49 sephe Exp $
  42  */
  43
  44 #include "use_bpf.h"
  45
  46 #include <sys/param.h>
  47 #include <sys/systm.h>
  48 #include <sys/conf.h>
  49 #include <sys/device.h>
  50 #include <sys/malloc.h>
  51 #include <sys/mbuf.h>
  52 #include <sys/time.h>
  53 #include <sys/proc.h>
  54 #include <sys/signalvar.h>
  55 #include <sys/filio.h>
  56 #include <sys/sockio.h>
  57 #include <sys/ttycom.h>
  58 #include <sys/filedesc.h>
  59
  60 #include <sys/poll.h>
  61 #include <sys/event.h>
  62
  63 #include <sys/socket.h>
  64 #include <sys/vnode.h>
  65
  66 #include <sys/thread2.h>
  67 #include <sys/mplock2.h>
  68
  69 #include <net/if.h>
  70 #include <net/bpf.h>
  71 #include <net/bpfdesc.h>
  72 #include <net/netmsg2.h>
  73
  74 #include <netinet/in.h>
  75 #include <netinet/if_ether.h>
  76 #include <sys/kernel.h>
  77 #include <sys/sysctl.h>
  78
  79 #include <sys/devfs.h>
  80
  81 struct netmsg_bpf_output {
  82         struct netmsg   nm_netmsg;
  83         struct mbuf     *nm_mbuf;
  84         struct ifnet    *nm_ifp;
  85         struct sockaddr *nm_dst;
  86 };
  87
  88 MALLOC_DEFINE(M_BPF, "BPF", "BPF data");
  89 DEVFS_DECLARE_CLONE_BITMAP(bpf);
  90
  91 #if NBPF <= 1
  92 #define BPF_PREALLOCATED_UNITS  4
  93 #else
  94 #define BPF_PREALLOCATED_UNITS  NBPF
  95 #endif
  96
  97 #if NBPF > 0
  98
  99 /*
 100  * The default read buffer size is patchable.
 101  */
 102 static int bpf_bufsize = BPF_DEFAULTBUFSIZE;
 103 SYSCTL_INT(_debug, OID_AUTO, bpf_bufsize, CTLFLAG_RW,
 104            &bpf_bufsize, 0, "");
 105 int bpf_maxbufsize = BPF_MAXBUFSIZE;
 106 SYSCTL_INT(_debug, OID_AUTO, bpf_maxbufsize, CTLFLAG_RW,
 107            &bpf_maxbufsize, 0, "");
 108
 109 /*
 110  *  bpf_iflist is the list of interfaces; each corresponds to an ifnet
 111  */
 112 static struct bpf_if    *bpf_iflist;
 113
 114 static int      bpf_allocbufs(struct bpf_d *);
 115 static void     bpf_attachd(struct bpf_d *d, struct bpf_if *bp);
 116 static void     bpf_detachd(struct bpf_d *d);
 117 static void     bpf_resetd(struct bpf_d *);
 118 static void     bpf_freed(struct bpf_d *);
 119 static void     bpf_mcopy(const void *, void *, size_t);
 120 static int      bpf_movein(struct uio *, int, struct mbuf **,
 121                            struct sockaddr *, int *, struct bpf_insn *);
 122 static int      bpf_setif(struct bpf_d *, struct ifreq *);
 123 static void     bpf_timed_out(void *);
 124 static void     bpf_wakeup(struct bpf_d *);
 125 static void     catchpacket(struct bpf_d *, u_char *, u_int, u_int,
 126                             void (*)(const void *, void *, size_t),
 127                             const struct timeval *);
 128 static int      bpf_setf(struct bpf_d *, struct bpf_program *, u_long cmd);
 129 static int      bpf_getdltlist(struct bpf_d *, struct bpf_dltlist *);
 130 static int      bpf_setdlt(struct bpf_d *, u_int);
 131 static void     bpf_drvinit(void *unused);
 132 static void     bpf_filter_detach(struct knote *kn);
 133 static int      bpf_filter_read(struct knote *kn, long hint);
 134
 135 static d_open_t         bpfopen;
 136 static d_clone_t        bpfclone;
 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 static d_kqfilter_t     bpfkqfilter;
 143
 144 #define CDEV_MAJOR 23
 145 static struct dev_ops bpf_ops = {
 146         { "bpf", CDEV_MAJOR, D_KQFILTER },
 147         .d_open =       bpfopen,
 148         .d_close =      bpfclose,
 149         .d_read =       bpfread,
 150         .d_write =      bpfwrite,
 151         .d_ioctl =      bpfioctl,
 152         .d_poll =       bpfpoll,
 153         .d_kqfilter =   bpfkqfilter
 154 };
 155
 156
 157 static int
 158 bpf_movein(struct uio *uio, int linktype, struct mbuf **mp,
 159            struct sockaddr *sockp, int *datlen, struct bpf_insn *wfilter)
 160 {
 161         struct mbuf *m;
 162         int error;
 163         int len;
 164         int hlen;
 165         int slen;
 166
 167         *datlen = 0;
 168         *mp = NULL;
 169
 170         /*
 171          * Build a sockaddr based on the data link layer type.
 172          * We do this at this level because the ethernet header
 173          * is copied directly into the data field of the sockaddr.
 174          * In the case of SLIP, there is no header and the packet
 175          * is forwarded as is.
 176          * Also, we are careful to leave room at the front of the mbuf
 177          * for the link level header.
 178          */
 179         switch (linktype) {
 180         case DLT_SLIP:
 181                 sockp->sa_family = AF_INET;
 182                 hlen = 0;
 183                 break;
 184
 185         case DLT_EN10MB:
 186                 sockp->sa_family = AF_UNSPEC;
 187                 /* XXX Would MAXLINKHDR be better? */
 188                 hlen = sizeof(struct ether_header);
 189                 break;
 190
 191         case DLT_RAW:
 192         case DLT_NULL:
 193                 sockp->sa_family = AF_UNSPEC;
 194                 hlen = 0;
 195                 break;
 196
 197         case DLT_ATM_RFC1483:
 198                 /*
 199                  * en atm driver requires 4-byte atm pseudo header.
 200                  * though it isn't standard, vpi:vci needs to be
 201                  * specified anyway.
 202                  */
 203                 sockp->sa_family = AF_UNSPEC;
 204                 hlen = 12;      /* XXX 4(ATM_PH) + 3(LLC) + 5(SNAP) */
 205                 break;
 206
 207         case DLT_PPP:
 208                 sockp->sa_family = AF_UNSPEC;
 209                 hlen = 4;       /* This should match PPP_HDRLEN */
 210                 break;
 211
 212         default:
 213                 return(EIO);
 214         }
 215
 216         len = uio->uio_resid;
 217         *datlen = len - hlen;
 218         if ((unsigned)len > MCLBYTES)
 219                 return(EIO);
 220
 221         m = m_getl(len, MB_WAIT, MT_DATA, M_PKTHDR, NULL);
 222         if (m == NULL)
 223                 return(ENOBUFS);
 224         m->m_pkthdr.len = m->m_len = len;
 225         m->m_pkthdr.rcvif = NULL;
 226         *mp = m;
 227
 228         if (m->m_len < hlen) {
 229                 error = EPERM;
 230                 goto bad;
 231         }
 232
 233         error = uiomove(mtod(m, u_char *), len, uio);
 234         if (error)
 235                 goto bad;
 236
 237         slen = bpf_filter(wfilter, mtod(m, u_char *), len, len);
 238         if (slen == 0) {
 239                 error = EPERM;
 240                 goto bad;
 241         }
 242
 243         /*
 244          * Make room for link header, and copy it to sockaddr.
 245          */
 246         if (hlen != 0) {
 247                 bcopy(m->m_data, sockp->sa_data, hlen);
 248                 m->m_pkthdr.len -= hlen;
 249                 m->m_len -= hlen;
 250                 m->m_data += hlen; /* XXX */
 251         }
 252         return (0);
 253 bad:
 254         m_freem(m);
 255         return(error);
 256 }
 257
 258 /*
 259  * Attach file to the bpf interface, i.e. make d listen on bp.
 260  * Must be called at splimp.
 261  */
 262 static void
 263 bpf_attachd(struct bpf_d *d, struct bpf_if *bp)
 264 {
 265         /*
 266          * Point d at bp, and add d to the interface's list of listeners.
 267          * Finally, point the driver's bpf cookie at the interface so
 268          * it will divert packets to bpf.
 269          */
 270         d->bd_bif = bp;
 271         SLIST_INSERT_HEAD(&bp->bif_dlist, d, bd_next);
 272         *bp->bif_driverp = bp;
 273
 274         EVENTHANDLER_INVOKE(bpf_track, bp->bif_ifp, bp->bif_dlt, 1);
 275 }
 276
 277 /*
 278  * Detach a file from its interface.
 279  */
 280 static void
 281 bpf_detachd(struct bpf_d *d)
 282 {
 283         int error;
 284         struct bpf_if *bp;
 285         struct ifnet *ifp;
 286
 287         bp = d->bd_bif;
 288         ifp = bp->bif_ifp;
 289
 290         /* Remove d from the interface's descriptor list. */
 291         SLIST_REMOVE(&bp->bif_dlist, d, bpf_d, bd_next);
 292
 293         if (SLIST_EMPTY(&bp->bif_dlist)) {
 294                 /*
 295                  * Let the driver know that there are no more listeners.
 296                  */
 297                 *bp->bif_driverp = NULL;
 298         }
 299         d->bd_bif = NULL;
 300
 301         EVENTHANDLER_INVOKE(bpf_track, ifp, bp->bif_dlt, 0);
 302
 303         /*
 304          * Check if this descriptor had requested promiscuous mode.
 305          * If so, turn it off.
 306          */
 307         if (d->bd_promisc) {
 308                 d->bd_promisc = 0;
 309                 error = ifpromisc(ifp, 0);
 310                 if (error != 0 && error != ENXIO) {
 311                         /*
 312                          * ENXIO can happen if a pccard is unplugged,
 313                          * Something is really wrong if we were able to put
 314                          * the driver into promiscuous mode, but can't
 315                          * take it out.
 316                          */
 317                         if_printf(ifp, "bpf_detach: ifpromisc failed(%d)\n",
 318                                   error);
 319                 }
 320         }
 321 }
 322
 323 /*
 324  * Open ethernet device.  Returns ENXIO for illegal minor device number,
 325  * EBUSY if file is open by another process.
 326  */
 327 /* ARGSUSED */
 328 static int
 329 bpfopen(struct dev_open_args *ap)
 330 {
 331         cdev_t dev = ap->a_head.a_dev;
 332         struct bpf_d *d;
 333
 334         if (ap->a_cred->cr_prison)
 335                 return(EPERM);
 336
 337         d = dev->si_drv1;
 338         /*
 339          * Each minor can be opened by only one process.  If the requested
 340          * minor is in use, return EBUSY.
 341          */
 342         if (d != NULL)
 343                 return(EBUSY);
 344
 345         MALLOC(d, struct bpf_d *, sizeof *d, M_BPF, M_WAITOK | M_ZERO);
 346         dev->si_drv1 = d;
 347         d->bd_bufsize = bpf_bufsize;
 348         d->bd_sig = SIGIO;
 349         d->bd_seesent = 1;
 350         callout_init(&d->bd_callout);
 351         return(0);
 352 }
 353
 354 static int
 355 bpfclone(struct dev_clone_args *ap)
 356 {
 357         int unit;
 358
 359         unit = devfs_clone_bitmap_get(&DEVFS_CLONE_BITMAP(bpf), 0);
 360         ap->a_dev = make_only_dev(&bpf_ops, unit, 0, 0, 0600, "bpf%d", unit);
 361
 362         return 0;
 363 }
 364
 365 /*
 366  * Close the descriptor by detaching it from its interface,
 367  * deallocating its buffers, and marking it free.
 368  */
 369 /* ARGSUSED */
 370 static int
 371 bpfclose(struct dev_close_args *ap)
 372 {
 373         cdev_t dev = ap->a_head.a_dev;
 374         struct bpf_d *d = dev->si_drv1;
 375
 376         funsetown(d->bd_sigio);
 377         crit_enter();
 378         if (d->bd_state == BPF_WAITING)
 379                 callout_stop(&d->bd_callout);
 380         d->bd_state = BPF_IDLE;
 381         if (d->bd_bif != NULL)
 382                 bpf_detachd(d);
 383         crit_exit();
 384         bpf_freed(d);
 385         dev->si_drv1 = NULL;
 386         if (dev->si_uminor >= BPF_PREALLOCATED_UNITS) {
 387                 devfs_clone_bitmap_put(&DEVFS_CLONE_BITMAP(bpf), dev->si_uminor);
 388                 destroy_dev(dev);
 389         }
 390         kfree(d, M_BPF);
 391         return(0);
 392 }
 393
 394 /*
 395  * Rotate the packet buffers in descriptor d.  Move the store buffer
 396  * into the hold slot, and the free buffer into the store slot.
 397  * Zero the length of the new store buffer.
 398  */
 399 #define ROTATE_BUFFERS(d) \
 400         (d)->bd_hbuf = (d)->bd_sbuf; \
 401         (d)->bd_hlen = (d)->bd_slen; \
 402         (d)->bd_sbuf = (d)->bd_fbuf; \
 403         (d)->bd_slen = 0; \
 404         (d)->bd_fbuf = NULL;
 405 /*
 406  *  bpfread - read next chunk of packets from buffers
 407  */
 408 static int
 409 bpfread(struct dev_read_args *ap)
 410 {
 411         cdev_t dev = ap->a_head.a_dev;
 412         struct bpf_d *d = dev->si_drv1;
 413         int timed_out;
 414         int error;
 415
 416         /*
 417          * Restrict application to use a buffer the same size as
 418          * as kernel buffers.
 419          */
 420         if (ap->a_uio->uio_resid != d->bd_bufsize)
 421                 return(EINVAL);
 422
 423         crit_enter();
 424         if (d->bd_state == BPF_WAITING)
 425                 callout_stop(&d->bd_callout);
 426         timed_out = (d->bd_state == BPF_TIMED_OUT);
 427         d->bd_state = BPF_IDLE;
 428         /*
 429          * If the hold buffer is empty, then do a timed sleep, which
 430          * ends when the timeout expires or when enough packets
 431          * have arrived to fill the store buffer.
 432          */
 433         while (d->bd_hbuf == NULL) {
 434                 if ((d->bd_immediate || (ap->a_ioflag & IO_NDELAY) || timed_out)
 435                     && d->bd_slen != 0) {
 436                         /*
 437                          * A packet(s) either arrived since the previous,
 438                          * We're in immediate mode, or are reading
 439                          * in non-blocking mode, and a packet(s)
 440                          * either arrived since the previous
 441                          * read or arrived while we were asleep.
 442                          * Rotate the buffers and return what's here.
 443                          */
 444                         ROTATE_BUFFERS(d);
 445                         break;
 446                 }
 447
 448                 /*
 449                  * No data is available, check to see if the bpf device
 450                  * is still pointed at a real interface.  If not, return
 451                  * ENXIO so that the userland process knows to rebind
 452                  * it before using it again.
 453                  */
 454                 if (d->bd_bif == NULL) {
 455                         crit_exit();
 456                         return(ENXIO);
 457                 }
 458
 459                 if (ap->a_ioflag & IO_NDELAY) {
 460                         crit_exit();
 461                         return(EWOULDBLOCK);
 462                 }
 463                 error = tsleep(d, PCATCH, "bpf", d->bd_rtout);
 464                 if (error == EINTR || error == ERESTART) {
 465                         crit_exit();
 466                         return(error);
 467                 }
 468                 if (error == EWOULDBLOCK) {
 469                         /*
 470                          * On a timeout, return what's in the buffer,
 471                          * which may be nothing.  If there is something
 472                          * in the store buffer, we can rotate the buffers.
 473                          */
 474                         if (d->bd_hbuf)
 475                                 /*
 476                                  * We filled up the buffer in between
 477                                  * getting the timeout and arriving
 478                                  * here, so we don't need to rotate.
 479                                  */
 480                                 break;
 481
 482                         if (d->bd_slen == 0) {
 483                                 crit_exit();
 484                                 return(0);
 485                         }
 486                         ROTATE_BUFFERS(d);
 487                         break;
 488                 }
 489         }
 490         /*
 491          * At this point, we know we have something in the hold slot.
 492          */
 493         crit_exit();
 494
 495         /*
 496          * Move data from hold buffer into user space.
 497          * We know the entire buffer is transferred since
 498          * we checked above that the read buffer is bpf_bufsize bytes.
 499          */
 500         error = uiomove(d->bd_hbuf, d->bd_hlen, ap->a_uio);
 501
 502         crit_enter();
 503         d->bd_fbuf = d->bd_hbuf;
 504         d->bd_hbuf = NULL;
 505         d->bd_hlen = 0;
 506         crit_exit();
 507
 508         return(error);
 509 }
 510
 511
 512 /*
 513  * If there are processes sleeping on this descriptor, wake them up.
 514  */
 515 static void
 516 bpf_wakeup(struct bpf_d *d)
 517 {
 518         if (d->bd_state == BPF_WAITING) {
 519                 callout_stop(&d->bd_callout);
 520                 d->bd_state = BPF_IDLE;
 521         }
 522         wakeup(d);
 523         if (d->bd_async && d->bd_sig && d->bd_sigio)
 524                 pgsigio(d->bd_sigio, d->bd_sig, 0);
 525
 526         get_mplock();
 527         selwakeup(&d->bd_sel);
 528         rel_mplock();
 529         /* XXX */
 530         d->bd_sel.si_pid = 0;
 531 }
 532
 533 static void
 534 bpf_timed_out(void *arg)
 535 {
 536         struct bpf_d *d = (struct bpf_d *)arg;
 537
 538         crit_enter();
 539         if (d->bd_state == BPF_WAITING) {
 540                 d->bd_state = BPF_TIMED_OUT;
 541                 if (d->bd_slen != 0)
 542                         bpf_wakeup(d);
 543         }
 544         crit_exit();
 545 }
 546
 547 static void
 548 bpf_output_dispatch(struct netmsg *nmsg)
 549 {
 550         struct netmsg_bpf_output *bmsg = (struct netmsg_bpf_output *)nmsg;
 551         struct ifnet *ifp = bmsg->nm_ifp;
 552         int error;
 553
 554         /*
 555          * The driver frees the mbuf.
 556          */
 557         error = ifp->if_output(ifp, bmsg->nm_mbuf, bmsg->nm_dst, NULL);
 558         lwkt_replymsg(&nmsg->nm_lmsg, error);
 559 }
 560
 561 static int
 562 bpfwrite(struct dev_write_args *ap)
 563 {
 564         cdev_t dev = ap->a_head.a_dev;
 565         struct bpf_d *d = dev->si_drv1;
 566         struct ifnet *ifp;
 567         struct mbuf *m;
 568         int error;
 569         struct sockaddr dst;
 570         int datlen;
 571         struct netmsg_bpf_output bmsg;
 572
 573         if (d->bd_bif == NULL)
 574                 return(ENXIO);
 575
 576         ifp = d->bd_bif->bif_ifp;
 577
 578         if (ap->a_uio->uio_resid == 0)
 579                 return(0);
 580
 581         error = bpf_movein(ap->a_uio, (int)d->bd_bif->bif_dlt, &m,
 582                            &dst, &datlen, d->bd_wfilter);
 583         if (error)
 584                 return(error);
 585
 586         if (datlen > ifp->if_mtu) {
 587                 m_freem(m);
 588                 return(EMSGSIZE);
 589         }
 590
 591         if (d->bd_hdrcmplt)
 592                 dst.sa_family = pseudo_AF_HDRCMPLT;
 593
 594         netmsg_init(&bmsg.nm_netmsg, NULL, &curthread->td_msgport,
 595                     MSGF_MPSAFE, bpf_output_dispatch);
 596         bmsg.nm_mbuf = m;
 597         bmsg.nm_ifp = ifp;
 598         bmsg.nm_dst = &dst;
 599
 600         return lwkt_domsg(cpu_portfn(0), &bmsg.nm_netmsg.nm_lmsg, 0);
 601 }
 602
 603 /*
 604  * Reset a descriptor by flushing its packet buffer and clearing the
 605  * receive and drop counts.  Should be called at splimp.
 606  */
 607 static void
 608 bpf_resetd(struct bpf_d *d)
 609 {
 610         if (d->bd_hbuf) {
 611                 /* Free the hold buffer. */
 612                 d->bd_fbuf = d->bd_hbuf;
 613                 d->bd_hbuf = NULL;
 614         }
 615         d->bd_slen = 0;
 616         d->bd_hlen = 0;
 617         d->bd_rcount = 0;
 618         d->bd_dcount = 0;
 619 }
 620
 621 /*
 622  *  FIONREAD            Check for read packet available.
 623  *  SIOCGIFADDR         Get interface address - convenient hook to driver.
 624  *  BIOCGBLEN           Get buffer len [for read()].
 625  *  BIOCSETF            Set ethernet read filter.
 626  *  BIOCSETWF           Set ethernet write filter.
 627  *  BIOCFLUSH           Flush read packet buffer.
 628  *  BIOCPROMISC         Put interface into promiscuous mode.
 629  *  BIOCGDLT            Get link layer type.
 630  *  BIOCGETIF           Get interface name.
 631  *  BIOCSETIF           Set interface.
 632  *  BIOCSRTIMEOUT       Set read timeout.
 633  *  BIOCGRTIMEOUT       Get read timeout.
 634  *  BIOCGSTATS          Get packet stats.
 635  *  BIOCIMMEDIATE       Set immediate mode.
 636  *  BIOCVERSION         Get filter language version.
 637  *  BIOCGHDRCMPLT       Get "header already complete" flag
 638  *  BIOCSHDRCMPLT       Set "header already complete" flag
 639  *  BIOCGSEESENT        Get "see packets sent" flag
 640  *  BIOCSSEESENT        Set "see packets sent" flag
 641  *  BIOCLOCK            Set "locked" flag
 642  */
 643 /* ARGSUSED */
 644 static int
 645 bpfioctl(struct dev_ioctl_args *ap)
 646 {
 647         cdev_t dev = ap->a_head.a_dev;
 648         struct bpf_d *d = dev->si_drv1;
 649         int error = 0;
 650
 651         crit_enter();
 652         if (d->bd_state == BPF_WAITING)
 653                 callout_stop(&d->bd_callout);
 654         d->bd_state = BPF_IDLE;
 655         crit_exit();
 656
 657         if (d->bd_locked == 1) {
 658                 switch (ap->a_cmd) {
 659                 case BIOCGBLEN:
 660                 case BIOCFLUSH:
 661                 case BIOCGDLT:
 662                 case BIOCGDLTLIST:
 663                 case BIOCGETIF:
 664                 case BIOCGRTIMEOUT:
 665                 case BIOCGSTATS:
 666                 case BIOCVERSION:
 667                 case BIOCGRSIG:
 668                 case BIOCGHDRCMPLT:
 669                 case FIONREAD:
 670                 case BIOCLOCK:
 671                 case BIOCSRTIMEOUT:
 672                 case BIOCIMMEDIATE:
 673                 case TIOCGPGRP:
 674                         break;
 675                 default:
 676                         return (EPERM);
 677                 }
 678         }
 679         switch (ap->a_cmd) {
 680         default:
 681                 error = EINVAL;
 682                 break;
 683
 684         /*
 685          * Check for read packet available.
 686          */
 687         case FIONREAD:
 688                 {
 689                         int n;
 690
 691                         crit_enter();
 692                         n = d->bd_slen;
 693                         if (d->bd_hbuf)
 694                                 n += d->bd_hlen;
 695                         crit_exit();
 696
 697                         *(int *)ap->a_data = n;
 698                         break;
 699                 }
 700
 701         case SIOCGIFADDR:
 702                 {
 703                         struct ifnet *ifp;
 704
 705                         if (d->bd_bif == NULL) {
 706                                 error = EINVAL;
 707                         } else {
 708                                 ifp = d->bd_bif->bif_ifp;
 709                                 ifnet_serialize_all(ifp);
 710                                 error = ifp->if_ioctl(ifp, ap->a_cmd,
 711                                                       ap->a_data, ap->a_cred);
 712                                 ifnet_deserialize_all(ifp);
 713                         }
 714                         break;
 715                 }
 716
 717         /*
 718          * Get buffer len [for read()].
 719          */
 720         case BIOCGBLEN:
 721                 *(u_int *)ap->a_data = d->bd_bufsize;
 722                 break;
 723
 724         /*
 725          * Set buffer length.
 726          */
 727         case BIOCSBLEN:
 728                 if (d->bd_bif != NULL) {
 729                         error = EINVAL;
 730                 } else {
 731                         u_int size = *(u_int *)ap->a_data;
 732
 733                         if (size > bpf_maxbufsize)
 734                                 *(u_int *)ap->a_data = size = bpf_maxbufsize;
 735                         else if (size < BPF_MINBUFSIZE)
 736                                 *(u_int *)ap->a_data = size = BPF_MINBUFSIZE;
 737                         d->bd_bufsize = size;
 738                 }
 739                 break;
 740
 741         /*
 742          * Set link layer read filter.
 743          */
 744         case BIOCSETF:
 745         case BIOCSETWF:
 746                 error = bpf_setf(d, (struct bpf_program *)ap->a_data,
 747                         ap->a_cmd);
 748                 break;
 749
 750         /*
 751          * Flush read packet buffer.
 752          */
 753         case BIOCFLUSH:
 754                 crit_enter();
 755                 bpf_resetd(d);
 756                 crit_exit();
 757                 break;
 758
 759         /*
 760          * Put interface into promiscuous mode.
 761          */
 762         case BIOCPROMISC:
 763                 if (d->bd_bif == NULL) {
 764                         /*
 765                          * No interface attached yet.
 766                          */
 767                         error = EINVAL;
 768                         break;
 769                 }
 770                 crit_enter();
 771                 if (d->bd_promisc == 0) {
 772                         error = ifpromisc(d->bd_bif->bif_ifp, 1);
 773                         if (error == 0)
 774                                 d->bd_promisc = 1;
 775                 }
 776                 crit_exit();
 777                 break;
 778
 779         /*
 780          * Get device parameters.
 781          */
 782         case BIOCGDLT:
 783                 if (d->bd_bif == NULL)
 784                         error = EINVAL;
 785                 else
 786                         *(u_int *)ap->a_data = d->bd_bif->bif_dlt;
 787                 break;
 788
 789         /*
 790          * Get a list of supported data link types.
 791          */
 792         case BIOCGDLTLIST:
 793                 if (d->bd_bif == NULL) {
 794                         error = EINVAL;
 795                 } else {
 796                         error = bpf_getdltlist(d,
 797                                 (struct bpf_dltlist *)ap->a_data);
 798                 }
 799                 break;
 800
 801         /*
 802          * Set data link type.
 803          */
 804         case BIOCSDLT:
 805                 if (d->bd_bif == NULL)
 806                         error = EINVAL;
 807                 else
 808                         error = bpf_setdlt(d, *(u_int *)ap->a_data);
 809                 break;
 810
 811         /*
 812          * Get interface name.
 813          */
 814         case BIOCGETIF:
 815                 if (d->bd_bif == NULL) {
 816                         error = EINVAL;
 817                 } else {
 818                         struct ifnet *const ifp = d->bd_bif->bif_ifp;
 819                         struct ifreq *const ifr = (struct ifreq *)ap->a_data;
 820
 821                         strlcpy(ifr->ifr_name, ifp->if_xname,
 822                                 sizeof ifr->ifr_name);
 823                 }
 824                 break;
 825
 826         /*
 827          * Set interface.
 828          */
 829         case BIOCSETIF:
 830                 error = bpf_setif(d, (struct ifreq *)ap->a_data);
 831                 break;
 832
 833         /*
 834          * Set read timeout.
 835          */
 836         case BIOCSRTIMEOUT:
 837                 {
 838                         struct timeval *tv = (struct timeval *)ap->a_data;
 839
 840                         /*
 841                          * Subtract 1 tick from tvtohz() since this isn't
 842                          * a one-shot timer.
 843                          */
 844                         if ((error = itimerfix(tv)) == 0)
 845                                 d->bd_rtout = tvtohz_low(tv);
 846                         break;
 847                 }
 848
 849         /*
 850          * Get read timeout.
 851          */
 852         case BIOCGRTIMEOUT:
 853                 {
 854                         struct timeval *tv = (struct timeval *)ap->a_data;
 855
 856                         tv->tv_sec = d->bd_rtout / hz;
 857                         tv->tv_usec = (d->bd_rtout % hz) * ustick;
 858                         break;
 859                 }
 860
 861         /*
 862          * Get packet stats.
 863          */
 864         case BIOCGSTATS:
 865                 {
 866                         struct bpf_stat *bs = (struct bpf_stat *)ap->a_data;
 867
 868                         bs->bs_recv = d->bd_rcount;
 869                         bs->bs_drop = d->bd_dcount;
 870                         break;
 871                 }
 872
 873         /*
 874          * Set immediate mode.
 875          */
 876         case BIOCIMMEDIATE:
 877                 d->bd_immediate = *(u_int *)ap->a_data;
 878                 break;
 879
 880         case BIOCVERSION:
 881                 {
 882                         struct bpf_version *bv = (struct bpf_version *)ap->a_data;
 883
 884                         bv->bv_major = BPF_MAJOR_VERSION;
 885                         bv->bv_minor = BPF_MINOR_VERSION;
 886                         break;
 887                 }
 888
 889         /*
 890          * Get "header already complete" flag
 891          */
 892         case BIOCGHDRCMPLT:
 893                 *(u_int *)ap->a_data = d->bd_hdrcmplt;
 894                 break;
 895
 896         /*
 897          * Set "header already complete" flag
 898          */
 899         case BIOCSHDRCMPLT:
 900                 d->bd_hdrcmplt = *(u_int *)ap->a_data ? 1 : 0;
 901                 break;
 902
 903         /*
 904          * Get "see sent packets" flag
 905          */
 906         case BIOCGSEESENT:
 907                 *(u_int *)ap->a_data = d->bd_seesent;
 908                 break;
 909
 910         /*
 911          * Set "see sent packets" flag
 912          */
 913         case BIOCSSEESENT:
 914                 d->bd_seesent = *(u_int *)ap->a_data;
 915                 break;
 916
 917         case FIOASYNC:          /* Send signal on receive packets */
 918                 d->bd_async = *(int *)ap->a_data;
 919                 break;
 920
 921         case FIOSETOWN:
 922                 error = fsetown(*(int *)ap->a_data, &d->bd_sigio);
 923                 break;
 924
 925         case FIOGETOWN:
 926                 *(int *)ap->a_data = fgetown(d->bd_sigio);
 927                 break;
 928
 929         /* This is deprecated, FIOSETOWN should be used instead. */
 930         case TIOCSPGRP:
 931                 error = fsetown(-(*(int *)ap->a_data), &d->bd_sigio);
 932                 break;
 933
 934         /* This is deprecated, FIOGETOWN should be used instead. */
 935         case TIOCGPGRP:
 936                 *(int *)ap->a_data = -fgetown(d->bd_sigio);
 937                 break;
 938
 939         case BIOCSRSIG:         /* Set receive signal */
 940                 {
 941                         u_int sig;
 942
 943                         sig = *(u_int *)ap->a_data;
 944
 945                         if (sig >= NSIG)
 946                                 error = EINVAL;
 947                         else
 948                                 d->bd_sig = sig;
 949                         break;
 950                 }
 951         case BIOCGRSIG:
 952                 *(u_int *)ap->a_data = d->bd_sig;
 953                 break;
 954         case BIOCLOCK:
 955                 d->bd_locked = 1;
 956                 break;
 957         }
 958         return(error);
 959 }
 960
 961 /*
 962  * Set d's packet filter program to fp.  If this file already has a filter,
 963  * free it and replace it.  Returns EINVAL for bogus requests.
 964  */
 965 static int
 966 bpf_setf(struct bpf_d *d, struct bpf_program *fp, u_long cmd)
 967 {
 968         struct bpf_insn *fcode, *old;
 969         u_int wfilter, flen, size;
 970
 971         if (cmd == BIOCSETWF) {
 972                 old = d->bd_wfilter;
 973                 wfilter = 1;
 974         } else {
 975                 wfilter = 0;
 976                 old = d->bd_rfilter;
 977         }
 978         if (fp->bf_insns == NULL) {
 979                 if (fp->bf_len != 0)
 980                         return(EINVAL);
 981                 crit_enter();
 982                 if (wfilter)
 983                         d->bd_wfilter = NULL;
 984                 else
 985                         d->bd_rfilter = NULL;
 986                 bpf_resetd(d);
 987                 crit_exit();
 988                 if (old != NULL)
 989                         kfree(old, M_BPF);
 990                 return(0);
 991         }
 992         flen = fp->bf_len;
 993         if (flen > BPF_MAXINSNS)
 994                 return(EINVAL);
 995
 996         size = flen * sizeof *fp->bf_insns;
 997         fcode = (struct bpf_insn *)kmalloc(size, M_BPF, M_WAITOK);
 998         if (copyin(fp->bf_insns, fcode, size) == 0 &&
 999             bpf_validate(fcode, (int)flen)) {
1000                 crit_enter();
1001                 if (wfilter)
1002                         d->bd_wfilter = fcode;
1003                 else
1004                         d->bd_rfilter = fcode;
1005                 bpf_resetd(d);
1006                 crit_exit();
1007                 if (old != NULL)
1008                         kfree(old, M_BPF);
1009
1010                 return(0);
1011         }
1012         kfree(fcode, M_BPF);
1013         return(EINVAL);
1014 }
1015
1016 /*
1017  * Detach a file from its current interface (if attached at all) and attach
1018  * to the interface indicated by the name stored in ifr.
1019  * Return an errno or 0.
1020  */
1021 static int
1022 bpf_setif(struct bpf_d *d, struct ifreq *ifr)
1023 {
1024         struct bpf_if *bp;
1025         int error;
1026         struct ifnet *theywant;
1027
1028         theywant = ifunit(ifr->ifr_name);
1029         if (theywant == NULL)
1030                 return(ENXIO);
1031
1032         /*
1033          * Look through attached interfaces for the named one.
1034          */
1035         for (bp = bpf_iflist; bp != NULL; bp = bp->bif_next) {
1036                 struct ifnet *ifp = bp->bif_ifp;
1037
1038                 if (ifp == NULL || ifp != theywant)
1039                         continue;
1040                 /* skip additional entry */
1041                 if (bp->bif_driverp != &ifp->if_bpf)
1042                         continue;
1043                 /*
1044                  * We found the requested interface.
1045                  * Allocate the packet buffers if we need to.
1046                  * If we're already attached to requested interface,
1047                  * just flush the buffer.
1048                  */
1049                 if (d->bd_sbuf == NULL) {
1050                         error = bpf_allocbufs(d);
1051                         if (error != 0)
1052                                 return(error);
1053                 }
1054                 crit_enter();
1055                 if (bp != d->bd_bif) {
1056                         if (d->bd_bif != NULL) {
1057                                 /*
1058                                  * Detach if attached to something else.
1059                                  */
1060                                 bpf_detachd(d);
1061                         }
1062
1063                         bpf_attachd(d, bp);
1064                 }
1065                 bpf_resetd(d);
1066                 crit_exit();
1067                 return(0);
1068         }
1069
1070         /* Not found. */
1071         return(ENXIO);
1072 }
1073
1074 /*
1075  * Support for select() and poll() system calls
1076  *
1077  * Return true iff the specific operation will not block indefinitely.
1078  * Otherwise, return false but make a note that a selwakeup() must be done.
1079  */
1080 static int
1081 bpfpoll(struct dev_poll_args *ap)
1082 {
1083         cdev_t dev = ap->a_head.a_dev;
1084         struct bpf_d *d;
1085         int revents;
1086
1087         d = dev->si_drv1;
1088         if (d->bd_bif == NULL)
1089                 return(ENXIO);
1090
1091         revents = ap->a_events & (POLLOUT | POLLWRNORM);
1092         crit_enter();
1093         if (ap->a_events & (POLLIN | POLLRDNORM)) {
1094                 /*
1095                  * An imitation of the FIONREAD ioctl code.
1096                  * XXX not quite.  An exact imitation:
1097                  *      if (d->b_slen != 0 ||
1098                  *          (d->bd_hbuf != NULL && d->bd_hlen != 0)
1099                  */
1100                 if (d->bd_hlen != 0 ||
1101                     ((d->bd_immediate || d->bd_state == BPF_TIMED_OUT) &&
1102                     d->bd_slen != 0)) {
1103                         revents |= ap->a_events & (POLLIN | POLLRDNORM);
1104                 } else {
1105                         selrecord(curthread, &d->bd_sel);
1106                         /* Start the read timeout if necessary. */
1107                         if (d->bd_rtout > 0 && d->bd_state == BPF_IDLE) {
1108                                 callout_reset(&d->bd_callout, d->bd_rtout,
1109                                     bpf_timed_out, d);
1110                                 d->bd_state = BPF_WAITING;
1111                         }
1112                 }
1113         }
1114         crit_exit();
1115         ap->a_events = revents;
1116         return(0);
1117 }
1118
1119 static struct filterops bpf_read_filtops =
1120         { 1, NULL, bpf_filter_detach, bpf_filter_read };
1121
1122 static int
1123 bpfkqfilter(struct dev_kqfilter_args *ap)
1124 {
1125         cdev_t dev = ap->a_head.a_dev;
1126         struct knote *kn = ap->a_kn;
1127         struct klist *klist;
1128         struct bpf_d *d;
1129
1130         d = dev->si_drv1;
1131         if (d->bd_bif == NULL) {
1132                 ap->a_result = 1;
1133                 return (0);
1134         }
1135
1136         ap->a_result = 0;
1137         switch (kn->kn_filter) {
1138         case EVFILT_READ:
1139                 kn->kn_fop = &bpf_read_filtops;
1140                 kn->kn_hook = (caddr_t)d;
1141                 break;
1142         default:
1143                 ap->a_result = 1;
1144                 return (0);
1145         }
1146
1147         crit_enter();
1148         klist = &d->bd_sel.si_note;
1149         SLIST_INSERT_HEAD(klist, kn, kn_selnext);
1150         crit_exit();
1151
1152         return (0);
1153 }
1154
1155 static void
1156 bpf_filter_detach(struct knote *kn)
1157 {
1158         struct klist *klist;
1159         struct bpf_d *d;
1160
1161         crit_enter();
1162         d = (struct bpf_d *)kn->kn_hook;
1163         klist = &d->bd_sel.si_note;
1164         SLIST_REMOVE(klist, kn, knote, kn_selnext);
1165         crit_exit();
1166 }
1167
1168 static int
1169 bpf_filter_read(struct knote *kn, long hint)
1170 {
1171         struct bpf_d *d;
1172         int ready = 0;
1173
1174         crit_enter();
1175         d = (struct bpf_d *)kn->kn_hook;
1176         if (d->bd_hlen != 0 ||
1177             ((d->bd_immediate || d->bd_state == BPF_TIMED_OUT) &&
1178             d->bd_slen != 0)) {
1179                 ready = 1;
1180         } else {
1181                 /* Start the read timeout if necessary. */
1182                 if (d->bd_rtout > 0 && d->bd_state == BPF_IDLE) {
1183                         callout_reset(&d->bd_callout, d->bd_rtout,
1184                             bpf_timed_out, d);
1185                         d->bd_state = BPF_WAITING;
1186                 }
1187         }
1188         crit_exit();
1189
1190         return (ready);
1191 }
1192
1193
1194 /*
1195  * Process the packet pkt of length pktlen.  The packet is parsed
1196  * by each listener's filter, and if accepted, stashed into the
1197  * corresponding buffer.
1198  */
1199 void
1200 bpf_tap(struct bpf_if *bp, u_char *pkt, u_int pktlen)
1201 {
1202         struct bpf_d *d;
1203         struct timeval tv;
1204         int gottime = 0;
1205         u_int slen;
1206
1207         get_mplock();
1208
1209         /* Re-check */
1210         if (bp == NULL) {
1211                 rel_mplock();
1212                 return;
1213         }
1214
1215         /*
1216          * Note that the ipl does not have to be raised at this point.
1217          * The only problem that could arise here is that if two different
1218          * interfaces shared any data.  This is not the case.
1219          */
1220         SLIST_FOREACH(d, &bp->bif_dlist, bd_next) {
1221                 ++d->bd_rcount;
1222                 slen = bpf_filter(d->bd_rfilter, pkt, pktlen, pktlen);
1223                 if (slen != 0) {
1224                         if (!gottime) {
1225                                 microtime(&tv);
1226                                 gottime = 1;
1227                         }
1228                         catchpacket(d, pkt, pktlen, slen, ovbcopy, &tv);
1229                 }
1230         }
1231
1232         rel_mplock();
1233 }
1234
1235 /*
1236  * Copy data from an mbuf chain into a buffer.  This code is derived
1237  * from m_copydata in sys/uipc_mbuf.c.
1238  */
1239 static void
1240 bpf_mcopy(const void *src_arg, void *dst_arg, size_t len)
1241 {
1242         const struct mbuf *m;
1243         u_int count;
1244         u_char *dst;
1245
1246         m = src_arg;
1247         dst = dst_arg;
1248         while (len > 0) {
1249                 if (m == NULL)
1250                         panic("bpf_mcopy");
1251                 count = min(m->m_len, len);
1252                 bcopy(mtod(m, void *), dst, count);
1253                 m = m->m_next;
1254                 dst += count;
1255                 len -= count;
1256         }
1257 }
1258
1259 /*
1260  * Process the packet in the mbuf chain m.  The packet is parsed by each
1261  * listener's filter, and if accepted, stashed into the corresponding
1262  * buffer.
1263  */
1264 void
1265 bpf_mtap(struct bpf_if *bp, struct mbuf *m)
1266 {
1267         struct bpf_d *d;
1268         u_int pktlen, slen;
1269         struct timeval tv;
1270         int gottime = 0;
1271
1272         get_mplock();
1273
1274         /* Re-check */
1275         if (bp == NULL) {
1276                 rel_mplock();
1277                 return;
1278         }
1279
1280         /* Don't compute pktlen, if no descriptor is attached. */
1281         if (SLIST_EMPTY(&bp->bif_dlist)) {
1282                 rel_mplock();
1283                 return;
1284         }
1285
1286         pktlen = m_lengthm(m, NULL);
1287
1288         SLIST_FOREACH(d, &bp->bif_dlist, bd_next) {
1289                 if (!d->bd_seesent && (m->m_pkthdr.rcvif == NULL))
1290                         continue;
1291                 ++d->bd_rcount;
1292                 slen = bpf_filter(d->bd_rfilter, (u_char *)m, pktlen, 0);
1293                 if (slen != 0) {
1294                         if (!gottime) {
1295                                 microtime(&tv);
1296                                 gottime = 1;
1297                         }
1298                         catchpacket(d, (u_char *)m, pktlen, slen, bpf_mcopy,
1299                                     &tv);
1300                 }
1301         }
1302
1303         rel_mplock();
1304 }
1305
1306 void
1307 bpf_mtap_family(struct bpf_if *bp, struct mbuf *m, sa_family_t family)
1308 {
1309         u_int family4;
1310
1311         KKASSERT(family != AF_UNSPEC);
1312
1313         family4 = (u_int)family;
1314         bpf_ptap(bp, m, &family4, sizeof(family4));
1315 }
1316
1317 /*
1318  * Process the packet in the mbuf chain m with the header in m prepended.
1319  * The packet is parsed by each listener's filter, and if accepted,
1320  * stashed into the corresponding buffer.
1321  */
1322 void
1323 bpf_ptap(struct bpf_if *bp, struct mbuf *m, const void *data, u_int dlen)
1324 {
1325         struct mbuf mb;
1326
1327         /*
1328          * Craft on-stack mbuf suitable for passing to bpf_mtap.
1329          * Note that we cut corners here; we only setup what's
1330          * absolutely needed--this mbuf should never go anywhere else.
1331          */
1332         mb.m_next = m;
1333         mb.m_data = __DECONST(void *, data); /* LINTED */
1334         mb.m_len = dlen;
1335         mb.m_pkthdr.rcvif = m->m_pkthdr.rcvif;
1336
1337         bpf_mtap(bp, &mb);
1338 }
1339
1340 /*
1341  * Move the packet data from interface memory (pkt) into the
1342  * store buffer.  Return 1 if it's time to wakeup a listener (buffer full),
1343  * otherwise 0.  "copy" is the routine called to do the actual data
1344  * transfer.  bcopy is passed in to copy contiguous chunks, while
1345  * bpf_mcopy is passed in to copy mbuf chains.  In the latter case,
1346  * pkt is really an mbuf.
1347  */
1348 static void
1349 catchpacket(struct bpf_d *d, u_char *pkt, u_int pktlen, u_int snaplen,
1350             void (*cpfn)(const void *, void *, size_t),
1351             const struct timeval *tv)
1352 {
1353         struct bpf_hdr *hp;
1354         int totlen, curlen;
1355         int hdrlen = d->bd_bif->bif_hdrlen;
1356         /*
1357          * Figure out how many bytes to move.  If the packet is
1358          * greater or equal to the snapshot length, transfer that
1359          * much.  Otherwise, transfer the whole packet (unless
1360          * we hit the buffer size limit).
1361          */
1362         totlen = hdrlen + min(snaplen, pktlen);
1363         if (totlen > d->bd_bufsize)
1364                 totlen = d->bd_bufsize;
1365
1366         /*
1367          * Round up the end of the previous packet to the next longword.
1368          */
1369         curlen = BPF_WORDALIGN(d->bd_slen);
1370         if (curlen + totlen > d->bd_bufsize) {
1371                 /*
1372                  * This packet will overflow the storage buffer.
1373                  * Rotate the buffers if we can, then wakeup any
1374                  * pending reads.
1375                  */
1376                 if (d->bd_fbuf == NULL) {
1377                         /*
1378                          * We haven't completed the previous read yet,
1379                          * so drop the packet.
1380                          */
1381                         ++d->bd_dcount;
1382                         return;
1383                 }
1384                 ROTATE_BUFFERS(d);
1385                 bpf_wakeup(d);
1386                 curlen = 0;
1387         } else if (d->bd_immediate || d->bd_state == BPF_TIMED_OUT) {
1388                 /*
1389                  * Immediate mode is set, or the read timeout has
1390                  * already expired during a select call.  A packet
1391                  * arrived, so the reader should be woken up.
1392                  */
1393                 bpf_wakeup(d);
1394         }
1395
1396         /*
1397          * Append the bpf header.
1398          */
1399         hp = (struct bpf_hdr *)(d->bd_sbuf + curlen);
1400         hp->bh_tstamp = *tv;
1401         hp->bh_datalen = pktlen;
1402         hp->bh_hdrlen = hdrlen;
1403         /*
1404          * Copy the packet data into the store buffer and update its length.
1405          */
1406         (*cpfn)(pkt, (u_char *)hp + hdrlen, (hp->bh_caplen = totlen - hdrlen));
1407         d->bd_slen = curlen + totlen;
1408 }
1409
1410 /*
1411  * Initialize all nonzero fields of a descriptor.
1412  */
1413 static int
1414 bpf_allocbufs(struct bpf_d *d)
1415 {
1416         d->bd_fbuf = kmalloc(d->bd_bufsize, M_BPF, M_WAITOK);
1417         d->bd_sbuf = kmalloc(d->bd_bufsize, M_BPF, M_WAITOK);
1418         d->bd_slen = 0;
1419         d->bd_hlen = 0;
1420         return(0);
1421 }
1422
1423 /*
1424  * Free buffers and packet filter program currently in use by a descriptor.
1425  * Called on close.
1426  */
1427 static void
1428 bpf_freed(struct bpf_d *d)
1429 {
1430         /*
1431          * We don't need to lock out interrupts since this descriptor has
1432          * been detached from its interface and it yet hasn't been marked
1433          * free.
1434          */
1435         if (d->bd_sbuf != NULL) {
1436                 kfree(d->bd_sbuf, M_BPF);
1437                 if (d->bd_hbuf != NULL)
1438                         kfree(d->bd_hbuf, M_BPF);
1439                 if (d->bd_fbuf != NULL)
1440                         kfree(d->bd_fbuf, M_BPF);
1441         }
1442         if (d->bd_rfilter)
1443                 kfree(d->bd_rfilter, M_BPF);
1444         if (d->bd_wfilter)
1445                 kfree(d->bd_wfilter, M_BPF);
1446 }
1447
1448 /*
1449  * Attach an interface to bpf.  ifp is a pointer to the structure
1450  * defining the interface to be attached, dlt is the link layer type,
1451  * and hdrlen is the fixed size of the link header (variable length
1452  * headers are not yet supported).
1453  */
1454 void
1455 bpfattach(struct ifnet *ifp, u_int dlt, u_int hdrlen)
1456 {
1457         bpfattach_dlt(ifp, dlt, hdrlen, &ifp->if_bpf);
1458 }
1459
1460 void
1461 bpfattach_dlt(struct ifnet *ifp, u_int dlt, u_int hdrlen, struct bpf_if **driverp)
1462 {
1463         struct bpf_if *bp;
1464
1465         bp = kmalloc(sizeof *bp, M_BPF, M_WAITOK | M_ZERO);
1466
1467         SLIST_INIT(&bp->bif_dlist);
1468         bp->bif_ifp = ifp;
1469         bp->bif_dlt = dlt;
1470         bp->bif_driverp = driverp;
1471         *bp->bif_driverp = NULL;
1472
1473         bp->bif_next = bpf_iflist;
1474         bpf_iflist = bp;
1475
1476         /*
1477          * Compute the length of the bpf header.  This is not necessarily
1478          * equal to SIZEOF_BPF_HDR because we want to insert spacing such
1479          * that the network layer header begins on a longword boundary (for
1480          * performance reasons and to alleviate alignment restrictions).
1481          */
1482         bp->bif_hdrlen = BPF_WORDALIGN(hdrlen + SIZEOF_BPF_HDR) - hdrlen;
1483
1484         if (bootverbose)
1485                 if_printf(ifp, "bpf attached\n");
1486 }
1487
1488 /*
1489  * Detach bpf from an interface.  This involves detaching each descriptor
1490  * associated with the interface, and leaving bd_bif NULL.  Notify each
1491  * descriptor as it's detached so that any sleepers wake up and get
1492  * ENXIO.
1493  */
1494 void
1495 bpfdetach(struct ifnet *ifp)
1496 {
1497         struct bpf_if *bp, *bp_prev;
1498         struct bpf_d *d;
1499
1500         crit_enter();
1501
1502         /* Locate BPF interface information */
1503         bp_prev = NULL;
1504         for (bp = bpf_iflist; bp != NULL; bp = bp->bif_next) {
1505                 if (ifp == bp->bif_ifp)
1506                         break;
1507                 bp_prev = bp;
1508         }
1509
1510         /* Interface wasn't attached */
1511         if (bp->bif_ifp == NULL) {
1512                 crit_exit();
1513                 kprintf("bpfdetach: %s was not attached\n", ifp->if_xname);
1514                 return;
1515         }
1516
1517         while ((d = SLIST_FIRST(&bp->bif_dlist)) != NULL) {
1518                 bpf_detachd(d);
1519                 bpf_wakeup(d);
1520         }
1521
1522         if (bp_prev != NULL)
1523                 bp_prev->bif_next = bp->bif_next;
1524         else
1525                 bpf_iflist = bp->bif_next;
1526
1527         kfree(bp, M_BPF);
1528
1529         crit_exit();
1530 }
1531
1532 /*
1533  * Get a list of available data link type of the interface.
1534  */
1535 static int
1536 bpf_getdltlist(struct bpf_d *d, struct bpf_dltlist *bfl)
1537 {
1538         int n, error;
1539         struct ifnet *ifp;
1540         struct bpf_if *bp;
1541
1542         ifp = d->bd_bif->bif_ifp;
1543         n = 0;
1544         error = 0;
1545         for (bp = bpf_iflist; bp != NULL; bp = bp->bif_next) {
1546                 if (bp->bif_ifp != ifp)
1547                         continue;
1548                 if (bfl->bfl_list != NULL) {
1549                         if (n >= bfl->bfl_len) {
1550                                 return (ENOMEM);
1551                         }
1552                         error = copyout(&bp->bif_dlt,
1553                             bfl->bfl_list + n, sizeof(u_int));
1554                 }
1555                 n++;
1556         }
1557         bfl->bfl_len = n;
1558         return(error);
1559 }
1560
1561 /*
1562  * Set the data link type of a BPF instance.
1563  */
1564 static int
1565 bpf_setdlt(struct bpf_d *d, u_int dlt)
1566 {
1567         int error, opromisc;
1568         struct ifnet *ifp;
1569         struct bpf_if *bp;
1570
1571         if (d->bd_bif->bif_dlt == dlt)
1572                 return (0);
1573         ifp = d->bd_bif->bif_ifp;
1574         for (bp = bpf_iflist; bp != NULL; bp = bp->bif_next) {
1575                 if (bp->bif_ifp == ifp && bp->bif_dlt == dlt)
1576                         break;
1577         }
1578         if (bp != NULL) {
1579                 opromisc = d->bd_promisc;
1580                 crit_enter();
1581                 bpf_detachd(d);
1582                 bpf_attachd(d, bp);
1583                 bpf_resetd(d);
1584                 if (opromisc) {
1585                         error = ifpromisc(bp->bif_ifp, 1);
1586                         if (error) {
1587                                 if_printf(bp->bif_ifp,
1588                                         "bpf_setdlt: ifpromisc failed (%d)\n",
1589                                         error);
1590                         } else {
1591                                 d->bd_promisc = 1;
1592                         }
1593                 }
1594                 crit_exit();
1595         }
1596         return(bp == NULL ? EINVAL : 0);
1597 }
1598
1599 static void
1600 bpf_drvinit(void *unused)
1601 {
1602         int i;
1603
1604         make_autoclone_dev(&bpf_ops, &DEVFS_CLONE_BITMAP(bpf),
1605                 bpfclone, 0, 0, 0600, "bpf");
1606         for (i = 0; i < BPF_PREALLOCATED_UNITS; i++) {
1607                 make_dev(&bpf_ops, i, 0, 0, 0600, "bpf%d", i);
1608                 devfs_clone_bitmap_set(&DEVFS_CLONE_BITMAP(bpf), i);
1609         }
1610 }
1611
1612 static void
1613 bpf_drvuninit(void *unused)
1614 {
1615         devfs_clone_handler_del("bpf");
1616         dev_ops_remove_all(&bpf_ops);
1617         devfs_clone_bitmap_uninit(&DEVFS_CLONE_BITMAP(bpf));
1618 }
1619
1620 SYSINIT(bpfdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,bpf_drvinit,NULL)
1621 SYSUNINIT(bpfdev, SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,bpf_drvuninit, NULL);
1622
1623 #else /* !BPF */
1624 /*
1625  * NOP stubs to allow bpf-using drivers to load and function.
1626  *
1627  * A 'better' implementation would allow the core bpf functionality
1628  * to be loaded at runtime.
1629  */
1630
1631 void
1632 bpf_tap(struct bpf_if *bp, u_char *pkt, u_int pktlen)
1633 {
1634 }
1635
1636 void
1637 bpf_mtap(struct bpf_if *bp, struct mbuf *m)
1638 {
1639 }
1640
1641 void
1642 bpf_ptap(struct bpf_if *bp, struct mbuf *m, const void *data, u_int dlen)
1643 {
1644 }
1645
1646 void
1647 bpfattach(struct ifnet *ifp, u_int dlt, u_int hdrlen)
1648 {
1649 }
1650
1651 void
1652 bpfattach_dlt(struct ifnet *ifp, u_int dlt, u_int hdrlen, struct bpf_if **driverp)
1653 {
1654 }
1655
1656 void
1657 bpfdetach(struct ifnet *ifp)
1658 {
1659 }
1660
1661 u_int
1662 bpf_filter(const struct bpf_insn *pc, u_char *p, u_int wirelen, u_int buflen)
1663 {
1664         return -1;      /* "no filter" behaviour */
1665 }
1666
1667 #endif /* !BPF */