From 989b793a3bf689757b2b8f08a1c264743d75fa0f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=81lvaro=20Neira=20Ayuso?= Date: Mon, 11 Nov 2013 21:09:35 +0100 Subject: src: unify parse and output types Unify parse and output types that are redundant to all existing nftables objects. Thus, all NFT_*_O_[XML|JSON|DEFAULT] are merged into NFT_OUTPUT_[JSON|XML] and NFT_PARSE_[JSON|XML]. Signed-off-by: Alvaro Neira Ayuso Signed-off-by: Pablo Neira Ayuso --- examples/nft-chain-get.c | 6 +++--- examples/nft-chain-json-add.c | 4 ++-- examples/nft-chain-xml-add.c | 4 ++-- examples/nft-events.c | 6 +++--- examples/nft-rule-get.c | 6 +++--- examples/nft-rule-json-add.c | 4 ++-- examples/nft-rule-xml-add.c | 4 ++-- examples/nft-set-elem-get.c | 6 +++--- examples/nft-set-get.c | 6 +++--- examples/nft-set-json-add.c | 4 ++-- examples/nft-table-get.c | 6 +++--- examples/nft-table-json-add.c | 4 ++-- examples/nft-table-xml-add.c | 4 ++-- include/libnftables/Makefile.am | 3 ++- include/libnftables/chain.h | 17 +++-------------- include/libnftables/common.h | 16 ++++++++++++++++ include/libnftables/rule.h | 17 +++-------------- include/libnftables/ruleset.h | 17 +++-------------- include/libnftables/set.h | 19 ++++--------------- include/libnftables/table.h | 17 +++-------------- src/chain.c | 12 ++++++------ src/expr/bitwise.c | 18 +++++++++--------- src/expr/byteorder.c | 6 +++--- src/expr/cmp.c | 12 ++++++------ src/expr/counter.c | 6 +++--- src/expr/ct.c | 6 +++--- src/expr/data_reg.c | 18 +++++++++--------- src/expr/exthdr.c | 6 +++--- src/expr/immediate.c | 24 ++++++++++++------------ src/expr/limit.c | 6 +++--- src/expr/log.c | 6 +++--- src/expr/lookup.c | 6 +++--- src/expr/match.c | 6 +++--- src/expr/meta.c | 6 +++--- src/expr/nat.c | 6 +++--- src/expr/payload.c | 6 +++--- src/expr/reject.c | 6 +++--- src/expr/target.c | 6 +++--- src/rule.c | 12 ++++++------ src/ruleset.c | 24 ++++++++++++------------ src/set.c | 14 +++++++------- src/set_elem.c | 18 +++++++++--------- src/table.c | 12 ++++++------ tests/nft-parsing-test.c | 40 ++++++++++++++++++++-------------------- 44 files changed, 207 insertions(+), 245 deletions(-) create mode 100644 include/libnftables/common.h diff --git a/examples/nft-chain-get.c b/examples/nft-chain-get.c index e466e8b..7e162f6 100644 --- a/examples/nft-chain-get.c +++ b/examples/nft-chain-get.c @@ -51,7 +51,7 @@ int main(int argc, char *argv[]) struct mnl_socket *nl; char buf[MNL_SOCKET_BUFFER_SIZE]; struct nlmsghdr *nlh; - uint32_t portid, seq, type = NFT_CHAIN_O_DEFAULT; + uint32_t portid, seq, type = NFT_OUTPUT_DEFAULT; struct nft_chain *t = NULL; int ret, family; @@ -96,9 +96,9 @@ int main(int argc, char *argv[]) } if (strcmp(argv[argc-1], "xml") == 0){ - type = NFT_CHAIN_O_XML; + type = NFT_OUTPUT_XML; }else if (strcmp(argv[argc-1], "json") == 0){ - type = NFT_CHAIN_O_JSON; + type = NFT_OUTPUT_JSON; } nl = mnl_socket_open(NETLINK_NETFILTER); diff --git a/examples/nft-chain-json-add.c b/examples/nft-chain-json-add.c index 42e2d82..50cb29f 100644 --- a/examples/nft-chain-json-add.c +++ b/examples/nft-chain-json-add.c @@ -65,12 +65,12 @@ int main(int argc, char *argv[]) close(fd); - if (nft_chain_parse(c, NFT_CHAIN_PARSE_JSON, json) < 0) { + if (nft_chain_parse(c, NFT_PARSE_JSON, json) < 0) { printf("E: Unable to parse JSON file: %s\n", strerror(errno)); exit(EXIT_FAILURE); } - nft_chain_snprintf(reprint, sizeof(reprint), c, NFT_CHAIN_O_JSON, 0); + nft_chain_snprintf(reprint, sizeof(reprint), c, NFT_OUTPUT_JSON, 0); printf("Parsed:\n%s\n", reprint); nft_chain_attr_unset(c, NFT_CHAIN_ATTR_HANDLE); diff --git a/examples/nft-chain-xml-add.c b/examples/nft-chain-xml-add.c index 2e2fe11..03a2950 100644 --- a/examples/nft-chain-xml-add.c +++ b/examples/nft-chain-xml-add.c @@ -63,12 +63,12 @@ int main(int argc, char *argv[]) close(fd); - if (nft_chain_parse(c, NFT_CHAIN_PARSE_XML, xml) < 0) { + if (nft_chain_parse(c, NFT_PARSE_XML, xml) < 0) { printf("E: Unable to parse XML file: %s\n", strerror(errno)); exit(EXIT_FAILURE); } - nft_chain_snprintf(reprint, sizeof(reprint), c, NFT_CHAIN_O_XML, 0); + nft_chain_snprintf(reprint, sizeof(reprint), c, NFT_OUTPUT_XML, 0); printf("Parsed:\n%s\n", reprint); nft_chain_attr_unset(c, NFT_CHAIN_ATTR_HANDLE); diff --git a/examples/nft-events.c b/examples/nft-events.c index 5550c70..29cb659 100644 --- a/examples/nft-events.c +++ b/examples/nft-events.c @@ -38,7 +38,7 @@ static int table_cb(const struct nlmsghdr *nlh, int type) goto err_free; } - nft_table_snprintf(buf, sizeof(buf), t, NFT_TABLE_O_DEFAULT, 0); + nft_table_snprintf(buf, sizeof(buf), t, NFT_OUTPUT_DEFAULT, 0); printf("[%s]\t%s\n", type == NFT_MSG_NEWTABLE ? "NEW" : "DEL", buf); err_free: @@ -63,7 +63,7 @@ static int rule_cb(const struct nlmsghdr *nlh, int type) goto err_free; } - nft_rule_snprintf(buf, sizeof(buf), t, NFT_RULE_O_DEFAULT, 0); + nft_rule_snprintf(buf, sizeof(buf), t, NFT_OUTPUT_DEFAULT, 0); printf("[%s]\t%s\n", type == NFT_MSG_NEWRULE ? "NEW" : "DEL", buf); err_free: @@ -88,7 +88,7 @@ static int chain_cb(const struct nlmsghdr *nlh, int type) goto err_free; } - nft_chain_snprintf(buf, sizeof(buf), t, NFT_CHAIN_O_DEFAULT, 0); + nft_chain_snprintf(buf, sizeof(buf), t, NFT_OUTPUT_DEFAULT, 0); printf("[%s]\t%s\n", type == NFT_MSG_NEWCHAIN ? "NEW" : "DEL", buf); err_free: diff --git a/examples/nft-rule-get.c b/examples/nft-rule-get.c index cd0f8dc..f17630b 100644 --- a/examples/nft-rule-get.c +++ b/examples/nft-rule-get.c @@ -51,7 +51,7 @@ int main(int argc, char *argv[]) struct mnl_socket *nl; char buf[MNL_SOCKET_BUFFER_SIZE]; struct nlmsghdr *nlh; - uint32_t portid, seq, type = NFT_RULE_O_DEFAULT; + uint32_t portid, seq, type = NFT_OUTPUT_DEFAULT; struct nft_rule *t = NULL; int ret, family; @@ -78,9 +78,9 @@ int main(int argc, char *argv[]) if (argc == 3) { if (strcmp(argv[2], "xml") == 0) - type = NFT_RULE_O_XML; + type = NFT_OUTPUT_XML; else if (strcmp(argv[2], "json") == 0) - type = NFT_RULE_O_JSON; + type = NFT_OUTPUT_JSON; } /* XXX requires table, chain and handle attributes for selective get */ diff --git a/examples/nft-rule-json-add.c b/examples/nft-rule-json-add.c index 83dec3e..8659081 100644 --- a/examples/nft-rule-json-add.c +++ b/examples/nft-rule-json-add.c @@ -63,12 +63,12 @@ int main(int argc, char *argv[]) exit(EXIT_FAILURE); } - if (nft_rule_parse(r, NFT_RULE_PARSE_JSON, json) < 0) { + if (nft_rule_parse(r, NFT_PARSE_JSON, json) < 0) { printf("E: Unable to parse JSON file: %s\n", strerror(errno)); exit(EXIT_FAILURE); } - nft_rule_snprintf(reprint, sizeof(reprint), r, NFT_RULE_O_JSON, 0); + nft_rule_snprintf(reprint, sizeof(reprint), r, NFT_OUTPUT_JSON, 0); printf("Parsed:\n%s\n", reprint); nft_rule_attr_unset(r, NFT_RULE_ATTR_HANDLE); diff --git a/examples/nft-rule-xml-add.c b/examples/nft-rule-xml-add.c index 4de7a69..ce33fe7 100644 --- a/examples/nft-rule-xml-add.c +++ b/examples/nft-rule-xml-add.c @@ -63,12 +63,12 @@ int main(int argc, char *argv[]) exit(EXIT_FAILURE); } - if (nft_rule_parse(r, NFT_RULE_PARSE_XML, xml) < 0) { + if (nft_rule_parse(r, NFT_PARSE_XML, xml) < 0) { printf("E: Unable to parse XML file: %s\n", strerror(errno)); exit(EXIT_FAILURE); } - nft_rule_snprintf(reprint, sizeof(reprint), r, NFT_RULE_O_XML, 0); + nft_rule_snprintf(reprint, sizeof(reprint), r, NFT_OUTPUT_XML, 0); printf("Parsed:\n%s\n", reprint); nft_rule_attr_unset(r, NFT_RULE_ATTR_HANDLE); diff --git a/examples/nft-set-elem-get.c b/examples/nft-set-elem-get.c index aeba400..0b46f36 100644 --- a/examples/nft-set-elem-get.c +++ b/examples/nft-set-elem-get.c @@ -52,7 +52,7 @@ int main(int argc, char *argv[]) char buf[MNL_SOCKET_BUFFER_SIZE]; struct nlmsghdr *nlh; uint32_t portid, seq, family; - uint32_t type = NFT_SET_O_DEFAULT; + uint32_t type = NFT_OUTPUT_DEFAULT; struct nft_set *t = NULL; int ret; @@ -81,9 +81,9 @@ int main(int argc, char *argv[]) } if (argc == 5 && strcmp(argv[4], "json") == 0 ) - type = NFT_SET_O_JSON; + type = NFT_OUTPUT_JSON; else if (argc == 5 && strcmp(argv[4], "xml") == 0) - type = NFT_SET_O_XML; + type = NFT_OUTPUT_XML; nlh = nft_set_nlmsg_build_hdr(buf, NFT_MSG_GETSETELEM, family, NLM_F_DUMP|NLM_F_ACK, seq); diff --git a/examples/nft-set-get.c b/examples/nft-set-get.c index 4bc585c..6762032 100644 --- a/examples/nft-set-get.c +++ b/examples/nft-set-get.c @@ -52,7 +52,7 @@ int main(int argc, char *argv[]) char buf[MNL_SOCKET_BUFFER_SIZE]; struct nlmsghdr *nlh; uint32_t portid, seq, family; - uint32_t type = NFT_SET_O_DEFAULT; + uint32_t type = NFT_OUTPUT_DEFAULT; struct nft_set *t = NULL; int ret; @@ -80,9 +80,9 @@ int main(int argc, char *argv[]) } if (argc == 3 && strcmp(argv[2], "json") == 0) - type = NFT_SET_O_JSON; + type = NFT_OUTPUT_JSON; else if (argc == 3 && strcmp(argv[2], "xml") == 0) - type = NFT_SET_O_XML; + type = NFT_OUTPUT_XML; nlh = nft_set_nlmsg_build_hdr(buf, NFT_MSG_GETSET, family, NLM_F_DUMP|NLM_F_ACK, seq); diff --git a/examples/nft-set-json-add.c b/examples/nft-set-json-add.c index 33c3acd..9a4aa48 100644 --- a/examples/nft-set-json-add.c +++ b/examples/nft-set-json-add.c @@ -64,12 +64,12 @@ int main(int argc, char *argv[]) close(fd); - if (nft_set_parse(s, NFT_SET_PARSE_JSON, json) < 0) { + if (nft_set_parse(s, NFT_PARSE_JSON, json) < 0) { printf("E: Unable to parse JSON file: %s\n", strerror(errno)); exit(EXIT_FAILURE); } - nft_set_snprintf(reprint, sizeof(reprint), s, NFT_SET_O_JSON, 0); + nft_set_snprintf(reprint, sizeof(reprint), s, NFT_OUTPUT_JSON, 0); printf("Parsed:\n%s\n", reprint); family = nft_set_attr_get_u32(s, NFT_SET_ATTR_FAMILY); diff --git a/examples/nft-table-get.c b/examples/nft-table-get.c index f57423b..c5bc89d 100644 --- a/examples/nft-table-get.c +++ b/examples/nft-table-get.c @@ -54,7 +54,7 @@ int main(int argc, char *argv[]) uint32_t portid, seq, family; struct nft_table *t = NULL; int ret; - uint32_t type = NFT_TABLE_O_DEFAULT; + uint32_t type = NFT_OUTPUT_DEFAULT; if (argc < 2 || argc > 4) { fprintf(stderr, "%s [] []\n", @@ -78,11 +78,11 @@ int main(int argc, char *argv[]) } if (strcmp(argv[argc-1], "xml") == 0) { - type = NFT_TABLE_O_XML; + type = NFT_OUTPUT_XML; argv[argc-1] = NULL; argc--; }else if (strcmp(argv[argc-1], "json") == 0) { - type = NFT_TABLE_O_JSON; + type = NFT_OUTPUT_JSON; argv[argc-1] = NULL; argc--; } else if (strcmp(argv[argc - 1], "default") == 0) { diff --git a/examples/nft-table-json-add.c b/examples/nft-table-json-add.c index 5526c91..6b16c7f 100644 --- a/examples/nft-table-json-add.c +++ b/examples/nft-table-json-add.c @@ -64,12 +64,12 @@ int main(int argc, char *argv[]) exit(EXIT_FAILURE); } - if (nft_table_parse(t, NFT_TABLE_PARSE_JSON, json) < 0) { + if (nft_table_parse(t, NFT_PARSE_JSON, json) < 0) { printf("E: Unable to parse JSON file: %s\n", strerror(errno)); exit(EXIT_FAILURE); } - nft_table_snprintf(reprint, sizeof(reprint), t, NFT_TABLE_O_JSON, 0); + nft_table_snprintf(reprint, sizeof(reprint), t, NFT_OUTPUT_JSON, 0); printf("Parsed:\n%s\n", reprint); family = nft_table_attr_get_u32(t, NFT_TABLE_ATTR_FAMILY); diff --git a/examples/nft-table-xml-add.c b/examples/nft-table-xml-add.c index 6de0855..6a9163b 100644 --- a/examples/nft-table-xml-add.c +++ b/examples/nft-table-xml-add.c @@ -60,12 +60,12 @@ int main(int argc, char *argv[]) exit(EXIT_FAILURE); } - if (nft_table_parse(t, NFT_TABLE_PARSE_XML, xml) < 0) { + if (nft_table_parse(t, NFT_PARSE_XML, xml) < 0) { printf("E: Unable to parse XML file: %s\n", strerror(errno)); exit(EXIT_FAILURE); } - nft_table_snprintf(reprint, sizeof(reprint), t, NFT_TABLE_O_XML, 0); + nft_table_snprintf(reprint, sizeof(reprint), t, NFT_OUTPUT_XML, 0); printf("Parsed:\n%s\n", reprint); family = nft_table_attr_get_u32(t, NFT_TABLE_ATTR_FAMILY); diff --git a/include/libnftables/Makefile.am b/include/libnftables/Makefile.am index e243f32..a0841d2 100644 --- a/include/libnftables/Makefile.am +++ b/include/libnftables/Makefile.am @@ -3,4 +3,5 @@ pkginclude_HEADERS = table.h \ rule.h \ expr.h \ set.h \ - ruleset.h + ruleset.h \ + common.h diff --git a/include/libnftables/chain.h b/include/libnftables/chain.h index 5de7318..c26b348 100644 --- a/include/libnftables/chain.h +++ b/include/libnftables/chain.h @@ -6,6 +6,8 @@ #include #include +#include + #ifdef __cplusplus extern "C" { #endif @@ -47,20 +49,7 @@ struct nlmsghdr; void nft_chain_nlmsg_build_payload(struct nlmsghdr *nlh, const struct nft_chain *t); -enum { - NFT_CHAIN_O_DEFAULT = 0, - NFT_CHAIN_O_XML, - NFT_CHAIN_O_JSON, -}; - -enum nft_chain_parse_type { - NFT_CHAIN_PARSE_NONE = 0, - NFT_CHAIN_PARSE_XML, - NFT_CHAIN_PARSE_JSON, - NFT_CHAIN_PARSE_MAX -}; - -int nft_chain_parse(struct nft_chain *c, enum nft_chain_parse_type type, const char *data); +int nft_chain_parse(struct nft_chain *c, enum nft_parse_type type, const char *data); int nft_chain_snprintf(char *buf, size_t size, struct nft_chain *t, uint32_t type, uint32_t flags); int nft_chain_fprintf(FILE *fp, struct nft_chain *c, uint32_t type, uint32_t flags); diff --git a/include/libnftables/common.h b/include/libnftables/common.h new file mode 100644 index 0000000..d19a84b --- /dev/null +++ b/include/libnftables/common.h @@ -0,0 +1,16 @@ +#ifndef _COMMON_H_ +#define _COMMON_H_ + +enum nft_output_type { + NFT_OUTPUT_DEFAULT = 0, + NFT_OUTPUT_XML, + NFT_OUTPUT_JSON, +}; + +enum nft_parse_type { + NFT_PARSE_NONE = 0, + NFT_PARSE_XML, + NFT_PARSE_JSON, + NFT_PARSE_MAX, +}; +#endif diff --git a/include/libnftables/rule.h b/include/libnftables/rule.h index b61afb0..4957a2a 100644 --- a/include/libnftables/rule.h +++ b/include/libnftables/rule.h @@ -6,6 +6,8 @@ #include #include +#include + #ifdef __cplusplus extern "C" { #endif @@ -45,20 +47,7 @@ struct nlmsghdr; void nft_rule_nlmsg_build_payload(struct nlmsghdr *nlh, struct nft_rule *t); -enum { - NFT_RULE_O_DEFAULT = 0, - NFT_RULE_O_XML, - NFT_RULE_O_JSON, -}; - -enum nft_rule_parse_type { - NFT_RULE_PARSE_NONE = 0, - NFT_RULE_PARSE_XML, - NFT_RULE_PARSE_JSON, - NFT_RULE_PARSE_MAX, -}; - -int nft_rule_parse(struct nft_rule *r, enum nft_rule_parse_type type, const char *data); +int nft_rule_parse(struct nft_rule *r, enum nft_parse_type type, const char *data); int nft_rule_snprintf(char *buf, size_t size, struct nft_rule *t, uint32_t type, uint32_t flags); int nft_rule_fprintf(FILE *fp, struct nft_rule *r, uint32_t type, uint32_t flags); diff --git a/include/libnftables/ruleset.h b/include/libnftables/ruleset.h index 3b20bfa..71ef3b1 100644 --- a/include/libnftables/ruleset.h +++ b/include/libnftables/ruleset.h @@ -7,6 +7,8 @@ #include #include +#include + #ifdef __cplusplus extern "C" { #endif @@ -28,20 +30,7 @@ void nft_ruleset_attr_unset(struct nft_ruleset *r, uint16_t attr); void nft_ruleset_attr_set(struct nft_ruleset *r, uint16_t attr, void *data); const void *nft_ruleset_attr_get(const struct nft_ruleset *r, uint16_t attr); -enum { - NFT_RULESET_O_DEFAULT = 0, - NFT_RULESET_O_XML, - NFT_RULESET_O_JSON, -}; - -enum nft_ruleset_parse_type { - NFT_RULESET_PARSE_NONE = 0, - NFT_RULESET_PARSE_XML, - NFT_RULESET_PARSE_JSON, - NFT_RULESET_PARSE_MAX, -}; - -int nft_ruleset_parse(struct nft_ruleset *rs, enum nft_ruleset_parse_type type, const char *data); +int nft_ruleset_parse(struct nft_ruleset *rs, enum nft_parse_type type, const char *data); int nft_ruleset_snprintf(char *buf, size_t size, const struct nft_ruleset *rs, uint32_t type, uint32_t flags); int nft_ruleset_fprintf(FILE *fp, const struct nft_ruleset *rs, uint32_t type, uint32_t flags); diff --git a/include/libnftables/set.h b/include/libnftables/set.h index cf63b9b..d378049 100644 --- a/include/libnftables/set.h +++ b/include/libnftables/set.h @@ -6,6 +6,8 @@ #include #include +#include + enum { NFT_SET_ATTR_TABLE, NFT_SET_ATTR_NAME, @@ -58,14 +60,7 @@ struct nft_set *nft_set_list_iter_cur(struct nft_set_list_iter *iter); struct nft_set *nft_set_list_iter_next(struct nft_set_list_iter *iter); void nft_set_list_iter_destroy(struct nft_set_list_iter *iter); -enum nft_set_parse_type { - NFT_SET_PARSE_NONE = 0, - NFT_SET_PARSE_XML, - NFT_SET_PARSE_JSON, - NFT_SET_PARSE_MAX, -}; - -int nft_set_parse(struct nft_set *s, enum nft_set_parse_type type, const char *data); +int nft_set_parse(struct nft_set *s, enum nft_parse_type type, const char *data); /* * Set elements @@ -79,12 +74,6 @@ enum { NFT_SET_ELEM_ATTR_DATA, }; -enum { - NFT_SET_O_DEFAULT = 0, - NFT_SET_O_XML, - NFT_SET_O_JSON, -}; - struct nft_set_elem; struct nft_set_elem *nft_set_elem_alloc(void); @@ -109,7 +98,7 @@ void nft_set_elem_nlmsg_build_payload(struct nlmsghdr *nlh, struct nft_set_elem int nft_set_elem_nlmsg_parse(const struct nlmsghdr *nlh, struct nft_set_elem *s); -int nft_set_elem_parse(struct nft_set_elem *e, enum nft_set_parse_type type, const char *data); +int nft_set_elem_parse(struct nft_set_elem *e, enum nft_parse_type type, const char *data); int nft_set_elem_snprintf(char *buf, size_t size, struct nft_set_elem *s, uint32_t type, uint32_t flags); int nft_set_elem_fprintf(FILE *fp, struct nft_set_elem *se, uint32_t type, uint32_t flags); diff --git a/include/libnftables/table.h b/include/libnftables/table.h index e3b4888..4902a1d 100644 --- a/include/libnftables/table.h +++ b/include/libnftables/table.h @@ -6,6 +6,8 @@ #include #include +#include + #ifdef __cplusplus extern "C" { #endif @@ -35,20 +37,7 @@ struct nlmsghdr; void nft_table_nlmsg_build_payload(struct nlmsghdr *nlh, const struct nft_table *t); -enum { - NFT_TABLE_O_DEFAULT = 0, - NFT_TABLE_O_XML, - NFT_TABLE_O_JSON, -}; - -enum nft_table_parse_type { - NFT_TABLE_PARSE_NONE = 0, - NFT_TABLE_PARSE_XML, - NFT_TABLE_PARSE_JSON, - NFT_TABLE_PARSE_MAX, -}; - -int nft_table_parse(struct nft_table *t, enum nft_table_parse_type type, const char *data); +int nft_table_parse(struct nft_table *t, enum nft_parse_type type, const char *data); int nft_table_snprintf(char *buf, size_t size, struct nft_table *t, uint32_t type, uint32_t flags); int nft_table_fprintf(FILE *fp, struct nft_table *t, uint32_t type, uint32_t flags); diff --git a/src/chain.c b/src/chain.c index cdb398f..a58999d 100644 --- a/src/chain.c +++ b/src/chain.c @@ -727,16 +727,16 @@ static int nft_chain_xml_parse(struct nft_chain *c, const char *xml) #endif } -int nft_chain_parse(struct nft_chain *c, enum nft_chain_parse_type type, +int nft_chain_parse(struct nft_chain *c, enum nft_parse_type type, const char *data) { int ret; switch (type) { - case NFT_CHAIN_PARSE_XML: + case NFT_PARSE_XML: ret = nft_chain_xml_parse(c, data); break; - case NFT_CHAIN_PARSE_JSON: + case NFT_PARSE_JSON: ret = nft_chain_json_parse(c, data); break; default: @@ -838,11 +838,11 @@ int nft_chain_snprintf(char *buf, size_t size, struct nft_chain *c, uint32_t type, uint32_t flags) { switch(type) { - case NFT_CHAIN_O_DEFAULT: + case NFT_OUTPUT_DEFAULT: return nft_chain_snprintf_default(buf, size, c); - case NFT_CHAIN_O_XML: + case NFT_OUTPUT_XML: return nft_chain_snprintf_xml(buf, size, c); - case NFT_CHAIN_O_JSON: + case NFT_OUTPUT_JSON: return nft_chain_snprintf_json(buf, size, c); default: break; diff --git a/src/expr/bitwise.c b/src/expr/bitwise.c index 0be1593..bcec516 100644 --- a/src/expr/bitwise.c +++ b/src/expr/bitwise.c @@ -293,14 +293,14 @@ nft_rule_expr_bitwise_snprintf_json(char *buf, size_t size, SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = nft_data_reg_snprintf(buf+offset, len, &bitwise->mask, - NFT_RULE_O_JSON, 0, DATA_VALUE); + NFT_OUTPUT_JSON, 0, DATA_VALUE); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = snprintf(buf+offset, len, "},\"xor\":{"); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = nft_data_reg_snprintf(buf+offset, len, &bitwise->xor, - NFT_RULE_O_JSON, 0, DATA_VALUE); + NFT_OUTPUT_JSON, 0, DATA_VALUE); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = snprintf(buf+offset, len, "}"); @@ -325,14 +325,14 @@ nft_rule_expr_bitwise_snprintf_xml(char *buf, size_t size, SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = nft_data_reg_snprintf(buf+offset, len, &bitwise->mask, - NFT_RULE_O_XML, 0, DATA_VALUE); + NFT_OUTPUT_XML, 0, DATA_VALUE); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = snprintf(buf+offset, len, ""); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = nft_data_reg_snprintf(buf+offset, len, &bitwise->xor, - NFT_RULE_O_XML, 0, DATA_VALUE); + NFT_OUTPUT_XML, 0, DATA_VALUE); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = snprintf(buf+offset, len, ""); @@ -352,14 +352,14 @@ nft_rule_expr_bitwise_snprintf_default(char *buf, size_t size, SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = nft_data_reg_snprintf(buf+offset, len, &bitwise->mask, - NFT_RULE_O_DEFAULT, 0, DATA_VALUE); + NFT_OUTPUT_DEFAULT, 0, DATA_VALUE); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = snprintf(buf+offset, len, ") ^ "); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = nft_data_reg_snprintf(buf+offset, len, &bitwise->xor, - NFT_RULE_O_DEFAULT, 0, DATA_VALUE); + NFT_OUTPUT_DEFAULT, 0, DATA_VALUE); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); return offset; @@ -372,12 +372,12 @@ nft_rule_expr_bitwise_snprintf(char *buf, size_t size, uint32_t type, struct nft_expr_bitwise *bitwise = nft_expr_data(e); switch(type) { - case NFT_RULE_O_DEFAULT: + case NFT_OUTPUT_DEFAULT: return nft_rule_expr_bitwise_snprintf_default(buf, size, bitwise); - case NFT_RULE_O_XML: + case NFT_OUTPUT_XML: return nft_rule_expr_bitwise_snprintf_xml(buf, size, bitwise); - case NFT_RULE_O_JSON: + case NFT_OUTPUT_JSON: return nft_rule_expr_bitwise_snprintf_json(buf, size, bitwise); default: break; diff --git a/src/expr/byteorder.c b/src/expr/byteorder.c index 7012452..7224c82 100644 --- a/src/expr/byteorder.c +++ b/src/expr/byteorder.c @@ -351,13 +351,13 @@ nft_rule_expr_byteorder_snprintf(char *buf, size_t size, uint32_t type, struct nft_expr_byteorder *byteorder = nft_expr_data(e); switch(type) { - case NFT_RULE_O_DEFAULT: + case NFT_OUTPUT_DEFAULT: return nft_rule_expr_byteorder_snprintf_default(buf, size, byteorder); - case NFT_RULE_O_XML: + case NFT_OUTPUT_XML: return nft_rule_expr_byteorder_snprintf_xml(buf, size, byteorder); - case NFT_RULE_O_JSON: + case NFT_OUTPUT_JSON: return nft_rule_expr_byteorder_snprintf_json(buf, size, byteorder); default: diff --git a/src/expr/cmp.c b/src/expr/cmp.c index 7de7226..246f22f 100644 --- a/src/expr/cmp.c +++ b/src/expr/cmp.c @@ -258,7 +258,7 @@ nft_rule_expr_cmp_snprintf_json(char *buf, size_t size, struct nft_expr_cmp *cmp SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = nft_data_reg_snprintf(buf+offset, len, &cmp->data, - NFT_RULE_O_JSON, 0, DATA_VALUE); + NFT_OUTPUT_JSON, 0, DATA_VALUE); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = snprintf(buf+offset, len, "}"); @@ -277,7 +277,7 @@ nft_rule_expr_cmp_snprintf_xml(char *buf, size_t size, struct nft_expr_cmp *cmp) SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = nft_data_reg_snprintf(buf+offset, len, &cmp->data, - NFT_RULE_O_XML, 0, DATA_VALUE); + NFT_OUTPUT_XML, 0, DATA_VALUE); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = snprintf(buf+offset, len, ""); @@ -297,7 +297,7 @@ nft_rule_expr_cmp_snprintf_default(char *buf, size_t size, SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = nft_data_reg_snprintf(buf+offset, len, &cmp->data, - NFT_RULE_O_DEFAULT, 0, DATA_VALUE); + NFT_OUTPUT_DEFAULT, 0, DATA_VALUE); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); return offset; @@ -310,11 +310,11 @@ nft_rule_expr_cmp_snprintf(char *buf, size_t size, uint32_t type, struct nft_expr_cmp *cmp = nft_expr_data(e); switch(type) { - case NFT_RULE_O_DEFAULT: + case NFT_OUTPUT_DEFAULT: return nft_rule_expr_cmp_snprintf_default(buf, size, cmp); - case NFT_RULE_O_XML: + case NFT_OUTPUT_XML: return nft_rule_expr_cmp_snprintf_xml(buf, size, cmp); - case NFT_RULE_O_JSON: + case NFT_OUTPUT_JSON: return nft_rule_expr_cmp_snprintf_json(buf, size, cmp); default: break; diff --git a/src/expr/counter.c b/src/expr/counter.c index 561f26c..4919a69 100644 --- a/src/expr/counter.c +++ b/src/expr/counter.c @@ -173,13 +173,13 @@ nft_rule_expr_counter_snprintf(char *buf, size_t len, uint32_t type, struct nft_expr_counter *ctr = nft_expr_data(e); switch(type) { - case NFT_RULE_O_DEFAULT: + case NFT_OUTPUT_DEFAULT: return snprintf(buf, len, "pkts %"PRIu64" bytes %"PRIu64" ", ctr->pkts, ctr->bytes); - case NFT_RULE_O_XML: + case NFT_OUTPUT_XML: return snprintf(buf, len, "%"PRIu64"%"PRIu64"", ctr->pkts, ctr->bytes); - case NFT_RULE_O_JSON: + case NFT_OUTPUT_JSON: return snprintf(buf, len, "\"pkts\":%"PRIu64",\"bytes\":%"PRIu64"", ctr->pkts, ctr->bytes); default: diff --git a/src/expr/ct.c b/src/expr/ct.c index e84d996..46e3cef 100644 --- a/src/expr/ct.c +++ b/src/expr/ct.c @@ -304,15 +304,15 @@ nft_rule_expr_ct_snprintf(char *buf, size_t len, uint32_t type, struct nft_expr_ct *ct = nft_expr_data(e); switch(type) { - case NFT_RULE_O_DEFAULT: + case NFT_OUTPUT_DEFAULT: return snprintf(buf, len, "load %s => reg %u dir %u ", ctkey2str(ct->key), ct->dreg, ct->dir); - case NFT_RULE_O_XML: + case NFT_OUTPUT_XML: return snprintf(buf, len, "%u" "%s" "%u", ct->dreg, ctkey2str(ct->key), ct->dir); - case NFT_RULE_O_JSON: + case NFT_OUTPUT_JSON: return nft_expr_ct_snprintf_json(buf, len, e); default: break; diff --git a/src/expr/data_reg.c b/src/expr/data_reg.c index 193f3ab..76231af 100644 --- a/src/expr/data_reg.c +++ b/src/expr/data_reg.c @@ -300,13 +300,13 @@ int nft_data_reg_snprintf(char *buf, size_t size, union nft_data_reg *reg, switch(reg_type) { case DATA_VALUE: switch(output_format) { - case NFT_RULE_O_DEFAULT: + case NFT_OUTPUT_DEFAULT: return nft_data_reg_value_snprintf_default(buf, size, reg, flags); - case NFT_RULE_O_XML: + case NFT_OUTPUT_XML: return nft_data_reg_value_snprintf_xml(buf, size, reg, flags); - case NFT_RULE_O_JSON: + case NFT_OUTPUT_JSON: return nft_data_reg_value_snprintf_json(buf, size, reg, flags); default: @@ -314,15 +314,15 @@ int nft_data_reg_snprintf(char *buf, size_t size, union nft_data_reg *reg, } case DATA_VERDICT: switch(output_format) { - case NFT_RULE_O_DEFAULT: + case NFT_OUTPUT_DEFAULT: return snprintf(buf, size, "%d ", reg->verdict); - case NFT_RULE_O_XML: + case NFT_OUTPUT_XML: return snprintf(buf, size, "" "%s" "", nft_verdict2str(reg->verdict)); - case NFT_RULE_O_JSON: + case NFT_OUTPUT_JSON: return snprintf(buf, size, "\"data_reg\":{" "\"type\":\"verdict\"," @@ -333,14 +333,14 @@ int nft_data_reg_snprintf(char *buf, size_t size, union nft_data_reg *reg, } case DATA_CHAIN: switch(output_format) { - case NFT_RULE_O_DEFAULT: + case NFT_OUTPUT_DEFAULT: return snprintf(buf, size, "%s ", reg->chain); - case NFT_RULE_O_XML: + case NFT_OUTPUT_XML: return snprintf(buf, size, "" "%s" "", reg->chain); - case NFT_RULE_O_JSON: + case NFT_OUTPUT_JSON: return snprintf(buf, size, "\"data_reg\":{\"type\":\"chain\"," "\"chain\":\"%s\"" diff --git a/src/expr/exthdr.c b/src/expr/exthdr.c index 32791d0..6841ac1 100644 --- a/src/expr/exthdr.c +++ b/src/expr/exthdr.c @@ -289,11 +289,11 @@ nft_rule_expr_exthdr_snprintf(char *buf, size_t len, uint32_t type, struct nft_expr_exthdr *exthdr = nft_expr_data(e); switch(type) { - case NFT_RULE_O_DEFAULT: + case NFT_OUTPUT_DEFAULT: return snprintf(buf, len, "load %ub @ %u + %u => reg %u ", exthdr->len, exthdr->type, exthdr->offset, exthdr->dreg); - case NFT_RULE_O_XML: + case NFT_OUTPUT_XML: return snprintf(buf, len, "%u" "%s" "%u" @@ -301,7 +301,7 @@ nft_rule_expr_exthdr_snprintf(char *buf, size_t len, uint32_t type, exthdr->dreg, exthdr_type2str(exthdr->type), exthdr->offset, exthdr->len); - case NFT_RULE_O_JSON: + case NFT_OUTPUT_JSON: return snprintf(buf, len, "\"dreg\":%u," "\"exthdr_type\":\"%s\",\"offset\":%u," "\"len\":%u", diff --git a/src/expr/immediate.c b/src/expr/immediate.c index cb3b209..a96d3de 100644 --- a/src/expr/immediate.c +++ b/src/expr/immediate.c @@ -268,17 +268,17 @@ nft_rule_expr_immediate_snprintf_json(char *buf, size_t len, if (e->flags & (1 << NFT_EXPR_IMM_DATA)) { ret = nft_data_reg_snprintf(buf+offset, len, &imm->data, - NFT_RULE_O_JSON, flags, DATA_VALUE); + NFT_OUTPUT_JSON, flags, DATA_VALUE); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } else if (e->flags & (1 << NFT_EXPR_IMM_VERDICT)) { ret = nft_data_reg_snprintf(buf+offset, len, &imm->data, - NFT_RULE_O_JSON, flags, DATA_VERDICT); + NFT_OUTPUT_JSON, flags, DATA_VERDICT); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } else if (e->flags & (1 << NFT_EXPR_IMM_CHAIN)) { ret = nft_data_reg_snprintf(buf+offset, len, &imm->data, - NFT_RULE_O_JSON, flags, DATA_CHAIN); + NFT_OUTPUT_JSON, flags, DATA_CHAIN); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } @@ -302,17 +302,17 @@ nft_rule_expr_immediate_snprintf_xml(char *buf, size_t len, if (e->flags & (1 << NFT_EXPR_IMM_DATA)) { ret = nft_data_reg_snprintf(buf+offset, len, &imm->data, - NFT_RULE_O_XML, flags, DATA_VALUE); + NFT_OUTPUT_XML, flags, DATA_VALUE); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } else if (e->flags & (1 << NFT_EXPR_IMM_VERDICT)) { ret = nft_data_reg_snprintf(buf+offset, len, &imm->data, - NFT_RULE_O_XML, flags, DATA_VERDICT); + NFT_OUTPUT_XML, flags, DATA_VERDICT); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } else if (e->flags & (1 << NFT_EXPR_IMM_CHAIN)) { ret = nft_data_reg_snprintf(buf+offset, len, &imm->data, - NFT_RULE_O_XML, flags, DATA_CHAIN); + NFT_OUTPUT_XML, flags, DATA_CHAIN); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } @@ -334,17 +334,17 @@ nft_rule_expr_immediate_snprintf_default(char *buf, size_t len, if (e->flags & (1 << NFT_EXPR_IMM_DATA)) { ret = nft_data_reg_snprintf(buf+offset, len, &imm->data, - NFT_RULE_O_DEFAULT, flags, DATA_VALUE); + NFT_OUTPUT_DEFAULT, flags, DATA_VALUE); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } else if (e->flags & (1 << NFT_EXPR_IMM_VERDICT)) { ret = nft_data_reg_snprintf(buf+offset, len, &imm->data, - NFT_RULE_O_DEFAULT, flags, DATA_VERDICT); + NFT_OUTPUT_DEFAULT, flags, DATA_VERDICT); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } else if (e->flags & (1 << NFT_EXPR_IMM_CHAIN)) { ret = nft_data_reg_snprintf(buf+offset, len, &imm->data, - NFT_RULE_O_DEFAULT, flags, DATA_CHAIN); + NFT_OUTPUT_DEFAULT, flags, DATA_CHAIN); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } @@ -356,11 +356,11 @@ nft_rule_expr_immediate_snprintf(char *buf, size_t len, uint32_t type, uint32_t flags, struct nft_rule_expr *e) { switch(type) { - case NFT_RULE_O_DEFAULT: + case NFT_OUTPUT_DEFAULT: return nft_rule_expr_immediate_snprintf_default(buf, len, e, flags); - case NFT_RULE_O_XML: + case NFT_OUTPUT_XML: return nft_rule_expr_immediate_snprintf_xml(buf, len, e, flags); - case NFT_RULE_O_JSON: + case NFT_OUTPUT_JSON: return nft_rule_expr_immediate_snprintf_json(buf, len, e, flags); default: break; diff --git a/src/expr/limit.c b/src/expr/limit.c index 4fcf798..4854a77 100644 --- a/src/expr/limit.c +++ b/src/expr/limit.c @@ -183,14 +183,14 @@ nft_rule_expr_limit_snprintf(char *buf, size_t len, uint32_t type, struct nft_expr_limit *limit = nft_expr_data(e); switch(type) { - case NFT_RULE_O_DEFAULT: + case NFT_OUTPUT_DEFAULT: return snprintf(buf, len, "rate %"PRIu64"/%s ", limit->rate, get_unit(limit->unit)); - case NFT_RULE_O_XML: + case NFT_OUTPUT_XML: return snprintf(buf, len, "%"PRIu64"" "%"PRIu64"", limit->rate, limit->unit); - case NFT_RULE_O_JSON: + case NFT_OUTPUT_JSON: return snprintf(buf, len, "\"rate\":%"PRIu64"," "\"unit\":%"PRIu64"", limit->rate, limit->unit); diff --git a/src/expr/log.c b/src/expr/log.c index 7722d62..1f88246 100644 --- a/src/expr/log.c +++ b/src/expr/log.c @@ -243,19 +243,19 @@ nft_rule_expr_log_snprintf(char *buf, size_t len, uint32_t type, struct nft_expr_log *log = nft_expr_data(e); switch(type) { - case NFT_RULE_O_DEFAULT: + case NFT_OUTPUT_DEFAULT: return snprintf(buf, len, "prefix '%s' group %u " "snaplen %u qthreshold %u ", log->prefix, log->group, log->snaplen, log->qthreshold); - case NFT_RULE_O_XML: + case NFT_OUTPUT_XML: return snprintf(buf, len, "%s" "%u" "%u" "%u", log->prefix, log->group, log->snaplen, log->qthreshold); - case NFT_RULE_O_JSON: + case NFT_OUTPUT_JSON: return snprintf(buf, len, "\"prefix\":\"%s\"," "\"group\":%u," "\"snaplen\":%u," diff --git a/src/expr/lookup.c b/src/expr/lookup.c index e37e295..4e91cfb 100644 --- a/src/expr/lookup.c +++ b/src/expr/lookup.c @@ -257,11 +257,11 @@ nft_rule_expr_lookup_snprintf(char *buf, size_t size, uint32_t type, struct nft_expr_lookup *lookup = nft_expr_data(e); switch(type) { - case NFT_RULE_O_DEFAULT: + case NFT_OUTPUT_DEFAULT: return nft_rule_expr_lookup_snprintf_default(buf, size, lookup); - case NFT_RULE_O_XML: + case NFT_OUTPUT_XML: return nft_rule_expr_lookup_snprintf_xml(buf, size, lookup); - case NFT_RULE_O_JSON: + case NFT_OUTPUT_JSON: return nft_rule_expr_lookup_snprintf_json(buf, size, lookup); default: break; diff --git a/src/expr/match.c b/src/expr/match.c index c03ab12..db2b987 100644 --- a/src/expr/match.c +++ b/src/expr/match.c @@ -245,12 +245,12 @@ nft_rule_expr_match_snprintf(char *buf, size_t len, uint32_t type, struct nft_expr_match *match = nft_expr_data(e); switch(type) { - case NFT_RULE_O_DEFAULT: + case NFT_OUTPUT_DEFAULT: return snprintf(buf, len, "name %s rev %u ", match->name, match->rev); - case NFT_RULE_O_XML: + case NFT_OUTPUT_XML: return nft_rule_expr_match_snprintf_xml(buf, len, match); - case NFT_RULE_O_JSON: + case NFT_OUTPUT_JSON: return nft_rule_expr_match_snprintf_json(buf, len, match); default: break; diff --git a/src/expr/meta.c b/src/expr/meta.c index beeb8ca..88d2908 100644 --- a/src/expr/meta.c +++ b/src/expr/meta.c @@ -231,14 +231,14 @@ nft_rule_expr_meta_snprintf(char *buf, size_t len, uint32_t type, struct nft_expr_meta *meta = nft_expr_data(e); switch(type) { - case NFT_RULE_O_DEFAULT: + case NFT_OUTPUT_DEFAULT: return snprintf(buf, len, "load %s => reg %u ", meta_key2str(meta->key), meta->dreg); - case NFT_RULE_O_XML: + case NFT_OUTPUT_XML: return snprintf(buf, len, "%u" "%s", meta->dreg, meta_key2str(meta->key)); - case NFT_RULE_O_JSON: + case NFT_OUTPUT_JSON: return snprintf(buf, len, "\"dreg\":%u," "\"key\":\"%s\"", meta->dreg, meta_key2str(meta->key)); diff --git a/src/expr/nat.c b/src/expr/nat.c index 7150eec..30b02ec 100644 --- a/src/expr/nat.c +++ b/src/expr/nat.c @@ -438,11 +438,11 @@ nft_rule_expr_nat_snprintf(char *buf, size_t size, uint32_t type, uint32_t flags, struct nft_rule_expr *e) { switch (type) { - case NFT_RULE_O_DEFAULT: + case NFT_OUTPUT_DEFAULT: return nft_rule_expr_nat_snprintf_default(buf, size, e); - case NFT_RULE_O_XML: + case NFT_OUTPUT_XML: return nft_rule_expr_nat_snprintf_xml(buf, size, e); - case NFT_RULE_O_JSON: + case NFT_OUTPUT_JSON: return nft_rule_expr_nat_snprintf_json(buf, size, e); default: break; diff --git a/src/expr/payload.c b/src/expr/payload.c index 390b8ef..fc32ff2 100644 --- a/src/expr/payload.c +++ b/src/expr/payload.c @@ -302,14 +302,14 @@ nft_rule_expr_payload_snprintf(char *buf, size_t len, uint32_t type, struct nft_expr_payload *payload = nft_expr_data(e); switch(type) { - case NFT_RULE_O_DEFAULT: + case NFT_OUTPUT_DEFAULT: return snprintf(buf, len, "load %ub @ %s header + %u => reg %u ", payload->len, base2str(payload->base), payload->offset, payload->dreg); - case NFT_RULE_O_XML: + case NFT_OUTPUT_XML: return nft_rule_expr_payload_snprintf_xml(buf, len, flags, payload); - case NFT_RULE_O_JSON: + case NFT_OUTPUT_JSON: return nft_rule_expr_payload_snprintf_json(buf, len, flags, payload); default: diff --git a/src/expr/reject.c b/src/expr/reject.c index ca008ef..848f004 100644 --- a/src/expr/reject.c +++ b/src/expr/reject.c @@ -177,14 +177,14 @@ nft_rule_expr_reject_snprintf(char *buf, size_t len, uint32_t type, struct nft_expr_reject *reject = nft_expr_data(e); switch(type) { - case NFT_RULE_O_DEFAULT: + case NFT_OUTPUT_DEFAULT: return snprintf(buf, len, "type %u code %u ", reject->type, reject->icmp_code); - case NFT_RULE_O_XML: + case NFT_OUTPUT_XML: return snprintf(buf, len, "%u" "%u", reject->type, reject->icmp_code); - case NFT_RULE_O_JSON: + case NFT_OUTPUT_JSON: return snprintf(buf, len, "\"type\":%u," "\"code\":%u,", reject->type, reject->icmp_code); diff --git a/src/expr/target.c b/src/expr/target.c index 43fb666..7994bcd 100644 --- a/src/expr/target.c +++ b/src/expr/target.c @@ -247,12 +247,12 @@ nft_rule_expr_target_snprintf(char *buf, size_t len, uint32_t type, struct nft_expr_target *target = nft_expr_data(e); switch(type) { - case NFT_RULE_O_DEFAULT: + case NFT_OUTPUT_DEFAULT: return snprintf(buf, len, "name %s rev %u ", target->name, target->rev); - case NFT_RULE_O_XML: + case NFT_OUTPUT_XML: return nft_rule_exp_target_snprintf_xml(buf, len, target); - case NFT_RULE_O_JSON: + case NFT_OUTPUT_JSON: return nft_rule_exp_target_snprintf_json(buf, len, target); default: break; diff --git a/src/rule.c b/src/rule.c index 3b45dc7..4f70dab 100644 --- a/src/rule.c +++ b/src/rule.c @@ -658,16 +658,16 @@ static int nft_rule_xml_parse(struct nft_rule *r, const char *xml) #endif } -int nft_rule_parse(struct nft_rule *r, enum nft_rule_parse_type type, +int nft_rule_parse(struct nft_rule *r, enum nft_parse_type type, const char *data) { int ret; switch (type) { - case NFT_RULE_PARSE_XML: + case NFT_PARSE_XML: ret = nft_rule_xml_parse(r, data); break; - case NFT_RULE_PARSE_JSON: + case NFT_PARSE_JSON: ret = nft_rule_json_parse(r, data); break; default: @@ -806,11 +806,11 @@ int nft_rule_snprintf(char *buf, size_t size, struct nft_rule *r, uint32_t type, uint32_t flags) { switch(type) { - case NFT_RULE_O_DEFAULT: + case NFT_OUTPUT_DEFAULT: return nft_rule_snprintf_default(buf, size, r, type, flags); - case NFT_RULE_O_XML: + case NFT_OUTPUT_XML: return nft_rule_snprintf_xml(buf, size, r, type, flags); - case NFT_RULE_O_JSON: + case NFT_OUTPUT_JSON: return nft_rule_snprintf_json(buf, size, r, type, flags); default: break; diff --git a/src/ruleset.c b/src/ruleset.c index ee2c60a..f591382 100644 --- a/src/ruleset.c +++ b/src/ruleset.c @@ -557,16 +557,16 @@ err: #endif } -int nft_ruleset_parse(struct nft_ruleset *r, enum nft_ruleset_parse_type type, +int nft_ruleset_parse(struct nft_ruleset *r, enum nft_parse_type type, const char *data) { int ret; switch (type) { - case NFT_RULESET_PARSE_XML: + case NFT_PARSE_XML: ret = nft_ruleset_xml_parse(r, data); break; - case NFT_RULESET_PARSE_JSON: + case NFT_PARSE_JSON: ret = nft_ruleset_json_parse(r, data); break; default: @@ -582,9 +582,9 @@ EXPORT_SYMBOL(nft_ruleset_parse); static const char *nft_ruleset_o_opentag(uint32_t type) { switch (type) { - case NFT_RULESET_O_XML: + case NFT_OUTPUT_XML: return ""; - case NFT_RULESET_O_JSON: + case NFT_OUTPUT_JSON: return "{\"nftables\":["; default: return ""; @@ -597,9 +597,9 @@ static const char *nft_ruleset_o_separator(void *obj, uint32_t type) return ""; switch (type) { - case NFT_RULESET_O_JSON: + case NFT_OUTPUT_JSON: return ","; - case NFT_RULESET_O_DEFAULT: + case NFT_OUTPUT_DEFAULT: return "\n"; default: return ""; @@ -609,9 +609,9 @@ static const char *nft_ruleset_o_separator(void *obj, uint32_t type) static const char *nft_ruleset_o_closetag(uint32_t type) { switch (type) { - case NFT_RULESET_O_XML: + case NFT_OUTPUT_XML: return ""; - case NFT_RULESET_O_JSON: + case NFT_OUTPUT_JSON: return "]}"; default: return ""; @@ -803,9 +803,9 @@ int nft_ruleset_snprintf(char *buf, size_t size, const struct nft_ruleset *r, uint32_t type, uint32_t flags) { switch (type) { - case NFT_RULESET_O_DEFAULT: - case NFT_RULESET_O_XML: - case NFT_RULESET_O_JSON: + case NFT_OUTPUT_DEFAULT: + case NFT_OUTPUT_XML: + case NFT_OUTPUT_JSON: return nft_ruleset_do_snprintf(buf, size, r, type, flags); default: errno = EOPNOTSUPP; diff --git a/src/set.c b/src/set.c index 9620006..ba39c43 100644 --- a/src/set.c +++ b/src/set.c @@ -515,16 +515,16 @@ static int nft_set_xml_parse(struct nft_set *s, const char *xml) #endif } -int nft_set_parse(struct nft_set *s, enum nft_set_parse_type type, +int nft_set_parse(struct nft_set *s, enum nft_parse_type type, const char *data) { int ret; switch (type) { - case NFT_SET_PARSE_XML: + case NFT_PARSE_XML: ret = nft_set_xml_parse(s, data); break; - case NFT_SET_PARSE_JSON: + case NFT_PARSE_JSON: ret = nft_set_json_parse(s, data); break; default: @@ -640,7 +640,7 @@ static int nft_set_snprintf_xml(char *buf, size_t size, struct nft_set *s, if (!list_empty(&s->element_list)) { list_for_each_entry(elem, &s->element_list, head) { ret = nft_set_elem_snprintf(buf+offset, len, elem, - NFT_SET_O_XML, flags); + NFT_OUTPUT_XML, flags); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } } @@ -655,11 +655,11 @@ int nft_set_snprintf(char *buf, size_t size, struct nft_set *s, uint32_t type, uint32_t flags) { switch(type) { - case NFT_SET_O_DEFAULT: + case NFT_OUTPUT_DEFAULT: return nft_set_snprintf_default(buf, size, s, type, flags); - case NFT_SET_O_XML: + case NFT_OUTPUT_XML: return nft_set_snprintf_xml(buf, size, s, flags); - case NFT_SET_O_JSON: + case NFT_OUTPUT_JSON: return nft_set_snprintf_json(buf, size, s, type, flags); default: break; diff --git a/src/set_elem.c b/src/set_elem.c index 516905d..297328f 100644 --- a/src/set_elem.c +++ b/src/set_elem.c @@ -434,11 +434,11 @@ static int nft_set_elem_xml_parse(struct nft_set_elem *e, const char *xml) } int nft_set_elem_parse(struct nft_set_elem *e, - enum nft_set_parse_type type, const char *data) { + enum nft_parse_type type, const char *data) { int ret; switch (type) { - case NFT_SET_PARSE_XML: + case NFT_PARSE_XML: ret = nft_set_elem_xml_parse(e, data); break; default: @@ -463,7 +463,7 @@ static int nft_set_elem_snprintf_json(char *buf, size_t size, SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = nft_data_reg_snprintf(buf+offset, len, &e->key, - NFT_RULE_O_JSON, flags, DATA_VALUE); + NFT_OUTPUT_JSON, flags, DATA_VALUE); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = snprintf(buf+offset, len, "}"); @@ -481,7 +481,7 @@ static int nft_set_elem_snprintf_json(char *buf, size_t size, SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = nft_data_reg_snprintf(buf+offset, len, &e->data, - NFT_RULE_O_JSON, flags, type); + NFT_OUTPUT_JSON, flags, type); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = snprintf(buf+offset, len, "}"); @@ -529,7 +529,7 @@ static int nft_set_elem_snprintf_xml(char *buf, size_t size, SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = nft_data_reg_snprintf(buf+offset, len, &e->key, - NFT_RULE_O_XML, flags, DATA_VALUE); + NFT_OUTPUT_XML, flags, DATA_VALUE); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = snprintf(buf+offset, len, ""); @@ -547,7 +547,7 @@ static int nft_set_elem_snprintf_xml(char *buf, size_t size, SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = nft_data_reg_snprintf(buf+offset, len, &e->data, - NFT_RULE_O_XML, flags, type); + NFT_OUTPUT_XML, flags, type); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = snprintf(buf+offset, len, ""); @@ -564,11 +564,11 @@ int nft_set_elem_snprintf(char *buf, size_t size, struct nft_set_elem *e, uint32_t type, uint32_t flags) { switch(type) { - case NFT_SET_O_DEFAULT: + case NFT_OUTPUT_DEFAULT: return nft_set_elem_snprintf_default(buf, size, e); - case NFT_SET_O_XML: + case NFT_OUTPUT_XML: return nft_set_elem_snprintf_xml(buf, size, e, flags); - case NFT_SET_O_JSON: + case NFT_OUTPUT_JSON: return nft_set_elem_snprintf_json(buf, size, e, flags); default: break; diff --git a/src/table.c b/src/table.c index d1acc7c..fe37f90 100644 --- a/src/table.c +++ b/src/table.c @@ -324,16 +324,16 @@ static int nft_table_json_parse(struct nft_table *t, const char *json) #endif } -int nft_table_parse(struct nft_table *t, enum nft_table_parse_type type, +int nft_table_parse(struct nft_table *t, enum nft_parse_type type, const char *data) { int ret; switch (type) { - case NFT_TABLE_PARSE_XML: + case NFT_PARSE_XML: ret = nft_table_xml_parse(t, data); break; - case NFT_TABLE_PARSE_JSON: + case NFT_PARSE_JSON: ret = nft_table_json_parse(t, data); break; default: @@ -375,11 +375,11 @@ int nft_table_snprintf(char *buf, size_t size, struct nft_table *t, uint32_t type, uint32_t flags) { switch(type) { - case NFT_TABLE_O_DEFAULT: + case NFT_OUTPUT_DEFAULT: return nft_table_snprintf_default(buf, size, t); - case NFT_TABLE_O_XML: + case NFT_OUTPUT_XML: return nft_table_snprintf_xml(buf, size, t); - case NFT_TABLE_O_JSON: + case NFT_OUTPUT_JSON: return nft_table_snprintf_json(buf, size, t); default: break; diff --git a/tests/nft-parsing-test.c b/tests/nft-parsing-test.c index 9fa69ae..6a5ab4d 100644 --- a/tests/nft-parsing-test.c +++ b/tests/nft-parsing-test.c @@ -112,36 +112,36 @@ static int compare_test(uint32_t type, void *input, const char *filename) switch (type) { case TEST_XML_TABLE: - nft_table_snprintf(out, sizeof(out), t, NFT_TABLE_O_XML, 0); + nft_table_snprintf(out, sizeof(out), t, NFT_OUTPUT_XML, 0); break; case TEST_JSON_TABLE: - nft_table_snprintf(out, sizeof(out), t, NFT_TABLE_O_JSON, 0); + nft_table_snprintf(out, sizeof(out), t, NFT_OUTPUT_JSON, 0); break; case TEST_XML_CHAIN: - nft_chain_snprintf(out, sizeof(out), c, NFT_CHAIN_O_XML, 0); + nft_chain_snprintf(out, sizeof(out), c, NFT_OUTPUT_XML, 0); break; case TEST_JSON_CHAIN: - nft_chain_snprintf(out, sizeof(out), c, NFT_CHAIN_O_JSON, 0); + nft_chain_snprintf(out, sizeof(out), c, NFT_OUTPUT_JSON, 0); break; case TEST_XML_RULE: - nft_rule_snprintf(out, sizeof(out), r, NFT_RULE_O_XML, 0); + nft_rule_snprintf(out, sizeof(out), r, NFT_OUTPUT_XML, 0); break; case TEST_JSON_RULE: - nft_rule_snprintf(out, sizeof(out), r, NFT_RULE_O_JSON, 0); + nft_rule_snprintf(out, sizeof(out), r, NFT_OUTPUT_JSON, 0); break; case TEST_XML_SET: - nft_set_snprintf(out, sizeof(out), s, NFT_SET_O_XML, 0); + nft_set_snprintf(out, sizeof(out), s, NFT_OUTPUT_XML, 0); break; case TEST_JSON_SET: - nft_set_snprintf(out, sizeof(out), s, NFT_SET_O_JSON, 0); + nft_set_snprintf(out, sizeof(out), s, NFT_OUTPUT_JSON, 0); break; case TEST_XML_RULESET: nft_ruleset_snprintf(out, sizeof(out), rs, - NFT_RULESET_O_XML, 0); + NFT_OUTPUT_XML, 0); break; case TEST_JSON_RULESET: nft_ruleset_snprintf(out, sizeof(out), rs, - NFT_RULESET_O_JSON, 0); + NFT_OUTPUT_JSON, 0); break; default: errno = EINVAL; @@ -191,7 +191,7 @@ static int test_json(const char *filename) if (json_object_get(root, "table") != NULL) { t = nft_table_alloc(); if (t != NULL) { - if (nft_table_parse(t, NFT_TABLE_PARSE_JSON, json) == 0) + if (nft_table_parse(t, NFT_PARSE_JSON, json) == 0) ret = compare_test(TEST_JSON_TABLE, t, filename); else goto failparsing; @@ -201,7 +201,7 @@ static int test_json(const char *filename) } else if (json_object_get(root, "chain") != NULL) { c = nft_chain_alloc(); if (c != NULL) { - if (nft_chain_parse(c, NFT_CHAIN_PARSE_JSON, json) == 0) + if (nft_chain_parse(c, NFT_PARSE_JSON, json) == 0) ret = compare_test(TEST_JSON_CHAIN, c, filename); else goto failparsing; @@ -211,7 +211,7 @@ static int test_json(const char *filename) } else if (json_object_get(root, "rule") != NULL) { r = nft_rule_alloc(); if (r != NULL) { - if (nft_rule_parse(r, NFT_RULE_PARSE_JSON, json) == 0) + if (nft_rule_parse(r, NFT_PARSE_JSON, json) == 0) ret = compare_test(TEST_JSON_RULE, r, filename); else goto failparsing; @@ -221,7 +221,7 @@ static int test_json(const char *filename) } else if (json_object_get(root, "set") != NULL) { s = nft_set_alloc(); if (s != NULL) { - if (nft_set_parse(s, NFT_SET_PARSE_JSON, json) == 0) + if (nft_set_parse(s, NFT_PARSE_JSON, json) == 0) ret = compare_test(TEST_JSON_SET, s, filename); else goto failparsing; @@ -231,7 +231,7 @@ static int test_json(const char *filename) } else if (json_object_get(root, "nftables") != NULL) { rs = nft_ruleset_alloc(); if (rs != NULL) { - if (nft_ruleset_parse(rs, NFT_RULESET_PARSE_JSON, json) == 0) + if (nft_ruleset_parse(rs, NFT_PARSE_JSON, json) == 0) ret = compare_test(TEST_JSON_RULESET, rs, filename); else goto failparsing; @@ -290,7 +290,7 @@ static int test_xml(const char *filename) if (strcmp(tree->value.opaque, "table") == 0) { t = nft_table_alloc(); if (t != NULL) { - if (nft_table_parse(t, NFT_TABLE_PARSE_XML, xml) == 0) + if (nft_table_parse(t, NFT_PARSE_XML, xml) == 0) ret = compare_test(TEST_XML_TABLE, t, filename); else goto failparsing; @@ -300,7 +300,7 @@ static int test_xml(const char *filename) } else if (strcmp(tree->value.opaque, "chain") == 0) { c = nft_chain_alloc(); if (c != NULL) { - if (nft_chain_parse(c, NFT_CHAIN_PARSE_XML, xml) == 0) + if (nft_chain_parse(c, NFT_PARSE_XML, xml) == 0) ret = compare_test(TEST_XML_CHAIN, c, filename); else goto failparsing; @@ -310,7 +310,7 @@ static int test_xml(const char *filename) } else if (strcmp(tree->value.opaque, "rule") == 0) { r = nft_rule_alloc(); if (r != NULL) { - if (nft_rule_parse(r, NFT_RULE_PARSE_XML, xml) == 0) + if (nft_rule_parse(r, NFT_PARSE_XML, xml) == 0) ret = compare_test(TEST_XML_RULE, r, filename); else goto failparsing; @@ -320,7 +320,7 @@ static int test_xml(const char *filename) } else if (strcmp(tree->value.opaque, "set") == 0) { s = nft_set_alloc(); if (s != NULL) { - if (nft_set_parse(s, NFT_SET_PARSE_XML, xml) == 0) + if (nft_set_parse(s, NFT_PARSE_XML, xml) == 0) ret = compare_test(TEST_XML_SET, s, filename); else goto failparsing; @@ -330,7 +330,7 @@ static int test_xml(const char *filename) } else if (strcmp(tree->value.opaque, "nftables") == 0) { rs = nft_ruleset_alloc(); if (rs != NULL) { - if (nft_ruleset_parse(rs, NFT_RULESET_PARSE_XML, + if (nft_ruleset_parse(rs, NFT_PARSE_XML, xml) == 0) ret = compare_test(TEST_XML_RULESET, rs, filename); -- cgit v1.2.3