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