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