libnftnl 1.3.2
bitwise.c
1/* SPDX-License-Identifier: GPL-2.0-or-later */
2/*
3 * (C) 2012 by Pablo Neira Ayuso <pablo@netfilter.org>
4 *
5 * This code has been sponsored by Sophos Astaro <http://www.sophos.com>
6 */
7
8#include "internal.h"
9
10#include <stdio.h>
11#include <stdint.h>
12#include <string.h> /* for memcpy */
13#include <arpa/inet.h>
14#include <errno.h>
15#include <libmnl/libmnl.h>
16#include <linux/netfilter/nf_tables.h>
17#include <libnftnl/expr.h>
18#include <libnftnl/rule.h>
19
20struct nftnl_expr_bitwise {
21 enum nft_registers sreg;
22 enum nft_registers sreg2;
23 enum nft_registers dreg;
24 enum nft_bitwise_ops op;
25 unsigned int len;
26 union nftnl_data_reg mask;
27 union nftnl_data_reg xor;
28 union nftnl_data_reg data;
29};
30
31static int
32nftnl_expr_bitwise_set(struct nftnl_expr *e, uint16_t type,
33 const void *data, uint32_t data_len, uint32_t byteorder)
34{
35 struct nftnl_expr_bitwise *bitwise = nftnl_expr_data(e);
36
37 switch(type) {
38 case NFTNL_EXPR_BITWISE_SREG:
39 memcpy(&bitwise->sreg, data, data_len);
40 break;
41 case NFTNL_EXPR_BITWISE_SREG2:
42 memcpy(&bitwise->sreg2, data, sizeof(bitwise->sreg2));
43 break;
44 case NFTNL_EXPR_BITWISE_DREG:
45 memcpy(&bitwise->dreg, data, data_len);
46 break;
47 case NFTNL_EXPR_BITWISE_OP:
48 memcpy(&bitwise->op, data, data_len);
49 break;
50 case NFTNL_EXPR_BITWISE_LEN:
51 memcpy(&bitwise->len, data, data_len);
52 break;
53 case NFTNL_EXPR_BITWISE_MASK:
54 return nftnl_data_cpy(&bitwise->mask, data,
55 data_len, byteorder, NULL);
56 case NFTNL_EXPR_BITWISE_XOR:
57 return nftnl_data_cpy(&bitwise->xor, data,
58 data_len, byteorder, NULL);
59 case NFTNL_EXPR_BITWISE_DATA:
60 return nftnl_data_cpy(&bitwise->data, data,
61 data_len, byteorder, NULL);
62 }
63 return 0;
64}
65
66static const void *
67nftnl_expr_bitwise_get(const struct nftnl_expr *e, uint16_t type,
68 uint32_t *data_len)
69{
70 struct nftnl_expr_bitwise *bitwise = nftnl_expr_data(e);
71
72 switch(type) {
73 case NFTNL_EXPR_BITWISE_SREG:
74 *data_len = sizeof(bitwise->sreg);
75 return &bitwise->sreg;
76 case NFTNL_EXPR_BITWISE_SREG2:
77 *data_len = sizeof(bitwise->sreg2);
78 return &bitwise->sreg2;
79 case NFTNL_EXPR_BITWISE_DREG:
80 *data_len = sizeof(bitwise->dreg);
81 return &bitwise->dreg;
82 case NFTNL_EXPR_BITWISE_OP:
83 *data_len = sizeof(bitwise->op);
84 return &bitwise->op;
85 case NFTNL_EXPR_BITWISE_LEN:
86 *data_len = sizeof(bitwise->len);
87 return &bitwise->len;
88 case NFTNL_EXPR_BITWISE_MASK:
89 *data_len = bitwise->mask.len;
90 return &bitwise->mask.val;
91 case NFTNL_EXPR_BITWISE_XOR:
92 *data_len = bitwise->xor.len;
93 return &bitwise->xor.val;
94 case NFTNL_EXPR_BITWISE_DATA:
95 *data_len = bitwise->data.len;
96 return &bitwise->data.val;
97 }
98 return NULL;
99}
100
101static int nftnl_expr_bitwise_cb(const struct nlattr *attr, void *data)
102{
103 const struct nlattr **tb = data;
104 int type = mnl_attr_get_type(attr);
105
106 if (mnl_attr_type_valid(attr, NFTA_BITWISE_MAX) < 0)
107 return MNL_CB_OK;
108
109 switch(type) {
110 case NFTA_BITWISE_SREG:
111 case NFTA_BITWISE_SREG2:
112 case NFTA_BITWISE_DREG:
113 case NFTA_BITWISE_OP:
114 case NFTA_BITWISE_LEN:
115 if (mnl_attr_validate(attr, MNL_TYPE_U32) < 0)
116 abi_breakage();
117 break;
118 case NFTA_BITWISE_MASK:
119 case NFTA_BITWISE_XOR:
120 case NFTA_BITWISE_DATA:
121 if (mnl_attr_validate(attr, MNL_TYPE_BINARY) < 0)
122 abi_breakage();
123 break;
124 }
125
126 tb[type] = attr;
127 return MNL_CB_OK;
128}
129
130static void
131nftnl_expr_bitwise_build(struct nlmsghdr *nlh, const struct nftnl_expr *e)
132{
133 struct nftnl_expr_bitwise *bitwise = nftnl_expr_data(e);
134
135 if (e->flags & (1 << NFTNL_EXPR_BITWISE_SREG))
136 mnl_attr_put_u32(nlh, NFTA_BITWISE_SREG, htonl(bitwise->sreg));
137 if (e->flags & (1 << NFTNL_EXPR_BITWISE_SREG2))
138 mnl_attr_put_u32(nlh, NFTA_BITWISE_SREG2, htonl(bitwise->sreg2));
139 if (e->flags & (1 << NFTNL_EXPR_BITWISE_DREG))
140 mnl_attr_put_u32(nlh, NFTA_BITWISE_DREG, htonl(bitwise->dreg));
141 if (e->flags & (1 << NFTNL_EXPR_BITWISE_OP))
142 mnl_attr_put_u32(nlh, NFTA_BITWISE_OP, htonl(bitwise->op));
143 if (e->flags & (1 << NFTNL_EXPR_BITWISE_LEN))
144 mnl_attr_put_u32(nlh, NFTA_BITWISE_LEN, htonl(bitwise->len));
145 if (e->flags & (1 << NFTNL_EXPR_BITWISE_MASK)) {
146 struct nlattr *nest;
147
148 nest = mnl_attr_nest_start(nlh, NFTA_BITWISE_MASK);
149 mnl_attr_put(nlh, NFTA_DATA_VALUE, bitwise->mask.len,
150 bitwise->mask.val);
151 mnl_attr_nest_end(nlh, nest);
152 }
153 if (e->flags & (1 << NFTNL_EXPR_BITWISE_XOR)) {
154 struct nlattr *nest;
155
156 nest = mnl_attr_nest_start(nlh, NFTA_BITWISE_XOR);
157 mnl_attr_put(nlh, NFTA_DATA_VALUE, bitwise->xor.len,
158 bitwise->xor.val);
159 mnl_attr_nest_end(nlh, nest);
160 }
161 if (e->flags & (1 << NFTNL_EXPR_BITWISE_DATA)) {
162 struct nlattr *nest;
163
164 nest = mnl_attr_nest_start(nlh, NFTA_BITWISE_DATA);
165 mnl_attr_put(nlh, NFTA_DATA_VALUE, bitwise->data.len,
166 bitwise->data.val);
167 mnl_attr_nest_end(nlh, nest);
168 }
169}
170
171static int
172nftnl_expr_bitwise_parse(struct nftnl_expr *e, struct nlattr *attr)
173{
174 struct nftnl_expr_bitwise *bitwise = nftnl_expr_data(e);
175 struct nlattr *tb[NFTA_BITWISE_MAX+1] = {};
176 int ret = 0;
177
178 if (mnl_attr_parse_nested(attr, nftnl_expr_bitwise_cb, tb) < 0)
179 return -1;
180
181 if (tb[NFTA_BITWISE_SREG]) {
182 bitwise->sreg = ntohl(mnl_attr_get_u32(tb[NFTA_BITWISE_SREG]));
183 e->flags |= (1 << NFTNL_EXPR_BITWISE_SREG);
184 }
185 if (tb[NFTA_BITWISE_SREG2]) {
186 bitwise->sreg2 = ntohl(mnl_attr_get_u32(tb[NFTA_BITWISE_SREG2]));
187 e->flags |= (1 << NFTNL_EXPR_BITWISE_SREG2);
188 }
189 if (tb[NFTA_BITWISE_DREG]) {
190 bitwise->dreg = ntohl(mnl_attr_get_u32(tb[NFTA_BITWISE_DREG]));
191 e->flags |= (1 << NFTNL_EXPR_BITWISE_DREG);
192 }
193 if (tb[NFTA_BITWISE_OP]) {
194 bitwise->op = ntohl(mnl_attr_get_u32(tb[NFTA_BITWISE_OP]));
195 e->flags |= (1 << NFTNL_EXPR_BITWISE_OP);
196 }
197 if (tb[NFTA_BITWISE_LEN]) {
198 bitwise->len = ntohl(mnl_attr_get_u32(tb[NFTA_BITWISE_LEN]));
199 e->flags |= (1 << NFTNL_EXPR_BITWISE_LEN);
200 }
201 if (tb[NFTA_BITWISE_MASK]) {
202 ret = nftnl_parse_data(&bitwise->mask, tb[NFTA_BITWISE_MASK], NULL);
203 e->flags |= (1 << NFTA_BITWISE_MASK);
204 }
205 if (tb[NFTA_BITWISE_XOR]) {
206 ret = nftnl_parse_data(&bitwise->xor, tb[NFTA_BITWISE_XOR], NULL);
207 e->flags |= (1 << NFTA_BITWISE_XOR);
208 }
209 if (tb[NFTA_BITWISE_DATA]) {
210 ret = nftnl_parse_data(&bitwise->data, tb[NFTA_BITWISE_DATA], NULL);
211 e->flags |= (1 << NFTNL_EXPR_BITWISE_DATA);
212 }
213
214 return ret;
215}
216
217static int
218nftnl_expr_bitwise_snprintf_mask_xor(char *buf, size_t remain,
219 const struct nftnl_expr_bitwise *bitwise)
220{
221 int offset = 0, ret;
222
223 ret = snprintf(buf, remain, "reg %u = ( reg %u & ",
224 bitwise->dreg, bitwise->sreg);
225 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
226
227 ret = nftnl_data_reg_snprintf(buf + offset, remain, &bitwise->mask,
228 0, DATA_VALUE);
229 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
230
231 ret = snprintf(buf + offset, remain, " ) ^ ");
232 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
233
234 ret = nftnl_data_reg_snprintf(buf + offset, remain, &bitwise->xor,
235 0, DATA_VALUE);
236 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
237
238 ret = snprintf(buf + offset, remain, " ");
239 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
240
241 return offset;
242}
243
244static int
245nftnl_expr_bitwise_snprintf_shift(char *buf, size_t remain, const char *op,
246 const struct nftnl_expr_bitwise *bitwise)
247{ int offset = 0, ret;
248
249 ret = snprintf(buf, remain, "reg %u = ( reg %u %s ",
250 bitwise->dreg, bitwise->sreg, op);
251 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
252
253 ret = nftnl_data_reg_snprintf(buf + offset, remain, &bitwise->data,
254 0, DATA_VALUE);
255 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
256
257 ret = snprintf(buf + offset, remain, " ) ");
258 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
259
260 return offset;
261}
262
263static int
264nftnl_expr_bitwise_snprintf_bool(char *buf, size_t remain, const char *op,
265 const struct nftnl_expr *e,
266 const struct nftnl_expr_bitwise *bitwise)
267{
268 int offset = 0, ret;
269
270 ret = snprintf(buf, remain, "reg %u = ( reg %u %s ",
271 bitwise->dreg, bitwise->sreg, op);
272 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
273
274 if (e->flags & (1 << NFTNL_EXPR_BITWISE_SREG2))
275 ret = snprintf(buf + offset, remain, "reg %u ", bitwise->sreg2);
276 else
277 ret = nftnl_data_reg_snprintf(buf + offset, remain,
278 &bitwise->data,
279 0, DATA_VALUE);
280 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
281
282 ret = snprintf(buf + offset, remain, ") ");
283 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
284
285 return offset;
286}
287
288static int
289nftnl_expr_bitwise_snprintf(char *buf, size_t size,
290 uint32_t flags, const struct nftnl_expr *e)
291{
292 struct nftnl_expr_bitwise *bitwise = nftnl_expr_data(e);
293 int err = -1;
294
295 switch (bitwise->op) {
296 case NFT_BITWISE_MASK_XOR:
297 err = nftnl_expr_bitwise_snprintf_mask_xor(buf, size, bitwise);
298 break;
299 case NFT_BITWISE_LSHIFT:
300 err = nftnl_expr_bitwise_snprintf_shift(buf, size, "<<",
301 bitwise);
302 break;
303 case NFT_BITWISE_RSHIFT:
304 err = nftnl_expr_bitwise_snprintf_shift(buf, size, ">>",
305 bitwise);
306 break;
307 case NFT_BITWISE_AND:
308 err = nftnl_expr_bitwise_snprintf_bool(buf, size, "&", e,
309 bitwise);
310 break;
311 case NFT_BITWISE_OR:
312 err = nftnl_expr_bitwise_snprintf_bool(buf, size, "|", e,
313 bitwise);
314 break;
315 case NFT_BITWISE_XOR:
316 err = nftnl_expr_bitwise_snprintf_bool(buf, size, "^", e,
317 bitwise);
318 break;
319 }
320
321 return err;
322}
323
324static struct attr_policy bitwise_attr_policy[__NFTNL_EXPR_BITWISE_MAX] = {
325 [NFTNL_EXPR_BITWISE_SREG] = { .maxlen = sizeof(uint32_t) },
326 [NFTNL_EXPR_BITWISE_DREG] = { .maxlen = sizeof(uint32_t) },
327 [NFTNL_EXPR_BITWISE_LEN] = { .maxlen = sizeof(uint32_t) },
328 [NFTNL_EXPR_BITWISE_MASK] = { .maxlen = NFT_DATA_VALUE_MAXLEN },
329 [NFTNL_EXPR_BITWISE_XOR] = { .maxlen = NFT_DATA_VALUE_MAXLEN },
330 [NFTNL_EXPR_BITWISE_OP] = { .maxlen = sizeof(uint32_t) },
331 [NFTNL_EXPR_BITWISE_DATA] = { .maxlen = NFT_DATA_VALUE_MAXLEN },
332};
333
334struct expr_ops expr_ops_bitwise = {
335 .name = "bitwise",
336 .alloc_len = sizeof(struct nftnl_expr_bitwise),
337 .nftnl_max_attr = __NFTNL_EXPR_BITWISE_MAX - 1,
338 .attr_policy = bitwise_attr_policy,
339 .set = nftnl_expr_bitwise_set,
340 .get = nftnl_expr_bitwise_get,
341 .parse = nftnl_expr_bitwise_parse,
342 .build = nftnl_expr_bitwise_build,
343 .output = nftnl_expr_bitwise_snprintf,
344};
nftnl_expr_bitwise
Definition bitwise.c:20
Generated by doxygen 1.15.0