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