19#include <libmnl/libmnl.h>
20#include <libnftnl/ruleset.h>
21#include <libnftnl/table.h>
22#include <libnftnl/chain.h>
23#include <libnftnl/set.h>
24#include <libnftnl/rule.h>
36 enum nftnl_cmd_type cmd;
37 enum nftnl_ruleset_type type;
41 struct nftnl_rule *rule;
42 struct nftnl_set *set;
43 struct nftnl_set_elem *set_elem;
56EXPORT_SYMBOL(nftnl_ruleset_alloc);
62EXPORT_SYMBOL(nftnl_ruleset_free);
65 if (r->flags & (1 << NFTNL_RULESET_TABLELIST))
66 nftnl_table_list_free(r->table_list);
67 if (r->flags & (1 << NFTNL_RULESET_CHAINLIST))
68 nftnl_chain_list_free(r->chain_list);
69 if (r->flags & (1 << NFTNL_RULESET_SETLIST))
70 nftnl_set_list_free(r->set_list);
71 if (r->flags & (1 << NFTNL_RULESET_RULELIST))
72 nftnl_rule_list_free(r->rule_list);
76EXPORT_SYMBOL(nftnl_ruleset_is_set);
77bool nftnl_ruleset_is_set(
const struct nftnl_ruleset *r, uint16_t attr)
79 return r->flags & (1 << attr);
82EXPORT_SYMBOL(nftnl_ruleset_unset);
83void nftnl_ruleset_unset(
struct nftnl_ruleset *r, uint16_t attr)
85 if (!(r->flags & (1 << attr)))
89 case NFTNL_RULESET_TABLELIST:
90 nftnl_table_list_free(r->table_list);
92 case NFTNL_RULESET_CHAINLIST:
93 nftnl_chain_list_free(r->chain_list);
95 case NFTNL_RULESET_SETLIST:
96 nftnl_set_list_free(r->set_list);
98 case NFTNL_RULESET_RULELIST:
99 nftnl_rule_list_free(r->rule_list);
102 r->flags &= ~(1 << attr);
105EXPORT_SYMBOL(nftnl_ruleset_set);
106void nftnl_ruleset_set(
struct nftnl_ruleset *r, uint16_t attr,
void *data)
109 case NFTNL_RULESET_TABLELIST:
110 nftnl_ruleset_unset(r, NFTNL_RULESET_TABLELIST);
111 r->table_list = data;
113 case NFTNL_RULESET_CHAINLIST:
114 nftnl_ruleset_unset(r, NFTNL_RULESET_CHAINLIST);
115 r->chain_list = data;
117 case NFTNL_RULESET_SETLIST:
118 nftnl_ruleset_unset(r, NFTNL_RULESET_SETLIST);
121 case NFTNL_RULESET_RULELIST:
122 nftnl_ruleset_unset(r, NFTNL_RULESET_RULELIST);
128 r->flags |= (1 << attr);
131EXPORT_SYMBOL(nftnl_ruleset_get);
132void *nftnl_ruleset_get(
const struct nftnl_ruleset *r, uint16_t attr)
134 if (!(r->flags & (1 << attr)))
138 case NFTNL_RULESET_TABLELIST:
139 return r->table_list;
140 case NFTNL_RULESET_CHAINLIST:
141 return r->chain_list;
142 case NFTNL_RULESET_SETLIST:
144 case NFTNL_RULESET_RULELIST:
151EXPORT_SYMBOL(nftnl_ruleset_ctx_free);
155 case NFTNL_RULESET_TABLE:
156 nftnl_table_free(ctx->table);
158 case NFTNL_RULESET_CHAIN:
159 nftnl_chain_free(ctx->chain);
161 case NFTNL_RULESET_RULE:
162 nftnl_rule_free(ctx->rule);
164 case NFTNL_RULESET_SET:
165 case NFTNL_RULESET_SET_ELEMS:
166 nftnl_set_free(ctx->set);
168 case NFTNL_RULESET_RULESET:
169 case NFTNL_RULESET_UNSPEC:
174EXPORT_SYMBOL(nftnl_ruleset_ctx_is_set);
175bool nftnl_ruleset_ctx_is_set(
const struct nftnl_parse_ctx *ctx, uint16_t attr)
177 return ctx->flags & (1 << attr);
180EXPORT_SYMBOL(nftnl_ruleset_ctx_get);
181void *nftnl_ruleset_ctx_get(
const struct nftnl_parse_ctx *ctx, uint16_t attr)
183 if (!(ctx->flags & (1 << attr)))
187 case NFTNL_RULESET_CTX_CMD:
188 return (
void *)&ctx->cmd;
189 case NFTNL_RULESET_CTX_TYPE:
190 return (
void *)&ctx->type;
191 case NFTNL_RULESET_CTX_TABLE:
193 case NFTNL_RULESET_CTX_CHAIN:
195 case NFTNL_RULESET_CTX_RULE:
197 case NFTNL_RULESET_CTX_SET:
199 case NFTNL_RULESET_CTX_DATA:
206EXPORT_SYMBOL(nftnl_ruleset_ctx_get_u32);
207uint32_t nftnl_ruleset_ctx_get_u32(
const struct nftnl_parse_ctx *ctx, uint16_t attr)
209 const void *ret = nftnl_ruleset_ctx_get(ctx, attr);
210 return ret == NULL ? 0 : *((uint32_t *)ret);
214EXPORT_SYMBOL(nftnl_ruleset_parse_file_cb);
215int nftnl_ruleset_parse_file_cb(
enum nftnl_parse_type type, FILE *fp,
216 struct nftnl_parse_err *err,
void *data,
223EXPORT_SYMBOL(nftnl_ruleset_parse_buffer_cb);
224int nftnl_ruleset_parse_buffer_cb(
enum nftnl_parse_type type,
const char *buffer,
225 struct nftnl_parse_err *err,
void *data,
236 if (ctx->cmd != NFTNL_CMD_ADD)
240 case NFTNL_RULESET_TABLE:
241 if (r->table_list == NULL) {
242 r->table_list = nftnl_table_list_alloc();
243 if (r->table_list == NULL)
246 nftnl_ruleset_set(r, NFTNL_RULESET_TABLELIST,
249 nftnl_table_list_add_tail(ctx->table, r->table_list);
251 case NFTNL_RULESET_CHAIN:
252 if (r->chain_list == NULL) {
253 r->chain_list = nftnl_chain_list_alloc();
254 if (r->chain_list == NULL)
257 nftnl_ruleset_set(r, NFTNL_RULESET_CHAINLIST,
260 nftnl_chain_list_add_tail(ctx->chain, r->chain_list);
262 case NFTNL_RULESET_SET:
263 if (r->set_list == NULL) {
264 r->set_list = nftnl_set_list_alloc();
265 if (r->set_list == NULL)
268 nftnl_ruleset_set(r, NFTNL_RULESET_SETLIST,
271 nftnl_set_list_add_tail(ctx->set, r->set_list);
273 case NFTNL_RULESET_RULE:
274 if (r->rule_list == NULL) {
275 r->rule_list = nftnl_rule_list_alloc();
276 if (r->rule_list == NULL)
279 nftnl_ruleset_set(r, NFTNL_RULESET_RULELIST,
282 nftnl_rule_list_add_tail(ctx->rule, r->rule_list);
284 case NFTNL_RULESET_RULESET:
293EXPORT_SYMBOL(nftnl_ruleset_parse);
294int nftnl_ruleset_parse(
struct nftnl_ruleset *r,
enum nftnl_parse_type type,
295 const char *data,
struct nftnl_parse_err *err)
301EXPORT_SYMBOL(nftnl_ruleset_parse_file);
302int nftnl_ruleset_parse_file(
struct nftnl_ruleset *rs,
enum nftnl_parse_type type,
303 FILE *fp,
struct nftnl_parse_err *err)
305 return nftnl_ruleset_parse_file_cb(type, fp, err, rs, nftnl_ruleset_cb);
309nftnl_ruleset_snprintf_table(
char *buf,
size_t remain,
315 const char *sep =
"";
318 ti = nftnl_table_list_iter_create(rs->table_list);
322 t = nftnl_table_list_iter_next(ti);
324 ret = snprintf(buf + offset, remain,
"%s", sep);
325 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
327 ret = nftnl_table_snprintf(buf + offset, remain, t, type, flags);
328 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
330 t = nftnl_table_list_iter_next(ti);
333 nftnl_table_list_iter_destroy(ti);
339nftnl_ruleset_snprintf_chain(
char *buf,
size_t remain,
345 const char *sep =
"";
348 ci = nftnl_chain_list_iter_create(rs->chain_list);
352 c = nftnl_chain_list_iter_next(ci);
354 ret = snprintf(buf + offset, remain,
"%s", sep);
355 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
357 ret = nftnl_chain_snprintf(buf + offset, remain, c, type, flags);
358 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
360 c = nftnl_chain_list_iter_next(ci);
363 nftnl_chain_list_iter_destroy(ci);
369nftnl_ruleset_snprintf_set(
char *buf,
size_t remain,
375 const char *sep =
"";
378 si = nftnl_set_list_iter_create(rs->set_list);
382 s = nftnl_set_list_iter_next(si);
384 ret = snprintf(buf + offset, remain,
"%s", sep);
385 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
387 ret = nftnl_set_snprintf(buf + offset, remain, s, type, flags);
388 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
390 s = nftnl_set_list_iter_next(si);
393 nftnl_set_list_iter_destroy(si);
399nftnl_ruleset_snprintf_rule(
char *buf,
size_t remain,
403 struct nftnl_rule *r;
405 const char *sep =
"";
408 ri = nftnl_rule_list_iter_create(rs->rule_list);
412 r = nftnl_rule_list_iter_next(ri);
414 ret = snprintf(buf + offset, remain,
"%s", sep);
415 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
417 ret = nftnl_rule_snprintf(buf + offset, remain, r, type, flags);
418 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
420 r = nftnl_rule_list_iter_next(ri);
423 nftnl_rule_list_iter_destroy(ri);
429nftnl_ruleset_do_snprintf(
char *buf,
size_t remain,
431 uint32_t cmd, uint32_t type, uint32_t flags)
433 uint32_t inner_flags = flags;
434 const char *sep =
"";
438 inner_flags &= ~NFTNL_OF_EVENT_ANY;
440 if (nftnl_ruleset_is_set(rs, NFTNL_RULESET_TABLELIST) &&
441 (!nftnl_table_list_is_empty(rs->table_list))) {
442 ret = nftnl_ruleset_snprintf_table(buf + offset, remain, rs,
444 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
450 if (nftnl_ruleset_is_set(rs, NFTNL_RULESET_CHAINLIST) &&
451 (!nftnl_chain_list_is_empty(rs->chain_list))) {
452 ret = snprintf(buf + offset, remain,
"%s", sep);
453 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
455 ret = nftnl_ruleset_snprintf_chain(buf + offset, remain, rs,
457 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
463 if (nftnl_ruleset_is_set(rs, NFTNL_RULESET_SETLIST) &&
464 (!nftnl_set_list_is_empty(rs->set_list))) {
465 ret = snprintf(buf + offset, remain,
"%s", sep);
466 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
468 ret = nftnl_ruleset_snprintf_set(buf + offset, remain, rs,
470 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
476 if (nftnl_ruleset_is_set(rs, NFTNL_RULESET_RULELIST) &&
477 (!nftnl_rule_list_is_empty(rs->rule_list))) {
478 ret = snprintf(buf + offset, remain,
"%s", sep);
479 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
481 ret = nftnl_ruleset_snprintf_rule(buf + offset, remain, rs,
483 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
489EXPORT_SYMBOL(nftnl_ruleset_snprintf);
490int nftnl_ruleset_snprintf(
char *buf,
size_t size,
const struct nftnl_ruleset *r,
491 uint32_t type, uint32_t flags)
496 if (type != NFTNL_OUTPUT_DEFAULT) {
500 return nftnl_ruleset_do_snprintf(buf, size, r, nftnl_flag2cmd(flags),
504static int nftnl_ruleset_fprintf_tables(FILE *fp,
const struct nftnl_ruleset *rs,
505 uint32_t type, uint32_t flags)
507 int len = 0, ret = 0;
510 const char *sep =
"";
512 ti = nftnl_table_list_iter_create(rs->table_list);
516 t = nftnl_table_list_iter_next(ti);
518 ret = fprintf(fp,
"%s", sep);
524 ret = nftnl_table_fprintf(fp, t, type, flags);
530 t = nftnl_table_list_iter_next(ti);
534 nftnl_table_list_iter_destroy(ti);
538 nftnl_table_list_iter_destroy(ti);
542static int nftnl_ruleset_fprintf_chains(FILE *fp,
const struct nftnl_ruleset *rs,
543 uint32_t type, uint32_t flags)
545 int len = 0, ret = 0;
548 const char *sep =
"";
550 i = nftnl_chain_list_iter_create(rs->chain_list);
554 o = nftnl_chain_list_iter_next(i);
556 ret = fprintf(fp,
"%s", sep);
562 ret = nftnl_chain_fprintf(fp, o, type, flags);
568 o = nftnl_chain_list_iter_next(i);
571 nftnl_chain_list_iter_destroy(i);
575 nftnl_chain_list_iter_destroy(i);
579static int nftnl_ruleset_fprintf_sets(FILE *fp,
const struct nftnl_ruleset *rs,
580 uint32_t type, uint32_t flags)
582 int len = 0, ret = 0;
585 const char *sep =
"";
587 i = nftnl_set_list_iter_create(rs->set_list);
591 o = nftnl_set_list_iter_next(i);
593 ret = fprintf(fp,
"%s", sep);
599 ret = nftnl_set_fprintf(fp, o, type, flags);
605 o = nftnl_set_list_iter_next(i);
608 nftnl_set_list_iter_destroy(i);
612 nftnl_set_list_iter_destroy(i);
616static int nftnl_ruleset_fprintf_rules(FILE *fp,
const struct nftnl_ruleset *rs,
617 uint32_t type, uint32_t flags)
619 int len = 0, ret = 0;
620 struct nftnl_rule *o;
622 const char *sep =
"";
624 i = nftnl_rule_list_iter_create(rs->rule_list);
628 o = nftnl_rule_list_iter_next(i);
630 ret = fprintf(fp,
"%s", sep);
636 ret = nftnl_rule_fprintf(fp, o, type, flags);
642 o = nftnl_rule_list_iter_next(i);
645 nftnl_rule_list_iter_destroy(i);
649 nftnl_rule_list_iter_destroy(i);
653#define NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len) \
658static int nftnl_ruleset_cmd_fprintf(FILE *fp,
const struct nftnl_ruleset *rs,
659 uint32_t cmd, uint32_t type, uint32_t flags)
661 int len = 0, ret = 0;
662 uint32_t inner_flags = flags;
663 const char *sep =
"";
666 inner_flags &= ~NFTNL_OF_EVENT_ANY;
668 if ((nftnl_ruleset_is_set(rs, NFTNL_RULESET_TABLELIST)) &&
669 (!nftnl_table_list_is_empty(rs->table_list))) {
670 ret = nftnl_ruleset_fprintf_tables(fp, rs, type, inner_flags);
671 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
677 if ((nftnl_ruleset_is_set(rs, NFTNL_RULESET_CHAINLIST)) &&
678 (!nftnl_chain_list_is_empty(rs->chain_list))) {
679 ret = fprintf(fp,
"%s", sep);
680 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
682 ret = nftnl_ruleset_fprintf_chains(fp, rs, type, inner_flags);
683 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
689 if ((nftnl_ruleset_is_set(rs, NFTNL_RULESET_SETLIST)) &&
690 (!nftnl_set_list_is_empty(rs->set_list))) {
691 ret = fprintf(fp,
"%s", sep);
692 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
694 ret = nftnl_ruleset_fprintf_sets(fp, rs, type, inner_flags);
695 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
701 if ((nftnl_ruleset_is_set(rs, NFTNL_RULESET_RULELIST)) &&
702 (!nftnl_rule_list_is_empty(rs->rule_list))) {
703 ret = fprintf(fp,
"%s", sep);
704 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
706 ret = nftnl_ruleset_fprintf_rules(fp, rs, type, inner_flags);
707 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
713EXPORT_SYMBOL(nftnl_ruleset_fprintf);
714int nftnl_ruleset_fprintf(FILE *fp,
const struct nftnl_ruleset *rs, uint32_t type,
717 return nftnl_ruleset_cmd_fprintf(fp, rs, nftnl_flag2cmd(flags), type,