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 <alvaroneay@gmail.com>
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>

diff --git a/examples/nft-chain-get.c b/examples/nft-chain-get.c
index e466e8b3ad0f5bee3b6ae666774c8cd92609f95a..7e162f66a03099aa33f46a6a1de52b25858229f9 100644 (file)
--- 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 42e2d82dbbfc66bea40fd80f286f9abf0249a9f0..50cb29f1ed0c30685810e291c95470188d42d632 100644 (file)
--- 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 2e2fe113b647e6a5f74d70e19175535929f940d8..03a295032f3ab392acfc5ceab429cd85c08cb5ee 100644 (file)
--- 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 5550c70402783f82d834db555f412a9d148208c7..29cb6592fc45ec6cb49c348e8ad39a0b3dcefbcf 100644 (file)
--- 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 cd0f8dc18bcef8b2413fb8383fd696a849bea89b..f17630b89ebc697952face0cbec88e0ba60340ce 100644 (file)
--- 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 83dec3ebedcb57f3135c650f1a25a42cffd21ea3..86590814d1222f3a3f2a5370ed04408e803a1c0b 100644 (file)
--- 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 4de7a6943f8b38924830dc0fd05b700b13a6e2ef..ce33fe7ca200ddf5300484690abd36836abb4dff 100644 (file)
--- 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 aeba4007ca4f9ed7b61751c323c86e5d9c83be61..0b46f36ad84d276ea2fccbf5f3409c13ad291e77 100644 (file)
--- 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 4bc585c7d0df133289bb852869443de390507608..676203251d4ef081e466d457e3c8bb7790cd2e7c 100644 (file)
--- 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 33c3acd823ac791c3b7f616d521a287be161f2b5..9a4aa48e89098af010a63ffabfb21ca2288976a3 100644 (file)
--- 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 f57423bdfb085be94d279db23671c078e8d9233e..c5bc89d6547c785cb12e91d39b119a4e298f03f6 100644 (file)
--- 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 <family> [<table>] [<default|xml|json>]\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 5526c91eed4af1306f7a582c751d797397511532..6b16c7f0b72aa444760d35b6b9b5021b868d5aba 100644 (file)
--- 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 6de0855d56fa1499f687e80bc89f9d516eeb2ae7..6a9163b241ae14d3a145c0850f09c3518e5e9c34 100644 (file)
--- 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 e243f3210aacda2287a153d6ead271522cd32a7c..a0841d28d0890817932b8f8f460a6aa9a63e03be 100644 (file)
--- 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 5de73181e4a8e097150aa1dcc1b7999fd9d3a8f9..c26b348bb15c3c59c881d64cc08a867432821317 100644 (file)
--- a/include/libnftables/chain.h
+++ b/include/libnftables/chain.h
@@ -6,6 +6,8 @@
 #include <stdbool.h>
 #include <sys/types.h>
 
+#include <libnftables/common.h>
+
 #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 (file)
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 b61afb0aa58021b10dbc7be75ffb8cf7a77b38a2..4957a2a14b4d61f5d571278c76118bd42dec8e3a 100644 (file)
--- a/include/libnftables/rule.h
+++ b/include/libnftables/rule.h
@@ -6,6 +6,8 @@
 #include <stdbool.h>
 #include <sys/types.h>
 
+#include <libnftables/common.h>
+
 #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 3b20bfa3eb8997644e9a412d0eb432b800b3831c..71ef3b157efca61282f460d1a3be5b05845ff63f 100644 (file)
--- a/include/libnftables/ruleset.h
+++ b/include/libnftables/ruleset.h
@@ -7,6 +7,8 @@
 #include <stdint.h>
 #include <sys/types.h>
 
+#include <libnftables/common.h>
+
 #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 cf63b9bba538804995ae8fe5b87b626ff6091d33..d3780496d2ea45e92d7dbd547763c3c35bd2e0c6 100644 (file)
--- a/include/libnftables/set.h
+++ b/include/libnftables/set.h
@@ -6,6 +6,8 @@
 #include <stdbool.h>
 #include <sys/types.h>
 
+#include <libnftables/common.h>
+
 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 e3b4888aefd8058a4b9fb821f358cf7bf68ee585..4902a1dacaf9c7b82a986966f4f9b7d10255e2d7 100644 (file)
--- a/include/libnftables/table.h
+++ b/include/libnftables/table.h
@@ -6,6 +6,8 @@
 #include <stdbool.h>
 #include <sys/types.h>
 
+#include <libnftables/common.h>
+
 #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 cdb398f5869394577d0dcf50f69a6280e9546340..a58999d4b76c6b063d8051a3f2e2710ac934b343 100644 (file)
--- 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 0be15934d2ca5b93e4200fc957a3ee2c892f2e3d..bcec516e1557ccec0190f8c547dfff4bd6aae29f 100644 (file)
--- 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, "</mask><xor>");
        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, "</xor>");
@@ -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 7012452aa456cf20725b1c581d7f51d8ac4cb573..7224c82eb5d82ec6581ba696e765b2fc1ec76d5b 100644 (file)
--- 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 7de72267559c3e6edc9867bf8d3547f3177c3858..246f22fac0d42f358ebd1e603d3b040f8b43948e 100644 (file)
--- 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, "</cmpdata>");
@@ -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 561f26c9dcf62008bc4aaaae9a7964173c3a962b..4919a69f2eab2407acad43d744db845fc02417ed 100644 (file)
--- 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, "<pkts>%"PRIu64"</pkts><bytes>%"PRIu64"</bytes>",
                                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 e84d996f40c90b786b1be093a428117226b2027b..46e3cef6e7be65232a015f7e036788eee039d648 100644 (file)
--- 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, "<dreg>%u</dreg>"
                                          "<key>%s</key>"
                                          "<dir>%u</dir>",
                                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 193f3ab60ef6d9cacbd42a5270e4c3e4a081a40a..76231af4829e2ed70b2d7f3ba207f155bffd55ec 100644 (file)
--- 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,
                                        "<data_reg type=\"verdict\">"
                                                "<verdict>%s</verdict>"
                                        "</data_reg>",
                                        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,
                                        "<data_reg type=\"chain\">"
                                                "<chain>%s</chain>"
                                        "</data_reg>", 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 32791d00723c645df1772e83052c62910d05eb9c..6841ac1d9ae8022065062184f5f6b29dcaafebcb 100644 (file)
--- 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, "<dreg>%u</dreg>"
                                          "<exthdr_type>%s</exthdr_type>"
                                          "<offset>%u</offset>"
@@ -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 cb3b209f79ad64a604003703572ab3d7a86b5872..a96d3dea6b4c54294a980c5d06f35aadc6f6a10d 100644 (file)
--- 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 4fcf7987b52ba186043ec05e5d17f7d8f801563c..4854a7707661e44548e9e9f70fcd4b41554247dd 100644 (file)
--- 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, "<rate>%"PRIu64"</rate>"
                                          "<unit>%"PRIu64"</unit>",
                                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 7722d62e2426478da80fee3e041efcd056171afb..1f88246c5a94f1a0175ec291ef23a5eddc72dff0 100644 (file)
--- 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, "<prefix>%s</prefix>"
                                          "<group>%u</group>"
                                          "<snaplen>%u</snaplen>"
                                          "<qthreshold>%u</qthreshold>",
                                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 e37e295629a812f23e4522d7628e896eaa85d5b6..4e91cfb79c608fb43bb2a1cddd594fe9bed82fec 100644 (file)
--- 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 c03ab124d1249fc51b18acb1436ef48dca8f3963..db2b9874c5e9898baa049906f8183a1353c398c7 100644 (file)
--- 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 beeb8caf693d473ec544ba366b8abc0c2ca44a41..88d29087047b7b672c760c7d0f1fd5c7f1ab1b6e 100644 (file)
--- 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, "<dreg>%u</dreg>"
                                          "<key>%s</key>",
                                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 7150eec775aec45f8c65c06b6f44d05a74518e35..30b02eca3bf74ec406190bb428be50c34d42981b 100644 (file)
--- 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 390b8efd3d7b8dfc350aaef83b0b5efd6577d1d3..fc32ff2dea9dfcd57813e4cab79775b8076d43a2 100644 (file)
--- 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 ca008efee15aa184a40069521ce6df67d573fee5..848f004b2997b21b68aaffb6c86fb79d1a0ace6b 100644 (file)
--- 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, "<type>%u</type>"
                                          "<code>%u</code>",
                                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 43fb666715e33296a5a408223534f0a011b950d1..7994bcd2d75a970a85f76e3a6f1680bb3f284bf0 100644 (file)
--- 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 3b45dc75af43dbed0826cde49be57f2fd6ec48b8..4f70dabb2c5bdc596cb585ff4b5ad24d4a22f06b 100644 (file)
--- 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 ee2c60abee03a480b9bf5a996aa23a96a5799888..f591382da73a869cdfea78dc6dfe3383e6b04d24 100644 (file)
--- 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 "<nftables>";
-       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 "</nftables>";
-       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 9620006b43c5147ebb3dd9148ded2e1504632394..ba39c43b4e523c20c63d27f1e68593c488399c91 100644 (file)
--- 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 516905d60d05cc3b521c15896d13792997f83f62..297328f9dc1f3a5f72206f21af50940950ac6703 100644 (file)
--- 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, "</key>");
@@ -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, "</data>");
@@ -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 d1acc7c1f82f593d77169da9752c6e72f1e33bbb..fe37f90ea7f0a9d37db09222418781ef67372776 100644 (file)
--- 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 9fa69ae63927e2a692a3fd8f914c2707fedeb125..6a5ab4db8f35c09d4c25868ff17363956457ac72 100644 (file)
--- 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);