kernel - Remove D_KQFILTER flag
[dragonfly.git] / sys / net / bpf.c
CommitLineData
984263bc
MD
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: src/sys/net/bpf.c,v 1.59.2.12 2002/04/14 21:41:48 luigi Exp $
92db3805 41 * $DragonFly: src/sys/net/bpf.c,v 1.50 2008/09/23 11:28:49 sephe Exp $
984263bc
MD
42 */
43
1f2de5d4 44#include "use_bpf.h"
984263bc 45
984263bc
MD
46#include <sys/param.h>
47#include <sys/systm.h>
48#include <sys/conf.h>
fef8985e 49#include <sys/device.h>
984263bc
MD
50#include <sys/malloc.h>
51#include <sys/mbuf.h>
52#include <sys/time.h>
53#include <sys/proc.h>
54#include <sys/signalvar.h>
55#include <sys/filio.h>
56#include <sys/sockio.h>
57#include <sys/ttycom.h>
58#include <sys/filedesc.h>
59
9fb2d31f 60#include <sys/event.h>
984263bc
MD
61
62#include <sys/socket.h>
63#include <sys/vnode.h>
64
0b31d406 65#include <sys/thread2.h>
684a93c4 66#include <sys/mplock2.h>
0b31d406 67
984263bc
MD
68#include <net/if.h>
69#include <net/bpf.h>
70#include <net/bpfdesc.h>
e1c548c2 71#include <net/netmsg2.h>
984263bc
MD
72
73#include <netinet/in.h>
74#include <netinet/if_ether.h>
75#include <sys/kernel.h>
76#include <sys/sysctl.h>
77
2c1e28dd 78#include <sys/devfs.h>
cd29885a 79
e1c548c2
SZ
80struct netmsg_bpf_output {
81 struct netmsg nm_netmsg;
82 struct mbuf *nm_mbuf;
83 struct ifnet *nm_ifp;
84 struct sockaddr *nm_dst;
85};
86
984263bc 87MALLOC_DEFINE(M_BPF, "BPF", "BPF data");
cd29885a 88DEVFS_DECLARE_CLONE_BITMAP(bpf);
95db3aac
AH
89
90#if NBPF <= 1
8be7edad 91#define BPF_PREALLOCATED_UNITS 4
95db3aac
AH
92#else
93#define BPF_PREALLOCATED_UNITS NBPF
94#endif
984263bc
MD
95
96#if NBPF > 0
97
984263bc
MD
98/*
99 * The default read buffer size is patchable.
100 */
5534e0c8
JS
101static int bpf_bufsize = BPF_DEFAULTBUFSIZE;
102SYSCTL_INT(_debug, OID_AUTO, bpf_bufsize, CTLFLAG_RW,
103 &bpf_bufsize, 0, "");
faff5ee2 104int bpf_maxbufsize = BPF_MAXBUFSIZE;
5534e0c8
JS
105SYSCTL_INT(_debug, OID_AUTO, bpf_maxbufsize, CTLFLAG_RW,
106 &bpf_maxbufsize, 0, "");
984263bc
MD
107
108/*
109 * bpf_iflist is the list of interfaces; each corresponds to an ifnet
110 */
111static struct bpf_if *bpf_iflist;
112
5534e0c8
JS
113static int bpf_allocbufs(struct bpf_d *);
114static void bpf_attachd(struct bpf_d *d, struct bpf_if *bp);
115static void bpf_detachd(struct bpf_d *d);
cefd3279 116static void bpf_resetd(struct bpf_d *);
5534e0c8
JS
117static void bpf_freed(struct bpf_d *);
118static void bpf_mcopy(const void *, void *, size_t);
119static int bpf_movein(struct uio *, int, struct mbuf **,
7cff0268 120 struct sockaddr *, int *, struct bpf_insn *);
5534e0c8
JS
121static int bpf_setif(struct bpf_d *, struct ifreq *);
122static void bpf_timed_out(void *);
123static void bpf_wakeup(struct bpf_d *);
124static void catchpacket(struct bpf_d *, u_char *, u_int, u_int,
aedcf384
SZ
125 void (*)(const void *, void *, size_t),
126 const struct timeval *);
7cff0268 127static int bpf_setf(struct bpf_d *, struct bpf_program *, u_long cmd);
1f8e62c9
JS
128static int bpf_getdltlist(struct bpf_d *, struct bpf_dltlist *);
129static int bpf_setdlt(struct bpf_d *, u_int);
5534e0c8 130static void bpf_drvinit(void *unused);
9fb2d31f
SG
131static void bpf_filter_detach(struct knote *kn);
132static int bpf_filter_read(struct knote *kn, long hint);
5534e0c8
JS
133
134static d_open_t bpfopen;
cd29885a 135static d_clone_t bpfclone;
5534e0c8
JS
136static d_close_t bpfclose;
137static d_read_t bpfread;
138static d_write_t bpfwrite;
139static d_ioctl_t bpfioctl;
9fb2d31f 140static d_kqfilter_t bpfkqfilter;
984263bc
MD
141
142#define CDEV_MAJOR 23
fef8985e 143static struct dev_ops bpf_ops = {
d4b8aec4 144 { "bpf", CDEV_MAJOR, 0 },
fef8985e
MD
145 .d_open = bpfopen,
146 .d_close = bpfclose,
147 .d_read = bpfread,
148 .d_write = bpfwrite,
149 .d_ioctl = bpfioctl,
9fb2d31f 150 .d_kqfilter = bpfkqfilter
984263bc
MD
151};
152
153
154static int
5534e0c8 155bpf_movein(struct uio *uio, int linktype, struct mbuf **mp,
7cff0268 156 struct sockaddr *sockp, int *datlen, struct bpf_insn *wfilter)
984263bc
MD
157{
158 struct mbuf *m;
159 int error;
160 int len;
161 int hlen;
7cff0268 162 int slen;
984263bc 163
77a30c79
SZ
164 *datlen = 0;
165 *mp = NULL;
166
984263bc
MD
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) {
984263bc
MD
177 case DLT_SLIP:
178 sockp->sa_family = AF_INET;
179 hlen = 0;
180 break;
181
182 case DLT_EN10MB:
183 sockp->sa_family = AF_UNSPEC;
184 /* XXX Would MAXLINKHDR be better? */
185 hlen = sizeof(struct ether_header);
186 break;
187
984263bc
MD
188 case DLT_RAW:
189 case DLT_NULL:
190 sockp->sa_family = AF_UNSPEC;
191 hlen = 0;
192 break;
193
984263bc
MD
194 case DLT_ATM_RFC1483:
195 /*
196 * en atm driver requires 4-byte atm pseudo header.
197 * though it isn't standard, vpi:vci needs to be
198 * specified anyway.
199 */
200 sockp->sa_family = AF_UNSPEC;
f23061d4 201 hlen = 12; /* XXX 4(ATM_PH) + 3(LLC) + 5(SNAP) */
984263bc 202 break;
5534e0c8 203
984263bc
MD
204 case DLT_PPP:
205 sockp->sa_family = AF_UNSPEC;
206 hlen = 4; /* This should match PPP_HDRLEN */
207 break;
208
209 default:
5534e0c8 210 return(EIO);
984263bc
MD
211 }
212
213 len = uio->uio_resid;
214 *datlen = len - hlen;
215 if ((unsigned)len > MCLBYTES)
5534e0c8 216 return(EIO);
984263bc 217
70978433 218 m = m_getl(len, MB_WAIT, MT_DATA, M_PKTHDR, NULL);
f23061d4 219 if (m == NULL)
5534e0c8 220 return(ENOBUFS);
984263bc
MD
221 m->m_pkthdr.len = m->m_len = len;
222 m->m_pkthdr.rcvif = NULL;
223 *mp = m;
7cff0268
MS
224
225 if (m->m_len < hlen) {
226 error = EPERM;
227 goto bad;
228 }
229
230 error = uiomove(mtod(m, u_char *), len, uio);
231 if (error)
232 goto bad;
233
234 slen = bpf_filter(wfilter, mtod(m, u_char *), len, len);
235 if (slen == 0) {
236 error = EPERM;
237 goto bad;
238 }
239
984263bc 240 /*
7cff0268 241 * Make room for link header, and copy it to sockaddr.
984263bc
MD
242 */
243 if (hlen != 0) {
7cff0268 244 bcopy(m->m_data, sockp->sa_data, hlen);
984263bc
MD
245 m->m_pkthdr.len -= hlen;
246 m->m_len -= hlen;
984263bc 247 m->m_data += hlen; /* XXX */
984263bc 248 }
7cff0268 249 return (0);
5534e0c8 250bad:
984263bc 251 m_freem(m);
5534e0c8 252 return(error);
984263bc
MD
253}
254
255/*
256 * Attach file to the bpf interface, i.e. make d listen on bp.
257 * Must be called at splimp.
258 */
259static void
5534e0c8 260bpf_attachd(struct bpf_d *d, struct bpf_if *bp)
984263bc
MD
261{
262 /*
263 * Point d at bp, and add d to the interface's list of listeners.
264 * Finally, point the driver's bpf cookie at the interface so
265 * it will divert packets to bpf.
266 */
267 d->bd_bif = bp;
f23061d4 268 SLIST_INSERT_HEAD(&bp->bif_dlist, d, bd_next);
1f8e62c9 269 *bp->bif_driverp = bp;
19f10c78
RP
270
271 EVENTHANDLER_INVOKE(bpf_track, bp->bif_ifp, bp->bif_dlt, 1);
984263bc
MD
272}
273
274/*
275 * Detach a file from its interface.
276 */
277static void
5534e0c8 278bpf_detachd(struct bpf_d *d)
984263bc 279{
1f8e62c9 280 int error;
984263bc 281 struct bpf_if *bp;
1f8e62c9 282 struct ifnet *ifp;
984263bc
MD
283
284 bp = d->bd_bif;
1f8e62c9
JS
285 ifp = bp->bif_ifp;
286
287 /* Remove d from the interface's descriptor list. */
288 SLIST_REMOVE(&bp->bif_dlist, d, bpf_d, bd_next);
289
290 if (SLIST_EMPTY(&bp->bif_dlist)) {
291 /*
292 * Let the driver know that there are no more listeners.
293 */
294 *bp->bif_driverp = NULL;
295 }
296 d->bd_bif = NULL;
19f10c78
RP
297
298 EVENTHANDLER_INVOKE(bpf_track, ifp, bp->bif_dlt, 0);
299
984263bc
MD
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;
1f8e62c9
JS
306 error = ifpromisc(ifp, 0);
307 if (error != 0 && error != ENXIO) {
984263bc 308 /*
1f8e62c9 309 * ENXIO can happen if a pccard is unplugged,
984263bc
MD
310 * Something is really wrong if we were able to put
311 * the driver into promiscuous mode, but can't
312 * take it out.
313 */
1f8e62c9
JS
314 if_printf(ifp, "bpf_detach: ifpromisc failed(%d)\n",
315 error);
5534e0c8 316 }
984263bc 317 }
984263bc
MD
318}
319
320/*
321 * Open ethernet device. Returns ENXIO for illegal minor device number,
322 * EBUSY if file is open by another process.
323 */
324/* ARGSUSED */
5534e0c8 325static int
fef8985e 326bpfopen(struct dev_open_args *ap)
984263bc 327{
b13267a5 328 cdev_t dev = ap->a_head.a_dev;
41c20dac 329 struct bpf_d *d;
41c20dac 330
fef8985e 331 if (ap->a_cred->cr_prison)
5534e0c8 332 return(EPERM);
984263bc
MD
333
334 d = dev->si_drv1;
335 /*
f23061d4 336 * Each minor can be opened by only one process. If the requested
984263bc
MD
337 * minor is in use, return EBUSY.
338 */
5534e0c8
JS
339 if (d != NULL)
340 return(EBUSY);
cd29885a 341
0c3c561c 342 MALLOC(d, struct bpf_d *, sizeof *d, M_BPF, M_WAITOK | M_ZERO);
984263bc
MD
343 dev->si_drv1 = d;
344 d->bd_bufsize = bpf_bufsize;
345 d->bd_sig = SIGIO;
346 d->bd_seesent = 1;
347 callout_init(&d->bd_callout);
5534e0c8 348 return(0);
984263bc
MD
349}
350
cd29885a
MD
351static int
352bpfclone(struct dev_clone_args *ap)
353{
354 int unit;
355
356 unit = devfs_clone_bitmap_get(&DEVFS_CLONE_BITMAP(bpf), 0);
357 ap->a_dev = make_only_dev(&bpf_ops, unit, 0, 0, 0600, "bpf%d", unit);
358
359 return 0;
360}
361
984263bc
MD
362/*
363 * Close the descriptor by detaching it from its interface,
364 * deallocating its buffers, and marking it free.
365 */
366/* ARGSUSED */
5534e0c8 367static int
fef8985e 368bpfclose(struct dev_close_args *ap)
984263bc 369{
b13267a5 370 cdev_t dev = ap->a_head.a_dev;
41c20dac 371 struct bpf_d *d = dev->si_drv1;
984263bc
MD
372
373 funsetown(d->bd_sigio);
0b31d406 374 crit_enter();
984263bc
MD
375 if (d->bd_state == BPF_WAITING)
376 callout_stop(&d->bd_callout);
377 d->bd_state = BPF_IDLE;
5534e0c8 378 if (d->bd_bif != NULL)
984263bc 379 bpf_detachd(d);
0b31d406 380 crit_exit();
984263bc 381 bpf_freed(d);
f23061d4 382 dev->si_drv1 = NULL;
8be7edad
MD
383 if (dev->si_uminor >= BPF_PREALLOCATED_UNITS) {
384 devfs_clone_bitmap_put(&DEVFS_CLONE_BITMAP(bpf), dev->si_uminor);
385 destroy_dev(dev);
386 }
efda3bd0 387 kfree(d, M_BPF);
5534e0c8 388 return(0);
984263bc 389}
984263bc
MD
390
391/*
392 * Rotate the packet buffers in descriptor d. Move the store buffer
393 * into the hold slot, and the free buffer into the store slot.
394 * Zero the length of the new store buffer.
395 */
396#define ROTATE_BUFFERS(d) \
397 (d)->bd_hbuf = (d)->bd_sbuf; \
398 (d)->bd_hlen = (d)->bd_slen; \
399 (d)->bd_sbuf = (d)->bd_fbuf; \
400 (d)->bd_slen = 0; \
f23061d4 401 (d)->bd_fbuf = NULL;
984263bc
MD
402/*
403 * bpfread - read next chunk of packets from buffers
404 */
5534e0c8 405static int
fef8985e 406bpfread(struct dev_read_args *ap)
984263bc 407{
b13267a5 408 cdev_t dev = ap->a_head.a_dev;
82ed7fc2 409 struct bpf_d *d = dev->si_drv1;
984263bc
MD
410 int timed_out;
411 int error;
984263bc
MD
412
413 /*
414 * Restrict application to use a buffer the same size as
415 * as kernel buffers.
416 */
fef8985e 417 if (ap->a_uio->uio_resid != d->bd_bufsize)
5534e0c8 418 return(EINVAL);
984263bc 419
0b31d406 420 crit_enter();
984263bc
MD
421 if (d->bd_state == BPF_WAITING)
422 callout_stop(&d->bd_callout);
423 timed_out = (d->bd_state == BPF_TIMED_OUT);
424 d->bd_state = BPF_IDLE;
425 /*
426 * If the hold buffer is empty, then do a timed sleep, which
427 * ends when the timeout expires or when enough packets
428 * have arrived to fill the store buffer.
429 */
f23061d4 430 while (d->bd_hbuf == NULL) {
95ec0a9c
MD
431 if ((d->bd_immediate || (ap->a_ioflag & IO_NDELAY) || timed_out)
432 && d->bd_slen != 0) {
984263bc 433 /*
95ec0a9c
MD
434 * A packet(s) either arrived since the previous,
435 * We're in immediate mode, or are reading
436 * in non-blocking mode, and a packet(s)
437 * either arrived since the previous
984263bc
MD
438 * read or arrived while we were asleep.
439 * Rotate the buffers and return what's here.
440 */
441 ROTATE_BUFFERS(d);
442 break;
443 }
444
445 /*
446 * No data is available, check to see if the bpf device
447 * is still pointed at a real interface. If not, return
448 * ENXIO so that the userland process knows to rebind
449 * it before using it again.
450 */
451 if (d->bd_bif == NULL) {
0b31d406 452 crit_exit();
5534e0c8 453 return(ENXIO);
984263bc
MD
454 }
455
fef8985e 456 if (ap->a_ioflag & IO_NDELAY) {
0b31d406 457 crit_exit();
5534e0c8 458 return(EWOULDBLOCK);
984263bc 459 }
5534e0c8 460 error = tsleep(d, PCATCH, "bpf", d->bd_rtout);
984263bc 461 if (error == EINTR || error == ERESTART) {
0b31d406 462 crit_exit();
5534e0c8 463 return(error);
984263bc
MD
464 }
465 if (error == EWOULDBLOCK) {
466 /*
467 * On a timeout, return what's in the buffer,
468 * which may be nothing. If there is something
469 * in the store buffer, we can rotate the buffers.
470 */
471 if (d->bd_hbuf)
472 /*
473 * We filled up the buffer in between
474 * getting the timeout and arriving
475 * here, so we don't need to rotate.
476 */
477 break;
478
479 if (d->bd_slen == 0) {
0b31d406 480 crit_exit();
5534e0c8 481 return(0);
984263bc
MD
482 }
483 ROTATE_BUFFERS(d);
484 break;
485 }
486 }
487 /*
488 * At this point, we know we have something in the hold slot.
489 */
0b31d406 490 crit_exit();
984263bc
MD
491
492 /*
493 * Move data from hold buffer into user space.
494 * We know the entire buffer is transferred since
495 * we checked above that the read buffer is bpf_bufsize bytes.
496 */
fef8985e 497 error = uiomove(d->bd_hbuf, d->bd_hlen, ap->a_uio);
984263bc 498
0b31d406 499 crit_enter();
984263bc 500 d->bd_fbuf = d->bd_hbuf;
f23061d4 501 d->bd_hbuf = NULL;
984263bc 502 d->bd_hlen = 0;
0b31d406 503 crit_exit();
984263bc 504
5534e0c8 505 return(error);
984263bc
MD
506}
507
508
509/*
510 * If there are processes sleeping on this descriptor, wake them up.
511 */
5534e0c8
JS
512static void
513bpf_wakeup(struct bpf_d *d)
984263bc
MD
514{
515 if (d->bd_state == BPF_WAITING) {
516 callout_stop(&d->bd_callout);
517 d->bd_state = BPF_IDLE;
518 }
f23061d4 519 wakeup(d);
984263bc
MD
520 if (d->bd_async && d->bd_sig && d->bd_sigio)
521 pgsigio(d->bd_sigio, d->bd_sig, 0);
522
78195a76 523 get_mplock();
5b22f1a7 524 KNOTE(&d->bd_kq.ki_note, 0);
78195a76 525 rel_mplock();
984263bc
MD
526}
527
528static void
5534e0c8 529bpf_timed_out(void *arg)
984263bc
MD
530{
531 struct bpf_d *d = (struct bpf_d *)arg;
984263bc 532
0b31d406 533 crit_enter();
984263bc
MD
534 if (d->bd_state == BPF_WAITING) {
535 d->bd_state = BPF_TIMED_OUT;
536 if (d->bd_slen != 0)
537 bpf_wakeup(d);
538 }
0b31d406 539 crit_exit();
984263bc
MD
540}
541
e1c548c2
SZ
542static void
543bpf_output_dispatch(struct netmsg *nmsg)
544{
545 struct netmsg_bpf_output *bmsg = (struct netmsg_bpf_output *)nmsg;
546 struct ifnet *ifp = bmsg->nm_ifp;
547 int error;
548
549 /*
550 * The driver frees the mbuf.
551 */
552 error = ifp->if_output(ifp, bmsg->nm_mbuf, bmsg->nm_dst, NULL);
553 lwkt_replymsg(&nmsg->nm_lmsg, error);
554}
555
0301afa9 556static int
fef8985e 557bpfwrite(struct dev_write_args *ap)
984263bc 558{
b13267a5 559 cdev_t dev = ap->a_head.a_dev;
82ed7fc2 560 struct bpf_d *d = dev->si_drv1;
984263bc
MD
561 struct ifnet *ifp;
562 struct mbuf *m;
0b31d406 563 int error;
daaccb0f 564 struct sockaddr dst;
984263bc 565 int datlen;
e1c548c2 566 struct netmsg_bpf_output bmsg;
984263bc 567
f23061d4 568 if (d->bd_bif == NULL)
5534e0c8 569 return(ENXIO);
984263bc
MD
570
571 ifp = d->bd_bif->bif_ifp;
572
fef8985e 573 if (ap->a_uio->uio_resid == 0)
5534e0c8 574 return(0);
984263bc 575
fef8985e 576 error = bpf_movein(ap->a_uio, (int)d->bd_bif->bif_dlt, &m,
7cff0268 577 &dst, &datlen, d->bd_wfilter);
984263bc 578 if (error)
5534e0c8 579 return(error);
984263bc 580
253ad594
MD
581 if (datlen > ifp->if_mtu) {
582 m_freem(m);
5534e0c8 583 return(EMSGSIZE);
253ad594 584 }
984263bc
MD
585
586 if (d->bd_hdrcmplt)
587 dst.sa_family = pseudo_AF_HDRCMPLT;
588
48e7b118
MD
589 netmsg_init(&bmsg.nm_netmsg, NULL, &curthread->td_msgport,
590 MSGF_MPSAFE, bpf_output_dispatch);
e1c548c2
SZ
591 bmsg.nm_mbuf = m;
592 bmsg.nm_ifp = ifp;
593 bmsg.nm_dst = &dst;
594
595 return lwkt_domsg(cpu_portfn(0), &bmsg.nm_netmsg.nm_lmsg, 0);
984263bc
MD
596}
597
598/*
599 * Reset a descriptor by flushing its packet buffer and clearing the
600 * receive and drop counts. Should be called at splimp.
601 */
602static void
cefd3279 603bpf_resetd(struct bpf_d *d)
984263bc
MD
604{
605 if (d->bd_hbuf) {
606 /* Free the hold buffer. */
607 d->bd_fbuf = d->bd_hbuf;
f23061d4 608 d->bd_hbuf = NULL;
984263bc
MD
609 }
610 d->bd_slen = 0;
611 d->bd_hlen = 0;
612 d->bd_rcount = 0;
613 d->bd_dcount = 0;
614}
615
616/*
617 * FIONREAD Check for read packet available.
618 * SIOCGIFADDR Get interface address - convenient hook to driver.
619 * BIOCGBLEN Get buffer len [for read()].
620 * BIOCSETF Set ethernet read filter.
7cff0268 621 * BIOCSETWF Set ethernet write filter.
984263bc
MD
622 * BIOCFLUSH Flush read packet buffer.
623 * BIOCPROMISC Put interface into promiscuous mode.
624 * BIOCGDLT Get link layer type.
625 * BIOCGETIF Get interface name.
626 * BIOCSETIF Set interface.
627 * BIOCSRTIMEOUT Set read timeout.
628 * BIOCGRTIMEOUT Get read timeout.
629 * BIOCGSTATS Get packet stats.
630 * BIOCIMMEDIATE Set immediate mode.
631 * BIOCVERSION Get filter language version.
632 * BIOCGHDRCMPLT Get "header already complete" flag
633 * BIOCSHDRCMPLT Set "header already complete" flag
634 * BIOCGSEESENT Get "see packets sent" flag
635 * BIOCSSEESENT Set "see packets sent" flag
7cff0268 636 * BIOCLOCK Set "locked" flag
984263bc
MD
637 */
638/* ARGSUSED */
5534e0c8 639static int
fef8985e 640bpfioctl(struct dev_ioctl_args *ap)
984263bc 641{
b13267a5 642 cdev_t dev = ap->a_head.a_dev;
41c20dac 643 struct bpf_d *d = dev->si_drv1;
0b31d406 644 int error = 0;
984263bc 645
0b31d406 646 crit_enter();
984263bc
MD
647 if (d->bd_state == BPF_WAITING)
648 callout_stop(&d->bd_callout);
649 d->bd_state = BPF_IDLE;
0b31d406 650 crit_exit();
984263bc 651
7cff0268
MS
652 if (d->bd_locked == 1) {
653 switch (ap->a_cmd) {
654 case BIOCGBLEN:
655 case BIOCFLUSH:
656 case BIOCGDLT:
657 case BIOCGDLTLIST:
658 case BIOCGETIF:
659 case BIOCGRTIMEOUT:
660 case BIOCGSTATS:
661 case BIOCVERSION:
662 case BIOCGRSIG:
663 case BIOCGHDRCMPLT:
664 case FIONREAD:
665 case BIOCLOCK:
666 case BIOCSRTIMEOUT:
667 case BIOCIMMEDIATE:
668 case TIOCGPGRP:
669 break;
670 default:
671 return (EPERM);
672 }
673 }
fef8985e 674 switch (ap->a_cmd) {
984263bc
MD
675 default:
676 error = EINVAL;
677 break;
678
679 /*
680 * Check for read packet available.
681 */
682 case FIONREAD:
683 {
684 int n;
685
0b31d406 686 crit_enter();
984263bc
MD
687 n = d->bd_slen;
688 if (d->bd_hbuf)
689 n += d->bd_hlen;
0b31d406 690 crit_exit();
984263bc 691
fef8985e 692 *(int *)ap->a_data = n;
984263bc
MD
693 break;
694 }
695
696 case SIOCGIFADDR:
697 {
698 struct ifnet *ifp;
699
67756095 700 if (d->bd_bif == NULL) {
984263bc 701 error = EINVAL;
67756095 702 } else {
984263bc 703 ifp = d->bd_bif->bif_ifp;
a3dd34d2 704 ifnet_serialize_all(ifp);
fef8985e
MD
705 error = ifp->if_ioctl(ifp, ap->a_cmd,
706 ap->a_data, ap->a_cred);
a3dd34d2 707 ifnet_deserialize_all(ifp);
984263bc
MD
708 }
709 break;
710 }
711
712 /*
713 * Get buffer len [for read()].
714 */
715 case BIOCGBLEN:
fef8985e 716 *(u_int *)ap->a_data = d->bd_bufsize;
984263bc
MD
717 break;
718
719 /*
720 * Set buffer length.
721 */
722 case BIOCSBLEN:
67756095 723 if (d->bd_bif != NULL) {
984263bc 724 error = EINVAL;
67756095 725 } else {
fef8985e 726 u_int size = *(u_int *)ap->a_data;
984263bc
MD
727
728 if (size > bpf_maxbufsize)
fef8985e 729 *(u_int *)ap->a_data = size = bpf_maxbufsize;
984263bc 730 else if (size < BPF_MINBUFSIZE)
fef8985e 731 *(u_int *)ap->a_data = size = BPF_MINBUFSIZE;
984263bc
MD
732 d->bd_bufsize = size;
733 }
984263bc
MD
734 break;
735
736 /*
737 * Set link layer read filter.
738 */
739 case BIOCSETF:
7cff0268
MS
740 case BIOCSETWF:
741 error = bpf_setf(d, (struct bpf_program *)ap->a_data,
742 ap->a_cmd);
984263bc
MD
743 break;
744
745 /*
746 * Flush read packet buffer.
747 */
748 case BIOCFLUSH:
0b31d406 749 crit_enter();
cefd3279 750 bpf_resetd(d);
0b31d406 751 crit_exit();
984263bc
MD
752 break;
753
754 /*
755 * Put interface into promiscuous mode.
756 */
757 case BIOCPROMISC:
f23061d4 758 if (d->bd_bif == NULL) {
984263bc
MD
759 /*
760 * No interface attached yet.
761 */
762 error = EINVAL;
763 break;
764 }
0b31d406 765 crit_enter();
984263bc
MD
766 if (d->bd_promisc == 0) {
767 error = ifpromisc(d->bd_bif->bif_ifp, 1);
768 if (error == 0)
769 d->bd_promisc = 1;
770 }
0b31d406 771 crit_exit();
984263bc
MD
772 break;
773
774 /*
775 * Get device parameters.
776 */
777 case BIOCGDLT:
f23061d4 778 if (d->bd_bif == NULL)
984263bc
MD
779 error = EINVAL;
780 else
fef8985e 781 *(u_int *)ap->a_data = d->bd_bif->bif_dlt;
984263bc
MD
782 break;
783
1f8e62c9
JS
784 /*
785 * Get a list of supported data link types.
786 */
787 case BIOCGDLTLIST:
67756095 788 if (d->bd_bif == NULL) {
1f8e62c9 789 error = EINVAL;
67756095
SZ
790 } else {
791 error = bpf_getdltlist(d,
792 (struct bpf_dltlist *)ap->a_data);
793 }
1f8e62c9
JS
794 break;
795
796 /*
797 * Set data link type.
798 */
799 case BIOCSDLT:
800 if (d->bd_bif == NULL)
801 error = EINVAL;
802 else
fef8985e 803 error = bpf_setdlt(d, *(u_int *)ap->a_data);
1f8e62c9
JS
804 break;
805
984263bc
MD
806 /*
807 * Get interface name.
808 */
809 case BIOCGETIF:
0c3c561c 810 if (d->bd_bif == NULL) {
984263bc 811 error = EINVAL;
0c3c561c 812 } else {
984263bc 813 struct ifnet *const ifp = d->bd_bif->bif_ifp;
fef8985e 814 struct ifreq *const ifr = (struct ifreq *)ap->a_data;
984263bc 815
3e4a09e7 816 strlcpy(ifr->ifr_name, ifp->if_xname,
0c3c561c 817 sizeof ifr->ifr_name);
984263bc
MD
818 }
819 break;
820
821 /*
822 * Set interface.
823 */
824 case BIOCSETIF:
fef8985e 825 error = bpf_setif(d, (struct ifreq *)ap->a_data);
984263bc
MD
826 break;
827
828 /*
829 * Set read timeout.
830 */
831 case BIOCSRTIMEOUT:
832 {
fef8985e 833 struct timeval *tv = (struct timeval *)ap->a_data;
984263bc
MD
834
835 /*
836 * Subtract 1 tick from tvtohz() since this isn't
837 * a one-shot timer.
838 */
839 if ((error = itimerfix(tv)) == 0)
a94976ad 840 d->bd_rtout = tvtohz_low(tv);
984263bc
MD
841 break;
842 }
843
844 /*
845 * Get read timeout.
846 */
847 case BIOCGRTIMEOUT:
848 {
fef8985e 849 struct timeval *tv = (struct timeval *)ap->a_data;
984263bc
MD
850
851 tv->tv_sec = d->bd_rtout / hz;
a591f597 852 tv->tv_usec = (d->bd_rtout % hz) * ustick;
984263bc
MD
853 break;
854 }
855
856 /*
857 * Get packet stats.
858 */
859 case BIOCGSTATS:
860 {
fef8985e 861 struct bpf_stat *bs = (struct bpf_stat *)ap->a_data;
984263bc
MD
862
863 bs->bs_recv = d->bd_rcount;
864 bs->bs_drop = d->bd_dcount;
865 break;
866 }
867
868 /*
869 * Set immediate mode.
870 */
871 case BIOCIMMEDIATE:
fef8985e 872 d->bd_immediate = *(u_int *)ap->a_data;
984263bc
MD
873 break;
874
875 case BIOCVERSION:
876 {
fef8985e 877 struct bpf_version *bv = (struct bpf_version *)ap->a_data;
984263bc
MD
878
879 bv->bv_major = BPF_MAJOR_VERSION;
880 bv->bv_minor = BPF_MINOR_VERSION;
881 break;
882 }
883
884 /*
885 * Get "header already complete" flag
886 */
887 case BIOCGHDRCMPLT:
fef8985e 888 *(u_int *)ap->a_data = d->bd_hdrcmplt;
984263bc
MD
889 break;
890
891 /*
892 * Set "header already complete" flag
893 */
894 case BIOCSHDRCMPLT:
fef8985e 895 d->bd_hdrcmplt = *(u_int *)ap->a_data ? 1 : 0;
984263bc
MD
896 break;
897
898 /*
899 * Get "see sent packets" flag
900 */
901 case BIOCGSEESENT:
fef8985e 902 *(u_int *)ap->a_data = d->bd_seesent;
984263bc
MD
903 break;
904
905 /*
906 * Set "see sent packets" flag
907 */
908 case BIOCSSEESENT:
fef8985e 909 d->bd_seesent = *(u_int *)ap->a_data;
984263bc
MD
910 break;
911
984263bc 912 case FIOASYNC: /* Send signal on receive packets */
fef8985e 913 d->bd_async = *(int *)ap->a_data;
984263bc
MD
914 break;
915
916 case FIOSETOWN:
fef8985e 917 error = fsetown(*(int *)ap->a_data, &d->bd_sigio);
984263bc
MD
918 break;
919
920 case FIOGETOWN:
fef8985e 921 *(int *)ap->a_data = fgetown(d->bd_sigio);
984263bc
MD
922 break;
923
924 /* This is deprecated, FIOSETOWN should be used instead. */
925 case TIOCSPGRP:
fef8985e 926 error = fsetown(-(*(int *)ap->a_data), &d->bd_sigio);
984263bc
MD
927 break;
928
929 /* This is deprecated, FIOGETOWN should be used instead. */
930 case TIOCGPGRP:
fef8985e 931 *(int *)ap->a_data = -fgetown(d->bd_sigio);
984263bc
MD
932 break;
933
934 case BIOCSRSIG: /* Set receive signal */
935 {
f23061d4 936 u_int sig;
984263bc 937
fef8985e 938 sig = *(u_int *)ap->a_data;
984263bc
MD
939
940 if (sig >= NSIG)
941 error = EINVAL;
942 else
943 d->bd_sig = sig;
944 break;
945 }
946 case BIOCGRSIG:
fef8985e 947 *(u_int *)ap->a_data = d->bd_sig;
984263bc 948 break;
7cff0268
MS
949 case BIOCLOCK:
950 d->bd_locked = 1;
951 break;
984263bc 952 }
5534e0c8 953 return(error);
984263bc
MD
954}
955
956/*
957 * Set d's packet filter program to fp. If this file already has a filter,
958 * free it and replace it. Returns EINVAL for bogus requests.
959 */
960static int
7cff0268 961bpf_setf(struct bpf_d *d, struct bpf_program *fp, u_long cmd)
984263bc
MD
962{
963 struct bpf_insn *fcode, *old;
7cff0268
MS
964 u_int wfilter, flen, size;
965
966 if (cmd == BIOCSETWF) {
967 old = d->bd_wfilter;
968 wfilter = 1;
969 } else {
970 wfilter = 0;
971 old = d->bd_rfilter;
972 }
f23061d4 973 if (fp->bf_insns == NULL) {
984263bc 974 if (fp->bf_len != 0)
5534e0c8 975 return(EINVAL);
0b31d406 976 crit_enter();
7cff0268
MS
977 if (wfilter)
978 d->bd_wfilter = NULL;
979 else
980 d->bd_rfilter = NULL;
cefd3279 981 bpf_resetd(d);
0b31d406 982 crit_exit();
67756095 983 if (old != NULL)
efda3bd0 984 kfree(old, M_BPF);
5534e0c8 985 return(0);
984263bc
MD
986 }
987 flen = fp->bf_len;
988 if (flen > BPF_MAXINSNS)
5534e0c8 989 return(EINVAL);
984263bc 990
0c3c561c 991 size = flen * sizeof *fp->bf_insns;
efda3bd0 992 fcode = (struct bpf_insn *)kmalloc(size, M_BPF, M_WAITOK);
f23061d4 993 if (copyin(fp->bf_insns, fcode, size) == 0 &&
984263bc 994 bpf_validate(fcode, (int)flen)) {
0b31d406 995 crit_enter();
7cff0268
MS
996 if (wfilter)
997 d->bd_wfilter = fcode;
998 else
999 d->bd_rfilter = fcode;
cefd3279 1000 bpf_resetd(d);
0b31d406 1001 crit_exit();
67756095 1002 if (old != NULL)
efda3bd0 1003 kfree(old, M_BPF);
984263bc 1004
5534e0c8 1005 return(0);
984263bc 1006 }
efda3bd0 1007 kfree(fcode, M_BPF);
5534e0c8 1008 return(EINVAL);
984263bc
MD
1009}
1010
1011/*
1012 * Detach a file from its current interface (if attached at all) and attach
1013 * to the interface indicated by the name stored in ifr.
1014 * Return an errno or 0.
1015 */
1016static int
5534e0c8 1017bpf_setif(struct bpf_d *d, struct ifreq *ifr)
984263bc
MD
1018{
1019 struct bpf_if *bp;
0b31d406 1020 int error;
984263bc
MD
1021 struct ifnet *theywant;
1022
1023 theywant = ifunit(ifr->ifr_name);
f23061d4 1024 if (theywant == NULL)
5534e0c8 1025 return(ENXIO);
984263bc
MD
1026
1027 /*
1028 * Look through attached interfaces for the named one.
1029 */
67756095 1030 for (bp = bpf_iflist; bp != NULL; bp = bp->bif_next) {
984263bc
MD
1031 struct ifnet *ifp = bp->bif_ifp;
1032
f23061d4 1033 if (ifp == NULL || ifp != theywant)
984263bc 1034 continue;
1f8e62c9
JS
1035 /* skip additional entry */
1036 if (bp->bif_driverp != &ifp->if_bpf)
1037 continue;
984263bc
MD
1038 /*
1039 * We found the requested interface.
984263bc
MD
1040 * Allocate the packet buffers if we need to.
1041 * If we're already attached to requested interface,
1042 * just flush the buffer.
1043 */
5534e0c8 1044 if (d->bd_sbuf == NULL) {
984263bc
MD
1045 error = bpf_allocbufs(d);
1046 if (error != 0)
5534e0c8 1047 return(error);
984263bc 1048 }
0b31d406 1049 crit_enter();
984263bc 1050 if (bp != d->bd_bif) {
5534e0c8 1051 if (d->bd_bif != NULL) {
984263bc
MD
1052 /*
1053 * Detach if attached to something else.
1054 */
1055 bpf_detachd(d);
5534e0c8 1056 }
984263bc
MD
1057
1058 bpf_attachd(d, bp);
1059 }
cefd3279 1060 bpf_resetd(d);
0b31d406 1061 crit_exit();
5534e0c8 1062 return(0);
984263bc 1063 }
5534e0c8 1064
984263bc 1065 /* Not found. */
5534e0c8 1066 return(ENXIO);
984263bc
MD
1067}
1068
9fb2d31f 1069static struct filterops bpf_read_filtops =
4c91dbc9 1070 { FILTEROP_ISFD, NULL, bpf_filter_detach, bpf_filter_read };
9fb2d31f
SG
1071
1072static int
1073bpfkqfilter(struct dev_kqfilter_args *ap)
1074{
1075 cdev_t dev = ap->a_head.a_dev;
1076 struct knote *kn = ap->a_kn;
1077 struct klist *klist;
1078 struct bpf_d *d;
1079
1080 d = dev->si_drv1;
1081 if (d->bd_bif == NULL) {
1082 ap->a_result = 1;
1083 return (0);
1084 }
1085
1086 ap->a_result = 0;
1087 switch (kn->kn_filter) {
1088 case EVFILT_READ:
1089 kn->kn_fop = &bpf_read_filtops;
1090 kn->kn_hook = (caddr_t)d;
1091 break;
1092 default:
b287d649 1093 ap->a_result = EOPNOTSUPP;
9fb2d31f
SG
1094 return (0);
1095 }
1096
5b22f1a7
SG
1097 klist = &d->bd_kq.ki_note;
1098 knote_insert(klist, kn);
9fb2d31f
SG
1099
1100 return (0);
1101}
1102
1103static void
1104bpf_filter_detach(struct knote *kn)
1105{
1106 struct klist *klist;
1107 struct bpf_d *d;
1108
9fb2d31f 1109 d = (struct bpf_d *)kn->kn_hook;
5b22f1a7
SG
1110 klist = &d->bd_kq.ki_note;
1111 knote_remove(klist, kn);
9fb2d31f
SG
1112}
1113
1114static int
1115bpf_filter_read(struct knote *kn, long hint)
1116{
1117 struct bpf_d *d;
1118 int ready = 0;
1119
1120 crit_enter();
1121 d = (struct bpf_d *)kn->kn_hook;
1122 if (d->bd_hlen != 0 ||
1123 ((d->bd_immediate || d->bd_state == BPF_TIMED_OUT) &&
1124 d->bd_slen != 0)) {
1125 ready = 1;
1126 } else {
1127 /* Start the read timeout if necessary. */
1128 if (d->bd_rtout > 0 && d->bd_state == BPF_IDLE) {
1129 callout_reset(&d->bd_callout, d->bd_rtout,
1130 bpf_timed_out, d);
1131 d->bd_state = BPF_WAITING;
1132 }
1133 }
1134 crit_exit();
1135
1136 return (ready);
1137}
1138
1139
984263bc 1140/*
1f8e62c9
JS
1141 * Process the packet pkt of length pktlen. The packet is parsed
1142 * by each listener's filter, and if accepted, stashed into the
1143 * corresponding buffer.
984263bc
MD
1144 */
1145void
1f8e62c9 1146bpf_tap(struct bpf_if *bp, u_char *pkt, u_int pktlen)
984263bc 1147{
82ed7fc2 1148 struct bpf_d *d;
aedcf384
SZ
1149 struct timeval tv;
1150 int gottime = 0;
82ed7fc2 1151 u_int slen;
f23061d4 1152
64202d9a
SZ
1153 get_mplock();
1154
1155 /* Re-check */
1156 if (bp == NULL) {
1157 rel_mplock();
1158 return;
1159 }
1160
984263bc
MD
1161 /*
1162 * Note that the ipl does not have to be raised at this point.
1163 * The only problem that could arise here is that if two different
1164 * interfaces shared any data. This is not the case.
1165 */
f23061d4 1166 SLIST_FOREACH(d, &bp->bif_dlist, bd_next) {
984263bc 1167 ++d->bd_rcount;
7cff0268 1168 slen = bpf_filter(d->bd_rfilter, pkt, pktlen, pktlen);
aedcf384
SZ
1169 if (slen != 0) {
1170 if (!gottime) {
1171 microtime(&tv);
1172 gottime = 1;
1173 }
1174 catchpacket(d, pkt, pktlen, slen, ovbcopy, &tv);
1175 }
984263bc 1176 }
64202d9a
SZ
1177
1178 rel_mplock();
984263bc
MD
1179}
1180
1181/*
1182 * Copy data from an mbuf chain into a buffer. This code is derived
1183 * from m_copydata in sys/uipc_mbuf.c.
1184 */
1185static void
5534e0c8 1186bpf_mcopy(const void *src_arg, void *dst_arg, size_t len)
984263bc 1187{
82ed7fc2
RG
1188 const struct mbuf *m;
1189 u_int count;
984263bc
MD
1190 u_char *dst;
1191
1192 m = src_arg;
1193 dst = dst_arg;
1194 while (len > 0) {
5534e0c8 1195 if (m == NULL)
984263bc
MD
1196 panic("bpf_mcopy");
1197 count = min(m->m_len, len);
1198 bcopy(mtod(m, void *), dst, count);
1199 m = m->m_next;
1200 dst += count;
1201 len -= count;
1202 }
1203}
1204
1205/*
1f8e62c9
JS
1206 * Process the packet in the mbuf chain m. The packet is parsed by each
1207 * listener's filter, and if accepted, stashed into the corresponding
1208 * buffer.
984263bc
MD
1209 */
1210void
1f8e62c9 1211bpf_mtap(struct bpf_if *bp, struct mbuf *m)
984263bc 1212{
984263bc
MD
1213 struct bpf_d *d;
1214 u_int pktlen, slen;
aedcf384
SZ
1215 struct timeval tv;
1216 int gottime = 0;
984263bc 1217
64202d9a
SZ
1218 get_mplock();
1219
1220 /* Re-check */
1221 if (bp == NULL) {
1222 rel_mplock();
1223 return;
1224 }
1225
1f8e62c9 1226 /* Don't compute pktlen, if no descriptor is attached. */
64202d9a
SZ
1227 if (SLIST_EMPTY(&bp->bif_dlist)) {
1228 rel_mplock();
1f8e62c9 1229 return;
64202d9a 1230 }
1f8e62c9 1231
cefd3279 1232 pktlen = m_lengthm(m, NULL);
984263bc 1233
f23061d4 1234 SLIST_FOREACH(d, &bp->bif_dlist, bd_next) {
984263bc
MD
1235 if (!d->bd_seesent && (m->m_pkthdr.rcvif == NULL))
1236 continue;
1237 ++d->bd_rcount;
7cff0268 1238 slen = bpf_filter(d->bd_rfilter, (u_char *)m, pktlen, 0);
aedcf384
SZ
1239 if (slen != 0) {
1240 if (!gottime) {
1241 microtime(&tv);
1242 gottime = 1;
1243 }
1244 catchpacket(d, (u_char *)m, pktlen, slen, bpf_mcopy,
1245 &tv);
1246 }
984263bc 1247 }
64202d9a
SZ
1248
1249 rel_mplock();
984263bc
MD
1250}
1251
70224baa
JL
1252/*
1253 * Incoming linkage from device drivers, where we have a mbuf chain
1254 * but need to prepend some arbitrary header from a linear buffer.
1255 *
1256 * Con up a minimal dummy header to pacify bpf. Allocate (only) a
1257 * struct m_hdr on the stack. This is safe as bpf only reads from the
1258 * fields in this header that we initialize, and will not try to free
1259 * it or keep a pointer to it.
1260 */
1261void
1262bpf_mtap_hdr(struct bpf_if *arg, caddr_t data, u_int dlen, struct mbuf *m, u_int direction)
1263{
1264 struct m_hdr mh;
1265
1266 mh.mh_flags = 0;
1267 mh.mh_next = m;
1268 mh.mh_len = dlen;
1269 mh.mh_data = data;
1270
1271 return bpf_mtap(arg, (struct mbuf *) &mh);
1272}
1273
81806f7a
HP
1274void
1275bpf_mtap_family(struct bpf_if *bp, struct mbuf *m, sa_family_t family)
1276{
1277 u_int family4;
1278
1279 KKASSERT(family != AF_UNSPEC);
cefd3279 1280
81806f7a
HP
1281 family4 = (u_int)family;
1282 bpf_ptap(bp, m, &family4, sizeof(family4));
1283}
1284
1f8e62c9
JS
1285/*
1286 * Process the packet in the mbuf chain m with the header in m prepended.
1287 * The packet is parsed by each listener's filter, and if accepted,
1288 * stashed into the corresponding buffer.
1289 */
1290void
1291bpf_ptap(struct bpf_if *bp, struct mbuf *m, const void *data, u_int dlen)
1292{
1293 struct mbuf mb;
1294
1295 /*
1296 * Craft on-stack mbuf suitable for passing to bpf_mtap.
1297 * Note that we cut corners here; we only setup what's
1298 * absolutely needed--this mbuf should never go anywhere else.
1299 */
1300 mb.m_next = m;
1301 mb.m_data = __DECONST(void *, data); /* LINTED */
1302 mb.m_len = dlen;
2265ca08 1303 mb.m_pkthdr.rcvif = m->m_pkthdr.rcvif;
1f8e62c9 1304
c972d9bf 1305 bpf_mtap(bp, &mb);
1f8e62c9
JS
1306}
1307
984263bc
MD
1308/*
1309 * Move the packet data from interface memory (pkt) into the
1310 * store buffer. Return 1 if it's time to wakeup a listener (buffer full),
1311 * otherwise 0. "copy" is the routine called to do the actual data
1312 * transfer. bcopy is passed in to copy contiguous chunks, while
1313 * bpf_mcopy is passed in to copy mbuf chains. In the latter case,
1314 * pkt is really an mbuf.
1315 */
1316static void
5534e0c8 1317catchpacket(struct bpf_d *d, u_char *pkt, u_int pktlen, u_int snaplen,
aedcf384
SZ
1318 void (*cpfn)(const void *, void *, size_t),
1319 const struct timeval *tv)
984263bc 1320{
82ed7fc2
RG
1321 struct bpf_hdr *hp;
1322 int totlen, curlen;
1323 int hdrlen = d->bd_bif->bif_hdrlen;
44aa8f02 1324 int wakeup = 0;
984263bc
MD
1325 /*
1326 * Figure out how many bytes to move. If the packet is
1327 * greater or equal to the snapshot length, transfer that
1328 * much. Otherwise, transfer the whole packet (unless
1329 * we hit the buffer size limit).
1330 */
1331 totlen = hdrlen + min(snaplen, pktlen);
1332 if (totlen > d->bd_bufsize)
1333 totlen = d->bd_bufsize;
1334
1335 /*
1336 * Round up the end of the previous packet to the next longword.
1337 */
1338 curlen = BPF_WORDALIGN(d->bd_slen);
1339 if (curlen + totlen > d->bd_bufsize) {
1340 /*
1341 * This packet will overflow the storage buffer.
1342 * Rotate the buffers if we can, then wakeup any
1343 * pending reads.
1344 */
f23061d4 1345 if (d->bd_fbuf == NULL) {
984263bc
MD
1346 /*
1347 * We haven't completed the previous read yet,
1348 * so drop the packet.
1349 */
1350 ++d->bd_dcount;
1351 return;
1352 }
1353 ROTATE_BUFFERS(d);
44aa8f02 1354 wakeup = 1;
984263bc 1355 curlen = 0;
67756095 1356 } else if (d->bd_immediate || d->bd_state == BPF_TIMED_OUT) {
984263bc
MD
1357 /*
1358 * Immediate mode is set, or the read timeout has
1359 * already expired during a select call. A packet
1360 * arrived, so the reader should be woken up.
1361 */
44aa8f02 1362 wakeup = 1;
67756095 1363 }
984263bc
MD
1364
1365 /*
1366 * Append the bpf header.
1367 */
1368 hp = (struct bpf_hdr *)(d->bd_sbuf + curlen);
aedcf384 1369 hp->bh_tstamp = *tv;
984263bc
MD
1370 hp->bh_datalen = pktlen;
1371 hp->bh_hdrlen = hdrlen;
1372 /*
1373 * Copy the packet data into the store buffer and update its length.
1374 */
1375 (*cpfn)(pkt, (u_char *)hp + hdrlen, (hp->bh_caplen = totlen - hdrlen));
1376 d->bd_slen = curlen + totlen;
44aa8f02
SG
1377
1378 if (wakeup)
1379 bpf_wakeup(d);
984263bc
MD
1380}
1381
1382/*
1383 * Initialize all nonzero fields of a descriptor.
1384 */
1385static int
5534e0c8 1386bpf_allocbufs(struct bpf_d *d)
984263bc 1387{
efda3bd0 1388 d->bd_fbuf = kmalloc(d->bd_bufsize, M_BPF, M_WAITOK);
efda3bd0 1389 d->bd_sbuf = kmalloc(d->bd_bufsize, M_BPF, M_WAITOK);
984263bc
MD
1390 d->bd_slen = 0;
1391 d->bd_hlen = 0;
5534e0c8 1392 return(0);
984263bc
MD
1393}
1394
1395/*
67756095 1396 * Free buffers and packet filter program currently in use by a descriptor.
984263bc
MD
1397 * Called on close.
1398 */
1399static void
5534e0c8 1400bpf_freed(struct bpf_d *d)
984263bc
MD
1401{
1402 /*
1403 * We don't need to lock out interrupts since this descriptor has
1404 * been detached from its interface and it yet hasn't been marked
1405 * free.
1406 */
f23061d4 1407 if (d->bd_sbuf != NULL) {
efda3bd0 1408 kfree(d->bd_sbuf, M_BPF);
f23061d4 1409 if (d->bd_hbuf != NULL)
efda3bd0 1410 kfree(d->bd_hbuf, M_BPF);
f23061d4 1411 if (d->bd_fbuf != NULL)
efda3bd0 1412 kfree(d->bd_fbuf, M_BPF);
984263bc 1413 }
7cff0268
MS
1414 if (d->bd_rfilter)
1415 kfree(d->bd_rfilter, M_BPF);
1416 if (d->bd_wfilter)
1417 kfree(d->bd_wfilter, M_BPF);
984263bc
MD
1418}
1419
1420/*
1421 * Attach an interface to bpf. ifp is a pointer to the structure
1422 * defining the interface to be attached, dlt is the link layer type,
1423 * and hdrlen is the fixed size of the link header (variable length
1f8e62c9 1424 * headers are not yet supported).
984263bc
MD
1425 */
1426void
5534e0c8 1427bpfattach(struct ifnet *ifp, u_int dlt, u_int hdrlen)
1f8e62c9
JS
1428{
1429 bpfattach_dlt(ifp, dlt, hdrlen, &ifp->if_bpf);
1430}
1431
1432void
1433bpfattach_dlt(struct ifnet *ifp, u_int dlt, u_int hdrlen, struct bpf_if **driverp)
984263bc
MD
1434{
1435 struct bpf_if *bp;
02334e23 1436
efda3bd0 1437 bp = kmalloc(sizeof *bp, M_BPF, M_WAITOK | M_ZERO);
984263bc 1438
1f8e62c9 1439 SLIST_INIT(&bp->bif_dlist);
984263bc
MD
1440 bp->bif_ifp = ifp;
1441 bp->bif_dlt = dlt;
1f8e62c9
JS
1442 bp->bif_driverp = driverp;
1443 *bp->bif_driverp = NULL;
984263bc
MD
1444
1445 bp->bif_next = bpf_iflist;
1446 bpf_iflist = bp;
1447
984263bc
MD
1448 /*
1449 * Compute the length of the bpf header. This is not necessarily
1450 * equal to SIZEOF_BPF_HDR because we want to insert spacing such
1451 * that the network layer header begins on a longword boundary (for
1452 * performance reasons and to alleviate alignment restrictions).
1453 */
1454 bp->bif_hdrlen = BPF_WORDALIGN(hdrlen + SIZEOF_BPF_HDR) - hdrlen;
1455
1456 if (bootverbose)
1f8e62c9 1457 if_printf(ifp, "bpf attached\n");
984263bc
MD
1458}
1459
1460/*
1461 * Detach bpf from an interface. This involves detaching each descriptor
1462 * associated with the interface, and leaving bd_bif NULL. Notify each
1463 * descriptor as it's detached so that any sleepers wake up and get
1464 * ENXIO.
1465 */
1466void
5534e0c8 1467bpfdetach(struct ifnet *ifp)
984263bc 1468{
5534e0c8
JS
1469 struct bpf_if *bp, *bp_prev;
1470 struct bpf_d *d;
984263bc 1471
0b31d406 1472 crit_enter();
984263bc
MD
1473
1474 /* Locate BPF interface information */
1475 bp_prev = NULL;
1476 for (bp = bpf_iflist; bp != NULL; bp = bp->bif_next) {
1477 if (ifp == bp->bif_ifp)
1478 break;
1479 bp_prev = bp;
1480 }
1481
1482 /* Interface wasn't attached */
1483 if (bp->bif_ifp == NULL) {
0b31d406 1484 crit_exit();
4b1cf444 1485 kprintf("bpfdetach: %s was not attached\n", ifp->if_xname);
984263bc
MD
1486 return;
1487 }
1488
f23061d4 1489 while ((d = SLIST_FIRST(&bp->bif_dlist)) != NULL) {
984263bc
MD
1490 bpf_detachd(d);
1491 bpf_wakeup(d);
1492 }
1493
5534e0c8 1494 if (bp_prev != NULL)
984263bc 1495 bp_prev->bif_next = bp->bif_next;
5534e0c8 1496 else
984263bc 1497 bpf_iflist = bp->bif_next;
984263bc 1498
efda3bd0 1499 kfree(bp, M_BPF);
984263bc 1500
0b31d406 1501 crit_exit();
984263bc
MD
1502}
1503
1f8e62c9
JS
1504/*
1505 * Get a list of available data link type of the interface.
1506 */
1507static int
1508bpf_getdltlist(struct bpf_d *d, struct bpf_dltlist *bfl)
1509{
1510 int n, error;
1511 struct ifnet *ifp;
1512 struct bpf_if *bp;
1513
1514 ifp = d->bd_bif->bif_ifp;
1515 n = 0;
1516 error = 0;
67756095 1517 for (bp = bpf_iflist; bp != NULL; bp = bp->bif_next) {
1f8e62c9
JS
1518 if (bp->bif_ifp != ifp)
1519 continue;
1520 if (bfl->bfl_list != NULL) {
1521 if (n >= bfl->bfl_len) {
1522 return (ENOMEM);
1523 }
1524 error = copyout(&bp->bif_dlt,
1525 bfl->bfl_list + n, sizeof(u_int));
1526 }
1527 n++;
1528 }
1529 bfl->bfl_len = n;
1530 return(error);
1531}
1532
1533/*
1534 * Set the data link type of a BPF instance.
1535 */
1536static int
1537bpf_setdlt(struct bpf_d *d, u_int dlt)
1538{
1539 int error, opromisc;
1540 struct ifnet *ifp;
1541 struct bpf_if *bp;
1f8e62c9
JS
1542
1543 if (d->bd_bif->bif_dlt == dlt)
1544 return (0);
1545 ifp = d->bd_bif->bif_ifp;
67756095 1546 for (bp = bpf_iflist; bp != NULL; bp = bp->bif_next) {
1f8e62c9
JS
1547 if (bp->bif_ifp == ifp && bp->bif_dlt == dlt)
1548 break;
1549 }
1550 if (bp != NULL) {
1551 opromisc = d->bd_promisc;
0b31d406 1552 crit_enter();
1f8e62c9
JS
1553 bpf_detachd(d);
1554 bpf_attachd(d, bp);
cefd3279 1555 bpf_resetd(d);
1f8e62c9
JS
1556 if (opromisc) {
1557 error = ifpromisc(bp->bif_ifp, 1);
67756095 1558 if (error) {
1f8e62c9
JS
1559 if_printf(bp->bif_ifp,
1560 "bpf_setdlt: ifpromisc failed (%d)\n",
1561 error);
67756095 1562 } else {
1f8e62c9 1563 d->bd_promisc = 1;
67756095 1564 }
1f8e62c9 1565 }
0b31d406 1566 crit_exit();
1f8e62c9
JS
1567 }
1568 return(bp == NULL ? EINVAL : 0);
1569}
1570
984263bc 1571static void
e4c9c0c8 1572bpf_drvinit(void *unused)
984263bc 1573{
8be7edad
MD
1574 int i;
1575
b96f3782
AH
1576 make_autoclone_dev(&bpf_ops, &DEVFS_CLONE_BITMAP(bpf),
1577 bpfclone, 0, 0, 0600, "bpf");
8be7edad
MD
1578 for (i = 0; i < BPF_PREALLOCATED_UNITS; i++) {
1579 make_dev(&bpf_ops, i, 0, 0, 0600, "bpf%d", i);
1580 devfs_clone_bitmap_set(&DEVFS_CLONE_BITMAP(bpf), i);
1581 }
cd29885a
MD
1582}
1583
1584static void
1585bpf_drvuninit(void *unused)
1586{
8be7edad 1587 devfs_clone_handler_del("bpf");
cd29885a
MD
1588 dev_ops_remove_all(&bpf_ops);
1589 devfs_clone_bitmap_uninit(&DEVFS_CLONE_BITMAP(bpf));
984263bc
MD
1590}
1591
1592SYSINIT(bpfdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,bpf_drvinit,NULL)
cd29885a 1593SYSUNINIT(bpfdev, SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,bpf_drvuninit, NULL);
984263bc
MD
1594
1595#else /* !BPF */
1596/*
1597 * NOP stubs to allow bpf-using drivers to load and function.
1598 *
1599 * A 'better' implementation would allow the core bpf functionality
1600 * to be loaded at runtime.
1601 */
1602
1603void
1f8e62c9
JS
1604bpf_tap(struct bpf_if *bp, u_char *pkt, u_int pktlen)
1605{
1606}
1607
1608void
1609bpf_mtap(struct bpf_if *bp, struct mbuf *m)
984263bc
MD
1610{
1611}
1612
1613void
f1555601 1614bpf_ptap(struct bpf_if *bp, struct mbuf *m, const void *data, u_int dlen)
984263bc
MD
1615{
1616}
1617
1618void
5534e0c8 1619bpfattach(struct ifnet *ifp, u_int dlt, u_int hdrlen)
984263bc
MD
1620{
1621}
1622
1f8e62c9
JS
1623void
1624bpfattach_dlt(struct ifnet *ifp, u_int dlt, u_int hdrlen, struct bpf_if **driverp)
1625{
1626}
1627
984263bc 1628void
5534e0c8 1629bpfdetach(struct ifnet *ifp)
984263bc
MD
1630{
1631}
1632
1633u_int
5534e0c8 1634bpf_filter(const struct bpf_insn *pc, u_char *p, u_int wirelen, u_int buflen)
984263bc
MD
1635{
1636 return -1; /* "no filter" behaviour */
1637}
1638
1639#endif /* !BPF */