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;
56 EXPORT_SYMBOL(nftnl_ruleset_alloc);
62 EXPORT_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);
76 EXPORT_SYMBOL(nftnl_ruleset_is_set);
77 bool nftnl_ruleset_is_set(
const struct nftnl_ruleset *r, uint16_t attr)
79 return r->flags & (1 << attr);
82 EXPORT_SYMBOL(nftnl_ruleset_unset);
83 void 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);
105 EXPORT_SYMBOL(nftnl_ruleset_set);
106 void 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);
131 EXPORT_SYMBOL(nftnl_ruleset_get);
132 void *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:
151 EXPORT_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:
174 EXPORT_SYMBOL(nftnl_ruleset_ctx_is_set);
175 bool nftnl_ruleset_ctx_is_set(
const struct nftnl_parse_ctx *ctx, uint16_t attr)
177 return ctx->flags & (1 << attr);
180 EXPORT_SYMBOL(nftnl_ruleset_ctx_get);
181 void *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:
206 EXPORT_SYMBOL(nftnl_ruleset_ctx_get_u32);
207 uint32_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);
214 EXPORT_SYMBOL(nftnl_ruleset_parse_file_cb);
215 int nftnl_ruleset_parse_file_cb(
enum nftnl_parse_type type, FILE *fp,
216 struct nftnl_parse_err *err,
void *data,
223 EXPORT_SYMBOL(nftnl_ruleset_parse_buffer_cb);
224 int 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:
293 EXPORT_SYMBOL(nftnl_ruleset_parse);
294 int nftnl_ruleset_parse(
struct nftnl_ruleset *r,
enum nftnl_parse_type type,
295 const char *data,
struct nftnl_parse_err *err)
301 EXPORT_SYMBOL(nftnl_ruleset_parse_file);
302 int 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);
308 static const char *nftnl_ruleset_o_opentag(uint32_t type)
311 case NFTNL_OUTPUT_JSON:
312 return "{\"nftables\":[";
313 case NFTNL_OUTPUT_XML:
319 static const char *nftnl_ruleset_o_separator(
void *obj, uint32_t type)
325 case NFTNL_OUTPUT_JSON:
327 case NFTNL_OUTPUT_DEFAULT:
334 static const char *nftnl_ruleset_o_closetag(uint32_t type)
337 case NFTNL_OUTPUT_JSON:
339 case NFTNL_OUTPUT_XML:
346 nftnl_ruleset_snprintf_table(
char *buf,
size_t size,
352 int ret, remain = size, offset = 0;
354 ti = nftnl_table_list_iter_create(rs->table_list);
358 t = nftnl_table_list_iter_next(ti);
360 ret = nftnl_table_snprintf(buf + offset, remain, t, type, flags);
361 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
363 t = nftnl_table_list_iter_next(ti);
365 ret = snprintf(buf + offset, remain,
"%s",
366 nftnl_ruleset_o_separator(t, type));
367 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
369 nftnl_table_list_iter_destroy(ti);
375 nftnl_ruleset_snprintf_chain(
char *buf,
size_t size,
381 int ret, remain = size, offset = 0;
383 ci = nftnl_chain_list_iter_create(rs->chain_list);
387 c = nftnl_chain_list_iter_next(ci);
389 ret = nftnl_chain_snprintf(buf + offset, remain, c, type, flags);
390 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
392 c = nftnl_chain_list_iter_next(ci);
394 ret = snprintf(buf + offset, remain,
"%s",
395 nftnl_ruleset_o_separator(c, type));
396 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
398 nftnl_chain_list_iter_destroy(ci);
404 nftnl_ruleset_snprintf_set(
char *buf,
size_t size,
410 int ret, remain = size, offset = 0;
412 si = nftnl_set_list_iter_create(rs->set_list);
416 s = nftnl_set_list_iter_next(si);
418 ret = nftnl_set_snprintf(buf + offset, remain, s, type, flags);
419 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
421 s = nftnl_set_list_iter_next(si);
423 ret = snprintf(buf + offset, remain,
"%s",
424 nftnl_ruleset_o_separator(s, type));
425 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
427 nftnl_set_list_iter_destroy(si);
433 nftnl_ruleset_snprintf_rule(
char *buf,
size_t size,
437 struct nftnl_rule *r;
439 int ret, remain = size, offset = 0;
441 ri = nftnl_rule_list_iter_create(rs->rule_list);
445 r = nftnl_rule_list_iter_next(ri);
447 ret = nftnl_rule_snprintf(buf + offset, remain, r, type, flags);
448 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
450 r = nftnl_rule_list_iter_next(ri);
452 ret = snprintf(buf + offset, remain,
"%s",
453 nftnl_ruleset_o_separator(r, type));
454 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
456 nftnl_rule_list_iter_destroy(ri);
462 nftnl_ruleset_do_snprintf(
char *buf,
size_t size,
const struct nftnl_ruleset *rs,
463 uint32_t cmd, uint32_t type, uint32_t flags)
465 int ret, remain = size, offset = 0;
467 uint32_t inner_flags = flags;
470 inner_flags &= ~NFTNL_OF_EVENT_ANY;
472 if (nftnl_ruleset_is_set(rs, NFTNL_RULESET_TABLELIST) &&
473 (!nftnl_table_list_is_empty(rs->table_list))) {
474 ret = nftnl_ruleset_snprintf_table(buf + offset, remain, rs,
476 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
479 prev = rs->table_list;
482 if (nftnl_ruleset_is_set(rs, NFTNL_RULESET_CHAINLIST) &&
483 (!nftnl_chain_list_is_empty(rs->chain_list))) {
484 ret = snprintf(buf + offset, remain,
"%s",
485 nftnl_ruleset_o_separator(prev, type));
486 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
488 ret = nftnl_ruleset_snprintf_chain(buf + offset, remain, rs,
490 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
493 prev = rs->chain_list;
496 if (nftnl_ruleset_is_set(rs, NFTNL_RULESET_SETLIST) &&
497 (!nftnl_set_list_is_empty(rs->set_list))) {
498 ret = snprintf(buf + offset, remain,
"%s",
499 nftnl_ruleset_o_separator(prev, type));
500 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
502 ret = nftnl_ruleset_snprintf_set(buf + offset, remain, rs,
504 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
510 if (nftnl_ruleset_is_set(rs, NFTNL_RULESET_RULELIST) &&
511 (!nftnl_rule_list_is_empty(rs->rule_list))) {
512 ret = snprintf(buf + offset, remain,
"%s",
513 nftnl_ruleset_o_separator(prev, type));
514 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
516 ret = nftnl_ruleset_snprintf_rule(buf + offset, remain, rs,
518 SNPRINTF_BUFFER_SIZE(ret, remain, offset);
524 static int nftnl_ruleset_cmd_snprintf(
char *buf,
size_t size,
526 uint32_t type, uint32_t flags)
529 case NFTNL_OUTPUT_DEFAULT:
530 case NFTNL_OUTPUT_JSON:
531 return nftnl_ruleset_do_snprintf(buf, size, r, cmd, type, flags);
532 case NFTNL_OUTPUT_XML:
539 EXPORT_SYMBOL(nftnl_ruleset_snprintf);
540 int nftnl_ruleset_snprintf(
char *buf,
size_t size,
const struct nftnl_ruleset *r,
541 uint32_t type, uint32_t flags)
547 case NFTNL_OUTPUT_DEFAULT:
548 case NFTNL_OUTPUT_JSON:
549 return nftnl_ruleset_cmd_snprintf(buf, size, r,
550 nftnl_flag2cmd(flags), type,
552 case NFTNL_OUTPUT_XML:
559 static int nftnl_ruleset_fprintf_tables(FILE *fp,
const struct nftnl_ruleset *rs,
560 uint32_t type, uint32_t flags)
562 int len = 0, ret = 0;
566 ti = nftnl_table_list_iter_create(rs->table_list);
570 t = nftnl_table_list_iter_next(ti);
572 ret = nftnl_table_fprintf(fp, t, type, flags);
578 t = nftnl_table_list_iter_next(ti);
580 ret = fprintf(fp,
"%s", nftnl_ruleset_o_separator(t, type));
586 nftnl_table_list_iter_destroy(ti);
590 nftnl_table_list_iter_destroy(ti);
594 static int nftnl_ruleset_fprintf_chains(FILE *fp,
const struct nftnl_ruleset *rs,
595 uint32_t type, uint32_t flags)
597 int len = 0, ret = 0;
601 i = nftnl_chain_list_iter_create(rs->chain_list);
605 o = nftnl_chain_list_iter_next(i);
607 ret = nftnl_chain_fprintf(fp, o, type, flags);
613 o = nftnl_chain_list_iter_next(i);
615 ret = fprintf(fp,
"%s", nftnl_ruleset_o_separator(o, type));
621 nftnl_chain_list_iter_destroy(i);
625 nftnl_chain_list_iter_destroy(i);
629 static int nftnl_ruleset_fprintf_sets(FILE *fp,
const struct nftnl_ruleset *rs,
630 uint32_t type, uint32_t flags)
632 int len = 0, ret = 0;
636 i = nftnl_set_list_iter_create(rs->set_list);
640 o = nftnl_set_list_iter_next(i);
642 ret = nftnl_set_fprintf(fp, o, type, flags);
648 o = nftnl_set_list_iter_next(i);
650 ret = fprintf(fp,
"%s", nftnl_ruleset_o_separator(o, type));
656 nftnl_set_list_iter_destroy(i);
660 nftnl_set_list_iter_destroy(i);
664 static int nftnl_ruleset_fprintf_rules(FILE *fp,
const struct nftnl_ruleset *rs,
665 uint32_t type, uint32_t flags)
667 int len = 0, ret = 0;
668 struct nftnl_rule *o;
671 i = nftnl_rule_list_iter_create(rs->rule_list);
675 o = nftnl_rule_list_iter_next(i);
677 ret = nftnl_rule_fprintf(fp, o, type, flags);
683 o = nftnl_rule_list_iter_next(i);
685 ret = fprintf(fp,
"%s", nftnl_ruleset_o_separator(o, type));
691 nftnl_rule_list_iter_destroy(i);
695 nftnl_rule_list_iter_destroy(i);
699 #define NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len) \ 704 static int nftnl_ruleset_cmd_fprintf(FILE *fp,
const struct nftnl_ruleset *rs,
705 uint32_t cmd, uint32_t type, uint32_t flags)
707 int len = 0, ret = 0;
709 uint32_t inner_flags = flags;
712 inner_flags &= ~NFTNL_OF_EVENT_ANY;
714 ret = fprintf(fp,
"%s", nftnl_ruleset_o_opentag(type));
715 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
717 if ((nftnl_ruleset_is_set(rs, NFTNL_RULESET_TABLELIST)) &&
718 (!nftnl_table_list_is_empty(rs->table_list))) {
719 ret = nftnl_ruleset_fprintf_tables(fp, rs, type, inner_flags);
720 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
723 prev = rs->table_list;
726 if ((nftnl_ruleset_is_set(rs, NFTNL_RULESET_CHAINLIST)) &&
727 (!nftnl_chain_list_is_empty(rs->chain_list))) {
728 ret = fprintf(fp,
"%s", nftnl_ruleset_o_separator(prev, type));
729 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
731 ret = nftnl_ruleset_fprintf_chains(fp, rs, type, inner_flags);
732 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
735 prev = rs->chain_list;
738 if ((nftnl_ruleset_is_set(rs, NFTNL_RULESET_SETLIST)) &&
739 (!nftnl_set_list_is_empty(rs->set_list))) {
740 ret = fprintf(fp,
"%s", nftnl_ruleset_o_separator(prev, type));
741 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
743 ret = nftnl_ruleset_fprintf_sets(fp, rs, type, inner_flags);
744 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
750 if ((nftnl_ruleset_is_set(rs, NFTNL_RULESET_RULELIST)) &&
751 (!nftnl_rule_list_is_empty(rs->rule_list))) {
752 ret = fprintf(fp,
"%s", nftnl_ruleset_o_separator(prev, type));
753 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
755 ret = nftnl_ruleset_fprintf_rules(fp, rs, type, inner_flags);
756 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
759 ret = fprintf(fp,
"%s", nftnl_ruleset_o_closetag(type));
760 NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
765 EXPORT_SYMBOL(nftnl_ruleset_fprintf);
766 int nftnl_ruleset_fprintf(FILE *fp,
const struct nftnl_ruleset *rs, uint32_t type,
769 return nftnl_ruleset_cmd_fprintf(fp, rs, nftnl_flag2cmd(flags), type,