libnftnl 1.3.2
set.c
1/* SPDX-License-Identifier: GPL-2.0-or-later */
2/*
3 * (C) 2012-2013 by Pablo Neira Ayuso <pablo@netfilter.org>
4 *
5 * This code has been sponsored by Sophos Astaro <http://www.sophos.com>
6 */
7#include "internal.h"
8
9#include <time.h>
10#include <endian.h>
11#include <stdint.h>
12#include <stdlib.h>
13#include <string.h>
14#include <inttypes.h>
15#include <netinet/in.h>
16#include <limits.h>
17#include <errno.h>
18
19#include <libmnl/libmnl.h>
20#include <linux/netfilter/nfnetlink.h>
21#include <linux/netfilter/nf_tables.h>
22
23#include <libnftnl/set.h>
24#include <libnftnl/expr.h>
25
26EXPORT_SYMBOL(nftnl_set_alloc);
27struct nftnl_set *nftnl_set_alloc(void)
28{
29 struct nftnl_set *s;
30
31 s = calloc(1, sizeof(struct nftnl_set));
32 if (s == NULL)
33 return NULL;
34
35 INIT_LIST_HEAD(&s->element_list);
36 INIT_LIST_HEAD(&s->expr_list);
37 return s;
38}
39
40EXPORT_SYMBOL(nftnl_set_free);
41void nftnl_set_free(const struct nftnl_set *s)
42{
43 struct nftnl_set_elem *elem, *tmp;
44 struct nftnl_expr *expr, *next;
45
46 if (s->flags & (1 << NFTNL_SET_TABLE))
47 xfree(s->table);
48 if (s->flags & (1 << NFTNL_SET_NAME))
49 xfree(s->name);
50 if (s->flags & (1 << NFTNL_SET_USERDATA))
51 xfree(s->user.data);
52
53 list_for_each_entry_safe(expr, next, &s->expr_list, head) {
54 list_del(&expr->head);
55 nftnl_expr_free(expr);
56 }
57
58 list_for_each_entry_safe(elem, tmp, &s->element_list, head) {
59 list_del(&elem->head);
60 nftnl_set_elem_free(elem);
61 }
62
63 xfree(s->type);
64 xfree(s);
65}
66
67EXPORT_SYMBOL(nftnl_set_is_set);
68bool nftnl_set_is_set(const struct nftnl_set *s, uint16_t attr)
69{
70 return s->flags & (1 << attr);
71}
72
73EXPORT_SYMBOL(nftnl_set_unset);
74void nftnl_set_unset(struct nftnl_set *s, uint16_t attr)
75{
76 struct nftnl_expr *expr, *tmp;
77
78 if (!(s->flags & (1 << attr)))
79 return;
80
81 switch (attr) {
82 case NFTNL_SET_TABLE:
83 xfree(s->table);
84 break;
85 case NFTNL_SET_NAME:
86 xfree(s->name);
87 break;
88 case NFTNL_SET_HANDLE:
89 case NFTNL_SET_FLAGS:
90 case NFTNL_SET_KEY_TYPE:
91 case NFTNL_SET_KEY_LEN:
92 case NFTNL_SET_DATA_TYPE:
93 case NFTNL_SET_DATA_LEN:
94 case NFTNL_SET_OBJ_TYPE:
95 case NFTNL_SET_FAMILY:
96 case NFTNL_SET_ID:
97 case NFTNL_SET_POLICY:
98 case NFTNL_SET_DESC_SIZE:
99 case NFTNL_SET_DESC_CONCAT:
100 case NFTNL_SET_TIMEOUT:
101 case NFTNL_SET_GC_INTERVAL:
102 case NFTNL_SET_COUNT:
103 break;
104 case NFTNL_SET_USERDATA:
105 xfree(s->user.data);
106 break;
107 case NFTNL_SET_EXPR:
108 case NFTNL_SET_EXPRESSIONS:
109 list_for_each_entry_safe(expr, tmp, &s->expr_list, head) {
110 list_del(&expr->head);
111 nftnl_expr_free(expr);
112 }
113 break;
114 default:
115 return;
116 }
117
118 s->flags &= ~(1 << attr);
119}
120
121static uint32_t nftnl_set_validate[NFTNL_SET_MAX + 1] = {
122 [NFTNL_SET_HANDLE] = sizeof(uint64_t),
123 [NFTNL_SET_FLAGS] = sizeof(uint32_t),
124 [NFTNL_SET_KEY_TYPE] = sizeof(uint32_t),
125 [NFTNL_SET_KEY_LEN] = sizeof(uint32_t),
126 [NFTNL_SET_DATA_TYPE] = sizeof(uint32_t),
127 [NFTNL_SET_DATA_LEN] = sizeof(uint32_t),
128 [NFTNL_SET_OBJ_TYPE] = sizeof(uint32_t),
129 [NFTNL_SET_FAMILY] = sizeof(uint32_t),
130 [NFTNL_SET_ID] = sizeof(uint32_t),
131 [NFTNL_SET_POLICY] = sizeof(uint32_t),
132 [NFTNL_SET_DESC_SIZE] = sizeof(uint32_t),
133 [NFTNL_SET_TIMEOUT] = sizeof(uint64_t),
134 [NFTNL_SET_GC_INTERVAL] = sizeof(uint32_t),
135 [NFTNL_SET_COUNT] = sizeof(uint32_t),
136};
137
138EXPORT_SYMBOL(nftnl_set_set_data);
139int nftnl_set_set_data(struct nftnl_set *s, uint16_t attr, const void *data,
140 uint32_t data_len)
141{
142 struct nftnl_expr *expr, *tmp;
143
144 nftnl_assert_attr_exists(attr, NFTNL_SET_MAX);
145 nftnl_assert_validate(data, nftnl_set_validate, attr, data_len);
146
147 switch(attr) {
148 case NFTNL_SET_TABLE:
149 return nftnl_set_str_attr(&s->table, &s->flags,
150 attr, data, data_len);
151 case NFTNL_SET_NAME:
152 return nftnl_set_str_attr(&s->name, &s->flags,
153 attr, data, data_len);
154 case NFTNL_SET_HANDLE:
155 memcpy(&s->handle, data, sizeof(s->handle));
156 break;
157 case NFTNL_SET_FLAGS:
158 memcpy(&s->set_flags, data, sizeof(s->set_flags));
159 break;
160 case NFTNL_SET_KEY_TYPE:
161 memcpy(&s->key_type, data, sizeof(s->key_type));
162 break;
163 case NFTNL_SET_KEY_LEN:
164 memcpy(&s->key_len, data, sizeof(s->key_len));
165 break;
166 case NFTNL_SET_DATA_TYPE:
167 memcpy(&s->data_type, data, sizeof(s->data_type));
168 break;
169 case NFTNL_SET_DATA_LEN:
170 memcpy(&s->data_len, data, sizeof(s->data_len));
171 break;
172 case NFTNL_SET_OBJ_TYPE:
173 memcpy(&s->obj_type, data, sizeof(s->obj_type));
174 break;
175 case NFTNL_SET_FAMILY:
176 memcpy(&s->family, data, sizeof(s->family));
177 break;
178 case NFTNL_SET_ID:
179 memcpy(&s->id, data, sizeof(s->id));
180 break;
181 case NFTNL_SET_POLICY:
182 memcpy(&s->policy, data, sizeof(s->policy));
183 break;
184 case NFTNL_SET_DESC_SIZE:
185 memcpy(&s->desc.size, data, sizeof(s->desc.size));
186 break;
187 case NFTNL_SET_DESC_CONCAT:
188 if (data_len > sizeof(s->desc.field_len))
189 return -1;
190
191 memcpy(&s->desc.field_len, data, data_len);
192 for (s->desc.field_count = 0;
193 s->desc.field_count < NFT_REG32_COUNT;
194 s->desc.field_count++) {
195 if (!s->desc.field_len[s->desc.field_count])
196 break;
197 }
198 break;
199 case NFTNL_SET_TIMEOUT:
200 memcpy(&s->timeout, data, sizeof(s->timeout));
201 break;
202 case NFTNL_SET_GC_INTERVAL:
203 memcpy(&s->gc_interval, data, sizeof(s->gc_interval));
204 break;
205 case NFTNL_SET_COUNT:
206 memcpy(&s->elemcount, data, sizeof(s->elemcount));
207 break;
208 case NFTNL_SET_USERDATA:
209 if (s->flags & (1 << NFTNL_SET_USERDATA))
210 xfree(s->user.data);
211
212 s->user.data = malloc(data_len);
213 if (!s->user.data)
214 return -1;
215 memcpy(s->user.data, data, data_len);
216 s->user.len = data_len;
217 break;
218 case NFTNL_SET_EXPR:
219 list_for_each_entry_safe(expr, tmp, &s->expr_list, head) {
220 list_del(&expr->head);
221 nftnl_expr_free(expr);
222 }
223
224 expr = (void *)data;
225 list_add(&expr->head, &s->expr_list);
226 break;
227 }
228 s->flags |= (1 << attr);
229 return 0;
230}
231
232int nftnl_set_set(struct nftnl_set *s, uint16_t attr, const void *data) __visible;
233int nftnl_set_set(struct nftnl_set *s, uint16_t attr, const void *data)
234{
235 return nftnl_set_set_data(s, attr, data, nftnl_set_validate[attr]);
236}
237
238EXPORT_SYMBOL(nftnl_set_set_u32);
239void nftnl_set_set_u32(struct nftnl_set *s, uint16_t attr, uint32_t val)
240{
241 nftnl_set_set_data(s, attr, &val, sizeof(uint32_t));
242}
243
244EXPORT_SYMBOL(nftnl_set_set_u64);
245void nftnl_set_set_u64(struct nftnl_set *s, uint16_t attr, uint64_t val)
246{
247 nftnl_set_set_data(s, attr, &val, sizeof(uint64_t));
248}
249
250EXPORT_SYMBOL(nftnl_set_set_str);
251int nftnl_set_set_str(struct nftnl_set *s, uint16_t attr, const char *str)
252{
253 return nftnl_set_set_data(s, attr, str, strlen(str) + 1);
254}
255
256EXPORT_SYMBOL(nftnl_set_get_data);
257const void *nftnl_set_get_data(const struct nftnl_set *s, uint16_t attr,
258 uint32_t *data_len)
259{
260 struct nftnl_expr *expr;
261
262 if (!(s->flags & (1 << attr)))
263 return NULL;
264
265 switch(attr) {
266 case NFTNL_SET_TABLE:
267 *data_len = strlen(s->table) + 1;
268 return s->table;
269 case NFTNL_SET_NAME:
270 *data_len = strlen(s->name) + 1;
271 return s->name;
272 case NFTNL_SET_HANDLE:
273 *data_len = sizeof(uint64_t);
274 return &s->handle;
275 case NFTNL_SET_FLAGS:
276 *data_len = sizeof(uint32_t);
277 return &s->set_flags;
278 case NFTNL_SET_KEY_TYPE:
279 *data_len = sizeof(uint32_t);
280 return &s->key_type;
281 case NFTNL_SET_KEY_LEN:
282 *data_len = sizeof(uint32_t);
283 return &s->key_len;
284 case NFTNL_SET_DATA_TYPE:
285 *data_len = sizeof(uint32_t);
286 return &s->data_type;
287 case NFTNL_SET_DATA_LEN:
288 *data_len = sizeof(uint32_t);
289 return &s->data_len;
290 case NFTNL_SET_OBJ_TYPE:
291 *data_len = sizeof(uint32_t);
292 return &s->obj_type;
293 case NFTNL_SET_FAMILY:
294 *data_len = sizeof(uint32_t);
295 return &s->family;
296 case NFTNL_SET_ID:
297 *data_len = sizeof(uint32_t);
298 return &s->id;
299 case NFTNL_SET_POLICY:
300 *data_len = sizeof(uint32_t);
301 return &s->policy;
302 case NFTNL_SET_DESC_SIZE:
303 *data_len = sizeof(uint32_t);
304 return &s->desc.size;
305 case NFTNL_SET_DESC_CONCAT:
306 *data_len = s->desc.field_count;
307 return s->desc.field_len;
308 case NFTNL_SET_TIMEOUT:
309 *data_len = sizeof(uint64_t);
310 return &s->timeout;
311 case NFTNL_SET_GC_INTERVAL:
312 *data_len = sizeof(uint32_t);
313 return &s->gc_interval;
314 case NFTNL_SET_COUNT:
315 *data_len = sizeof(uint32_t);
316 return &s->elemcount;
317 case NFTNL_SET_USERDATA:
318 *data_len = s->user.len;
319 return s->user.data;
320 case NFTNL_SET_EXPR:
321 list_for_each_entry(expr, &s->expr_list, head)
322 break;
323 return expr;
324 }
325 return NULL;
326}
327
328EXPORT_SYMBOL(nftnl_set_get);
329const void *nftnl_set_get(const struct nftnl_set *s, uint16_t attr)
330{
331 uint32_t data_len;
332 return nftnl_set_get_data(s, attr, &data_len);
333}
334
335EXPORT_SYMBOL(nftnl_set_get_str);
336const char *nftnl_set_get_str(const struct nftnl_set *s, uint16_t attr)
337{
338 return nftnl_set_get(s, attr);
339}
340
341EXPORT_SYMBOL(nftnl_set_get_u32);
342uint32_t nftnl_set_get_u32(const struct nftnl_set *s, uint16_t attr)
343{
344 uint32_t data_len;
345 const uint32_t *val = nftnl_set_get_data(s, attr, &data_len);
346
347 nftnl_assert(val, attr, data_len == sizeof(uint32_t));
348
349 return val ? *val : 0;
350}
351
352EXPORT_SYMBOL(nftnl_set_get_u64);
353uint64_t nftnl_set_get_u64(const struct nftnl_set *s, uint16_t attr)
354{
355 uint32_t data_len;
356 const uint64_t *val = nftnl_set_get_data(s, attr, &data_len);
357
358 nftnl_assert(val, attr, data_len == sizeof(uint64_t));
359
360 return val ? *val : 0;
361}
362
363static void nftnl_set_nlmsg_build_desc_size_payload(struct nlmsghdr *nlh,
364 struct nftnl_set *s)
365{
366 mnl_attr_put_u32(nlh, NFTA_SET_DESC_SIZE, htonl(s->desc.size));
367}
368
369static void nftnl_set_nlmsg_build_desc_concat_payload(struct nlmsghdr *nlh,
370 struct nftnl_set *s)
371{
372 struct nlattr *nest;
373 int i;
374
375 nest = mnl_attr_nest_start(nlh, NFTA_SET_DESC_CONCAT);
376 for (i = 0; i < NFT_REG32_COUNT && i < s->desc.field_count; i++) {
377 struct nlattr *nest_elem;
378
379 nest_elem = mnl_attr_nest_start(nlh, NFTA_LIST_ELEM);
380 mnl_attr_put_u32(nlh, NFTA_SET_FIELD_LEN,
381 htonl(s->desc.field_len[i]));
382 mnl_attr_nest_end(nlh, nest_elem);
383 }
384 mnl_attr_nest_end(nlh, nest);
385}
386
387static void
388nftnl_set_nlmsg_build_desc_payload(struct nlmsghdr *nlh, struct nftnl_set *s)
389{
390 struct nlattr *nest;
391
392 nest = mnl_attr_nest_start(nlh, NFTA_SET_DESC);
393
394 if (s->flags & (1 << NFTNL_SET_DESC_SIZE))
395 nftnl_set_nlmsg_build_desc_size_payload(nlh, s);
396 if (s->flags & (1 << NFTNL_SET_DESC_CONCAT))
397 nftnl_set_nlmsg_build_desc_concat_payload(nlh, s);
398
399 mnl_attr_nest_end(nlh, nest);
400}
401
402EXPORT_SYMBOL(nftnl_set_nlmsg_build_payload);
403void nftnl_set_nlmsg_build_payload(struct nlmsghdr *nlh, struct nftnl_set *s)
404{
405 int num_exprs = 0;
406
407 if (s->flags & (1 << NFTNL_SET_TABLE))
408 mnl_attr_put_strz(nlh, NFTA_SET_TABLE, s->table);
409 if (s->flags & (1 << NFTNL_SET_NAME))
410 mnl_attr_put_strz(nlh, NFTA_SET_NAME, s->name);
411 if (s->flags & (1 << NFTNL_SET_HANDLE))
412 mnl_attr_put_u64(nlh, NFTA_SET_HANDLE, htobe64(s->handle));
413 if (s->flags & (1 << NFTNL_SET_FLAGS))
414 mnl_attr_put_u32(nlh, NFTA_SET_FLAGS, htonl(s->set_flags));
415 if (s->flags & (1 << NFTNL_SET_KEY_TYPE))
416 mnl_attr_put_u32(nlh, NFTA_SET_KEY_TYPE, htonl(s->key_type));
417 if (s->flags & (1 << NFTNL_SET_KEY_LEN))
418 mnl_attr_put_u32(nlh, NFTA_SET_KEY_LEN, htonl(s->key_len));
419 /* These are only used to map matching -> action (1:1) */
420 if (s->flags & (1 << NFTNL_SET_DATA_TYPE))
421 mnl_attr_put_u32(nlh, NFTA_SET_DATA_TYPE, htonl(s->data_type));
422 if (s->flags & (1 << NFTNL_SET_DATA_LEN))
423 mnl_attr_put_u32(nlh, NFTA_SET_DATA_LEN, htonl(s->data_len));
424 if (s->flags & (1 << NFTNL_SET_OBJ_TYPE))
425 mnl_attr_put_u32(nlh, NFTA_SET_OBJ_TYPE, htonl(s->obj_type));
426 if (s->flags & (1 << NFTNL_SET_ID))
427 mnl_attr_put_u32(nlh, NFTA_SET_ID, htonl(s->id));
428 if (s->flags & (1 << NFTNL_SET_POLICY))
429 mnl_attr_put_u32(nlh, NFTA_SET_POLICY, htonl(s->policy));
430 if (s->flags & (1 << NFTNL_SET_DESC_SIZE | 1 << NFTNL_SET_DESC_CONCAT))
431 nftnl_set_nlmsg_build_desc_payload(nlh, s);
432 if (s->flags & (1 << NFTNL_SET_TIMEOUT))
433 mnl_attr_put_u64(nlh, NFTA_SET_TIMEOUT, htobe64(s->timeout));
434 if (s->flags & (1 << NFTNL_SET_GC_INTERVAL))
435 mnl_attr_put_u32(nlh, NFTA_SET_GC_INTERVAL, htonl(s->gc_interval));
436 if (s->flags & (1 << NFTNL_SET_USERDATA))
437 mnl_attr_put(nlh, NFTA_SET_USERDATA, s->user.len, s->user.data);
438 if (!list_empty(&s->expr_list)) {
439 struct nftnl_expr *expr;
440
441 list_for_each_entry(expr, &s->expr_list, head)
442 num_exprs++;
443
444 if (num_exprs == 1) {
445 struct nlattr *nest1;
446
447 nest1 = mnl_attr_nest_start(nlh, NFTA_SET_EXPR);
448 list_for_each_entry(expr, &s->expr_list, head)
449 nftnl_expr_build_payload(nlh, expr);
450
451 mnl_attr_nest_end(nlh, nest1);
452 } else if (num_exprs > 1) {
453 struct nlattr *nest1, *nest2;
454
455 nest1 = mnl_attr_nest_start(nlh, NFTA_SET_EXPRESSIONS);
456 list_for_each_entry(expr, &s->expr_list, head) {
457 nest2 = mnl_attr_nest_start(nlh, NFTA_LIST_ELEM);
458 nftnl_expr_build_payload(nlh, expr);
459 mnl_attr_nest_end(nlh, nest2);
460 }
461 mnl_attr_nest_end(nlh, nest1);
462 }
463 }
464}
465
466EXPORT_SYMBOL(nftnl_set_add_expr);
467void nftnl_set_add_expr(struct nftnl_set *s, struct nftnl_expr *expr)
468{
469 list_add_tail(&expr->head, &s->expr_list);
470}
471
472EXPORT_SYMBOL(nftnl_set_expr_foreach);
473int nftnl_set_expr_foreach(const struct nftnl_set *s,
474 int (*cb)(struct nftnl_expr *e, void *data),
475 void *data)
476{
477 struct nftnl_expr *cur, *tmp;
478 int ret;
479
480 list_for_each_entry_safe(cur, tmp, &s->expr_list, head) {
481 ret = cb(cur, data);
482 if (ret < 0)
483 return ret;
484 }
485 return 0;
486}
487
488static int nftnl_set_parse_attr_cb(const struct nlattr *attr, void *data)
489{
490 const struct nlattr **tb = data;
491 int type = mnl_attr_get_type(attr);
492
493 if (mnl_attr_type_valid(attr, NFTA_SET_MAX) < 0)
494 return MNL_CB_OK;
495
496 switch(type) {
497 case NFTA_SET_TABLE:
498 case NFTA_SET_NAME:
499 case NFTA_SET_TYPE:
500 if (mnl_attr_validate(attr, MNL_TYPE_STRING) < 0)
501 abi_breakage();
502 break;
503 case NFTA_SET_HANDLE:
504 if (mnl_attr_validate(attr, MNL_TYPE_U64) < 0)
505 abi_breakage();
506 break;
507 case NFTA_SET_FLAGS:
508 case NFTA_SET_KEY_TYPE:
509 case NFTA_SET_KEY_LEN:
510 case NFTA_SET_DATA_TYPE:
511 case NFTA_SET_DATA_LEN:
512 case NFTA_SET_ID:
513 case NFTA_SET_POLICY:
514 case NFTA_SET_GC_INTERVAL:
515 case NFTA_SET_COUNT:
516 if (mnl_attr_validate(attr, MNL_TYPE_U32) < 0)
517 abi_breakage();
518 break;
519 case NFTA_SET_USERDATA:
520 if (mnl_attr_validate(attr, MNL_TYPE_BINARY) < 0)
521 abi_breakage();
522 break;
523 case NFTA_SET_TIMEOUT:
524 if (mnl_attr_validate(attr, MNL_TYPE_U64) < 0)
525 abi_breakage();
526 break;
527 case NFTA_SET_DESC:
528 case NFTA_SET_EXPR:
529 case NFTA_SET_EXPRESSIONS:
530 if (mnl_attr_validate(attr, MNL_TYPE_NESTED) < 0)
531 abi_breakage();
532 break;
533 }
534
535 tb[type] = attr;
536 return MNL_CB_OK;
537}
538
539static int
540nftnl_set_desc_concat_field_parse_attr_cb(const struct nlattr *attr, void *data)
541{
542 int type = mnl_attr_get_type(attr);
543 struct nftnl_set *s = data;
544
545 if (type != NFTA_SET_FIELD_LEN)
546 return MNL_CB_OK;
547
548 if (mnl_attr_validate(attr, MNL_TYPE_U32))
549 return MNL_CB_ERROR;
550
551 s->desc.field_len[s->desc.field_count] = ntohl(mnl_attr_get_u32(attr));
552 s->desc.field_count++;
553
554 return MNL_CB_OK;
555}
556
557static int
558nftnl_set_desc_concat_parse_attr_cb(const struct nlattr *attr, void *data)
559{
560 int type = mnl_attr_get_type(attr);
561 struct nftnl_set *s = data;
562
563 if (type != NFTA_LIST_ELEM)
564 return MNL_CB_OK;
565
566 return mnl_attr_parse_nested(attr,
567 nftnl_set_desc_concat_field_parse_attr_cb,
568 s);
569}
570
571static int nftnl_set_desc_parse_attr_cb(const struct nlattr *attr, void *data)
572{
573 int type = mnl_attr_get_type(attr), err;
574 struct nftnl_set *s = data;
575
576 if (mnl_attr_type_valid(attr, NFTA_SET_DESC_MAX) < 0)
577 return MNL_CB_OK;
578
579 switch (type) {
580 case NFTA_SET_DESC_SIZE:
581 if (mnl_attr_validate(attr, MNL_TYPE_U32) < 0) {
582 abi_breakage();
583 break;
584 }
585
586 s->desc.size = ntohl(mnl_attr_get_u32(attr));
587 s->flags |= (1 << NFTNL_SET_DESC_SIZE);
588 break;
589 case NFTA_SET_DESC_CONCAT:
590 err = mnl_attr_parse_nested(attr,
591 nftnl_set_desc_concat_parse_attr_cb,
592 s);
593 if (err != MNL_CB_OK)
594 abi_breakage();
595
596 s->flags |= (1 << NFTNL_SET_DESC_CONCAT);
597 break;
598 default:
599 break;
600 }
601
602 return MNL_CB_OK;
603}
604
605static int nftnl_set_desc_parse(struct nftnl_set *s, const struct nlattr *attr)
606{
607 return mnl_attr_parse_nested(attr, nftnl_set_desc_parse_attr_cb, s);
608}
609
610EXPORT_SYMBOL(nftnl_set_nlmsg_parse);
611int nftnl_set_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_set *s)
612{
613 struct nlattr *tb[NFTA_SET_MAX+1] = {};
614 struct nfgenmsg *nfg = mnl_nlmsg_get_payload(nlh);
615 struct nftnl_expr *expr, *next;
616 int ret;
617
618 if (mnl_attr_parse(nlh, sizeof(*nfg), nftnl_set_parse_attr_cb, tb) < 0)
619 return -1;
620
621 if (nftnl_parse_str_attr(tb[NFTA_SET_TABLE], NFTNL_SET_TABLE,
622 &s->table, &s->flags) < 0)
623 return -1;
624 if (nftnl_parse_str_attr(tb[NFTA_SET_NAME], NFTNL_SET_NAME,
625 &s->name, &s->flags) < 0)
626 return -1;
627 if (tb[NFTA_SET_HANDLE]) {
628 s->handle = be64toh(mnl_attr_get_u64(tb[NFTA_SET_HANDLE]));
629 s->flags |= (1 << NFTNL_SET_HANDLE);
630 }
631 if (tb[NFTA_SET_FLAGS]) {
632 s->set_flags = ntohl(mnl_attr_get_u32(tb[NFTA_SET_FLAGS]));
633 s->flags |= (1 << NFTNL_SET_FLAGS);
634 }
635 if (tb[NFTA_SET_KEY_TYPE]) {
636 s->key_type = ntohl(mnl_attr_get_u32(tb[NFTA_SET_KEY_TYPE]));
637 s->flags |= (1 << NFTNL_SET_KEY_TYPE);
638 }
639 if (tb[NFTA_SET_KEY_LEN]) {
640 s->key_len = ntohl(mnl_attr_get_u32(tb[NFTA_SET_KEY_LEN]));
641 s->flags |= (1 << NFTNL_SET_KEY_LEN);
642 }
643 if (tb[NFTA_SET_DATA_TYPE]) {
644 s->data_type = ntohl(mnl_attr_get_u32(tb[NFTA_SET_DATA_TYPE]));
645 s->flags |= (1 << NFTNL_SET_DATA_TYPE);
646 }
647 if (tb[NFTA_SET_DATA_LEN]) {
648 s->data_len = ntohl(mnl_attr_get_u32(tb[NFTA_SET_DATA_LEN]));
649 s->flags |= (1 << NFTNL_SET_DATA_LEN);
650 }
651 if (tb[NFTA_SET_OBJ_TYPE]) {
652 s->obj_type = ntohl(mnl_attr_get_u32(tb[NFTA_SET_OBJ_TYPE]));
653 s->flags |= (1 << NFTNL_SET_OBJ_TYPE);
654 }
655 if (tb[NFTA_SET_ID]) {
656 s->id = ntohl(mnl_attr_get_u32(tb[NFTA_SET_ID]));
657 s->flags |= (1 << NFTNL_SET_ID);
658 }
659 if (tb[NFTA_SET_POLICY]) {
660 s->policy = ntohl(mnl_attr_get_u32(tb[NFTA_SET_POLICY]));
661 s->flags |= (1 << NFTNL_SET_POLICY);
662 }
663 if (tb[NFTA_SET_TIMEOUT]) {
664 s->timeout = be64toh(mnl_attr_get_u64(tb[NFTA_SET_TIMEOUT]));
665 s->flags |= (1 << NFTNL_SET_TIMEOUT);
666 }
667 if (tb[NFTA_SET_GC_INTERVAL]) {
668 s->gc_interval = ntohl(mnl_attr_get_u32(tb[NFTA_SET_GC_INTERVAL]));
669 s->flags |= (1 << NFTNL_SET_GC_INTERVAL);
670 }
671 if (tb[NFTA_SET_USERDATA]) {
672 ret = nftnl_set_set_data(s, NFTNL_SET_USERDATA,
673 mnl_attr_get_payload(tb[NFTA_SET_USERDATA]),
674 mnl_attr_get_payload_len(tb[NFTA_SET_USERDATA]));
675 if (ret < 0)
676 return ret;
677 }
678 if (tb[NFTA_SET_DESC]) {
679 ret = nftnl_set_desc_parse(s, tb[NFTA_SET_DESC]);
680 if (ret < 0)
681 return ret;
682 }
683 if (tb[NFTA_SET_EXPR]) {
684 expr = nftnl_expr_parse(tb[NFTA_SET_EXPR]);
685 if (!expr)
686 goto out_set_expr;
687
688 list_add(&expr->head, &s->expr_list);
689 s->flags |= (1 << NFTNL_SET_EXPR);
690 } else if (tb[NFTA_SET_EXPRESSIONS]) {
691 struct nlattr *attr;
692
693 mnl_attr_for_each_nested(attr, tb[NFTA_SET_EXPRESSIONS]) {
694 if (mnl_attr_get_type(attr) != NFTA_LIST_ELEM)
695 goto out_set_expr;
696
697 expr = nftnl_expr_parse(attr);
698 if (expr == NULL)
699 goto out_set_expr;
700
701 list_add_tail(&expr->head, &s->expr_list);
702 }
703 s->flags |= (1 << NFTNL_SET_EXPRESSIONS);
704 }
705
706 if (tb[NFTA_SET_TYPE]) {
707 xfree(s->type);
708 s->type = strdup(mnl_attr_get_str(tb[NFTA_SET_TYPE]));
709 }
710
711 if (tb[NFTA_SET_COUNT]) {
712 s->elemcount = ntohl(mnl_attr_get_u32(tb[NFTA_SET_COUNT]));
713 s->flags |= (1 << NFTNL_SET_COUNT);
714 }
715
716 s->family = nfg->nfgen_family;
717 s->flags |= (1 << NFTNL_SET_FAMILY);
718
719 return 0;
720out_set_expr:
721 list_for_each_entry_safe(expr, next, &s->expr_list, head) {
722 list_del(&expr->head);
723 nftnl_expr_free(expr);
724 }
725
726 return -1;
727}
728
729EXPORT_SYMBOL(nftnl_set_parse);
730int nftnl_set_parse(struct nftnl_set *s, enum nftnl_parse_type type,
731 const char *data, struct nftnl_parse_err *err)
732{
733 errno = EOPNOTSUPP;
734
735 return -1;
736}
737
738EXPORT_SYMBOL(nftnl_set_parse_file);
739int nftnl_set_parse_file(struct nftnl_set *s, enum nftnl_parse_type type,
740 FILE *fp, struct nftnl_parse_err *err)
741{
742 errno = EOPNOTSUPP;
743
744 return -1;
745}
746
747static int nftnl_set_snprintf_default(char *buf, size_t remain,
748 const struct nftnl_set *s,
749 uint32_t type, uint32_t flags)
750{
751 struct nftnl_set_elem *elem;
752 int ret, offset = 0;
753
754 ret = snprintf(buf, remain, "%s %s %x",
755 s->name, s->table, s->set_flags);
756 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
757
758 if (s->flags & (1 << NFTNL_SET_TIMEOUT)) {
759 ret = snprintf(buf + offset, remain, " timeout %"PRIu64"ms",
760 s->timeout);
761 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
762 }
763
764 if (s->flags & (1 << NFTNL_SET_GC_INTERVAL)) {
765 ret = snprintf(buf + offset, remain, " gc_interval %ums",
766 s->gc_interval);
767 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
768 }
769
770 if (s->flags & (1 << NFTNL_SET_POLICY)) {
771 ret = snprintf(buf + offset, remain, " policy %u", s->policy);
772 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
773 }
774
775 if (s->flags & (1 << NFTNL_SET_DESC_SIZE)) {
776 ret = snprintf(buf + offset, remain, " size %u", s->desc.size);
777 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
778 }
779
780 if (s->type) {
781 ret = snprintf(buf + offset, remain, " backend %s", s->type);
782 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
783 }
784
785 if (s->elemcount) {
786 ret = snprintf(buf + offset, remain, " count %u", s->elemcount);
787 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
788 }
789
790 /* Empty set? Skip printinf of elements */
791 if (list_empty(&s->element_list))
792 return offset;
793
794 ret = snprintf(buf + offset, remain, "\n");
795 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
796
797 list_for_each_entry(elem, &s->element_list, head) {
798 ret = snprintf(buf + offset, remain, "\t");
799 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
800
801 ret = nftnl_set_elem_snprintf_default(buf + offset, remain,
802 elem);
803 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
804 }
805
806 return offset;
807}
808
809static int nftnl_set_cmd_snprintf(char *buf, size_t remain,
810 const struct nftnl_set *s, uint32_t cmd,
811 uint32_t type, uint32_t flags)
812{
813 uint32_t inner_flags = flags;
814 int ret, offset = 0;
815
816 if (type != NFTNL_OUTPUT_DEFAULT)
817 return -1;
818
819 /* prevent set_elems to print as events */
820 inner_flags &= ~NFTNL_OF_EVENT_ANY;
821
822 ret = nftnl_set_snprintf_default(buf + offset, remain, s, type,
823 inner_flags);
824 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
825 return offset;
826}
827
828EXPORT_SYMBOL(nftnl_set_snprintf);
829int nftnl_set_snprintf(char *buf, size_t size, const struct nftnl_set *s,
830 uint32_t type, uint32_t flags)
831{
832 if (size)
833 buf[0] = '\0';
834
835 return nftnl_set_cmd_snprintf(buf, size, s, nftnl_flag2cmd(flags), type,
836 flags);
837}
838
839static int nftnl_set_do_snprintf(char *buf, size_t size, const void *s,
840 uint32_t cmd, uint32_t type, uint32_t flags)
841{
842 return nftnl_set_snprintf(buf, size, s, type, flags);
843}
844
845EXPORT_SYMBOL(nftnl_set_fprintf);
846int nftnl_set_fprintf(FILE *fp, const struct nftnl_set *s, uint32_t type,
847 uint32_t flags)
848{
849 return nftnl_fprintf(fp, s, NFTNL_CMD_UNSPEC, type, flags,
850 nftnl_set_do_snprintf);
851}
852
853EXPORT_SYMBOL(nftnl_set_elem_add);
854void nftnl_set_elem_add(struct nftnl_set *s, struct nftnl_set_elem *elem)
855{
856 list_add_tail(&elem->head, &s->element_list);
857}
858
859#define SET_NAME_HSIZE 512
860
861struct nftnl_set_list {
862 struct list_head list;
863 struct hlist_head name_hash[SET_NAME_HSIZE];
864};
865
866EXPORT_SYMBOL(nftnl_set_list_alloc);
867struct nftnl_set_list *nftnl_set_list_alloc(void)
868{
869 struct nftnl_set_list *list;
870 int i;
871
872 list = calloc(1, sizeof(struct nftnl_set_list));
873 if (list == NULL)
874 return NULL;
875
876 INIT_LIST_HEAD(&list->list);
877 for (i = 0; i < SET_NAME_HSIZE; i++)
878 INIT_HLIST_HEAD(&list->name_hash[i]);
879
880 return list;
881}
882
883EXPORT_SYMBOL(nftnl_set_list_free);
884void nftnl_set_list_free(struct nftnl_set_list *list)
885{
886 struct nftnl_set *s, *tmp;
887
888 list_for_each_entry_safe(s, tmp, &list->list, head) {
889 list_del(&s->head);
890 hlist_del(&s->hnode);
891 nftnl_set_free(s);
892 }
893 xfree(list);
894}
895
896EXPORT_SYMBOL(nftnl_set_list_is_empty);
897int nftnl_set_list_is_empty(const struct nftnl_set_list *list)
898{
899 return list_empty(&list->list);
900}
901
902static uint32_t djb_hash(const char *key)
903{
904 uint32_t i, hash = 5381;
905
906 for (i = 0; i < strlen(key); i++)
907 hash = ((hash << 5) + hash) + key[i];
908
909 return hash;
910}
911
912EXPORT_SYMBOL(nftnl_set_list_add);
913void nftnl_set_list_add(struct nftnl_set *s, struct nftnl_set_list *list)
914{
915 int key = djb_hash(s->name) % SET_NAME_HSIZE;
916
917 hlist_add_head(&s->hnode, &list->name_hash[key]);
918 list_add(&s->head, &list->list);
919}
920
921EXPORT_SYMBOL(nftnl_set_list_add_tail);
922void nftnl_set_list_add_tail(struct nftnl_set *s, struct nftnl_set_list *list)
923{
924 int key = djb_hash(s->name) % SET_NAME_HSIZE;
925
926 hlist_add_head(&s->hnode, &list->name_hash[key]);
927 list_add_tail(&s->head, &list->list);
928}
929
930EXPORT_SYMBOL(nftnl_set_list_del);
931void nftnl_set_list_del(struct nftnl_set *s)
932{
933 list_del(&s->head);
934 hlist_del(&s->hnode);
935}
936
937EXPORT_SYMBOL(nftnl_set_list_foreach);
938int nftnl_set_list_foreach(struct nftnl_set_list *set_list,
939 int (*cb)(struct nftnl_set *t, void *data), void *data)
940{
941 struct nftnl_set *cur, *tmp;
942 int ret;
943
944 list_for_each_entry_safe(cur, tmp, &set_list->list, head) {
945 ret = cb(cur, data);
946 if (ret < 0)
947 return ret;
948 }
949 return 0;
950}
951
952struct nftnl_set_list_iter {
953 const struct nftnl_set_list *list;
954 struct nftnl_set *cur;
955};
956
957EXPORT_SYMBOL(nftnl_set_list_iter_create);
958struct nftnl_set_list_iter *
959nftnl_set_list_iter_create(const struct nftnl_set_list *l)
960{
961 struct nftnl_set_list_iter *iter;
962
963 iter = calloc(1, sizeof(struct nftnl_set_list_iter));
964 if (iter == NULL)
965 return NULL;
966
967 iter->list = l;
968 if (nftnl_set_list_is_empty(l))
969 iter->cur = NULL;
970 else
971 iter->cur = list_entry(l->list.next, struct nftnl_set, head);
972
973 return iter;
974}
975
976EXPORT_SYMBOL(nftnl_set_list_iter_cur);
977struct nftnl_set *
978nftnl_set_list_iter_cur(const struct nftnl_set_list_iter *iter)
979{
980 return iter->cur;
981}
982
983EXPORT_SYMBOL(nftnl_set_list_iter_next);
984struct nftnl_set *nftnl_set_list_iter_next(struct nftnl_set_list_iter *iter)
985{
986 struct nftnl_set *s = iter->cur;
987
988 if (s == NULL)
989 return NULL;
990
991 /* get next rule, if any */
992 iter->cur = list_entry(iter->cur->head.next, struct nftnl_set, head);
993 if (&iter->cur->head == iter->list->list.next)
994 return NULL;
995
996 return s;
997}
998
999EXPORT_SYMBOL(nftnl_set_list_iter_destroy);
1000void nftnl_set_list_iter_destroy(const struct nftnl_set_list_iter *iter)
1001{
1002 xfree(iter);
1003}
1004
1005EXPORT_SYMBOL(nftnl_set_list_lookup_byname);
1006struct nftnl_set *
1007nftnl_set_list_lookup_byname(struct nftnl_set_list *set_list, const char *set)
1008{
1009 int key = djb_hash(set) % SET_NAME_HSIZE;
1010 struct hlist_node *n;
1011 struct nftnl_set *s;
1012
1013 hlist_for_each_entry(s, n, &set_list->name_hash[key], hnode) {
1014 if (!strcmp(set, s->name))
1015 return s;
1016 }
1017 return NULL;
1018}
1019
1020int nftnl_set_lookup_id(struct nftnl_expr *e,
1021 struct nftnl_set_list *set_list, uint32_t *set_id)
1022{
1023 const char *set_name;
1024 struct nftnl_set *s;
1025
1026 set_name = nftnl_expr_get_str(e, NFTNL_EXPR_LOOKUP_SET);
1027 if (set_name == NULL)
1028 return 0;
1029
1030 s = nftnl_set_list_lookup_byname(set_list, set_name);
1031 if (s == NULL)
1032 return 0;
1033
1034 *set_id = nftnl_set_get_u32(s, NFTNL_SET_ID);
1035 return 1;
1036}
nftnl_set_list_iter
Definition set.c:952
nftnl_set_list
Definition set.c:861
Generated by doxygen 1.15.0