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 
20 struct 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 
31 static int
32 nftnl_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 
66 static const void *
67 nftnl_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 
101 static 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 
130 static void
131 nftnl_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 
171 static int
172 nftnl_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 
217 static int
218 nftnl_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 
244 static int
245 nftnl_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 
263 static int
264 nftnl_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 
288 static int
289 nftnl_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 
324 static 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 
334 struct 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.8.10