diff options
76 files changed, 2739 insertions, 0 deletions
diff --git a/tools/regression/bpf/Makefile b/tools/regression/bpf/Makefile new file mode 100644 index 000000000000..8fac0b461be7 --- /dev/null +++ b/tools/regression/bpf/Makefile @@ -0,0 +1,5 @@ +# $FreeBSD$ + +SUBDIR= bpf_filter + +.include <bsd.subdir.mk> diff --git a/tools/regression/bpf/bpf_filter/Makefile b/tools/regression/bpf/bpf_filter/Makefile new file mode 100644 index 000000000000..6c668d5c49a0 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/Makefile @@ -0,0 +1,65 @@ +# $FreeBSD$ + +TEST_CASES= test0001 test0002 test0003 test0004 \ + test0005 test0006 test0007 test0008 \ + test0009 test0010 test0011 test0012 \ + test0013 test0014 test0015 test0016 \ + test0017 test0018 test0019 test0020 \ + test0021 test0022 test0023 test0024 \ + test0025 test0026 test0027 test0028 \ + test0029 test0030 test0031 test0032 \ + test0033 test0034 test0035 test0036 \ + test0037 test0038 test0039 test0040 \ + test0041 test0042 test0043 test0044 \ + test0045 test0046 test0047 test0048 \ + test0049 test0050 test0051 test0052 \ + test0053 test0054 test0055 test0056 \ + test0057 test0058 test0059 test0060 \ + test0061 test0062 test0063 test0064 \ + test0065 test0066 test0067 test0068 \ + test0069 test0070 test0071 test0072 \ + test0073 + +SYSDIR?= ${.CURDIR}/../../../../sys + +SRCS= ${.CURDIR}/bpf_test.c + +CFLAGS+= -g -fno-builtin-abort -I${.CURDIR}/tests + +.if defined(LOG_LEVEL) +CFLAGS+= -DLOG_LEVEL="${LOG_LEVEL}" +.endif + +.if defined(BPF_VALIDATE) +CFLAGS+= -DBPF_VALIDATE +.endif + +.if (${MACHINE_ARCH} == "amd64" || ${MACHINE_ARCH} == "i386") && defined(BPF_JIT) +SRCS+= ${SYSDIR}/${MACHINE_ARCH}/${MACHINE_ARCH}/bpf_jit_machdep.c +CFLAGS+= -I${SYSDIR} -DBPF_JIT_COMPILER +WARNS?= 6 +.else +SRCS+= ${SYSDIR}/net/bpf_filter.c +WARNS?= 1 +.endif + +.for TEST in ${TEST_CASES} +${TEST}: ${.CURDIR}/tests/${TEST}.h ${SRCS} + @${CC} ${CFLAGS} -DBPF_TEST_H=\"${TEST}.h\" -o ${.CURDIR}/${TEST} ${SRCS} +.endfor + +all: ${TEST_CASES} +.for TEST in ${TEST_CASES} +.if !defined(LOG_LEVEL) || (${LOG_LEVEL} > 0) + @${ECHO} -n "${TEST}: " +.endif + @-${.CURDIR}/${TEST} + @rm -f ${.CURDIR}/${TEST} +.endfor + +clean: +.for TEST in ${TEST_CASES} + @rm -f ${.CURDIR}/${TEST} +.endfor + +.include <bsd.prog.mk> diff --git a/tools/regression/bpf/bpf_filter/bpf_test.c b/tools/regression/bpf/bpf_filter/bpf_test.c new file mode 100644 index 000000000000..441272839003 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/bpf_test.c @@ -0,0 +1,238 @@ +/*- + * Copyright (C) 2008 Jung-uk Kim <jkim@FreeBSD.org>. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include <sys/cdefs.h> +__FBSDID("$FreeBSD$"); + +#include <signal.h> +#include <stdio.h> +#include <stdlib.h> + +#include <sys/types.h> + +#include <net/bpf.h> + +#include BPF_TEST_H + +#define PASSED 0 +#define FAILED 1 +#define FATAL -1 + +#ifndef LOG_LEVEL +#define LOG_LEVEL 1 +#endif + +static void sig_handler(int); + +static int nins = sizeof(pc) / sizeof(pc[0]); +static int verbose = LOG_LEVEL; + +#ifdef BPF_JIT_COMPILER + +#include <string.h> + +#include <net/bpf_jitter.h> + +bpf_filter_func bpf_jit_compile(struct bpf_insn *, u_int, int *); + +static u_int +bpf_compile_and_filter(void) +{ + bpf_jit_filter filter; + u_int ret; + + /* Do not use BPF JIT compiler for an empty program */ + if (nins == 0) + return (0); + + /* Allocate the filter's memory */ + if ((filter.mem = (int *)malloc(BPF_MEMWORDS * sizeof(int))) == NULL) + goto fail; + + /* Create the binary */ + if ((filter.func = bpf_jit_compile(pc, nins, filter.mem)) == NULL) + goto fail; + + ret = (*(filter.func))(pkt, wirelen, buflen); + + free(filter.mem); + free(filter.func); + + return (ret); + +fail: + if (filter.mem != NULL) + free(filter.mem); + + if (verbose > 1) + printf("Failed to allocate memory:\t"); + if (verbose > 0) + printf("FATAL\n"); + exit(FATAL); +} + +#else + +u_int bpf_filter(struct bpf_insn *, u_char *, u_int, u_int); + +#endif + +#ifdef BPF_VALIDATE +/* + * XXX Copied from sys/net/bpf_filter.c and modified. + * + * Return true if the 'fcode' is a valid filter program. + * The constraints are that each jump be forward and to a valid + * code. The code must terminate with either an accept or reject. + * + * The kernel needs to be able to verify an application's filter code. + * Otherwise, a bogus program could easily crash the system. + */ +static int +bpf_validate(const struct bpf_insn *f, int len) +{ + register int i; + register const struct bpf_insn *p; + + /* Do not accept negative length filter. */ + if (len < 0) + return (0); + + /* An empty filter means accept all. */ + if (len == 0) + return (1); + + for (i = 0; i < len; ++i) { + /* + * Check that that jumps are forward, and within + * the code block. + */ + p = &f[i]; + if (BPF_CLASS(p->code) == BPF_JMP) { + register int from = i + 1; + + if (BPF_OP(p->code) == BPF_JA) { + if (from >= len || p->k >= (u_int)len - from) + return (0); + } + else if (from >= len || p->jt >= len - from || + p->jf >= len - from) + return (0); + } + /* + * Check that memory operations use valid addresses. + */ + if ((BPF_CLASS(p->code) == BPF_ST || + (BPF_CLASS(p->code) == BPF_LD && + (p->code & 0xe0) == BPF_MEM)) && + p->k >= BPF_MEMWORDS) + return (0); + /* + * Check for constant division by 0. + */ + if (p->code == (BPF_ALU|BPF_DIV|BPF_K) && p->k == 0) + return (0); + } + return (BPF_CLASS(f[len - 1].code) == BPF_RET); +} +#endif + +int +main(void) +{ + u_int ret; + int sig; +#ifdef BPF_VALIDATE + int valid; +#endif + + /* Try to catch all signals */ + for (sig = SIGHUP; sig <= SIGUSR2; sig++) + signal(sig, sig_handler); + +#ifdef BPF_VALIDATE + valid = bpf_validate(pc, nins); + if (valid != 0 && invalid != 0) { + if (verbose > 1) + printf("Validated invalid instructions:\t"); + if (verbose > 0) + printf("FAILED\n"); + return (FAILED); + } else if (valid == 0 && invalid == 0) { + if (verbose > 1) + printf("Invalidated valid instructions:\t"); + if (verbose > 0) + printf("FAILED\n"); + return (FAILED); + } +#endif + +#ifdef BPF_JIT_COMPILER + ret = bpf_compile_and_filter(); +#else + ret = bpf_filter(pc, pkt, wirelen, buflen); +#endif + if (ret != expect) { + if (verbose > 1) + printf("Expected 0x%x but got 0x%x:\t", expect, ret); + if (verbose > 0) + printf("FAILED\n"); + return (FAILED); + } + if (verbose > 1) + printf("Expected and got 0x%x:\t", ret); + if (verbose > 0) + printf("PASSED\n"); + + return (PASSED); +} + +static void +sig_handler(int sig) +{ + + if (expect_signal == 0) { + if (verbose > 1) + printf("Received unexpected signal %d:\t", sig); + if (verbose > 0) + printf("FATAL\n"); + exit(FATAL); + } + if (expect_signal != sig) { + if (verbose > 1) + printf("Expected signal %d but got %d:\t", + expect_signal, sig); + if (verbose > 0) + printf("FAILED\n"); + exit(FAILED); + } + + if (verbose > 1) + printf("Expected and got signal %d:\t", sig); + if (verbose > 0) + printf("PASSED\n"); + + exit(PASSED); +} diff --git a/tools/regression/bpf/bpf_filter/tests/test0001.h b/tools/regression/bpf/bpf_filter/tests/test0001.h new file mode 100644 index 000000000000..57c9a95703ad --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0001.h @@ -0,0 +1,30 @@ +/*- + * Test 0001: Catch illegal instruction. + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(0xdead, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 1; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = SIGABRT; diff --git a/tools/regression/bpf/bpf_filter/tests/test0002.h b/tools/regression/bpf/bpf_filter/tests/test0002.h new file mode 100644 index 000000000000..af66976fb240 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0002.h @@ -0,0 +1,30 @@ +/*- + * Test 0002: BPF_RET+BPF_K + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_RET+BPF_K, 0xdeadc0de), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xdeadc0de; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0003.h b/tools/regression/bpf/bpf_filter/tests/test0003.h new file mode 100644 index 000000000000..9089f0511fd5 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0003.h @@ -0,0 +1,31 @@ +/*- + * Test 0003: BPF_LD+BPF_IMM & BPF_RET+BPF_A + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD+BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xdeadc0de; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0004.h b/tools/regression/bpf/bpf_filter/tests/test0004.h new file mode 100644 index 000000000000..78866cedf439 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0004.h @@ -0,0 +1,31 @@ +/*- + * Test 0004: BPF_LD|BPF_W|BPF_ABS + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_W|BPF_ABS, 1), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, 0x67, 0x89, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0x23456789; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0005.h b/tools/regression/bpf/bpf_filter/tests/test0005.h new file mode 100644 index 000000000000..ec9b0fdc1f3e --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0005.h @@ -0,0 +1,31 @@ +/*- + * Test 0005: BPF_LD|BPF_H|BPF_ABS + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_H|BPF_ABS, 1), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0x2345; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0006.h b/tools/regression/bpf/bpf_filter/tests/test0006.h new file mode 100644 index 000000000000..2d0a0b65dc3f --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0006.h @@ -0,0 +1,31 @@ +/*- + * Test 0006: BPF_LD|BPF_B|BPF_ABS + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_B|BPF_ABS, 1), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0x23; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0007.h b/tools/regression/bpf/bpf_filter/tests/test0007.h new file mode 100644 index 000000000000..c2534806ad8a --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0007.h @@ -0,0 +1,29 @@ +/*- + * Test 0007: BPF_LD|BPF_W|BPF_LEN + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_W|BPF_LEN, 0), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[0xdeadc0de]; + +/* Packet length seen on wire */ +u_int wirelen = 0xdeadc0de; + +/* Packet length passed on buffer */ +u_int buflen = 0xdeadc0de; + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xdeadc0de; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0008.h b/tools/regression/bpf/bpf_filter/tests/test0008.h new file mode 100644 index 000000000000..432eaaa69ea8 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0008.h @@ -0,0 +1,30 @@ +/*- + * Test 0008: BPF_LDX|BPF_W|BPF_LEN & BPF_MISC|BPF_TXA + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LDX|BPF_W|BPF_LEN, 0), + BPF_STMT(BPF_MISC|BPF_TXA, 0), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[0xdeadc0de]; + +/* Packet length seen on wire */ +u_int wirelen = 0xdeadc0de; + +/* Packet length passed on buffer */ +u_int buflen = 0xdeadc0de; + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xdeadc0de; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0009.h b/tools/regression/bpf/bpf_filter/tests/test0009.h new file mode 100644 index 000000000000..17c8089ad7c4 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0009.h @@ -0,0 +1,32 @@ +/*- + * Test 0009: BPF_LDX|BPF_IMM & BPF_LD|BPF_W|BPF_IND + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LDX|BPF_IMM, 1), + BPF_STMT(BPF_LD|BPF_W|BPF_IND, 1), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0x456789ab; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0010.h b/tools/regression/bpf/bpf_filter/tests/test0010.h new file mode 100644 index 000000000000..cc5abb81f3b1 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0010.h @@ -0,0 +1,32 @@ +/*- + * Test 0010: BPF_LD|BPF_H|BPF_IND + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LDX|BPF_IMM, 1), + BPF_STMT(BPF_LD|BPF_H|BPF_IND, 1), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, 0x67, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0x4567; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0011.h b/tools/regression/bpf/bpf_filter/tests/test0011.h new file mode 100644 index 000000000000..9cfd2c5af9e4 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0011.h @@ -0,0 +1,32 @@ +/*- + * Test 0011: BPF_LD|BPF_B|BPF_IND + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LDX|BPF_IMM, 1), + BPF_STMT(BPF_LD|BPF_B|BPF_IND, 1), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0x45; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0012.h b/tools/regression/bpf/bpf_filter/tests/test0012.h new file mode 100644 index 000000000000..b388a062f13b --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0012.h @@ -0,0 +1,32 @@ +/*- + * Test 0012: BPF_LDX|BPF_MSH|BPF_B + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LDX|BPF_MSH|BPF_B, 1), + BPF_STMT(BPF_MISC|BPF_TXA, 0), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = (0x23 & 0xf) << 2; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0013.h b/tools/regression/bpf/bpf_filter/tests/test0013.h new file mode 100644 index 000000000000..2670fc2dee7c --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0013.h @@ -0,0 +1,34 @@ +/*- + * Test 0013: BPF_ST & BPF_LDX|BPF_MEM + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_ST, 7), + BPF_STMT(BPF_LDX|BPF_MEM, 7), + BPF_STMT(BPF_MISC|BPF_TXA, 0), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xdeadc0de; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0014.h b/tools/regression/bpf/bpf_filter/tests/test0014.h new file mode 100644 index 000000000000..43011097000f --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0014.h @@ -0,0 +1,33 @@ +/*- + * Test 0014: BPF_STX & BPF_LD|BPF_MEM + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LDX|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_STX, 7), + BPF_STMT(BPF_LD|BPF_MEM, 7), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xdeadc0de; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0015.h b/tools/regression/bpf/bpf_filter/tests/test0015.h new file mode 100644 index 000000000000..9a2aea34e1d0 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0015.h @@ -0,0 +1,33 @@ +/*- + * Test 0015: BPF_JMP|BPF_JA + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xc0decafe), + BPF_STMT(BPF_JMP|BPF_JA, 1), + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xc0decafe; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0016.h b/tools/regression/bpf/bpf_filter/tests/test0016.h new file mode 100644 index 000000000000..bd7cee3376d0 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0016.h @@ -0,0 +1,37 @@ +/*- + * Test 0016: BPF_JMP|BPF_JGT|BPF_K + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0x01234567), + BPF_JUMP(BPF_JMP|BPF_JGT|BPF_K, 0x01234568, 2, 0), + BPF_JUMP(BPF_JMP|BPF_JGT|BPF_K, 0x01234566, 2, 1), + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_RET+BPF_A, 0), + BPF_JUMP(BPF_JMP|BPF_JGT|BPF_K, 0x01234567, 1, 0), + BPF_STMT(BPF_LD|BPF_IMM, 0xc0decafe), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xc0decafe; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0017.h b/tools/regression/bpf/bpf_filter/tests/test0017.h new file mode 100644 index 000000000000..e286249aacc0 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0017.h @@ -0,0 +1,37 @@ +/*- + * Test 0017: BPF_JMP|BPF_JGE|BPF_K + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0x01234567), + BPF_JUMP(BPF_JMP|BPF_JGE|BPF_K, 0x01234568, 2, 0), + BPF_JUMP(BPF_JMP|BPF_JGE|BPF_K, 0x01234567, 2, 1), + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_RET+BPF_A, 0), + BPF_JUMP(BPF_JMP|BPF_JGE|BPF_K, 0x01234566, 0, 1), + BPF_STMT(BPF_LD|BPF_IMM, 0xc0decafe), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xc0decafe; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0018.h b/tools/regression/bpf/bpf_filter/tests/test0018.h new file mode 100644 index 000000000000..17c5ee8de177 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0018.h @@ -0,0 +1,37 @@ +/*- + * Test 0018: BPF_JMP|BPF_JEQ|BPF_K + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0x01234567), + BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, 0x01234568, 2, 0), + BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, 0x01234567, 2, 1), + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_RET+BPF_A, 0), + BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, 0x01234566, 1, 0), + BPF_STMT(BPF_LD|BPF_IMM, 0xc0decafe), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xc0decafe; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0019.h b/tools/regression/bpf/bpf_filter/tests/test0019.h new file mode 100644 index 000000000000..df7bccd81c3c --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0019.h @@ -0,0 +1,42 @@ +/*- + * Test 0019: BPF_JMP|BPF_JSET|BPF_K + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0x01234567), + BPF_JUMP(BPF_JMP|BPF_JSET|BPF_K, 0x80000000, 5, 0), + BPF_JUMP(BPF_JMP|BPF_JSET|BPF_K, 0x40000000, 4, 0), + BPF_JUMP(BPF_JMP|BPF_JSET|BPF_K, 0x20000000, 3, 0), + BPF_JUMP(BPF_JMP|BPF_JSET|BPF_K, 0x10000000, 2, 0), + BPF_JUMP(BPF_JMP|BPF_JSET|BPF_K, 0x1, 2, 1), + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_RET+BPF_A, 0), + BPF_JUMP(BPF_JMP|BPF_JSET|BPF_K, 0x08000000, 3, 0), + BPF_JUMP(BPF_JMP|BPF_JSET|BPF_K, 0x04000000, 2, 0), + BPF_JUMP(BPF_JMP|BPF_JSET|BPF_K, 0x02000000, 1, 0), + BPF_STMT(BPF_LD|BPF_IMM, 0xc0decafe), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xc0decafe; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0020.h b/tools/regression/bpf/bpf_filter/tests/test0020.h new file mode 100644 index 000000000000..5b58e70f316d --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0020.h @@ -0,0 +1,40 @@ +/*- + * Test 0020: BPF_JMP|BPF_JGT|BPF_X + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0x01234567), + BPF_STMT(BPF_LDX|BPF_IMM, 0x01234568), + BPF_JUMP(BPF_JMP|BPF_JGT|BPF_X, 0, 3, 0), + BPF_STMT(BPF_LDX|BPF_IMM, 0x01234566), + BPF_JUMP(BPF_JMP|BPF_JGT|BPF_X, 0, 2, 1), + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_RET+BPF_A, 0), + BPF_STMT(BPF_LDX|BPF_IMM, 0x01234567), + BPF_JUMP(BPF_JMP|BPF_JGT|BPF_X, 0, 1, 0), + BPF_STMT(BPF_LD|BPF_IMM, 0xc0decafe), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xc0decafe; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0021.h b/tools/regression/bpf/bpf_filter/tests/test0021.h new file mode 100644 index 000000000000..4979cf8f6d89 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0021.h @@ -0,0 +1,40 @@ +/*- + * Test 0021: BPF_JMP|BPF_JGE|BPF_X + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0x01234567), + BPF_STMT(BPF_LDX|BPF_IMM, 0x01234568), + BPF_JUMP(BPF_JMP|BPF_JGE|BPF_X, 0, 3, 0), + BPF_STMT(BPF_LDX|BPF_IMM, 0x01234567), + BPF_JUMP(BPF_JMP|BPF_JGE|BPF_X, 0, 2, 1), + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_RET+BPF_A, 0), + BPF_STMT(BPF_LDX|BPF_IMM, 0x01234566), + BPF_JUMP(BPF_JMP|BPF_JGE|BPF_X, 0, 0, 1), + BPF_STMT(BPF_LD|BPF_IMM, 0xc0decafe), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xc0decafe; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0022.h b/tools/regression/bpf/bpf_filter/tests/test0022.h new file mode 100644 index 000000000000..f6e41028d6a1 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0022.h @@ -0,0 +1,40 @@ +/*- + * Test 0022: BPF_JMP|BPF_JEQ|BPF_X + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0x01234567), + BPF_STMT(BPF_LDX|BPF_IMM, 0x01234568), + BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_X, 0, 3, 0), + BPF_STMT(BPF_LDX|BPF_IMM, 0x01234567), + BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_X, 0, 2, 1), + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_RET+BPF_A, 0), + BPF_STMT(BPF_LDX|BPF_IMM, 0x01234566), + BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_X, 0, 1, 0), + BPF_STMT(BPF_LD|BPF_IMM, 0xc0decafe), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xc0decafe; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0023.h b/tools/regression/bpf/bpf_filter/tests/test0023.h new file mode 100644 index 000000000000..6b5dc01b45a7 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0023.h @@ -0,0 +1,50 @@ +/*- + * Test 0023: BPF_JMP|BPF_JSET|BPF_X + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0x01234567), + BPF_STMT(BPF_LDX|BPF_IMM, 0x80000000), + BPF_JUMP(BPF_JMP|BPF_JSET|BPF_X, 0, 9, 0), + BPF_STMT(BPF_LDX|BPF_IMM, 0x40000000), + BPF_JUMP(BPF_JMP|BPF_JSET|BPF_X, 0, 7, 0), + BPF_STMT(BPF_LDX|BPF_IMM, 0x20000000), + BPF_JUMP(BPF_JMP|BPF_JSET|BPF_X, 0, 5, 0), + BPF_STMT(BPF_LDX|BPF_IMM, 0x10000000), + BPF_JUMP(BPF_JMP|BPF_JSET|BPF_X, 0, 3, 0), + BPF_STMT(BPF_LDX|BPF_IMM, 0x1), + BPF_JUMP(BPF_JMP|BPF_JSET|BPF_X, 0x1, 2, 1), + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_RET+BPF_A, 0), + BPF_STMT(BPF_LDX|BPF_IMM, 0x08000000), + BPF_JUMP(BPF_JMP|BPF_JSET|BPF_X, 0, 5, 0), + BPF_STMT(BPF_LDX|BPF_IMM, 0x04000000), + BPF_JUMP(BPF_JMP|BPF_JSET|BPF_X, 0, 3, 0), + BPF_STMT(BPF_LDX|BPF_IMM, 0x02000000), + BPF_JUMP(BPF_JMP|BPF_JSET|BPF_X, 0, 1, 0), + BPF_STMT(BPF_LD|BPF_IMM, 0xc0decafe), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xc0decafe; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0024.h b/tools/regression/bpf/bpf_filter/tests/test0024.h new file mode 100644 index 000000000000..7c4347f9fcb4 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0024.h @@ -0,0 +1,33 @@ +/*- + * Test 0024: BPF_ALU|BPF_ADD|BPF_X + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xbeadb8dd), + BPF_STMT(BPF_LDX|BPF_IMM, 0x20000801), + BPF_STMT(BPF_ALU|BPF_ADD|BPF_X, 0), + BPF_STMT(BPF_RET|BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xdeadc0de; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0025.h b/tools/regression/bpf/bpf_filter/tests/test0025.h new file mode 100644 index 000000000000..16800f391a83 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0025.h @@ -0,0 +1,33 @@ +/*- + * Test 0025: BPF_ALU|BPF_SUB|BPF_X + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 0x20000801), + BPF_STMT(BPF_ALU|BPF_SUB|BPF_X, 0), + BPF_STMT(BPF_RET|BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xbeadb8dd; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0026.h b/tools/regression/bpf/bpf_filter/tests/test0026.h new file mode 100644 index 000000000000..9ef1bc1cf125 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0026.h @@ -0,0 +1,33 @@ +/*- + * Test 0026: BPF_ALU|BPF_MUL|BPF_X + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdead), + BPF_STMT(BPF_LDX|BPF_IMM, 0xc0de), + BPF_STMT(BPF_ALU|BPF_MUL|BPF_X, 0), + BPF_STMT(BPF_RET|BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xa7c2da06; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0027.h b/tools/regression/bpf/bpf_filter/tests/test0027.h new file mode 100644 index 000000000000..8417e1a7a23c --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0027.h @@ -0,0 +1,33 @@ +/*- + * Test 0027: BPF_ALU|BPF_DIV|BPF_X + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xa7c2da06), + BPF_STMT(BPF_LDX|BPF_IMM, 0xdead), + BPF_STMT(BPF_ALU|BPF_DIV|BPF_X, 0), + BPF_STMT(BPF_RET|BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xc0de; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0028.h b/tools/regression/bpf/bpf_filter/tests/test0028.h new file mode 100644 index 000000000000..7bcc455c3222 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0028.h @@ -0,0 +1,33 @@ +/*- + * Test 0028: BPF_ALU|BPF_AND|BPF_X + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 0xc0decafe), + BPF_STMT(BPF_ALU|BPF_AND|BPF_X, 0), + BPF_STMT(BPF_RET|BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xc08cc0de; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0029.h b/tools/regression/bpf/bpf_filter/tests/test0029.h new file mode 100644 index 000000000000..6ac2b678d122 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0029.h @@ -0,0 +1,33 @@ +/*- + * Test 0029: BPF_ALU|BPF_OR|BPF_X + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 0xc0decafe), + BPF_STMT(BPF_ALU|BPF_OR|BPF_X, 0), + BPF_STMT(BPF_RET|BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xdeffcafe; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0030.h b/tools/regression/bpf/bpf_filter/tests/test0030.h new file mode 100644 index 000000000000..b2eb60cabb0f --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0030.h @@ -0,0 +1,33 @@ +/*- + * Test 0030: BPF_ALU|BPF_LSH|BPF_X + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdefc0), + BPF_STMT(BPF_LDX|BPF_IMM, 9), + BPF_STMT(BPF_ALU|BPF_LSH|BPF_X, 0), + BPF_STMT(BPF_RET|BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0x1bdf8000; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0031.h b/tools/regression/bpf/bpf_filter/tests/test0031.h new file mode 100644 index 000000000000..5db96bec7d72 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0031.h @@ -0,0 +1,33 @@ +/*- + * Test 0031: BPF_ALU|BPF_RSH|BPF_X + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 13), + BPF_STMT(BPF_ALU|BPF_RSH|BPF_X, 0), + BPF_STMT(BPF_RET|BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0x6f56e; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0032.h b/tools/regression/bpf/bpf_filter/tests/test0032.h new file mode 100644 index 000000000000..05fb432e23e5 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0032.h @@ -0,0 +1,32 @@ +/*- + * Test 0032: BPF_ALU|BPF_ADD|BPF_K + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xbeadb8dd), + BPF_STMT(BPF_ALU|BPF_ADD|BPF_K, 0x20000801), + BPF_STMT(BPF_RET|BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xdeadc0de; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0033.h b/tools/regression/bpf/bpf_filter/tests/test0033.h new file mode 100644 index 000000000000..79ddafcbeb08 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0033.h @@ -0,0 +1,32 @@ +/*- + * Test 0033: BPF_ALU|BPF_SUB|BPF_K + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_ALU|BPF_SUB|BPF_K, 0x20000801), + BPF_STMT(BPF_RET|BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xbeadb8dd; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0034.h b/tools/regression/bpf/bpf_filter/tests/test0034.h new file mode 100644 index 000000000000..5c09da1dae39 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0034.h @@ -0,0 +1,32 @@ +/*- + * Test 0034: BPF_ALU|BPF_MUL|BPF_K + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdead), + BPF_STMT(BPF_ALU|BPF_MUL|BPF_K, 0xc0de), + BPF_STMT(BPF_RET|BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xa7c2da06; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0035.h b/tools/regression/bpf/bpf_filter/tests/test0035.h new file mode 100644 index 000000000000..1283a88c9f33 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0035.h @@ -0,0 +1,32 @@ +/*- + * Test 0035: BPF_ALU|BPF_DIV|BPF_K + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xa7c2da06), + BPF_STMT(BPF_ALU|BPF_DIV|BPF_K, 0xdead), + BPF_STMT(BPF_RET|BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xc0de; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0036.h b/tools/regression/bpf/bpf_filter/tests/test0036.h new file mode 100644 index 000000000000..8506b90476b2 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0036.h @@ -0,0 +1,32 @@ +/*- + * Test 0036: BPF_ALU|BPF_AND|BPF_K + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_ALU|BPF_AND|BPF_K, 0xc0decafe), + BPF_STMT(BPF_RET|BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xc08cc0de; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0037.h b/tools/regression/bpf/bpf_filter/tests/test0037.h new file mode 100644 index 000000000000..f231debfd015 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0037.h @@ -0,0 +1,32 @@ +/*- + * Test 0037: BPF_ALU|BPF_OR|BPF_K + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_ALU|BPF_OR|BPF_K, 0xc0decafe), + BPF_STMT(BPF_RET|BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xdeffcafe; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0038.h b/tools/regression/bpf/bpf_filter/tests/test0038.h new file mode 100644 index 000000000000..1c9b7641c2ef --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0038.h @@ -0,0 +1,32 @@ +/*- + * Test 0038: BPF_ALU|BPF_LSH|BPF_K + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdefc0), + BPF_STMT(BPF_ALU|BPF_LSH|BPF_K, 9), + BPF_STMT(BPF_RET|BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0x1bdf8000; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0039.h b/tools/regression/bpf/bpf_filter/tests/test0039.h new file mode 100644 index 000000000000..848c0cdb2db1 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0039.h @@ -0,0 +1,32 @@ +/*- + * Test 0039: BPF_ALU|BPF_RSH|BPF_K + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_ALU|BPF_RSH|BPF_K, 13), + BPF_STMT(BPF_RET|BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0x6f56e; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0040.h b/tools/regression/bpf/bpf_filter/tests/test0040.h new file mode 100644 index 000000000000..c08fe9127b8c --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0040.h @@ -0,0 +1,32 @@ +/*- + * Test 0040: BPF_ALU|BPF_NEG + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0x21523f22), + BPF_STMT(BPF_ALU|BPF_NEG, 0), + BPF_STMT(BPF_RET|BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xdeadc0de; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0041.h b/tools/regression/bpf/bpf_filter/tests/test0041.h new file mode 100644 index 000000000000..5480bdaae9a6 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0041.h @@ -0,0 +1,34 @@ +/*- + * Test 0041: BPF_MISC|BPF_TAX + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_MISC|BPF_TAX, 0), + BPF_STMT(BPF_STX, 0), + BPF_STMT(BPF_LD|BPF_MEM, 0), + BPF_STMT(BPF_RET|BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x00, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0xdeadc0de; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0042.h b/tools/regression/bpf/bpf_filter/tests/test0042.h new file mode 100644 index 000000000000..bf9cf5b62b7e --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0042.h @@ -0,0 +1,32 @@ +/*- + * Test 0042: Check boundary conditions (BPF_LD|BPF_W|BPF_ABS) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LD|BPF_W|BPF_ABS, 2), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, 0x67, 0x89, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0043.h b/tools/regression/bpf/bpf_filter/tests/test0043.h new file mode 100644 index 000000000000..2e06829ecbc0 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0043.h @@ -0,0 +1,32 @@ +/*- + * Test 0043: Check boundary conditions (BPF_LD|BPF_H|BPF_ABS) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LD|BPF_H|BPF_ABS, 2), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0044.h b/tools/regression/bpf/bpf_filter/tests/test0044.h new file mode 100644 index 000000000000..ae6e8ee5a0ed --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0044.h @@ -0,0 +1,32 @@ +/*- + * Test 0044: Check boundary conditions (BPF_LD|BPF_B|BPF_ABS) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LD|BPF_B|BPF_ABS, 2), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0045.h b/tools/regression/bpf/bpf_filter/tests/test0045.h new file mode 100644 index 000000000000..329357fdeb73 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0045.h @@ -0,0 +1,33 @@ +/*- + * Test 0045: Check boundary conditions (BPF_LD|BPF_W|BPF_IND) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 1), + BPF_STMT(BPF_LD|BPF_W|BPF_IND, 2), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0046.h b/tools/regression/bpf/bpf_filter/tests/test0046.h new file mode 100644 index 000000000000..0c9d72efe621 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0046.h @@ -0,0 +1,33 @@ +/*- + * Test 0046: Check boundary conditions (BPF_LD|BPF_H|BPF_IND) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 1), + BPF_STMT(BPF_LD|BPF_H|BPF_IND, 2), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, 0x67, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0047.h b/tools/regression/bpf/bpf_filter/tests/test0047.h new file mode 100644 index 000000000000..2561c650479e --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0047.h @@ -0,0 +1,33 @@ +/*- + * Test 0047: Check boundary conditions (BPF_LD|BPF_B|BPF_IND) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 1), + BPF_STMT(BPF_LD|BPF_B|BPF_IND, 2), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0048.h b/tools/regression/bpf/bpf_filter/tests/test0048.h new file mode 100644 index 000000000000..a9330784d4c5 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0048.h @@ -0,0 +1,33 @@ +/*- + * Test 0048: Check boundary conditions (BPF_LDX|BPF_MSH|BPF_B) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_MSH|BPF_B, 2), + BPF_STMT(BPF_MISC|BPF_TXA, 0), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0049.h b/tools/regression/bpf/bpf_filter/tests/test0049.h new file mode 100644 index 000000000000..47ca7713e7b1 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0049.h @@ -0,0 +1,32 @@ +/*- + * Test 0049: Check boundary conditions (BPF_LD|BPF_W|BPF_ABS) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LD|BPF_W|BPF_ABS, 6), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, 0x67, 0x89, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0050.h b/tools/regression/bpf/bpf_filter/tests/test0050.h new file mode 100644 index 000000000000..4f560c9f70de --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0050.h @@ -0,0 +1,32 @@ +/*- + * Test 0050: Check boundary conditions (BPF_LD|BPF_H|BPF_ABS) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LD|BPF_H|BPF_ABS, 4), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0051.h b/tools/regression/bpf/bpf_filter/tests/test0051.h new file mode 100644 index 000000000000..2036cb3060aa --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0051.h @@ -0,0 +1,33 @@ +/*- + * Test 0051: Check boundary conditions (BPF_LD|BPF_W|BPF_IND) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 1), + BPF_STMT(BPF_LD|BPF_W|BPF_IND, 6), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0052.h b/tools/regression/bpf/bpf_filter/tests/test0052.h new file mode 100644 index 000000000000..976d1cd8b4ea --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0052.h @@ -0,0 +1,33 @@ +/*- + * Test 0052: Check boundary conditions (BPF_LD|BPF_H|BPF_IND) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 1), + BPF_STMT(BPF_LD|BPF_H|BPF_IND, 4), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, 0x67, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0053.h b/tools/regression/bpf/bpf_filter/tests/test0053.h new file mode 100644 index 000000000000..4b4d0c1b2f3d --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0053.h @@ -0,0 +1,33 @@ +/*- + * Test 0053: Check boundary conditions (BPF_LD|BPF_B|BPF_IND) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 1), + BPF_STMT(BPF_LD|BPF_B|BPF_IND, 3), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0054.h b/tools/regression/bpf/bpf_filter/tests/test0054.h new file mode 100644 index 000000000000..534b7f6505f5 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0054.h @@ -0,0 +1,33 @@ +/*- + * Test 0054: Check boundary conditions (BPF_LD|BPF_W|BPF_IND) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 6), + BPF_STMT(BPF_LD|BPF_W|BPF_IND, 1), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0055.h b/tools/regression/bpf/bpf_filter/tests/test0055.h new file mode 100644 index 000000000000..6460846c165a --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0055.h @@ -0,0 +1,33 @@ +/*- + * Test 0055: Check boundary conditions (BPF_LD|BPF_H|BPF_IND) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 4), + BPF_STMT(BPF_LD|BPF_H|BPF_IND, 1), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, 0x67, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0056.h b/tools/regression/bpf/bpf_filter/tests/test0056.h new file mode 100644 index 000000000000..790a9b953c99 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0056.h @@ -0,0 +1,33 @@ +/*- + * Test 0056: Check boundary conditions (BPF_LD|BPF_W|BPF_IND) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 1), + BPF_STMT(BPF_LD|BPF_W|BPF_IND, 0xffffffff), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0057.h b/tools/regression/bpf/bpf_filter/tests/test0057.h new file mode 100644 index 000000000000..9df308807f4f --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0057.h @@ -0,0 +1,33 @@ +/*- + * Test 0057: Check boundary conditions (BPF_LD|BPF_H|BPF_IND) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 1), + BPF_STMT(BPF_LD|BPF_H|BPF_IND, 0xffffffff), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, 0x67, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0058.h b/tools/regression/bpf/bpf_filter/tests/test0058.h new file mode 100644 index 000000000000..419983c19824 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0058.h @@ -0,0 +1,33 @@ +/*- + * Test 0058: Check boundary conditions (BPF_LD|BPF_B|BPF_IND) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 1), + BPF_STMT(BPF_LD|BPF_B|BPF_IND, 0xffffffff), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0059.h b/tools/regression/bpf/bpf_filter/tests/test0059.h new file mode 100644 index 000000000000..193abd7d23a4 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0059.h @@ -0,0 +1,33 @@ +/*- + * Test 0059: Check boundary conditions (BPF_LD|BPF_W|BPF_IND) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 0xffffffff), + BPF_STMT(BPF_LD|BPF_W|BPF_IND, 1), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0060.h b/tools/regression/bpf/bpf_filter/tests/test0060.h new file mode 100644 index 000000000000..f23bb49fab42 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0060.h @@ -0,0 +1,33 @@ +/*- + * Test 0060: Check boundary conditions (BPF_LD|BPF_H|BPF_IND) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 0xffffffff), + BPF_STMT(BPF_LD|BPF_H|BPF_IND, 1), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, 0x67, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0061.h b/tools/regression/bpf/bpf_filter/tests/test0061.h new file mode 100644 index 000000000000..f9f7dad69a32 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0061.h @@ -0,0 +1,33 @@ +/*- + * Test 0061: Check boundary conditions (BPF_LD|BPF_B|BPF_IND) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 0xffffffff), + BPF_STMT(BPF_LD|BPF_B|BPF_IND, 1), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = sizeof(pkt); + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0062.h b/tools/regression/bpf/bpf_filter/tests/test0062.h new file mode 100644 index 000000000000..817305b40716 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0062.h @@ -0,0 +1,33 @@ +/*- + * Test 0062: Check boundary conditions (BPF_LD|BPF_W|BPF_IND) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 1), + BPF_STMT(BPF_LD|BPF_W|BPF_IND, 1), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = 0; + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0063.h b/tools/regression/bpf/bpf_filter/tests/test0063.h new file mode 100644 index 000000000000..f01232391289 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0063.h @@ -0,0 +1,33 @@ +/*- + * Test 0063: Check boundary conditions (BPF_LD|BPF_H|BPF_IND) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 1), + BPF_STMT(BPF_LD|BPF_H|BPF_IND, 1), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, 0x67, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = 0; + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0064.h b/tools/regression/bpf/bpf_filter/tests/test0064.h new file mode 100644 index 000000000000..97886023ebb6 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0064.h @@ -0,0 +1,33 @@ +/*- + * Test 0064: Check boundary conditions (BPF_LD|BPF_B|BPF_IND) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 1), + BPF_STMT(BPF_LD|BPF_B|BPF_IND, 1), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = 0; + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0065.h b/tools/regression/bpf/bpf_filter/tests/test0065.h new file mode 100644 index 000000000000..66b119795e0f --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0065.h @@ -0,0 +1,33 @@ +/*- + * Test 0065: Check boundary conditions (BPF_LD|BPF_W|BPF_IND) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 0), + BPF_STMT(BPF_LD|BPF_W|BPF_IND, 1), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = 0; + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0066.h b/tools/regression/bpf/bpf_filter/tests/test0066.h new file mode 100644 index 000000000000..1276ac88a5f3 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0066.h @@ -0,0 +1,33 @@ +/*- + * Test 0066: Check boundary conditions (BPF_LD|BPF_H|BPF_IND) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 0), + BPF_STMT(BPF_LD|BPF_H|BPF_IND, 1), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, 0x67, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = 0; + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0067.h b/tools/regression/bpf/bpf_filter/tests/test0067.h new file mode 100644 index 000000000000..0b21c44fbbc9 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0067.h @@ -0,0 +1,33 @@ +/*- + * Test 0067: Check boundary conditions (BPF_LD|BPF_B|BPF_IND) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 0), + BPF_STMT(BPF_LD|BPF_B|BPF_IND, 1), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = 0; + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0068.h b/tools/regression/bpf/bpf_filter/tests/test0068.h new file mode 100644 index 000000000000..62511e05e480 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0068.h @@ -0,0 +1,33 @@ +/*- + * Test 0068: Check boundary conditions (BPF_LD|BPF_W|BPF_IND) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 1), + BPF_STMT(BPF_LD|BPF_W|BPF_IND, 0), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = 0; + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0069.h b/tools/regression/bpf/bpf_filter/tests/test0069.h new file mode 100644 index 000000000000..7d12bdc56f9b --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0069.h @@ -0,0 +1,33 @@ +/*- + * Test 0069: Check boundary conditions (BPF_LD|BPF_H|BPF_IND) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 1), + BPF_STMT(BPF_LD|BPF_H|BPF_IND, 0), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, 0x67, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = 0; + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0070.h b/tools/regression/bpf/bpf_filter/tests/test0070.h new file mode 100644 index 000000000000..a6eb7daaa5cc --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0070.h @@ -0,0 +1,33 @@ +/*- + * Test 0070: Check boundary conditions (BPF_LD|BPF_B|BPF_IND) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 1), + BPF_STMT(BPF_LD|BPF_B|BPF_IND, 0), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = 0; + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0071.h b/tools/regression/bpf/bpf_filter/tests/test0071.h new file mode 100644 index 000000000000..d9383788e8aa --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0071.h @@ -0,0 +1,33 @@ +/*- + * Test 0071: Check boundary conditions (BPF_LD|BPF_W|BPF_IND) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 0), + BPF_STMT(BPF_LD|BPF_W|BPF_IND, 0), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = 0; + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0072.h b/tools/regression/bpf/bpf_filter/tests/test0072.h new file mode 100644 index 000000000000..38ba942125d1 --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0072.h @@ -0,0 +1,33 @@ +/*- + * Test 0072: Check boundary conditions (BPF_LD|BPF_H|BPF_IND) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 0), + BPF_STMT(BPF_LD|BPF_H|BPF_IND, 0), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, 0x67, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = 0; + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; diff --git a/tools/regression/bpf/bpf_filter/tests/test0073.h b/tools/regression/bpf/bpf_filter/tests/test0073.h new file mode 100644 index 000000000000..d9fae4ad3d0b --- /dev/null +++ b/tools/regression/bpf/bpf_filter/tests/test0073.h @@ -0,0 +1,33 @@ +/*- + * Test 0073: Check boundary conditions (BPF_LD|BPF_B|BPF_IND) + * + * $FreeBSD$ + */ + +/* BPF program */ +struct bpf_insn pc[] = { + BPF_STMT(BPF_LD|BPF_IMM, 0xdeadc0de), + BPF_STMT(BPF_LDX|BPF_IMM, 0), + BPF_STMT(BPF_LD|BPF_B|BPF_IND, 0), + BPF_STMT(BPF_RET+BPF_A, 0), +}; + +/* Packet */ +u_char pkt[] = { + 0x01, 0x23, 0x45, +}; + +/* Packet length seen on wire */ +u_int wirelen = sizeof(pkt); + +/* Packet length passed on buffer */ +u_int buflen = 0; + +/* Invalid instruction */ +int invalid = 0; + +/* Expected return value */ +u_int expect = 0; + +/* Expeced signal */ +int expect_signal = 0; |