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