libnftnl 1.2.6
nft-expr_bitwise-test.c
1/*
2 * (C) 2013 by Ana Rey Botello <anarey@gmail.com>
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 */
10
11#include <stdio.h>
12#include <stdlib.h>
13#include <string.h>
14
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>
21
22static int test_ok = 1;
23
24static void print_err(const char *test, const char *msg)
25{
26 test_ok = 0;
27 printf("\033[31mERROR:\e[0m [%s] %s\n", test, msg);
28}
29
30static void cmp_nftnl_expr_bool(struct nftnl_expr *rule_a,
31 struct nftnl_expr *rule_b)
32{
33 uint32_t maska, maskb;
34 uint32_t xora, xorb;
35
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);
50 if (maska != 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);
54 if (xora != xorb)
55 print_err("bool", "Size of BITWISE_XOR mismatches");
56}
57
58static void cmp_nftnl_expr_lshift(struct nftnl_expr *rule_a,
59 struct nftnl_expr *rule_b)
60{
61 uint32_t data_a, data_b;
62
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);
77 if (data_a != data_b)
78 print_err("lshift", "Expr BITWISE_DATA mismatches");
79}
80
81static void cmp_nftnl_expr_rshift(struct nftnl_expr *rule_a,
82 struct nftnl_expr *rule_b)
83{
84 uint32_t data_a, data_b;
85
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");
102}
103
104static void test_bool(void)
105{
106 struct nftnl_rule *a, *b = NULL;
107 struct nftnl_expr *ex = NULL;
108 struct nlmsghdr *nlh;
109 char buf[4096];
110 struct nftnl_expr_iter *iter_a, *iter_b = NULL;
111 struct nftnl_expr *rule_a, *rule_b = NULL;
112 uint32_t mask = 0x01010101;
113 uint32_t xor = 0x12345678;
114
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");
120 if (ex == NULL)
121 print_err("bool", "OOM");
122
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));
129
130 nftnl_rule_add_expr(a, ex);
131
132 nlh = nftnl_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
133 nftnl_rule_nlmsg_build_payload(nlh, a);
134
135 if (nftnl_rule_nlmsg_parse(nlh, b) < 0)
136 print_err("bool", "parsing problems");
137
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");
142
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");
147
148 if (nftnl_expr_iter_next(iter_a) != NULL ||
149 nftnl_expr_iter_next(iter_b) != NULL)
150 print_err("bool", "More 1 expr.");
151
152 nftnl_expr_iter_destroy(iter_a);
153 nftnl_expr_iter_destroy(iter_b);
154
155 cmp_nftnl_expr_bool(rule_a,rule_b);
156
157 nftnl_rule_free(a);
158 nftnl_rule_free(b);
159}
160
161static void test_lshift(void)
162{
163 struct nftnl_rule *a, *b = NULL;
164 struct nftnl_expr *ex = NULL;
165 struct nlmsghdr *nlh;
166 char buf[4096];
167 struct nftnl_expr_iter *iter_a, *iter_b = NULL;
168 struct nftnl_expr *rule_a, *rule_b = NULL;
169
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");
175 if (ex == NULL)
176 print_err("lshift", "OOM");
177
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);
183
184 nftnl_rule_add_expr(a, ex);
185
186 nlh = nftnl_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
187 nftnl_rule_nlmsg_build_payload(nlh, a);
188
189 if (nftnl_rule_nlmsg_parse(nlh, b) < 0)
190 print_err("lshift", "parsing problems");
191
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");
196
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");
201
202 if (nftnl_expr_iter_next(iter_a) != NULL ||
203 nftnl_expr_iter_next(iter_b) != NULL)
204 print_err("lshift", "More 1 expr.");
205
206 nftnl_expr_iter_destroy(iter_a);
207 nftnl_expr_iter_destroy(iter_b);
208
209 cmp_nftnl_expr_lshift(rule_a,rule_b);
210
211 nftnl_rule_free(a);
212 nftnl_rule_free(b);
213}
214
215static void test_rshift(void)
216{
217 struct nftnl_rule *a, *b = NULL;
218 struct nftnl_expr *ex = NULL;
219 struct nlmsghdr *nlh;
220 char buf[4096];
221 struct nftnl_expr_iter *iter_a, *iter_b = NULL;
222 struct nftnl_expr *rule_a, *rule_b = NULL;
223
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");
229 if (ex == NULL)
230 print_err("rshift", "OOM");
231
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);
237
238 nftnl_rule_add_expr(a, ex);
239
240 nlh = nftnl_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
241 nftnl_rule_nlmsg_build_payload(nlh, a);
242
243 if (nftnl_rule_nlmsg_parse(nlh, b) < 0)
244 print_err("rshift", "parsing problems");
245
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");
250
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");
255
256 if (nftnl_expr_iter_next(iter_a) != NULL ||
257 nftnl_expr_iter_next(iter_b) != NULL)
258 print_err("rshift", "More 1 expr.");
259
260 nftnl_expr_iter_destroy(iter_a);
261 nftnl_expr_iter_destroy(iter_b);
262
263 cmp_nftnl_expr_rshift(rule_a,rule_b);
264
265 nftnl_rule_free(a);
266 nftnl_rule_free(b);
267}
268
269int main(int argc, char *argv[])
270{
271 test_bool();
272 if (!test_ok)
273 exit(EXIT_FAILURE);
274
275 test_lshift();
276 if (!test_ok)
277 exit(EXIT_FAILURE);
278
279 test_rshift();
280 if (!test_ok)
281 exit(EXIT_FAILURE);
282
283 printf("%s: \033[32mOK\e[0m\n", argv[0]);
284 return EXIT_SUCCESS;
285}