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