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