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 */ 1668