2 * Copyright (c) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997
3 * The Regents of the University of California. All rights reserved.
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
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
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.
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
38 * @(#)bpf.c 7.5 (Berkeley) 7/15/91
45 #include <pcap/pcap-inttypes.h>
46 #include "pcap-types.h"
48 #include "diag-control.h"
50 #define EXTRACT_SHORT EXTRACT_BE_U_2
51 #define EXTRACT_LONG EXTRACT_BE_U_4
54 #include <sys/param.h>
55 #include <sys/types.h>
64 #include <linux/types.h>
65 #include <linux/if_packet.h>
66 #include <linux/filter.h>
72 BPF_S_ANC_VLAN_TAG_PRESENT,
76 * Execute the filter program starting at pc on the packet p
77 * wirelen is the length of the original packet
78 * buflen is the amount of data present
79 * aux_data is auxiliary data, currently used only when interpreting
80 * filters intended for the Linux kernel in cases where the kernel
81 * rejects the filter; it contains VLAN tag information
82 * For the kernel, p is assumed to be a pointer to an mbuf if buflen is 0,
83 * in all other cases, p is a pointer to a buffer and buflen is its size.
85 * Thanks to Ani Sinha <ani@arista.com> for providing initial implementation
87 #if defined(SKF_AD_VLAN_TAG_PRESENT)
89 pcap_filter_with_aux_data(const struct bpf_insn *pc, const u_char *p,
90 u_int wirelen, u_int buflen, const struct pcap_bpf_aux_data *aux_data)
93 pcap_filter_with_aux_data(const struct bpf_insn *pc, const u_char *p,
94 u_int wirelen, u_int buflen, const struct pcap_bpf_aux_data *aux_data _U_)
97 register uint32_t A, X;
98 register bpf_u_int32 k;
99 uint32_t mem[BPF_MEMWORDS];
103 * No filter means accept all.
121 case BPF_LD|BPF_W|BPF_ABS:
123 if (k > buflen || sizeof(int32_t) > buflen - k) {
126 A = EXTRACT_LONG(&p[k]);
129 case BPF_LD|BPF_H|BPF_ABS:
131 if (k > buflen || sizeof(int16_t) > buflen - k) {
134 A = EXTRACT_SHORT(&p[k]);
137 case BPF_LD|BPF_B|BPF_ABS:
139 * Yes, we know, this switch doesn't do
140 * anything unless we're building for
141 * a Linux kernel with removed VLAN
142 * tags available as meta-data.
144 DIAG_OFF_DEFAULT_ONLY_SWITCH
147 #if defined(SKF_AD_VLAN_TAG_PRESENT)
148 case SKF_AD_OFF + SKF_AD_VLAN_TAG:
151 A = aux_data->vlan_tag;
154 case SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT:
157 A = aux_data->vlan_tag_present;
168 DIAG_ON_DEFAULT_ONLY_SWITCH
171 case BPF_LD|BPF_W|BPF_LEN:
175 case BPF_LDX|BPF_W|BPF_LEN:
179 case BPF_LD|BPF_W|BPF_IND:
181 if (pc->k > buflen || X > buflen - pc->k ||
182 sizeof(int32_t) > buflen - k) {
185 A = EXTRACT_LONG(&p[k]);
188 case BPF_LD|BPF_H|BPF_IND:
190 if (X > buflen || pc->k > buflen - X ||
191 sizeof(int16_t) > buflen - k) {
194 A = EXTRACT_SHORT(&p[k]);
197 case BPF_LD|BPF_B|BPF_IND:
199 if (pc->k >= buflen || X >= buflen - pc->k) {
205 case BPF_LDX|BPF_MSH|BPF_B:
210 X = (p[pc->k] & 0xf) << 2;
217 case BPF_LDX|BPF_IMM:
225 case BPF_LDX|BPF_MEM:
239 * XXX - we currently implement "ip6 protochain"
240 * with backward jumps, so sign-extend pc->k.
242 pc += (bpf_int32)pc->k;
245 case BPF_JMP|BPF_JGT|BPF_K:
246 pc += (A > pc->k) ? pc->jt : pc->jf;
249 case BPF_JMP|BPF_JGE|BPF_K:
250 pc += (A >= pc->k) ? pc->jt : pc->jf;
253 case BPF_JMP|BPF_JEQ|BPF_K:
254 pc += (A == pc->k) ? pc->jt : pc->jf;
257 case BPF_JMP|BPF_JSET|BPF_K:
258 pc += (A & pc->k) ? pc->jt : pc->jf;
261 case BPF_JMP|BPF_JGT|BPF_X:
262 pc += (A > X) ? pc->jt : pc->jf;
265 case BPF_JMP|BPF_JGE|BPF_X:
266 pc += (A >= X) ? pc->jt : pc->jf;
269 case BPF_JMP|BPF_JEQ|BPF_X:
270 pc += (A == X) ? pc->jt : pc->jf;
273 case BPF_JMP|BPF_JSET|BPF_X:
274 pc += (A & X) ? pc->jt : pc->jf;
277 case BPF_ALU|BPF_ADD|BPF_X:
281 case BPF_ALU|BPF_SUB|BPF_X:
285 case BPF_ALU|BPF_MUL|BPF_X:
289 case BPF_ALU|BPF_DIV|BPF_X:
295 case BPF_ALU|BPF_MOD|BPF_X:
301 case BPF_ALU|BPF_AND|BPF_X:
305 case BPF_ALU|BPF_OR|BPF_X:
309 case BPF_ALU|BPF_XOR|BPF_X:
313 case BPF_ALU|BPF_LSH|BPF_X:
320 case BPF_ALU|BPF_RSH|BPF_X:
327 case BPF_ALU|BPF_ADD|BPF_K:
331 case BPF_ALU|BPF_SUB|BPF_K:
335 case BPF_ALU|BPF_MUL|BPF_K:
339 case BPF_ALU|BPF_DIV|BPF_K:
343 case BPF_ALU|BPF_MOD|BPF_K:
347 case BPF_ALU|BPF_AND|BPF_K:
351 case BPF_ALU|BPF_OR|BPF_K:
355 case BPF_ALU|BPF_XOR|BPF_K:
359 case BPF_ALU|BPF_LSH|BPF_K:
363 case BPF_ALU|BPF_RSH|BPF_K:
367 case BPF_ALU|BPF_NEG:
369 * Most BPF arithmetic is unsigned, but negation
370 * can't be unsigned; respecify it as subtracting
371 * the accumulator from 0U, so that 1) we don't
372 * get compiler warnings about negating an unsigned
373 * value and 2) don't get UBSan warnings about
374 * the result of negating 0x80000000 being undefined.
379 case BPF_MISC|BPF_TAX:
383 case BPF_MISC|BPF_TXA:
391 pcap_filter(const struct bpf_insn *pc, const u_char *p, u_int wirelen,
394 return pcap_filter_with_aux_data(pc, p, wirelen, buflen, NULL);
398 * Return true if the 'fcode' is a valid filter program.
399 * The constraints are that each jump be forward and to a valid
400 * code, that memory accesses are within valid ranges (to the
401 * extent that this can be checked statically; loads of packet
402 * data have to be, and are, also checked at run time), and that
403 * the code terminates with either an accept or reject.
405 * The kernel needs to be able to verify an application's filter code.
406 * Otherwise, a bogus program could easily crash the system.
409 pcap_validate_filter(const struct bpf_insn *f, int len)
412 const struct bpf_insn *p;
417 for (i = 0; i < (u_int)len; ++i) {
419 switch (BPF_CLASS(p->code)) {
421 * Check that memory operations use valid addresses.
425 switch (BPF_MODE(p->code)) {
432 * There's no maximum packet data size
433 * in userland. The runtime packet length
438 if (p->k >= BPF_MEMWORDS)
449 if (p->k >= BPF_MEMWORDS)
453 switch (BPF_OP(p->code)) {
467 * Check for constant division or modulus
470 if (BPF_SRC(p->code) == BPF_K && p->k == 0)
479 * Check that jumps are within the code block,
480 * and that unconditional branches don't go
481 * backwards as a result of an overflow.
482 * Unconditional branches have a 32-bit offset,
483 * so they could overflow; we check to make
484 * sure they don't. Conditional branches have
485 * an 8-bit offset, and the from address is <=
486 * BPF_MAXINSNS, and we assume that BPF_MAXINSNS
487 * is sufficiently small that adding 255 to it
490 * We know that len is <= BPF_MAXINSNS, and we
491 * assume that BPF_MAXINSNS is < the maximum size
492 * of a u_int, so that i + 1 doesn't overflow.
494 * For userland, we don't know that the from
495 * or len are <= BPF_MAXINSNS, but we know that
496 * from <= len, and, except on a 64-bit system,
497 * it's unlikely that len, if it truly reflects
498 * the size of the program we've been handed,
499 * will be anywhere near the maximum size of
500 * a u_int. We also don't check for backward
501 * branches, as we currently support them in
502 * userland for the protochain operation.
505 switch (BPF_OP(p->code)) {
507 if (from + p->k >= (u_int)len)
514 if (from + p->jt >= (u_int)len || from + p->jf >= (u_int)len)
529 return BPF_CLASS(f[len - 1].code) == BPF_RET;
533 * Exported because older versions of libpcap exported them.
536 bpf_filter(const struct bpf_insn *pc, const u_char *p, u_int wirelen,
539 return pcap_filter(pc, p, wirelen, buflen);
543 bpf_validate(const struct bpf_insn *f, int len)
545 return pcap_validate_filter(f, len);