15#include <libmnl/libmnl.h>
16#include <libnftnl/ruleset.h>
17#include <libnftnl/table.h>
18#include <libnftnl/chain.h>
19#include <libnftnl/set.h>
20#include <libnftnl/rule.h>
32 enum nftnl_cmd_type cmd;
33 enum nftnl_ruleset_type type;
37 struct nftnl_rule *rule;
38 struct nftnl_set *set;
39 struct nftnl_set_elem *set_elem;
52EXPORT_SYMBOL(nftnl_ruleset_alloc);
58EXPORT_SYMBOL(nftnl_ruleset_free);
61 if (r->flags & (1 << NFTNL_RULESET_TABLELIST))
62 nftnl_table_list_free(r->table_list);
63 if (r->flags & (1 << NFTNL_RULESET_CHAINLIST))
64 nftnl_chain_list_free(r->chain_list);
65 if (r->flags & (1 << NFTNL_RULESET_SETLIST))
66 nftnl_set_list_free(r->set_list);
67 if (r->flags & (1 << NFTNL_RULESET_RULELIST))
68 nftnl_rule_list_free(r->rule_list);
72EXPORT_SYMBOL(nftnl_ruleset_is_set);
73bool nftnl_ruleset_is_set(
const struct nftnl_ruleset *r, uint16_t attr)
75 return r->flags & (1 << attr);
78EXPORT_SYMBOL(nftnl_ruleset_unset);
79void nftnl_ruleset_unset(
struct nftnl_ruleset *r, uint16_t attr)
81 if (!(r->flags & (1 << attr)))
85 case NFTNL_RULESET_TABLELIST:
86 nftnl_table_list_free(r->table_list);
88 case NFTNL_RULESET_CHAINLIST:
89 nftnl_chain_list_free(r->chain_list);
91 case NFTNL_RULESET_SETLIST:
92 nftnl_set_list_free(r->set_list);
94 case NFTNL_RULESET_RULELIST:
95 nftnl_rule_list_free(r->rule_list);
98 r->flags &= ~(1 << attr);
101EXPORT_SYMBOL(nftnl_ruleset_set);
102void nftnl_ruleset_set(
struct nftnl_ruleset *r, uint16_t attr,
void *data)
105 case NFTNL_RULESET_TABLELIST:
106 nftnl_ruleset_unset(r, NFTNL_RULESET_TABLELIST);
107 r->table_list = data;
109 case NFTNL_RULESET_CHAINLIST:
110 nftnl_ruleset_unset(r, NFTNL_RULESET_CHAINLIST);
111 r->chain_list = data;
113 case NFTNL_RULESET_SETLIST:
114 nftnl_ruleset_unset(r, NFTNL_RULESET_SETLIST);
117 case NFTNL_RULESET_RULELIST:
118 nftnl_ruleset_unset(r, NFTNL_RULESET_RULELIST);
124 r->flags |= (1 << attr);
127EXPORT_SYMBOL(nftnl_ruleset_get);
128void *nftnl_ruleset_get(
const struct nftnl_ruleset *r, uint16_t attr)
130 if (!(r->flags & (1 << attr)))
134 case NFTNL_RULESET_TABLELIST:
135 return r->table_list;
136 case NFTNL_RULESET_CHAINLIST:
137 return r->chain_list;
138 case NFTNL_RULESET_SETLIST:
140 case NFTNL_RULESET_RULELIST:
147EXPORT_SYMBOL(nftnl_ruleset_ctx_free);
151 case NFTNL_RULESET_TABLE:
152 nftnl_table_free(ctx->table);
154 case NFTNL_RULESET_CHAIN:
155 nftnl_chain_free(ctx->chain);
157 case NFTNL_RULESET_RULE:
158 nftnl_rule_free(ctx->rule);
160 case NFTNL_RULESET_SET:
161 case NFTNL_RULESET_SET_ELEMS:
162 nftnl_set_free(ctx->set);
164 case NFTNL_RULESET_RULESET:
165 case NFTNL_RULESET_UNSPEC:
170EXPORT_SYMBOL(nftnl_ruleset_ctx_is_set);
171bool nftnl_ruleset_ctx_is_set(
const struct nftnl_parse_ctx *ctx, uint16_t attr)
173 return ctx->flags & (1 << attr);
176EXPORT_SYMBOL(nftnl_ruleset_ctx_get);
177void *nftnl_ruleset_ctx_get(
const struct nftnl_parse_ctx *ctx, uint16_t attr)
179 if (!(ctx->flags & (1 << attr)))
183 case NFTNL_RULESET_CTX_CMD:
184 return (
void *)&ctx->cmd;
185 case NFTNL_RULESET_CTX_TYPE:
186 return (
void *)&ctx->type;
187 case NFTNL_RULESET_CTX_TABLE:
189 case NFTNL_RULESET_CTX_CHAIN:
191 case NFTNL_RULESET_CTX_RULE:
193 case NFTNL_RULESET_CTX_SET:
195 case NFTNL_RULESET_CTX_DATA:
202EXPORT_SYMBOL(nftnl_ruleset_ctx_get_u32);
203uint32_t nftnl_ruleset_ctx_get_u32(
const struct nftnl_parse_ctx *ctx, uint16_t attr)
205 const void *ret = nftnl_ruleset_ctx_get(ctx, attr);
206 return ret == NULL ? 0 : *((uint32_t *)ret);
210EXPORT_SYMBOL(nftnl_ruleset_parse_file_cb);
211int nftnl_ruleset_parse_file_cb(
enum nftnl_parse_type type, FILE *fp,
212 struct nftnl_parse_err *err,
void *data,
219EXPORT_SYMBOL(nftnl_ruleset_parse_buffer_cb);
220int nftnl_ruleset_parse_buffer_cb(
enum nftnl_parse_type type,
const char *buffer,
221 struct nftnl_parse_err *err,
void *data,
232 if (ctx->cmd != NFTNL_CMD_ADD)
236 case NFTNL_RULESET_TABLE:
237 if (r->table_list == NULL) {
238 r->table_list = nftnl_table_list_alloc();
239 if (r->table_list == NULL)
242 nftnl_ruleset_set(r, NFTNL_RULESET_TABLELIST,
245 nftnl_table_list_add_tail(ctx->table, r->table_list);
247 case NFTNL_RULESET_CHAIN:
248 if (r->chain_list == NULL) {
249 r->chain_list = nftnl_chain_list_alloc();
250 if (r->chain_list == NULL)
253 nftnl_ruleset_set(r, NFTNL_RULESET_CHAINLIST,
256 nftnl_chain_list_add_tail(ctx->chain, r->chain_list);
258 case NFTNL_RULESET_SET:
259 if (r->set_list == NULL) {
260 r->set_list = nftnl_set_list_alloc();
261 if (r->set_list == NULL)
264 nftnl_ruleset_set(r, NFTNL_RULESET_SETLIST,
267 nftnl_set_list_add_tail(ctx->set, r->set_list);
269 case NFTNL_RULESET_RULE:
270 if (r->rule_list == NULL) {
271 r->rule_list = nftnl_rule_list_alloc();
272 if (r->rule_list == NULL)
275 nftnl_ruleset_set(r, NFTNL_RULESET_RULELIST,
278 nftnl_rule_list_add_tail(ctx->rule, r->rule_list);
280 case NFTNL_RULESET_RULESET:
289EXPORT_SYMBOL(nftnl_ruleset_parse);
290int nftnl_ruleset_parse(
struct nftnl_ruleset *r,
enum nftnl_parse_type type,
291 const char *data,
struct nftnl_parse_err *err)
297EXPORT_SYMBOL(nftnl_ruleset_parse_file);
298int nftnl_ruleset_parse_file(
struct nftnl_ruleset *rs,
enum nftnl_parse_type type,
299 FILE *fp,
struct nftnl_parse_err *err)
301 return nftnl_ruleset_parse_file_cb(type, fp, err, rs, nftnl_ruleset_cb);
305nftnl_ruleset_snprintf_table(
char *buf,
size_t remain,
311 const char *sep =
"";
314 ti = nftnl_table_list_iter_create(rs->table_list);
318 t = nftnl_table_list_iter_next(ti);
320 ret = snprintf(buf + offset, remain,
"%s", sep);
321 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
323 ret = nftnl_table_snprintf(buf + offset, remain, t, type, flags);
324 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
326 t = nftnl_table_list_iter_next(ti);
329 nftnl_table_list_iter_destroy(ti);
335nftnl_ruleset_snprintf_chain(
char *buf,
size_t remain,
341 const char *sep =
"";
344 ci = nftnl_chain_list_iter_create(rs->chain_list);
348 c = nftnl_chain_list_iter_next(ci);
350 ret = snprintf(buf + offset, remain,
"%s", sep);
351 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
353 ret = nftnl_chain_snprintf(buf + offset, remain, c, type, flags);
354 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
356 c = nftnl_chain_list_iter_next(ci);
359 nftnl_chain_list_iter_destroy(ci);
365nftnl_ruleset_snprintf_set(
char *buf,
size_t remain,
371 const char *sep =
"";
374 si = nftnl_set_list_iter_create(rs->set_list);
378 s = nftnl_set_list_iter_next(si);
380 ret = snprintf(buf + offset, remain,
"%s", sep);
381 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
383 ret = nftnl_set_snprintf(buf + offset, remain, s, type, flags);
384 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
386 s = nftnl_set_list_iter_next(si);
389 nftnl_set_list_iter_destroy(si);
395nftnl_ruleset_snprintf_rule(
char *buf,
size_t remain,
399 struct nftnl_rule *r;
401 const char *sep =
"";
404 ri = nftnl_rule_list_iter_create(rs->rule_list);
408 r = nftnl_rule_list_iter_next(ri);
410 ret = snprintf(buf + offset, remain,
"%s", sep);
411 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
413 ret = nftnl_rule_snprintf(buf + offset, remain, r, type, flags);
414 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
416 r = nftnl_rule_list_iter_next(ri);
419 nftnl_rule_list_iter_destroy(ri);
425nftnl_ruleset_do_snprintf(
char *buf,
size_t remain,
427 uint32_t cmd, uint32_t type, uint32_t flags)
429 uint32_t inner_flags = flags;
430 const char *sep =
"";
434 inner_flags &= ~NFTNL_OF_EVENT_ANY;
436 if (nftnl_ruleset_is_set(rs, NFTNL_RULESET_TABLELIST) &&
437 (!nftnl_table_list_is_empty(rs->table_list))) {
438 ret = nftnl_ruleset_snprintf_table(buf + offset, remain, rs,
440 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
446 if (nftnl_ruleset_is_set(rs, NFTNL_RULESET_CHAINLIST) &&
447 (!nftnl_chain_list_is_empty(rs->chain_list))) {
448 ret = snprintf(buf + offset, remain,
"%s", sep);
449 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
451 ret = nftnl_ruleset_snprintf_chain(buf + offset, remain, rs,
453 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
459 if (nftnl_ruleset_is_set(rs, NFTNL_RULESET_SETLIST) &&
460 (!nftnl_set_list_is_empty(rs->set_list))) {
461 ret = snprintf(buf + offset, remain,
"%s", sep);
462 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
464 ret = nftnl_ruleset_snprintf_set(buf + offset, remain, rs,
466 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
472 if (nftnl_ruleset_is_set(rs, NFTNL_RULESET_RULELIST) &&
473 (!nftnl_rule_list_is_empty(rs->rule_list))) {
474 ret = snprintf(buf + offset, remain,
"%s", sep);
475 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
477 ret = nftnl_ruleset_snprintf_rule(buf + offset, remain, rs,
479 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
485EXPORT_SYMBOL(nftnl_ruleset_snprintf);
486int nftnl_ruleset_snprintf(
char *buf,
size_t size,
const struct nftnl_ruleset *r,
487 uint32_t type, uint32_t flags)
492 if (type != NFTNL_OUTPUT_DEFAULT) {
496 return nftnl_ruleset_do_snprintf(buf, size, r, nftnl_flag2cmd(flags),
500static int nftnl_ruleset_fprintf_tables(FILE *fp,
const struct nftnl_ruleset *rs,
501 uint32_t type, uint32_t flags)
503 int len = 0, ret = 0;
506 const char *sep =
"";
508 ti = nftnl_table_list_iter_create(rs->table_list);
512 t = nftnl_table_list_iter_next(ti);
514 ret = fprintf(fp,
"%s", sep);
520 ret = nftnl_table_fprintf(fp, t, type, flags);
526 t = nftnl_table_list_iter_next(ti);
530 nftnl_table_list_iter_destroy(ti);
534 nftnl_table_list_iter_destroy(ti);
538static int nftnl_ruleset_fprintf_chains(FILE *fp,
const struct nftnl_ruleset *rs,
539 uint32_t type, uint32_t flags)
541 int len = 0, ret = 0;
544 const char *sep =
"";
546 i = nftnl_chain_list_iter_create(rs->chain_list);
550 o = nftnl_chain_list_iter_next(i);
552 ret = fprintf(fp,
"%s", sep);
558 ret = nftnl_chain_fprintf(fp, o, type, flags);
564 o = nftnl_chain_list_iter_next(i);
567 nftnl_chain_list_iter_destroy(i);
571 nftnl_chain_list_iter_destroy(i);
575static int nftnl_ruleset_fprintf_sets(FILE *fp,
const struct nftnl_ruleset *rs,
576 uint32_t type, uint32_t flags)
578 int len = 0, ret = 0;
581 const char *sep =
"";
583 i = nftnl_set_list_iter_create(rs->set_list);
587 o = nftnl_set_list_iter_next(i);
589 ret = fprintf(fp,
"%s", sep);
595 ret = nftnl_set_fprintf(fp, o, type, flags);
601 o = nftnl_set_list_iter_next(i);
604 nftnl_set_list_iter_destroy(i);
608 nftnl_set_list_iter_destroy(i);
612static int nftnl_ruleset_fprintf_rules(FILE *fp,
const struct nftnl_ruleset *rs,
613 uint32_t type, uint32_t flags)
615 int len = 0, ret = 0;
616 struct nftnl_rule *o;
618 const char *sep =
"";
620 i = nftnl_rule_list_iter_create(rs->rule_list);
624 o = nftnl_rule_list_iter_next(i);
626 ret = fprintf(fp,
"%s", sep);
632 ret = nftnl_rule_fprintf(fp, o, type, flags);
638 o = nftnl_rule_list_iter_next(i);
641 nftnl_rule_list_iter_destroy(i);
645 nftnl_rule_list_iter_destroy(i);
649#define NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len) \
654static int nftnl_ruleset_cmd_fprintf(FILE *fp,
const struct nftnl_ruleset *rs,
655 uint32_t cmd, uint32_t type, uint32_t flags)
657 int len = 0, ret = 0;
658 uint32_t inner_flags = flags;
659 const char *sep =
"";
662 inner_flags &= ~NFTNL_OF_EVENT_ANY;
664 if ((nftnl_ruleset_is_set(rs, NFTNL_RULESET_TABLELIST)) &&
665 (!nftnl_table_list_is_empty(rs->table_list))) {
666 ret = nftnl_ruleset_fprintf_tables(fp, rs, type, inner_flags);
667 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
673 if ((nftnl_ruleset_is_set(rs, NFTNL_RULESET_CHAINLIST)) &&
674 (!nftnl_chain_list_is_empty(rs->chain_list))) {
675 ret = fprintf(fp,
"%s", sep);
676 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
678 ret = nftnl_ruleset_fprintf_chains(fp, rs, type, inner_flags);
679 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
685 if ((nftnl_ruleset_is_set(rs, NFTNL_RULESET_SETLIST)) &&
686 (!nftnl_set_list_is_empty(rs->set_list))) {
687 ret = fprintf(fp,
"%s", sep);
688 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
690 ret = nftnl_ruleset_fprintf_sets(fp, rs, type, inner_flags);
691 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
697 if ((nftnl_ruleset_is_set(rs, NFTNL_RULESET_RULELIST)) &&
698 (!nftnl_rule_list_is_empty(rs->rule_list))) {
699 ret = fprintf(fp,
"%s", sep);
700 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
702 ret = nftnl_ruleset_fprintf_rules(fp, rs, type, inner_flags);
703 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
709EXPORT_SYMBOL(nftnl_ruleset_fprintf);
710int nftnl_ruleset_fprintf(FILE *fp,
const struct nftnl_ruleset *rs, uint32_t type,
713 return nftnl_ruleset_cmd_fprintf(fp, rs, nftnl_flag2cmd(flags), type,