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