15#include <netinet/in.h>
16#include <netinet/ip.h>
17#include <linux/netfilter/nf_tables.h>
18#include <libmnl/libmnl.h>
19#include <libnftnl/rule.h>
20#include <libnftnl/expr.h>
22static int test_ok = 1;
24static void print_err(
const char *test,
const char *msg)
27 printf(
"\033[31mERROR:\e[0m [%s] %s\n", test, msg);
30static void cmp_nftnl_expr_bool(
struct nftnl_expr *rule_a,
31 struct nftnl_expr *rule_b)
33 uint32_t maska, maskb;
36 if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_DREG) !=
37 nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_DREG))
38 print_err(
"bool",
"Expr BITWISE_DREG mismatches");
39 if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_SREG) !=
40 nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_SREG))
41 print_err(
"bool",
"Expr BITWISE_SREG mismatches");
42 if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_OP) !=
43 nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_OP))
44 print_err(
"bool",
"Expr BITWISE_OP mismatches");
45 if (nftnl_expr_get_u16(rule_a, NFTNL_EXPR_BITWISE_LEN) !=
46 nftnl_expr_get_u16(rule_b, NFTNL_EXPR_BITWISE_LEN))
47 print_err(
"bool",
"Expr BITWISE_LEN mismatches");
48 nftnl_expr_get(rule_a, NFTNL_EXPR_BITWISE_MASK, &maska);
49 nftnl_expr_get(rule_b, NFTNL_EXPR_BITWISE_MASK, &maskb);
51 print_err(
"bool",
"Size of BITWISE_MASK mismatches");
52 nftnl_expr_get(rule_a, NFTNL_EXPR_BITWISE_XOR, &xora);
53 nftnl_expr_get(rule_b, NFTNL_EXPR_BITWISE_XOR, &xorb);
55 print_err(
"bool",
"Size of BITWISE_XOR mismatches");
58static void cmp_nftnl_expr_lshift(
struct nftnl_expr *rule_a,
59 struct nftnl_expr *rule_b)
61 uint32_t data_a, data_b;
63 if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_DREG) !=
64 nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_DREG))
65 print_err(
"lshift",
"Expr BITWISE_DREG mismatches");
66 if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_SREG) !=
67 nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_SREG))
68 print_err(
"lshift",
"Expr BITWISE_SREG mismatches");
69 if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_OP) !=
70 nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_OP))
71 print_err(
"lshift",
"Expr BITWISE_OP mismatches");
72 if (nftnl_expr_get_u16(rule_a, NFTNL_EXPR_BITWISE_LEN) !=
73 nftnl_expr_get_u16(rule_b, NFTNL_EXPR_BITWISE_LEN))
74 print_err(
"lshift",
"Expr BITWISE_LEN mismatches");
75 nftnl_expr_get(rule_a, NFTNL_EXPR_BITWISE_DATA, &data_a);
76 nftnl_expr_get(rule_b, NFTNL_EXPR_BITWISE_DATA, &data_b);
78 print_err(
"lshift",
"Expr BITWISE_DATA mismatches");
81static void cmp_nftnl_expr_rshift(
struct nftnl_expr *rule_a,
82 struct nftnl_expr *rule_b)
84 uint32_t data_a, data_b;
86 if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_DREG) !=
87 nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_DREG))
88 print_err(
"rshift",
"Expr BITWISE_DREG mismatches");
89 if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_SREG) !=
90 nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_SREG))
91 print_err(
"rshift",
"Expr BITWISE_SREG mismatches");
92 if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_OP) !=
93 nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_OP))
94 print_err(
"rshift",
"Expr BITWISE_OP mismatches");
95 if (nftnl_expr_get_u16(rule_a, NFTNL_EXPR_BITWISE_LEN) !=
96 nftnl_expr_get_u16(rule_b, NFTNL_EXPR_BITWISE_LEN))
97 print_err(
"rshift",
"Expr BITWISE_LEN mismatches");
98 nftnl_expr_get(rule_a, NFTNL_EXPR_BITWISE_DATA, &data_a);
99 nftnl_expr_get(rule_b, NFTNL_EXPR_BITWISE_DATA, &data_b);
100 if (data_a != data_b)
101 print_err(
"rshift",
"Expr BITWISE_DATA mismatches");
104static void test_bool(
void)
106 struct nftnl_rule *a, *b = NULL;
107 struct nftnl_expr *ex = NULL;
108 struct nlmsghdr *nlh;
111 struct nftnl_expr *rule_a, *rule_b = NULL;
112 uint32_t mask = 0x01010101;
113 uint32_t xor = 0x12345678;
115 a = nftnl_rule_alloc();
116 b = nftnl_rule_alloc();
117 if (a == NULL || b == NULL)
118 print_err(
"bool",
"OOM");
119 ex = nftnl_expr_alloc(
"bitwise");
121 print_err(
"bool",
"OOM");
123 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_SREG, 0x12345678);
124 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_DREG, 0x78123456);
125 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_OP, NFT_BITWISE_BOOL);
126 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_LEN, 0x56781234);
127 nftnl_expr_set(ex, NFTNL_EXPR_BITWISE_MASK, &mask,
sizeof(mask));
128 nftnl_expr_set(ex, NFTNL_EXPR_BITWISE_XOR, &xor,
sizeof(xor));
130 nftnl_rule_add_expr(a, ex);
132 nlh = nftnl_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
133 nftnl_rule_nlmsg_build_payload(nlh, a);
135 if (nftnl_rule_nlmsg_parse(nlh, b) < 0)
136 print_err(
"bool",
"parsing problems");
138 iter_a = nftnl_expr_iter_create(a);
139 iter_b = nftnl_expr_iter_create(b);
140 if (iter_a == NULL || iter_b == NULL)
141 print_err(
"bool",
"OOM");
143 rule_a = nftnl_expr_iter_next(iter_a);
144 rule_b = nftnl_expr_iter_next(iter_b);
145 if (rule_a == NULL || rule_b == NULL)
146 print_err(
"bool",
"OOM");
148 if (nftnl_expr_iter_next(iter_a) != NULL ||
149 nftnl_expr_iter_next(iter_b) != NULL)
150 print_err(
"bool",
"More 1 expr.");
152 nftnl_expr_iter_destroy(iter_a);
153 nftnl_expr_iter_destroy(iter_b);
155 cmp_nftnl_expr_bool(rule_a,rule_b);
161static void test_lshift(
void)
163 struct nftnl_rule *a, *b = NULL;
164 struct nftnl_expr *ex = NULL;
165 struct nlmsghdr *nlh;
168 struct nftnl_expr *rule_a, *rule_b = NULL;
170 a = nftnl_rule_alloc();
171 b = nftnl_rule_alloc();
172 if (a == NULL || b == NULL)
173 print_err(
"lshift",
"OOM");
174 ex = nftnl_expr_alloc(
"bitwise");
176 print_err(
"lshift",
"OOM");
178 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_SREG, 0x12345678);
179 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_DREG, 0x78123456);
180 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_OP, NFT_BITWISE_LSHIFT);
181 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_LEN, 0x56781234);
182 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_DATA, 13);
184 nftnl_rule_add_expr(a, ex);
186 nlh = nftnl_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
187 nftnl_rule_nlmsg_build_payload(nlh, a);
189 if (nftnl_rule_nlmsg_parse(nlh, b) < 0)
190 print_err(
"lshift",
"parsing problems");
192 iter_a = nftnl_expr_iter_create(a);
193 iter_b = nftnl_expr_iter_create(b);
194 if (iter_a == NULL || iter_b == NULL)
195 print_err(
"lshift",
"OOM");
197 rule_a = nftnl_expr_iter_next(iter_a);
198 rule_b = nftnl_expr_iter_next(iter_b);
199 if (rule_a == NULL || rule_b == NULL)
200 print_err(
"lshift",
"OOM");
202 if (nftnl_expr_iter_next(iter_a) != NULL ||
203 nftnl_expr_iter_next(iter_b) != NULL)
204 print_err(
"lshift",
"More 1 expr.");
206 nftnl_expr_iter_destroy(iter_a);
207 nftnl_expr_iter_destroy(iter_b);
209 cmp_nftnl_expr_lshift(rule_a,rule_b);
215static void test_rshift(
void)
217 struct nftnl_rule *a, *b = NULL;
218 struct nftnl_expr *ex = NULL;
219 struct nlmsghdr *nlh;
222 struct nftnl_expr *rule_a, *rule_b = NULL;
224 a = nftnl_rule_alloc();
225 b = nftnl_rule_alloc();
226 if (a == NULL || b == NULL)
227 print_err(
"rshift",
"OOM");
228 ex = nftnl_expr_alloc(
"bitwise");
230 print_err(
"rshift",
"OOM");
232 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_SREG, 0x12345678);
233 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_DREG, 0x78123456);
234 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_OP, NFT_BITWISE_RSHIFT);
235 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_LEN, 0x56781234);
236 nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_DATA, 17);
238 nftnl_rule_add_expr(a, ex);
240 nlh = nftnl_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
241 nftnl_rule_nlmsg_build_payload(nlh, a);
243 if (nftnl_rule_nlmsg_parse(nlh, b) < 0)
244 print_err(
"rshift",
"parsing problems");
246 iter_a = nftnl_expr_iter_create(a);
247 iter_b = nftnl_expr_iter_create(b);
248 if (iter_a == NULL || iter_b == NULL)
249 print_err(
"rshift",
"OOM");
251 rule_a = nftnl_expr_iter_next(iter_a);
252 rule_b = nftnl_expr_iter_next(iter_b);
253 if (rule_a == NULL || rule_b == NULL)
254 print_err(
"rshift",
"OOM");
256 if (nftnl_expr_iter_next(iter_a) != NULL ||
257 nftnl_expr_iter_next(iter_b) != NULL)
258 print_err(
"rshift",
"More 1 expr.");
260 nftnl_expr_iter_destroy(iter_a);
261 nftnl_expr_iter_destroy(iter_b);
263 cmp_nftnl_expr_rshift(rule_a,rule_b);
269int main(
int argc,
char *argv[])
283 printf(
"%s: \033[32mOK\e[0m\n", argv[0]);