10#include <netinet/in.h>
11#include <netinet/ip.h>
12#include <linux/netfilter/nf_tables.h>
13#include <libmnl/libmnl.h>
14#include <libnftnl/rule.h>
15#include <libnftnl/expr.h>
17static int test_ok = 1;
19static void print_err(
const char *test,
const char *msg)
22 printf(
"\033[31mERROR:\e[0m [%s] %s\n", test, msg);
25static void cmp_nftnl_expr_mask_xor(
struct nftnl_expr *rule_a,
26 struct nftnl_expr *rule_b)
28 uint32_t maska, maskb;
31 if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_DREG) !=
32 nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_DREG))
33 print_err(
"mask & xor",
"Expr BITWISE_DREG mismatches");
34 if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_SREG) !=
35 nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_SREG))
36 print_err(
"mask & xor",
"Expr BITWISE_SREG mismatches");
37 if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_OP) !=
38 nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_OP))
39 print_err(
"mask & xor",
"Expr BITWISE_OP mismatches");
40 if (nftnl_expr_get_u16(rule_a, NFTNL_EXPR_BITWISE_LEN) !=
41 nftnl_expr_get_u16(rule_b, NFTNL_EXPR_BITWISE_LEN))
42 print_err(
"mask & xor",
"Expr BITWISE_LEN mismatches");
43 nftnl_expr_get(rule_a, NFTNL_EXPR_BITWISE_MASK, &maska);
44 nftnl_expr_get(rule_b, NFTNL_EXPR_BITWISE_MASK, &maskb);
46 print_err(
"mask & xor",
"Size of BITWISE_MASK mismatches");
47 nftnl_expr_get(rule_a, NFTNL_EXPR_BITWISE_XOR, &xora);
48 nftnl_expr_get(rule_b, NFTNL_EXPR_BITWISE_XOR, &xorb);
50 print_err(
"mask & xor",
"Size of BITWISE_XOR mismatches");
53static void test_mask_xor(
void)
55 struct nftnl_rule *a, *b = NULL;
56 struct nftnl_expr *ex = NULL;
60 struct nftnl_expr *rule_a, *rule_b = NULL;
61 uint32_t mask = 0x01010101;
62 uint32_t xor = 0x12345678;
64 a = nftnl_rule_alloc();
65 b = nftnl_rule_alloc();
66 if (a == NULL || b == NULL)
67 print_err(
"mask & xor",
"OOM");
68 ex = nftnl_expr_alloc(
"bitwise");
70 print_err(
"mask & xor",
"OOM");
72 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_SREG, 0x12345678);
73 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_DREG, 0x78123456);
74 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_OP, NFT_BITWISE_BOOL);
75 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_LEN, 0x56781234);
76 nftnl_expr_set(ex, NFTNL_EXPR_BITWISE_MASK, &mask,
sizeof(mask));
77 nftnl_expr_set(ex, NFTNL_EXPR_BITWISE_XOR, &xor,
sizeof(xor));
79 nftnl_rule_add_expr(a, ex);
81 nlh = nftnl_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
82 nftnl_rule_nlmsg_build_payload(nlh, a);
84 if (nftnl_rule_nlmsg_parse(nlh, b) < 0)
85 print_err(
"mask & xor",
"parsing problems");
87 iter_a = nftnl_expr_iter_create(a);
88 iter_b = nftnl_expr_iter_create(b);
89 if (iter_a == NULL || iter_b == NULL)
90 print_err(
"mask & xor",
"OOM");
92 rule_a = nftnl_expr_iter_next(iter_a);
93 rule_b = nftnl_expr_iter_next(iter_b);
94 if (rule_a == NULL || rule_b == NULL)
95 print_err(
"mask & xor",
"OOM");
97 if (nftnl_expr_iter_next(iter_a) != NULL ||
98 nftnl_expr_iter_next(iter_b) != NULL)
99 print_err(
"mask & xor",
"More 1 expr.");
101 nftnl_expr_iter_destroy(iter_a);
102 nftnl_expr_iter_destroy(iter_b);
104 cmp_nftnl_expr_mask_xor(rule_a,rule_b);
110static void cmp_nftnl_expr_shift(
const char *opname,
111 const struct nftnl_expr *rule_a,
112 const struct nftnl_expr *rule_b)
114 uint32_t data_a, data_b;
116 if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_DREG) !=
117 nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_DREG))
118 print_err(opname,
"Expr BITWISE_DREG mismatches");
119 if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_SREG) !=
120 nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_SREG))
121 print_err(opname,
"Expr BITWISE_SREG mismatches");
122 if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_OP) !=
123 nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_OP))
124 print_err(opname,
"Expr BITWISE_OP mismatches");
125 if (nftnl_expr_get_u16(rule_a, NFTNL_EXPR_BITWISE_LEN) !=
126 nftnl_expr_get_u16(rule_b, NFTNL_EXPR_BITWISE_LEN))
127 print_err(opname,
"Expr BITWISE_LEN mismatches");
128 nftnl_expr_get(rule_a, NFTNL_EXPR_BITWISE_DATA, &data_a);
129 nftnl_expr_get(rule_b, NFTNL_EXPR_BITWISE_DATA, &data_b);
130 if (data_a != data_b)
131 print_err(opname,
"Expr BITWISE_DATA mismatches");
134static void test_shift(
enum nft_bitwise_ops op)
136 struct nftnl_rule *a, *b;
137 struct nftnl_expr *ex;
138 struct nlmsghdr *nlh;
141 struct nftnl_expr *rule_a, *rule_b;
142 const char *opname = op == NFT_BITWISE_LSHIFT ?
"lshift" :
"rshift";
144 a = nftnl_rule_alloc();
145 b = nftnl_rule_alloc();
146 if (a == NULL || b == NULL)
147 print_err(opname,
"OOM");
148 ex = nftnl_expr_alloc(
"bitwise");
150 print_err(opname,
"OOM");
152 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_SREG, 0x12345678);
153 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_DREG, 0x78123456);
154 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_OP, op);
155 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_LEN, 0x56781234);
156 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_DATA, 13);
158 nftnl_rule_add_expr(a, ex);
160 nlh = nftnl_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
161 nftnl_rule_nlmsg_build_payload(nlh, a);
163 if (nftnl_rule_nlmsg_parse(nlh, b) < 0)
164 print_err(opname,
"parsing problems");
166 iter_a = nftnl_expr_iter_create(a);
167 iter_b = nftnl_expr_iter_create(b);
168 if (iter_a == NULL || iter_b == NULL)
169 print_err(opname,
"OOM");
171 rule_a = nftnl_expr_iter_next(iter_a);
172 rule_b = nftnl_expr_iter_next(iter_b);
173 if (rule_a == NULL || rule_b == NULL)
174 print_err(opname,
"OOM");
176 if (nftnl_expr_iter_next(iter_a) != NULL ||
177 nftnl_expr_iter_next(iter_b) != NULL)
178 print_err(opname,
"More 1 expr.");
180 nftnl_expr_iter_destroy(iter_a);
181 nftnl_expr_iter_destroy(iter_b);
183 cmp_nftnl_expr_shift(opname, rule_a, rule_b);
189static void test_lshift(
void)
191 test_shift(NFT_BITWISE_LSHIFT);
194static void test_rshift(
void)
196 test_shift(NFT_BITWISE_RSHIFT);
199static void cmp_nftnl_expr_bool(
const char *opname,
200 const struct nftnl_expr *rule_a,
201 const struct nftnl_expr *rule_b)
203 if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_DREG) !=
204 nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_DREG))
205 print_err(opname,
"Expr BITWISE_DREG mismatches");
206 if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_SREG) !=
207 nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_SREG))
208 print_err(opname,
"Expr BITWISE_SREG mismatches");
209 if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_SREG2) !=
210 nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_SREG2))
211 print_err(opname,
"Expr BITWISE_SREG2 mismatches");
212 if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_OP) !=
213 nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_OP))
214 print_err(opname,
"Expr BITWISE_OP mismatches");
215 if (nftnl_expr_get_u16(rule_a, NFTNL_EXPR_BITWISE_LEN) !=
216 nftnl_expr_get_u16(rule_b, NFTNL_EXPR_BITWISE_LEN))
217 print_err(opname,
"Expr BITWISE_LEN mismatches");
220static void test_bool(
enum nft_bitwise_ops op)
222 struct nftnl_rule *a, *b;
223 struct nftnl_expr *ex;
224 struct nlmsghdr *nlh;
227 struct nftnl_expr *rule_a, *rule_b;
229 op == NFT_BITWISE_AND ?
"and" :
230 op == NFT_BITWISE_OR ?
"or" :
"xor";
232 a = nftnl_rule_alloc();
233 b = nftnl_rule_alloc();
234 if (a == NULL || b == NULL)
235 print_err(opname,
"OOM");
236 ex = nftnl_expr_alloc(
"bitwise");
238 print_err(opname,
"OOM");
240 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_SREG, 0x12345678);
241 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_SREG2, 0x90abcdef);
242 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_DREG, 0x78123456);
243 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_OP, op);
244 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_LEN, 0x56781234);
246 nftnl_rule_add_expr(a, ex);
248 nlh = nftnl_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
249 nftnl_rule_nlmsg_build_payload(nlh, a);
251 if (nftnl_rule_nlmsg_parse(nlh, b) < 0)
252 print_err(opname,
"parsing problems");
254 iter_a = nftnl_expr_iter_create(a);
255 iter_b = nftnl_expr_iter_create(b);
256 if (iter_a == NULL || iter_b == NULL)
257 print_err(opname,
"OOM");
259 rule_a = nftnl_expr_iter_next(iter_a);
260 rule_b = nftnl_expr_iter_next(iter_b);
261 if (rule_a == NULL || rule_b == NULL)
262 print_err(opname,
"OOM");
264 if (nftnl_expr_iter_next(iter_a) != NULL ||
265 nftnl_expr_iter_next(iter_b) != NULL)
266 print_err(opname,
"More 1 expr.");
268 nftnl_expr_iter_destroy(iter_a);
269 nftnl_expr_iter_destroy(iter_b);
271 cmp_nftnl_expr_bool(opname, rule_a, rule_b);
277static void test_and(
void)
279 test_bool(NFT_BITWISE_AND);
282static void test_or(
void)
284 test_bool(NFT_BITWISE_OR);
287static void test_xor(
void)
289 test_bool(NFT_BITWISE_XOR);
292int main(
int argc,
char *argv[])
318 printf(
"%s: \033[32mOK\e[0m\n", argv[0]);