![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bpf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / net|
Return to bpf.c CVS log | Up to [Net/2] / Net2 / net |
1.1 ! root 1: /*- ! 2: * Copyright (c) 1991 The Regents of the University of California. ! 3: * 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 of Lawrence Berkeley Laboratory. ! 8: * ! 9: * Redistribution and use in source and binary forms, with or without ! 10: * modification, are permitted provided that the following conditions ! 11: * are met: ! 12: * 1. Redistributions of source code must retain the above copyright ! 13: * notice, this list of conditions and the following disclaimer. ! 14: * 2. Redistributions in binary form must reproduce the above copyright ! 15: * notice, this list of conditions and the following disclaimer in the ! 16: * documentation and/or other materials provided with the distribution. ! 17: * 3. All advertising materials mentioning features or use of this software ! 18: * must display the following acknowledgement: ! 19: * This product includes software developed by the University of ! 20: * California, Berkeley and its contributors. ! 21: * 4. Neither the name of the University nor the names of its contributors ! 22: * may be used to endorse or promote products derived from this software ! 23: * without specific prior written permission. ! 24: * ! 25: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 26: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 27: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 28: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 29: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 30: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 31: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 32: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 33: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 34: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 35: * SUCH DAMAGE. ! 36: * ! 37: * @(#)bpf.c 7.4 (Berkeley) 6/17/91 ! 38: * ! 39: * static char rcsid[] = ! 40: * "$Header: bpf.c,v 1.23 91/01/30 18:22:13 mccanne Exp $"; ! 41: */ ! 42: ! 43: #include "bpfilter.h" ! 44: ! 45: #if (NBPFILTER > 0) ! 46: ! 47: #include <sys/param.h> ! 48: #include <sys/systm.h> ! 49: #include <sys/mbuf.h> ! 50: #include <sys/buf.h> ! 51: #include <sys/dir.h> ! 52: #include <sys/proc.h> ! 53: #include <sys/user.h> ! 54: #include <sys/ioctl.h> ! 55: #include <sys/map.h> ! 56: ! 57: #include <sys/file.h> ! 58: #ifdef sparc ! 59: #include <sys/stream.h> ! 60: #endif ! 61: #include <sys/tty.h> ! 62: #include <sys/uio.h> ! 63: ! 64: #include <sys/protosw.h> ! 65: #include <sys/socket.h> ! 66: #include <net/if.h> ! 67: ! 68: #include <net/bpf.h> ! 69: #include <net/bpfdesc.h> ! 70: ! 71: #include <sys/errno.h> ! 72: ! 73: #include <netinet/in.h> ! 74: #include <netinet/if_ether.h> ! 75: #include <sys/kernel.h> ! 76: ! 77: #define PRINET 26 /* interruptible */ ! 78: ! 79: /* ! 80: * The default read buffer size is patchable. ! 81: */ ! 82: int bpf_bufsize = MCLBYTES; ! 83: ! 84: /* ! 85: * bpf_iflist is the list of interfaces; each corresponds to an ifnet ! 86: * bpf_dtab holds the descriptors, indexed by minor device # ! 87: * ! 88: * We really don't need NBPFILTER bpf_if entries, but this eliminates ! 89: * the need to account for all possible drivers here. ! 90: * This problem will go away when these structures are allocated dynamically. ! 91: */ ! 92: static struct bpf_if *bpf_iflist; ! 93: static struct bpf_d bpf_dtab[NBPFILTER]; ! 94: ! 95: static void bpf_ifname(); ! 96: static void catchpacket(); ! 97: static int bpf_setif(); ! 98: static int bpf_initd(); ! 99: ! 100: static int ! 101: bpf_movein(uio, linktype, mp, sockp) ! 102: register struct uio *uio; ! 103: int linktype; ! 104: register struct mbuf **mp; ! 105: register struct sockaddr *sockp; ! 106: { ! 107: struct mbuf *m; ! 108: int error; ! 109: int len; ! 110: int hlen; ! 111: ! 112: /* ! 113: * Build a sockaddr based on the data link layer type. ! 114: * We do this at this level because the ethernet header ! 115: * is copied directly into the data field of the sockaddr. ! 116: * In the case of SLIP, there is no header and the packet ! 117: * is forwarded as is. ! 118: * Also, we are careful to leave room at the front of the mbuf ! 119: * for the link level header. ! 120: */ ! 121: switch (linktype) { ! 122: case DLT_SLIP: ! 123: sockp->sa_family = AF_INET; ! 124: hlen = 0; ! 125: break; ! 126: ! 127: case DLT_EN10MB: ! 128: sockp->sa_family = AF_UNSPEC; ! 129: /* XXX Would MAXLINKHDR be better? */ ! 130: hlen = sizeof(struct ether_header); ! 131: break; ! 132: ! 133: case DLT_FDDI: ! 134: sockp->sa_family = AF_UNSPEC; ! 135: /* XXX 4(FORMAC)+6(dst)+6(src)+3(LLC)+5(SNAP) */ ! 136: hlen = 24; ! 137: break; ! 138: ! 139: default: ! 140: return (EIO); ! 141: } ! 142: ! 143: len = uio->uio_resid; ! 144: if ((unsigned)len > MCLBYTES) ! 145: return (EIO); ! 146: ! 147: MGET(m, M_WAIT, MT_DATA); ! 148: if (m == 0) ! 149: return (ENOBUFS); ! 150: if (len > MLEN) { ! 151: MCLGET(m, M_WAIT); ! 152: if ((m->m_flags & M_EXT) == 0) { ! 153: error = ENOBUFS; ! 154: goto bad; ! 155: } ! 156: } ! 157: m->m_len = len; ! 158: *mp = m; ! 159: /* ! 160: * Make room for link header. ! 161: */ ! 162: if (hlen) { ! 163: m->m_len -= hlen; ! 164: m->m_data += hlen; /* XXX */ ! 165: ! 166: error = uiomove((caddr_t)sockp->sa_data, hlen, uio); ! 167: if (error) ! 168: goto bad; ! 169: } ! 170: error = uiomove(mtod(m, caddr_t), len - hlen, uio); ! 171: if (!error) ! 172: return (0); ! 173: bad: ! 174: m_freem(m); ! 175: return (error); ! 176: } ! 177: ! 178: /* ! 179: * Attach 'd' to the bpf interface 'bp', i.e. make 'd' listen on 'bp'. ! 180: * Must be called at splimp. ! 181: */ ! 182: static void ! 183: bpf_attachd(d, bp) ! 184: struct bpf_d *d; ! 185: struct bpf_if *bp; ! 186: { ! 187: /* Point d at bp. */ ! 188: d->bd_bif = bp; ! 189: ! 190: /* Add d to bp's list of listeners. */ ! 191: d->bd_next = bp->bif_dlist; ! 192: bp->bif_dlist = d; ! 193: ! 194: /* ! 195: * Let the driver know we're here (if it doesn't already). ! 196: */ ! 197: *bp->bif_driverp = bp; ! 198: } ! 199: ! 200: static void ! 201: bpf_detachd(d) ! 202: struct bpf_d *d; ! 203: { ! 204: struct bpf_d **p; ! 205: struct bpf_if *bp; ! 206: ! 207: bp = d->bd_bif; ! 208: /* ! 209: * Check if this descriptor had requested promiscuous mode. ! 210: * If so, turn it off. ! 211: */ ! 212: if (d->bd_promisc) { ! 213: d->bd_promisc = 0; ! 214: if (ifpromisc(bp->bif_ifp, 0)) ! 215: /* ! 216: * Something is really wrong if we were able to put ! 217: * the driver into promiscuous mode, but can't ! 218: * take it out. ! 219: */ ! 220: panic("bpf_detachd: ifpromisc failed"); ! 221: } ! 222: /* Remove 'd' from the interface's descriptor list. */ ! 223: p = &bp->bif_dlist; ! 224: while (*p != d) { ! 225: p = &(*p)->bd_next; ! 226: if (*p == 0) ! 227: panic("bpf_detachd: descriptor not in list"); ! 228: } ! 229: *p = (*p)->bd_next; ! 230: if (bp->bif_dlist == 0) ! 231: /* ! 232: * Let the driver know that there are no more listeners. ! 233: */ ! 234: *d->bd_bif->bif_driverp = 0; ! 235: d->bd_bif = 0; ! 236: } ! 237: ! 238: ! 239: /* ! 240: * Mark a descriptor free by making it point to itself. ! 241: * This is probably cheaper than marking with a constant since ! 242: * the address should be in a register anyway. ! 243: */ ! 244: #define D_ISFREE(d) ((d) == (d)->bd_next) ! 245: #define D_MARKFREE(d) ((d)->bd_next = (d)) ! 246: #define D_MARKUSED(d) ((d)->bd_next = 0) ! 247: ! 248: /* ! 249: * bpfopen - open ethernet device ! 250: * ! 251: * Errors: ENXIO - illegal minor device number ! 252: * EBUSY - too many files open ! 253: */ ! 254: /* ARGSUSED */ ! 255: int ! 256: bpfopen(dev, flag) ! 257: dev_t dev; ! 258: int flag; ! 259: { ! 260: int error, s; ! 261: register struct bpf_d *d; ! 262: ! 263: if (minor(dev) >= NBPFILTER) ! 264: return (ENXIO); ! 265: ! 266: /* ! 267: * Each minor can be opened by only one process. If the requested ! 268: * minor is in use, return EBUSY. ! 269: */ ! 270: s = splimp(); ! 271: d = &bpf_dtab[minor(dev)]; ! 272: if (!D_ISFREE(d)) { ! 273: splx(s); ! 274: return (EBUSY); ! 275: } else ! 276: /* Mark "free" and do most initialization. */ ! 277: bzero((char *)d, sizeof(*d)); ! 278: splx(s); ! 279: ! 280: error = bpf_initd(d); ! 281: if (error) { ! 282: D_MARKFREE(d); ! 283: return (error); ! 284: } ! 285: return (0); ! 286: } ! 287: ! 288: /* ! 289: * Close the descriptor by detaching it from its interface, ! 290: * deallocating its buffers, and marking it free. ! 291: */ ! 292: /* ARGSUSED */ ! 293: bpfclose(dev, flag) ! 294: dev_t dev; ! 295: int flag; ! 296: { ! 297: register struct bpf_d *d = &bpf_dtab[minor(dev)]; ! 298: int s; ! 299: ! 300: s = splimp(); ! 301: if (d->bd_bif) ! 302: bpf_detachd(d); ! 303: splx(s); ! 304: ! 305: /* Free the buffer space. */ ! 306: if (d->bd_hbuf) ! 307: free(d->bd_hbuf, M_DEVBUF); ! 308: if (d->bd_fbuf) ! 309: free(d->bd_fbuf, M_DEVBUF); ! 310: free(d->bd_sbuf, M_DEVBUF); ! 311: if (d->bd_filter) ! 312: free((caddr_t)d->bd_filter, M_DEVBUF); ! 313: ! 314: D_MARKFREE(d); ! 315: } ! 316: ! 317: /* ! 318: * Rotate the packet buffers in descriptor d. Move the store buffer ! 319: * into the hold slot, and the free buffer into the store slot. ! 320: * Zero the length of the new store buffer. ! 321: */ ! 322: #define ROTATE_BUFFERS(d) \ ! 323: (d)->bd_hbuf = (d)->bd_sbuf; \ ! 324: (d)->bd_hlen = (d)->bd_slen; \ ! 325: (d)->bd_sbuf = (d)->bd_fbuf; \ ! 326: (d)->bd_slen = 0; \ ! 327: (d)->bd_fbuf = 0; ! 328: /* ! 329: * bpfread - read next chunk of packets from buffers ! 330: */ ! 331: int ! 332: bpfread(dev, uio) ! 333: dev_t dev; ! 334: register struct uio *uio; ! 335: { ! 336: register struct bpf_d *d = &bpf_dtab[minor(dev)]; ! 337: int error; ! 338: int s; ! 339: ! 340: /* ! 341: * Restrict application to use a buffer the same size as ! 342: * as kernel buffers. ! 343: */ ! 344: if (uio->uio_resid != d->bd_bufsize) ! 345: return (EINVAL); ! 346: ! 347: s = splimp(); ! 348: /* ! 349: * If the hold buffer is empty, then set a timer and sleep ! 350: * until either the timeout has occurred or enough packets have ! 351: * arrived to fill the store buffer. ! 352: */ ! 353: while (d->bd_hbuf == 0) { ! 354: if (d->bd_immediate && d->bd_slen != 0) { ! 355: /* ! 356: * A packet(s) either arrived since the previous ! 357: * read or arrived while we were asleep. ! 358: * Rotate the buffers and return what's here. ! 359: */ ! 360: ROTATE_BUFFERS(d); ! 361: break; ! 362: } ! 363: error = tsleep((caddr_t)d, PRINET|PCATCH, "bpf", d->bd_rtout); ! 364: if (error == EINTR || error == ERESTART) { ! 365: splx(s); ! 366: return (error); ! 367: } ! 368: if (error == EWOULDBLOCK) { ! 369: /* ! 370: * On a timeout, return what's in the buffer, ! 371: * which may be nothing. If there is something ! 372: * in the store buffer, we can rotate the buffers. ! 373: */ ! 374: if (d->bd_hbuf) ! 375: /* ! 376: * We filled up the buffer in between ! 377: * getting the timeout and arriving ! 378: * here, so we don't need to rotate. ! 379: */ ! 380: break; ! 381: ! 382: if (d->bd_slen == 0) { ! 383: splx(s); ! 384: return (0); ! 385: } ! 386: ROTATE_BUFFERS(d); ! 387: break; ! 388: } ! 389: } ! 390: /* ! 391: * At this point, we know we have something in the hold slot. ! 392: */ ! 393: splx(s); ! 394: ! 395: /* ! 396: * Move data from hold buffer into user space. ! 397: * We know the entire buffer is transferred since ! 398: * we checked above that the read buffer is bpf_bufsize bytes. ! 399: */ ! 400: error = uiomove(d->bd_hbuf, d->bd_hlen, uio); ! 401: ! 402: s = splimp(); ! 403: d->bd_fbuf = d->bd_hbuf; ! 404: d->bd_hbuf = 0; ! 405: splx(s); ! 406: ! 407: return (error); ! 408: } ! 409: ! 410: ! 411: /* ! 412: * If there are processes sleeping on this descriptor, wake them up. ! 413: */ ! 414: static inline void ! 415: bpf_wakeup(d) ! 416: register struct bpf_d *d; ! 417: { ! 418: wakeup((caddr_t)d); ! 419: if (d->bd_selproc) { ! 420: selwakeup(d->bd_selproc, (int)d->bd_selcoll); ! 421: d->bd_selcoll = 0; ! 422: d->bd_selproc = 0; ! 423: } ! 424: } ! 425: ! 426: int ! 427: bpfwrite(dev, uio) ! 428: dev_t dev; ! 429: struct uio *uio; ! 430: { ! 431: register struct bpf_d *d = &bpf_dtab[minor(dev)]; ! 432: struct ifnet *ifp; ! 433: struct mbuf *m; ! 434: int error, s; ! 435: static struct sockaddr dst; ! 436: ! 437: if (d->bd_bif == 0) ! 438: return (ENXIO); ! 439: ! 440: ifp = d->bd_bif->bif_ifp; ! 441: ! 442: if (uio->uio_resid == 0) ! 443: return (0); ! 444: if (uio->uio_resid > ifp->if_mtu) ! 445: return (EMSGSIZE); ! 446: ! 447: error = bpf_movein(uio, (int)d->bd_bif->bif_dlt, &m, &dst); ! 448: if (error) ! 449: return (error); ! 450: ! 451: s = splnet(); ! 452: error = (*ifp->if_output)(ifp, m, &dst); ! 453: splx(s); ! 454: /* ! 455: * The driver frees the mbuf. ! 456: */ ! 457: return (error); ! 458: } ! 459: ! 460: /* ! 461: * Reset a descriptor by flushing its packet bufferand clearing the receive ! 462: * and drop counts. Should be called at splimp. ! 463: */ ! 464: static void ! 465: reset_d(d) ! 466: struct bpf_d *d; ! 467: { ! 468: if (d->bd_hbuf) { ! 469: /* Free the hold buffer. */ ! 470: d->bd_fbuf = d->bd_hbuf; ! 471: d->bd_hbuf = 0; ! 472: } ! 473: d->bd_slen = 0; ! 474: d->bd_rcount = 0; ! 475: d->bd_dcount = 0; ! 476: } ! 477: ! 478: /* ! 479: * FIONREAD Check for read packet available. ! 480: * SIOCGIFADDR Get interface address - convenient hook to driver. ! 481: * BIOCGFLEN Get max filter len. ! 482: * BIOCGBLEN Get buffer len [for read()]. ! 483: * BIOCSETF Set ethernet read filter. ! 484: * BIOCFLUSH Flush read packet buffer. ! 485: * BIOCPROMISC Put interface into promiscuous mode. ! 486: * BIOCGDLT Get link layer type. ! 487: * BIOCGETIF Get interface name. ! 488: * BIOCSETIF Set interface. ! 489: * BIOCSRTIMEOUT Set read timeout. ! 490: * BIOCGRTIMEOUT Get read timeout. ! 491: * BIOCGSTATS Get packet stats. ! 492: * BIOCIMMEDIATE Set immediate mode. ! 493: */ ! 494: /* ARGSUSED */ ! 495: int ! 496: bpfioctl(dev, cmd, addr, flag) ! 497: dev_t dev; ! 498: int cmd; ! 499: caddr_t addr; ! 500: int flag; ! 501: { ! 502: register struct bpf_d *d = &bpf_dtab[minor(dev)]; ! 503: int s, error = 0; ! 504: ! 505: switch (cmd) { ! 506: ! 507: default: ! 508: error = EINVAL; ! 509: break; ! 510: ! 511: /* ! 512: * Check for read packet available. ! 513: */ ! 514: case FIONREAD: ! 515: { ! 516: int n; ! 517: ! 518: s = splimp(); ! 519: n = d->bd_slen; ! 520: if (d->bd_hbuf) ! 521: n += d->bd_hlen; ! 522: splx(s); ! 523: ! 524: *(int *)addr = n; ! 525: break; ! 526: } ! 527: ! 528: case SIOCGIFADDR: ! 529: { ! 530: struct ifnet *ifp; ! 531: ! 532: if (d->bd_bif == 0) ! 533: error = EINVAL; ! 534: else { ! 535: ifp = d->bd_bif->bif_ifp; ! 536: error = (*ifp->if_ioctl)(ifp, cmd, addr); ! 537: } ! 538: break; ! 539: } ! 540: ! 541: /* ! 542: * Get max filter len. ! 543: */ ! 544: case BIOCGFLEN: ! 545: *(u_int *)addr = BPF_MAXINSNS; ! 546: break; ! 547: /* ! 548: * Get buffer len [for read()]. ! 549: */ ! 550: case BIOCGBLEN: ! 551: *(u_int *)addr = d->bd_bufsize; ! 552: break; ! 553: ! 554: /* ! 555: * Set ethernet read filter. ! 556: */ ! 557: case BIOCSETF: ! 558: error = bpf_setf(d, (struct bpf_program *)addr); ! 559: break; ! 560: ! 561: /* ! 562: * Flush read packet buffer. ! 563: */ ! 564: case BIOCFLUSH: ! 565: s = splimp(); ! 566: reset_d(d); ! 567: splx(s); ! 568: break; ! 569: ! 570: /* ! 571: * Put interface into promiscuous mode. ! 572: */ ! 573: case BIOCPROMISC: ! 574: if (d->bd_bif == 0) { ! 575: /* ! 576: * No interface attached yet. ! 577: */ ! 578: error = EINVAL; ! 579: break; ! 580: } ! 581: s = splimp(); ! 582: if (d->bd_promisc == 0) { ! 583: d->bd_promisc = 1; ! 584: error = ifpromisc(d->bd_bif->bif_ifp, 1); ! 585: } ! 586: splx(s); ! 587: break; ! 588: ! 589: /* ! 590: * Get device parameters. ! 591: */ ! 592: case BIOCGDLT: ! 593: if (d->bd_bif == 0) ! 594: error = EINVAL; ! 595: else ! 596: *(u_int *)addr = d->bd_bif->bif_dlt; ! 597: break; ! 598: ! 599: /* ! 600: * Set interface name. ! 601: */ ! 602: case BIOCGETIF: ! 603: if (d->bd_bif == 0) ! 604: error = EINVAL; ! 605: else ! 606: bpf_ifname(d->bd_bif->bif_ifp, (struct ifreq *)addr); ! 607: break; ! 608: ! 609: /* ! 610: * Set interface. ! 611: */ ! 612: case BIOCSETIF: ! 613: error = bpf_setif(d, (struct ifreq *)addr); ! 614: break; ! 615: ! 616: /* ! 617: * Set read timeout. ! 618: */ ! 619: case BIOCSRTIMEOUT: ! 620: { ! 621: struct timeval *tv = (struct timeval *)addr; ! 622: u_long msec; ! 623: ! 624: /* Compute number of milliseconds. */ ! 625: msec = tv->tv_sec * 1000 + tv->tv_usec / 1000; ! 626: /* Scale milliseconds to ticks. Assume hard ! 627: clock has millisecond or greater resolution ! 628: (i.e. tick >= 1000). For 10ms hardclock, ! 629: tick/1000 = 10, so rtout<-msec/10. */ ! 630: d->bd_rtout = msec / (tick / 1000); ! 631: break; ! 632: } ! 633: ! 634: /* ! 635: * Get read timeout. ! 636: */ ! 637: case BIOCGRTIMEOUT: ! 638: { ! 639: struct timeval *tv = (struct timeval *)addr; ! 640: u_long msec = d->bd_rtout; ! 641: ! 642: msec *= tick / 1000; ! 643: tv->tv_sec = msec / 1000; ! 644: tv->tv_usec = msec % 1000; ! 645: break; ! 646: } ! 647: ! 648: /* ! 649: * Get packet stats. ! 650: */ ! 651: case BIOCGSTATS: ! 652: { ! 653: struct bpf_stat *bs = (struct bpf_stat *)addr; ! 654: ! 655: bs->bs_recv = d->bd_rcount; ! 656: bs->bs_drop = d->bd_dcount; ! 657: break; ! 658: } ! 659: ! 660: /* ! 661: * Set immediate mode. ! 662: */ ! 663: case BIOCIMMEDIATE: ! 664: d->bd_immediate = *(u_int *)addr; ! 665: break; ! 666: } ! 667: return (error); ! 668: } ! 669: ! 670: /* ! 671: * Set d's packet filter program to 'fp'. If 'd' already has a filter, ! 672: * free it and replace it. Returns EINVAL for bogus requests. ! 673: */ ! 674: int ! 675: bpf_setf(d, fp) ! 676: struct bpf_d *d; ! 677: struct bpf_program *fp; ! 678: { ! 679: struct bpf_insn *fcode, *old; ! 680: u_int flen, size; ! 681: int s; ! 682: ! 683: old = d->bd_filter; ! 684: if (fp->bf_insns == 0) { ! 685: if (fp->bf_len != 0) ! 686: return (EINVAL); ! 687: s = splimp(); ! 688: d->bd_filter = 0; ! 689: reset_d(d); ! 690: splx(s); ! 691: if (old != 0) ! 692: free((caddr_t)old, M_DEVBUF); ! 693: return (0); ! 694: } ! 695: flen = fp->bf_len; ! 696: if (flen > BPF_MAXINSNS) ! 697: return (EINVAL); ! 698: ! 699: size = flen * sizeof(*fp->bf_insns); ! 700: fcode = (struct bpf_insn *)malloc(size, M_DEVBUF, M_WAITOK); ! 701: if (copyin((caddr_t)fp->bf_insns, (caddr_t)fcode, size)) ! 702: return (EINVAL); ! 703: ! 704: if (bpf_validate(fcode, (int)flen)) { ! 705: s = splimp(); ! 706: d->bd_filter = fcode; ! 707: reset_d(d); ! 708: splx(s); ! 709: if (old != 0) ! 710: free((caddr_t)old, M_DEVBUF); ! 711: ! 712: return (0); ! 713: } ! 714: free((caddr_t)fcode, M_DEVBUF); ! 715: return (EINVAL); ! 716: } ! 717: ! 718: /* ! 719: * Detach 'd' from its current interface (if attached at all) and attach to ! 720: * the interface named 'name'. Return ioctl error code or 0. ! 721: */ ! 722: static int ! 723: bpf_setif(d, ifr) ! 724: struct bpf_d *d; ! 725: struct ifreq *ifr; ! 726: { ! 727: struct bpf_if *bp; ! 728: char *cp; ! 729: int unit, s; ! 730: ! 731: /* ! 732: * Separate string into name part and unit number. Put a null ! 733: * byte at the end of the name part, and compute the number. ! 734: * If the a unit number is unspecified, the default is 0, ! 735: * as initialized above. XXX This should be common code. ! 736: */ ! 737: unit = 0; ! 738: cp = ifr->ifr_name; ! 739: cp[sizeof(ifr->ifr_name) - 1] = '\0'; ! 740: while (*cp++) { ! 741: if (*cp >= '0' && *cp <= '9') { ! 742: unit = *cp - '0'; ! 743: *cp++ = '\0'; ! 744: while (*cp) ! 745: unit = 10 * unit + *cp++ - '0'; ! 746: break; ! 747: } ! 748: } ! 749: /* ! 750: * Look through attached interfaces for the named one. ! 751: */ ! 752: for (bp = bpf_iflist; bp != 0; bp = bp->bif_next) { ! 753: struct ifnet *ifp = bp->bif_ifp; ! 754: ! 755: if (ifp == 0 || unit != ifp->if_unit ! 756: || strcmp(ifp->if_name, ifr->ifr_name) != 0) ! 757: continue; ! 758: /* ! 759: * We found the requested interface. If we're ! 760: * already attached to it, just flush the buffer. ! 761: * If it's not up, return an error. ! 762: */ ! 763: if ((ifp->if_flags & IFF_UP) == 0) ! 764: return (ENETDOWN); ! 765: s = splimp(); ! 766: if (bp != d->bd_bif) { ! 767: if (d->bd_bif) ! 768: /* ! 769: * Detach if attached to something else. ! 770: */ ! 771: bpf_detachd(d); ! 772: ! 773: bpf_attachd(d, bp); ! 774: } ! 775: reset_d(d); ! 776: splx(s); ! 777: return (0); ! 778: } ! 779: /* Not found. */ ! 780: return (ENXIO); ! 781: } ! 782: ! 783: /* ! 784: * Lookup the name of the 'ifp' interface and return it in 'ifr->ifr_name'. ! 785: * We augment the ifp's base name with its unit number. ! 786: */ ! 787: static void ! 788: bpf_ifname(ifp, ifr) ! 789: struct ifnet *ifp; ! 790: struct ifreq *ifr; ! 791: { ! 792: char *s = ifp->if_name; ! 793: char *d = ifr->ifr_name; ! 794: ! 795: while (*d++ = *s++) ! 796: ; ! 797: /* XXX Assume that unit number is less than 10. */ ! 798: *d++ = ifp->if_unit + '0'; ! 799: *d = '\0'; ! 800: } ! 801: ! 802: /* ! 803: * Support for select() system call ! 804: * Inspired by the code in tty.c for the same purpose. ! 805: * ! 806: * bpfselect - returns true iff the specific operation ! 807: * will not block indefinitely. Otherwise, return ! 808: * false but make a note that a selwakeup() must be done. ! 809: */ ! 810: int ! 811: bpfselect(dev, rw, p) ! 812: register dev_t dev; ! 813: int rw; ! 814: struct proc *p; ! 815: { ! 816: register struct bpf_d *d; ! 817: register int s; ! 818: ! 819: if (rw != FREAD) ! 820: return (0); ! 821: /* ! 822: * An imitation of the FIONREAD ioctl code. ! 823: */ ! 824: d = &bpf_dtab[minor(dev)]; ! 825: ! 826: s = splimp(); ! 827: if (d->bd_hlen != 0 || (d->bd_immediate && d->bd_slen != 0)) { ! 828: /* ! 829: * There is data waiting. ! 830: */ ! 831: splx(s); ! 832: return (1); ! 833: } ! 834: /* ! 835: * No data ready. If there's already a select() waiting on this ! 836: * minor device then this is a collision. This shouldn't happen ! 837: * because minors really should not be shared, but if a process ! 838: * forks while one of these is open, it is possible that both ! 839: * processes could select on the same descriptor. ! 840: */ ! 841: if (d->bd_selproc && d->bd_selproc->p_wchan == (caddr_t)&selwait) ! 842: d->bd_selcoll = 1; ! 843: else ! 844: d->bd_selproc = p; ! 845: ! 846: splx(s); ! 847: return (0); ! 848: } ! 849: ! 850: /* ! 851: * bpf_tap - incoming linkage from device drivers ! 852: */ ! 853: void ! 854: bpf_tap(arg, pkt, pktlen) ! 855: caddr_t arg; ! 856: register u_char *pkt; ! 857: register u_int pktlen; ! 858: { ! 859: struct bpf_if *bp; ! 860: register struct bpf_d *d; ! 861: register u_int slen; ! 862: /* ! 863: * Note that the ipl does not have to be raised at this point. ! 864: * The only problem that could arise here is that if two different ! 865: * interfaces shared any data. This is not the case. ! 866: */ ! 867: bp = (struct bpf_if *)arg; ! 868: for (d = bp->bif_dlist; d != 0; d = d->bd_next) { ! 869: ++d->bd_rcount; ! 870: slen = bpf_filter(d->bd_filter, pkt, pktlen, pktlen); ! 871: if (slen != 0) ! 872: catchpacket(d, pkt, pktlen, slen, bcopy); ! 873: } ! 874: } ! 875: ! 876: /* ! 877: * Copy data from an mbuf chain into a buffer. This code is derived ! 878: * from m_copydata in sys/uipc_mbuf.c. ! 879: */ ! 880: static void ! 881: bpf_mcopy(src, dst, len) ! 882: u_char *src; ! 883: u_char *dst; ! 884: register int len; ! 885: { ! 886: register struct mbuf *m = (struct mbuf *)src; ! 887: register unsigned count; ! 888: ! 889: while (len > 0) { ! 890: if (m == 0) ! 891: panic("bpf_mcopy"); ! 892: count = MIN(m->m_len, len); ! 893: bcopy(mtod(m, caddr_t), (caddr_t)dst, count); ! 894: m = m->m_next; ! 895: dst += count; ! 896: len -= count; ! 897: } ! 898: } ! 899: ! 900: /* ! 901: * bpf_mtap - incoming linkage from device drivers, when packet ! 902: * is in an mbuf chain ! 903: */ ! 904: void ! 905: bpf_mtap(arg, m) ! 906: caddr_t arg; ! 907: struct mbuf *m; ! 908: { ! 909: struct bpf_if *bp = (struct bpf_if *)arg; ! 910: struct bpf_d *d; ! 911: u_int pktlen, slen; ! 912: struct mbuf *m0; ! 913: ! 914: pktlen = 0; ! 915: for (m0 = m; m0 != m; m0 = m0->m_next) ! 916: pktlen += m0->m_len; ! 917: ! 918: for (d = bp->bif_dlist; d != 0; d = d->bd_next) { ! 919: ++d->bd_rcount; ! 920: slen = bpf_filter(d->bd_filter, (u_char *)m, pktlen, 0); ! 921: if (slen != 0) ! 922: catchpacket(d, (u_char *)m, pktlen, slen, bpf_mcopy); ! 923: } ! 924: } ! 925: ! 926: /* ! 927: * Move the packet data from interface memory (pkt) into the ! 928: * store buffer. Return 1 if it's time to wakeup a listener (buffer full), ! 929: * otherwise 0. 'copy' is the routine called to do the actual data ! 930: * transfer. 'bcopy' is passed in to copy contiguous chunks, while ! 931: * 'bpf_mcopy' is passed in to copy mbuf chains. In the latter ! 932: * case, 'pkt' is really an mbuf. ! 933: */ ! 934: static void ! 935: catchpacket(d, pkt, pktlen, snaplen, cpfn) ! 936: register struct bpf_d *d; ! 937: register u_char *pkt; ! 938: register u_int pktlen, snaplen; ! 939: register void (*cpfn)(); ! 940: { ! 941: register struct bpf_hdr *hp; ! 942: register int totlen, curlen; ! 943: register int hdrlen = d->bd_bif->bif_hdrlen; ! 944: /* ! 945: * Figure out how many bytes to move. If the packet is ! 946: * greater or equal to the snapshot length, transfer that ! 947: * much. Otherwise, transfer the whole packet (unless ! 948: * we hit the buffer size limit). ! 949: */ ! 950: totlen = hdrlen + MIN(snaplen, pktlen); ! 951: if (totlen > d->bd_bufsize) ! 952: totlen = d->bd_bufsize; ! 953: ! 954: /* ! 955: * Round up the end of the previous packet to the next longword. ! 956: */ ! 957: curlen = BPF_WORDALIGN(d->bd_slen); ! 958: if (curlen + totlen > d->bd_bufsize) { ! 959: /* ! 960: * This packet will overflow the storage buffer. ! 961: * Rotate the buffers if we can, then wakeup any ! 962: * pending reads. ! 963: */ ! 964: if (d->bd_fbuf == 0) { ! 965: /* ! 966: * We haven't completed the previous read yet, ! 967: * so drop the packet. ! 968: */ ! 969: ++d->bd_dcount; ! 970: return; ! 971: } ! 972: ROTATE_BUFFERS(d); ! 973: bpf_wakeup(d); ! 974: curlen = 0; ! 975: } ! 976: else if (d->bd_immediate) ! 977: /* ! 978: * Immediate mode is set. A packet arrived so any ! 979: * reads should be woken up. ! 980: */ ! 981: bpf_wakeup(d); ! 982: ! 983: /* ! 984: * Append the bpf header. ! 985: */ ! 986: hp = (struct bpf_hdr *)(d->bd_sbuf + curlen); ! 987: #ifdef sun ! 988: uniqtime(&hp->bh_tstamp); ! 989: #else ! 990: #ifdef hp300 ! 991: microtime(&hp->bh_tstamp); ! 992: #else ! 993: hp->bh_tstamp = time; ! 994: #endif ! 995: #endif ! 996: hp->bh_datalen = pktlen; ! 997: hp->bh_hdrlen = hdrlen; ! 998: /* ! 999: * Copy the packet data into the store buffer and update its length. ! 1000: */ ! 1001: (*cpfn)(pkt, (u_char *)hp + hdrlen, (hp->bh_caplen = totlen - hdrlen)); ! 1002: d->bd_slen = curlen + totlen; ! 1003: } ! 1004: ! 1005: /* ! 1006: * Initialize all nonzero fields of a descriptor. ! 1007: */ ! 1008: static int ! 1009: bpf_initd(d) ! 1010: register struct bpf_d *d; ! 1011: { ! 1012: d->bd_bufsize = bpf_bufsize; ! 1013: d->bd_fbuf = (caddr_t)malloc(d->bd_bufsize, M_DEVBUF, M_WAITOK); ! 1014: if (d->bd_fbuf == 0) ! 1015: return (ENOBUFS); ! 1016: ! 1017: d->bd_sbuf = (caddr_t)malloc(d->bd_bufsize, M_DEVBUF, M_WAITOK); ! 1018: if (d->bd_sbuf == 0) { ! 1019: free(d->bd_fbuf, M_DEVBUF); ! 1020: return (ENOBUFS); ! 1021: } ! 1022: d->bd_slen = 0; ! 1023: d->bd_hlen = 0; ! 1024: return (0); ! 1025: } ! 1026: ! 1027: /* ! 1028: * Register 'ifp' with bpf. XXX ! 1029: * and 'driverp' is a pointer to the 'struct bpf_if *' in the driver's softc. ! 1030: */ ! 1031: void ! 1032: bpfattach(driverp, ifp, dlt, hdrlen) ! 1033: caddr_t *driverp; ! 1034: struct ifnet *ifp; ! 1035: u_int dlt, hdrlen; ! 1036: { ! 1037: struct bpf_if *bp; ! 1038: int i; ! 1039: ! 1040: bp = (struct bpf_if *)malloc(sizeof(*bp), M_DEVBUF, M_DONTWAIT); ! 1041: if (bp == 0) ! 1042: panic("bpfattach"); ! 1043: ! 1044: bp->bif_dlist = 0; ! 1045: bp->bif_driverp = (struct bpf_if **)driverp; ! 1046: bp->bif_ifp = ifp; ! 1047: bp->bif_dlt = dlt; ! 1048: ! 1049: bp->bif_next = bpf_iflist; ! 1050: bpf_iflist = bp; ! 1051: ! 1052: *bp->bif_driverp = 0; ! 1053: ! 1054: /* ! 1055: * Compute the length of the bpf header. This is not necessarily ! 1056: * equal to SIZEOF_BPF_HDR because we want to insert spacing such ! 1057: * that the network layer header begins on a longword boundary (for ! 1058: * performance reasons and to alleviate alignment restrictions). ! 1059: */ ! 1060: bp->bif_hdrlen = BPF_WORDALIGN(hdrlen + SIZEOF_BPF_HDR) - hdrlen; ! 1061: ! 1062: /* ! 1063: * Mark all the descriptors free if this hasn't been done. ! 1064: */ ! 1065: if (!D_ISFREE(&bpf_dtab[0])) ! 1066: for (i = 0; i < NBPFILTER; ++i) ! 1067: D_MARKFREE(&bpf_dtab[i]); ! 1068: ! 1069: printf("bpf: %s%d attached\n", ifp->if_name, ifp->if_unit); ! 1070: } ! 1071: ! 1072: /* XXX This routine belongs in net/if.c. */ ! 1073: /* ! 1074: * Set/clear promiscuous mode on interface ifp based on the truth value` ! 1075: * of pswitch. The calls are reference counted so that only the first ! 1076: * on request actually has an effect, as does the final off request. ! 1077: * Results are undefined if the off and on requests are not matched. ! 1078: */ ! 1079: int ! 1080: ifpromisc(ifp, pswitch) ! 1081: struct ifnet *ifp; ! 1082: int pswitch; ! 1083: { ! 1084: struct ifreq ifr; ! 1085: /* ! 1086: * If the device is not configured up, we cannot put it in ! 1087: * promiscuous mode. ! 1088: */ ! 1089: if ((ifp->if_flags & IFF_UP) == 0) ! 1090: return (ENETDOWN); ! 1091: ! 1092: if (pswitch) { ! 1093: if (ifp->if_pcount++ != 0) ! 1094: return (0); ! 1095: ifp->if_flags |= IFF_PROMISC; ! 1096: } else { ! 1097: if (--ifp->if_pcount > 0) ! 1098: return (0); ! 1099: ifp->if_flags &= ~IFF_PROMISC; ! 1100: } ! 1101: ifr.ifr_flags = ifp->if_flags; ! 1102: return ((*ifp->if_ioctl)(ifp, SIOCSIFFLAGS, (caddr_t)&ifr)); ! 1103: } ! 1104: ! 1105: #endif (NBPFILTER > 0)
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.