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 --- 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 ++++++------ 23 files changed, 121 insertions(+), 121 deletions(-) (limited to 'src') 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; -- cgit v1.2.3