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;
42 struct nftnl_set *set;
43 struct nftnl_set_elem *set_elem;
62 EXPORT_SYMBOL(nftnl_ruleset_alloc);
66 if (r->flags & (1 << NFTNL_RULESET_TABLELIST))
67 nftnl_table_list_free(r->table_list);
68 if (r->flags & (1 << NFTNL_RULESET_CHAINLIST))
69 nftnl_chain_list_free(r->chain_list);
70 if (r->flags & (1 << NFTNL_RULESET_SETLIST))
71 nftnl_set_list_free(r->set_list);
72 if (r->flags & (1 << NFTNL_RULESET_RULELIST))
73 nftnl_rule_list_free(r->rule_list);
76 EXPORT_SYMBOL(nftnl_ruleset_free);
78 bool nftnl_ruleset_is_set(
const struct nftnl_ruleset *r, uint16_t attr)
80 return r->flags & (1 << attr);
82 EXPORT_SYMBOL(nftnl_ruleset_is_set);
84 void nftnl_ruleset_unset(
struct nftnl_ruleset *r, uint16_t attr)
86 if (!(r->flags & (1 << attr)))
90 case NFTNL_RULESET_TABLELIST:
91 nftnl_table_list_free(r->table_list);
93 case NFTNL_RULESET_CHAINLIST:
94 nftnl_chain_list_free(r->chain_list);
96 case NFTNL_RULESET_SETLIST:
97 nftnl_set_list_free(r->set_list);
99 case NFTNL_RULESET_RULELIST:
100 nftnl_rule_list_free(r->rule_list);
103 r->flags &= ~(1 << attr);
105 EXPORT_SYMBOL(nftnl_ruleset_unset);
107 void nftnl_ruleset_set(
struct nftnl_ruleset *r, uint16_t attr,
void *data)
110 case NFTNL_RULESET_TABLELIST:
111 nftnl_ruleset_unset(r, NFTNL_RULESET_TABLELIST);
112 r->table_list = data;
114 case NFTNL_RULESET_CHAINLIST:
115 nftnl_ruleset_unset(r, NFTNL_RULESET_CHAINLIST);
116 r->chain_list = data;
118 case NFTNL_RULESET_SETLIST:
119 nftnl_ruleset_unset(r, NFTNL_RULESET_SETLIST);
122 case NFTNL_RULESET_RULELIST:
123 nftnl_ruleset_unset(r, NFTNL_RULESET_RULELIST);
129 r->flags |= (1 << attr);
131 EXPORT_SYMBOL(nftnl_ruleset_set);
133 void *nftnl_ruleset_get(
const struct nftnl_ruleset *r, uint16_t attr)
135 if (!(r->flags & (1 << attr)))
139 case NFTNL_RULESET_TABLELIST:
140 return r->table_list;
141 case NFTNL_RULESET_CHAINLIST:
142 return r->chain_list;
143 case NFTNL_RULESET_SETLIST:
145 case NFTNL_RULESET_RULELIST:
151 EXPORT_SYMBOL(nftnl_ruleset_get);
156 case NFTNL_RULESET_TABLE:
157 nftnl_table_free(ctx->table);
159 case NFTNL_RULESET_CHAIN:
160 nftnl_chain_free(ctx->chain);
162 case NFTNL_RULESET_RULE:
163 nftnl_rule_free(ctx->rule);
165 case NFTNL_RULESET_SET:
166 case NFTNL_RULESET_SET_ELEMS:
167 nftnl_set_free(ctx->set);
169 case NFTNL_RULESET_RULESET:
170 case NFTNL_RULESET_UNSPEC:
174 EXPORT_SYMBOL(nftnl_ruleset_ctx_free);
176 bool nftnl_ruleset_ctx_is_set(
const struct nftnl_parse_ctx *ctx, uint16_t attr)
178 return ctx->flags & (1 << attr);
180 EXPORT_SYMBOL(nftnl_ruleset_ctx_is_set);
182 void *nftnl_ruleset_ctx_get(
const struct nftnl_parse_ctx *ctx, uint16_t attr)
184 if (!(ctx->flags & (1 << attr)))
188 case NFTNL_RULESET_CTX_CMD:
189 return (
void *)&ctx->cmd;
190 case NFTNL_RULESET_CTX_TYPE:
191 return (
void *)&ctx->type;
192 case NFTNL_RULESET_CTX_TABLE:
194 case NFTNL_RULESET_CTX_CHAIN:
196 case NFTNL_RULESET_CTX_RULE:
198 case NFTNL_RULESET_CTX_SET:
200 case NFTNL_RULESET_CTX_DATA:
206 EXPORT_SYMBOL(nftnl_ruleset_ctx_get);
208 uint32_t nftnl_ruleset_ctx_get_u32(
const struct nftnl_parse_ctx *ctx, uint16_t attr)
210 const void *ret = nftnl_ruleset_ctx_get(ctx, attr);
211 return ret == NULL ? 0 : *((uint32_t *)ret);
213 EXPORT_SYMBOL(nftnl_ruleset_ctx_get_u32);
215 #if defined(JSON_PARSING)
216 static void nftnl_ruleset_ctx_set(
struct nftnl_parse_ctx *ctx, uint16_t attr,
220 case NFTNL_RULESET_CTX_CMD:
221 ctx->cmd = *((uint32_t *)data);
223 case NFTNL_RULESET_CTX_TYPE:
224 ctx->type = *((uint32_t *)data);
226 case NFTNL_RULESET_CTX_TABLE:
229 case NFTNL_RULESET_CTX_CHAIN:
232 case NFTNL_RULESET_CTX_RULE:
235 case NFTNL_RULESET_CTX_SET:
238 case NFTNL_RULESET_CTX_DATA:
242 ctx->flags |= (1 << attr);
245 static void nftnl_ruleset_ctx_set_u32(
struct nftnl_parse_ctx *ctx, uint16_t attr,
248 nftnl_ruleset_ctx_set(ctx, attr, &val);
252 struct nftnl_parse_err *err)
256 table = nftnl_table_alloc();
260 switch (ctx->format) {
261 case NFTNL_OUTPUT_JSON:
263 if (nftnl_jansson_parse_table(table, ctx->json, err) < 0)
267 case NFTNL_OUTPUT_XML:
273 nftnl_ruleset_ctx_set_u32(ctx, NFTNL_RULESET_CTX_TYPE, NFTNL_RULESET_TABLE);
274 nftnl_ruleset_ctx_set(ctx, NFTNL_RULESET_CTX_TABLE, table);
275 if (ctx->cb(ctx) < 0)
280 nftnl_table_free(table);
285 struct nftnl_parse_err *err)
289 chain = nftnl_chain_alloc();
293 switch (ctx->format) {
294 case NFTNL_OUTPUT_JSON:
296 if (nftnl_jansson_parse_chain(chain, ctx->json, err) < 0)
300 case NFTNL_OUTPUT_XML:
306 nftnl_ruleset_ctx_set_u32(ctx, NFTNL_RULESET_CTX_TYPE, NFTNL_RULESET_CHAIN);
307 nftnl_ruleset_ctx_set(ctx, NFTNL_RULESET_CTX_CHAIN, chain);
308 if (ctx->cb(ctx) < 0)
313 nftnl_chain_free(chain);
318 struct nftnl_set *set, uint32_t type,
319 struct nftnl_parse_err *err)
321 struct nftnl_set *newset;
323 nftnl_set_set_u32(set, NFTNL_SET_ID, ctx->set_id++);
325 newset = nftnl_set_clone(set);
329 nftnl_set_list_add_tail(newset, ctx->set_list);
331 nftnl_ruleset_ctx_set_u32(ctx, NFTNL_RULESET_CTX_TYPE, type);
332 nftnl_ruleset_ctx_set(ctx, NFTNL_RULESET_CTX_SET, set);
333 if (ctx->cb(ctx) < 0)
342 struct nftnl_parse_err *err)
344 struct nftnl_set *set;
346 set = nftnl_set_alloc();
350 switch (ctx->format) {
351 case NFTNL_OUTPUT_JSON:
353 if (nftnl_jansson_parse_elem(set, ctx->json, err) < 0)
357 case NFTNL_OUTPUT_XML:
363 if (nftnl_ruleset_parse_set(ctx, set, NFTNL_RULESET_SET_ELEMS, err) < 0)
373 struct nftnl_parse_err *err)
375 struct nftnl_set *set;
377 set = nftnl_set_alloc();
381 switch (ctx->format) {
382 case NFTNL_OUTPUT_JSON:
384 if (nftnl_jansson_parse_set(set, ctx->json, err) < 0)
388 case NFTNL_OUTPUT_XML:
394 if (nftnl_ruleset_parse_set(ctx, set, NFTNL_RULESET_SET, err) < 0)
404 struct nftnl_parse_err *err)
408 rule = nftnl_rule_alloc();
412 switch (ctx->format) {
413 case NFTNL_OUTPUT_JSON:
415 if (nftnl_jansson_parse_rule(rule, ctx->json, err,
420 case NFTNL_OUTPUT_XML:
426 nftnl_ruleset_ctx_set_u32(ctx, NFTNL_RULESET_CTX_TYPE, NFTNL_RULESET_RULE);
427 nftnl_ruleset_ctx_set(ctx, NFTNL_RULESET_CTX_RULE, rule);
428 if (ctx->cb(ctx) < 0)
433 nftnl_rule_free(rule);
439 static int nftnl_ruleset_json_parse_ruleset(
struct nftnl_parse_ctx *ctx,
440 struct nftnl_parse_err *err)
442 json_t *node, *array = ctx->json;
445 len = json_array_size(array);
446 for (i = 0; i < len; i++) {
447 node = json_array_get(array, i);
454 if (nftnl_jansson_node_exist(node,
"table"))
455 ret = nftnl_ruleset_parse_tables(ctx, err);
456 else if (nftnl_jansson_node_exist(node,
"chain"))
457 ret = nftnl_ruleset_parse_chains(ctx, err);
458 else if (nftnl_jansson_node_exist(node,
"set"))
459 ret = nftnl_ruleset_parse_sets(ctx, err);
460 else if (nftnl_jansson_node_exist(node,
"rule"))
461 ret = nftnl_ruleset_parse_rules(ctx, err);
462 else if (nftnl_jansson_node_exist(node,
"element"))
463 ret = nftnl_ruleset_parse_set_elems(ctx, err);
471 if (len == 0 && ctx->cmd == NFTNL_CMD_FLUSH) {
472 nftnl_ruleset_ctx_set_u32(ctx, NFTNL_RULESET_CTX_TYPE,
473 NFTNL_RULESET_RULESET);
474 if (ctx->cb(ctx) < 0)
481 static int nftnl_ruleset_json_parse_cmd(
const char *cmd,
482 struct nftnl_parse_err *err,
488 cmdnum = nftnl_str2cmd(cmd);
489 if (cmdnum == NFTNL_CMD_UNSPEC) {
490 err->error = NFTNL_PARSE_EMISSINGNODE;
491 err->node_name = strdup(cmd);
495 nftnl_ruleset_ctx_set_u32(ctx, NFTNL_RULESET_CTX_CMD, cmdnum);
497 nodecmd = json_object_get(ctx->json, cmd);
502 if (nftnl_ruleset_json_parse_ruleset(ctx, err) != 0)
511 static int nftnl_ruleset_json_parse(
const void *json,
512 struct nftnl_parse_err *err,
513 enum nftnl_parse_input input,
514 enum nftnl_parse_type type,
void *arg,
518 json_t *root, *array, *node;
528 ctx.set_list = nftnl_set_list_alloc();
529 if (ctx.set_list == NULL)
533 nftnl_ruleset_ctx_set(&ctx, NFTNL_RULESET_CTX_DATA, arg);
535 root = nftnl_jansson_create_root(json, &error, err, input);
539 array = json_object_get(root,
"nftables");
545 len = json_array_size(array);
546 for (i = 0; i < len; i++) {
547 node = json_array_get(array, i);
553 key = json_object_iter_key(json_object_iter(node));
557 if (nftnl_ruleset_json_parse_cmd(key, err, &ctx) < 0)
561 nftnl_set_list_free(ctx.set_list);
562 nftnl_jansson_free_root(root);
565 nftnl_jansson_free_root(root);
567 nftnl_set_list_free(ctx.set_list);
576 nftnl_ruleset_do_parse(
enum nftnl_parse_type type,
const void *data,
577 struct nftnl_parse_err *err,
enum nftnl_parse_input input,
583 case NFTNL_PARSE_JSON:
584 ret = nftnl_ruleset_json_parse(data, err, input, type, arg, cb);
586 case NFTNL_PARSE_XML:
596 int nftnl_ruleset_parse_file_cb(
enum nftnl_parse_type type, FILE *fp,
597 struct nftnl_parse_err *err,
void *data,
600 return nftnl_ruleset_do_parse(type, fp, err, NFTNL_PARSE_FILE, data, cb);
602 EXPORT_SYMBOL(nftnl_ruleset_parse_file_cb);
604 int nftnl_ruleset_parse_buffer_cb(
enum nftnl_parse_type type,
const char *buffer,
605 struct nftnl_parse_err *err,
void *data,
608 return nftnl_ruleset_do_parse(type, buffer, err, NFTNL_PARSE_BUFFER, data,
611 EXPORT_SYMBOL(nftnl_ruleset_parse_buffer_cb);
617 if (ctx->cmd != NFTNL_CMD_ADD)
621 case NFTNL_RULESET_TABLE:
622 if (r->table_list == NULL) {
623 r->table_list = nftnl_table_list_alloc();
624 if (r->table_list == NULL)
627 nftnl_ruleset_set(r, NFTNL_RULESET_TABLELIST,
630 nftnl_table_list_add_tail(ctx->table, r->table_list);
632 case NFTNL_RULESET_CHAIN:
633 if (r->chain_list == NULL) {
634 r->chain_list = nftnl_chain_list_alloc();
635 if (r->chain_list == NULL)
638 nftnl_ruleset_set(r, NFTNL_RULESET_CHAINLIST,
641 nftnl_chain_list_add_tail(ctx->chain, r->chain_list);
643 case NFTNL_RULESET_SET:
644 if (r->set_list == NULL) {
645 r->set_list = nftnl_set_list_alloc();
646 if (r->set_list == NULL)
649 nftnl_ruleset_set(r, NFTNL_RULESET_SETLIST,
652 nftnl_set_list_add_tail(ctx->set, r->set_list);
654 case NFTNL_RULESET_RULE:
655 if (r->rule_list == NULL) {
656 r->rule_list = nftnl_rule_list_alloc();
657 if (r->rule_list == NULL)
660 nftnl_ruleset_set(r, NFTNL_RULESET_RULELIST,
663 nftnl_rule_list_add_tail(ctx->rule, r->rule_list);
665 case NFTNL_RULESET_RULESET:
674 int nftnl_ruleset_parse(
struct nftnl_ruleset *r,
enum nftnl_parse_type type,
675 const char *data,
struct nftnl_parse_err *err)
677 return nftnl_ruleset_parse_buffer_cb(type, data, err, r, nftnl_ruleset_cb);
679 EXPORT_SYMBOL(nftnl_ruleset_parse);
681 int nftnl_ruleset_parse_file(
struct nftnl_ruleset *rs,
enum nftnl_parse_type type,
682 FILE *fp,
struct nftnl_parse_err *err)
684 return nftnl_ruleset_parse_file_cb(type, fp, err, rs, nftnl_ruleset_cb);
686 EXPORT_SYMBOL(nftnl_ruleset_parse_file);
688 static const char *nftnl_ruleset_o_opentag(uint32_t type)
691 case NFTNL_OUTPUT_JSON:
692 return "{\"nftables\":[";
693 case NFTNL_OUTPUT_XML:
699 static const char *nftnl_ruleset_o_separator(
void *obj, uint32_t type)
705 case NFTNL_OUTPUT_JSON:
707 case NFTNL_OUTPUT_DEFAULT:
714 static const char *nftnl_ruleset_o_closetag(uint32_t type)
717 case NFTNL_OUTPUT_JSON:
719 case NFTNL_OUTPUT_XML:
726 nftnl_ruleset_snprintf_table(
char *buf,
size_t size,
732 int ret, remain = size, offset = 0;
734 ti = nftnl_table_list_iter_create(rs->table_list);
738 t = nftnl_table_list_iter_next(ti);
740 ret = nftnl_table_snprintf(buf + offset, remain, t, type, flags);
741 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
743 t = nftnl_table_list_iter_next(ti);
745 ret = snprintf(buf + offset, remain,
"%s",
746 nftnl_ruleset_o_separator(t, type));
747 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
749 nftnl_table_list_iter_destroy(ti);
755 nftnl_ruleset_snprintf_chain(
char *buf,
size_t size,
761 int ret, remain = size, offset = 0;
763 ci = nftnl_chain_list_iter_create(rs->chain_list);
767 c = nftnl_chain_list_iter_next(ci);
769 ret = nftnl_chain_snprintf(buf + offset, remain, c, type, flags);
770 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
772 c = nftnl_chain_list_iter_next(ci);
774 ret = snprintf(buf + offset, remain,
"%s",
775 nftnl_ruleset_o_separator(c, type));
776 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
778 nftnl_chain_list_iter_destroy(ci);
784 nftnl_ruleset_snprintf_set(
char *buf,
size_t size,
790 int ret, remain = size, offset = 0;
792 si = nftnl_set_list_iter_create(rs->set_list);
796 s = nftnl_set_list_iter_next(si);
798 ret = nftnl_set_snprintf(buf + offset, remain, s, type, flags);
799 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
801 s = nftnl_set_list_iter_next(si);
803 ret = snprintf(buf + offset, remain,
"%s",
804 nftnl_ruleset_o_separator(s, type));
805 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
807 nftnl_set_list_iter_destroy(si);
813 nftnl_ruleset_snprintf_rule(
char *buf,
size_t size,
819 int ret, remain = size, offset = 0;
821 ri = nftnl_rule_list_iter_create(rs->rule_list);
825 r = nftnl_rule_list_iter_next(ri);
827 ret = nftnl_rule_snprintf(buf + offset, remain, r, type, flags);
828 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
830 r = nftnl_rule_list_iter_next(ri);
832 ret = snprintf(buf + offset, remain,
"%s",
833 nftnl_ruleset_o_separator(r, type));
834 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
836 nftnl_rule_list_iter_destroy(ri);
842 nftnl_ruleset_do_snprintf(
char *buf,
size_t size,
const struct nftnl_ruleset *rs,
843 uint32_t cmd, uint32_t type, uint32_t flags)
845 int ret, remain = size, offset = 0;
847 uint32_t inner_flags = flags;
850 inner_flags &= ~NFTNL_OF_EVENT_ANY;
852 ret = snprintf(buf + offset, remain,
"%s",
853 nftnl_ruleset_o_opentag(type));
854 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
856 ret = nftnl_cmd_header_snprintf(buf + offset, remain, cmd, type, flags);
857 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
859 if (nftnl_ruleset_is_set(rs, NFTNL_RULESET_TABLELIST) &&
860 (!nftnl_table_list_is_empty(rs->table_list))) {
861 ret = nftnl_ruleset_snprintf_table(buf + offset, remain, rs,
863 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
866 prev = rs->table_list;
869 if (nftnl_ruleset_is_set(rs, NFTNL_RULESET_CHAINLIST) &&
870 (!nftnl_chain_list_is_empty(rs->chain_list))) {
871 ret = snprintf(buf + offset, remain,
"%s",
872 nftnl_ruleset_o_separator(prev, type));
873 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
875 ret = nftnl_ruleset_snprintf_chain(buf + offset, remain, rs,
877 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
880 prev = rs->chain_list;
883 if (nftnl_ruleset_is_set(rs, NFTNL_RULESET_SETLIST) &&
884 (!nftnl_set_list_is_empty(rs->set_list))) {
885 ret = snprintf(buf + offset, remain,
"%s",
886 nftnl_ruleset_o_separator(prev, type));
887 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
889 ret = nftnl_ruleset_snprintf_set(buf + offset, remain, rs,
891 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
897 if (nftnl_ruleset_is_set(rs, NFTNL_RULESET_RULELIST) &&
898 (!nftnl_rule_list_is_empty(rs->rule_list))) {
899 ret = snprintf(buf + offset, remain,
"%s",
900 nftnl_ruleset_o_separator(prev, type));
901 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
903 ret = nftnl_ruleset_snprintf_rule(buf + offset, remain, rs,
905 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
908 ret = nftnl_cmd_footer_snprintf(buf + offset, remain, cmd, type, flags);
909 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
911 ret = snprintf(buf + offset, remain,
"%s",
912 nftnl_ruleset_o_closetag(type));
913 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
918 static int nftnl_ruleset_cmd_snprintf(
char *buf,
size_t size,
920 uint32_t type, uint32_t flags)
923 case NFTNL_OUTPUT_DEFAULT:
924 case NFTNL_OUTPUT_JSON:
925 return nftnl_ruleset_do_snprintf(buf, size, r, cmd, type, flags);
926 case NFTNL_OUTPUT_XML:
933 int nftnl_ruleset_snprintf(
char *buf,
size_t size,
const struct nftnl_ruleset *r,
934 uint32_t type, uint32_t flags)
940 case NFTNL_OUTPUT_DEFAULT:
941 case NFTNL_OUTPUT_JSON:
942 return nftnl_ruleset_cmd_snprintf(buf, size, r,
943 nftnl_flag2cmd(flags), type,
945 case NFTNL_OUTPUT_XML:
951 EXPORT_SYMBOL(nftnl_ruleset_snprintf);
953 static int nftnl_ruleset_fprintf_tables(FILE *fp,
const struct nftnl_ruleset *rs,
954 uint32_t type, uint32_t flags)
956 int len = 0, ret = 0;
960 ti = nftnl_table_list_iter_create(rs->table_list);
964 t = nftnl_table_list_iter_next(ti);
966 ret = nftnl_table_fprintf(fp, t, type, flags);
972 t = nftnl_table_list_iter_next(ti);
974 ret = fprintf(fp,
"%s", nftnl_ruleset_o_separator(t, type));
980 nftnl_table_list_iter_destroy(ti);
984 nftnl_table_list_iter_destroy(ti);
988 static int nftnl_ruleset_fprintf_chains(FILE *fp,
const struct nftnl_ruleset *rs,
989 uint32_t type, uint32_t flags)
991 int len = 0, ret = 0;
995 i = nftnl_chain_list_iter_create(rs->chain_list);
999 o = nftnl_chain_list_iter_next(i);
1001 ret = nftnl_chain_fprintf(fp, o, type, flags);
1007 o = nftnl_chain_list_iter_next(i);
1009 ret = fprintf(fp,
"%s", nftnl_ruleset_o_separator(o, type));
1015 nftnl_chain_list_iter_destroy(i);
1019 nftnl_chain_list_iter_destroy(i);
1023 static int nftnl_ruleset_fprintf_sets(FILE *fp,
const struct nftnl_ruleset *rs,
1024 uint32_t type, uint32_t flags)
1026 int len = 0, ret = 0;
1027 struct nftnl_set *o;
1030 i = nftnl_set_list_iter_create(rs->set_list);
1034 o = nftnl_set_list_iter_next(i);
1036 ret = nftnl_set_fprintf(fp, o, type, flags);
1042 o = nftnl_set_list_iter_next(i);
1044 ret = fprintf(fp,
"%s", nftnl_ruleset_o_separator(o, type));
1050 nftnl_set_list_iter_destroy(i);
1054 nftnl_set_list_iter_destroy(i);
1058 static int nftnl_ruleset_fprintf_rules(FILE *fp,
const struct nftnl_ruleset *rs,
1059 uint32_t type, uint32_t flags)
1061 int len = 0, ret = 0;
1065 i = nftnl_rule_list_iter_create(rs->rule_list);
1069 o = nftnl_rule_list_iter_next(i);
1071 ret = nftnl_rule_fprintf(fp, o, type, flags);
1077 o = nftnl_rule_list_iter_next(i);
1079 ret = fprintf(fp,
"%s", nftnl_ruleset_o_separator(o, type));
1085 nftnl_rule_list_iter_destroy(i);
1089 nftnl_rule_list_iter_destroy(i);
1093 #define NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len) \
1098 static int nftnl_ruleset_cmd_fprintf(FILE *fp,
const struct nftnl_ruleset *rs,
1099 uint32_t cmd, uint32_t type, uint32_t flags)
1101 int len = 0, ret = 0;
1103 uint32_t inner_flags = flags;
1106 inner_flags &= ~NFTNL_OF_EVENT_ANY;
1108 ret = fprintf(fp,
"%s", nftnl_ruleset_o_opentag(type));
1109 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
1111 ret = nftnl_cmd_header_fprintf(fp, cmd, type, flags);
1112 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
1114 if ((nftnl_ruleset_is_set(rs, NFTNL_RULESET_TABLELIST)) &&
1115 (!nftnl_table_list_is_empty(rs->table_list))) {
1116 ret = nftnl_ruleset_fprintf_tables(fp, rs, type, inner_flags);
1117 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
1120 prev = rs->table_list;
1123 if ((nftnl_ruleset_is_set(rs, NFTNL_RULESET_CHAINLIST)) &&
1124 (!nftnl_chain_list_is_empty(rs->chain_list))) {
1125 ret = fprintf(fp,
"%s", nftnl_ruleset_o_separator(prev, type));
1126 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
1128 ret = nftnl_ruleset_fprintf_chains(fp, rs, type, inner_flags);
1129 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
1132 prev = rs->chain_list;
1135 if ((nftnl_ruleset_is_set(rs, NFTNL_RULESET_SETLIST)) &&
1136 (!nftnl_set_list_is_empty(rs->set_list))) {
1137 ret = fprintf(fp,
"%s", nftnl_ruleset_o_separator(prev, type));
1138 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
1140 ret = nftnl_ruleset_fprintf_sets(fp, rs, type, inner_flags);
1141 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
1144 prev = rs->set_list;
1147 if ((nftnl_ruleset_is_set(rs, NFTNL_RULESET_RULELIST)) &&
1148 (!nftnl_rule_list_is_empty(rs->rule_list))) {
1149 ret = fprintf(fp,
"%s", nftnl_ruleset_o_separator(prev, type));
1150 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
1152 ret = nftnl_ruleset_fprintf_rules(fp, rs, type, inner_flags);
1153 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
1156 ret = nftnl_cmd_footer_fprintf(fp, cmd, type, flags);
1157 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
1159 ret = fprintf(fp,
"%s", nftnl_ruleset_o_closetag(type));
1160 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
1165 int nftnl_ruleset_fprintf(FILE *fp,
const struct nftnl_ruleset *rs, uint32_t type,
1168 return nftnl_ruleset_cmd_fprintf(fp, rs, nftnl_flag2cmd(flags), type,
1171 EXPORT_SYMBOL(nftnl_ruleset_fprintf);