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