diff options
author | Pablo Neira Ayuso <pablo@netfilter.org> | 2015-09-01 20:19:56 +0200 |
---|---|---|
committer | Pablo Neira Ayuso <pablo@netfilter.org> | 2015-09-07 19:24:19 +0200 |
commit | 760768890e60617acfd144dce875a4a3be14513c (patch) | |
tree | 14a3a4f53e81fd9b44c8481e123f2c0ceb6f2bff /src/expr | |
parent | b7154e52fc417e927bef0bbfa5db6e7a71f28602 (diff) |
src: rename existing functions to use the nftnl_ prefix
So we can use the nft_* prefix anytime soon for our upcoming higher level
library.
After this patch, the nft_* symbols become an alias of the nftnl_* symbols.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
Diffstat (limited to 'src/expr')
-rw-r--r-- | src/expr/bitwise.c | 202 | ||||
-rw-r--r-- | src/expr/byteorder.c | 192 | ||||
-rw-r--r-- | src/expr/cmp.c | 152 | ||||
-rw-r--r-- | src/expr/counter.c | 120 | ||||
-rw-r--r-- | src/expr/ct.c | 174 | ||||
-rw-r--r-- | src/expr/data_reg.c | 150 | ||||
-rw-r--r-- | src/expr/dynset.c | 218 | ||||
-rw-r--r-- | src/expr/exthdr.c | 168 | ||||
-rw-r--r-- | src/expr/immediate.c | 196 | ||||
-rw-r--r-- | src/expr/limit.c | 120 | ||||
-rw-r--r-- | src/expr/log.c | 222 | ||||
-rw-r--r-- | src/expr/lookup.c | 148 | ||||
-rw-r--r-- | src/expr/masq.c | 100 | ||||
-rw-r--r-- | src/expr/match.c | 114 | ||||
-rw-r--r-- | src/expr/meta.c | 150 | ||||
-rw-r--r-- | src/expr/nat.c | 250 | ||||
-rw-r--r-- | src/expr/payload.c | 168 | ||||
-rw-r--r-- | src/expr/queue.c | 150 | ||||
-rw-r--r-- | src/expr/redir.c | 148 | ||||
-rw-r--r-- | src/expr/reject.c | 120 | ||||
-rw-r--r-- | src/expr/target.c | 114 |
21 files changed, 1688 insertions, 1688 deletions
diff --git a/src/expr/bitwise.c b/src/expr/bitwise.c index f0851b0..331fd20 100644 --- a/src/expr/bitwise.c +++ b/src/expr/bitwise.c @@ -21,35 +21,35 @@ #include <libnftnl/expr.h> #include <libnftnl/rule.h> -struct nft_expr_bitwise { +struct nftnl_expr_bitwise { enum nft_registers sreg; enum nft_registers dreg; unsigned int len; - union nft_data_reg mask; - union nft_data_reg xor; + union nftnl_data_reg mask; + union nftnl_data_reg xor; }; static int -nft_rule_expr_bitwise_set(struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_bitwise_set(struct nftnl_rule_expr *e, uint16_t type, const void *data, uint32_t data_len) { - struct nft_expr_bitwise *bitwise = nft_expr_data(e); + struct nftnl_expr_bitwise *bitwise = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_BITWISE_SREG: + case NFTNL_EXPR_BITWISE_SREG: bitwise->sreg = *((uint32_t *)data); break; - case NFT_EXPR_BITWISE_DREG: + case NFTNL_EXPR_BITWISE_DREG: bitwise->dreg = *((uint32_t *)data); break; - case NFT_EXPR_BITWISE_LEN: + case NFTNL_EXPR_BITWISE_LEN: bitwise->len = *((unsigned int *)data); break; - case NFT_EXPR_BITWISE_MASK: + case NFTNL_EXPR_BITWISE_MASK: memcpy(&bitwise->mask.val, data, data_len); bitwise->mask.len = data_len; break; - case NFT_EXPR_BITWISE_XOR: + case NFTNL_EXPR_BITWISE_XOR: memcpy(&bitwise->xor.val, data, data_len); bitwise->xor.len = data_len; break; @@ -60,32 +60,32 @@ nft_rule_expr_bitwise_set(struct nft_rule_expr *e, uint16_t type, } static const void * -nft_rule_expr_bitwise_get(const struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_bitwise_get(const struct nftnl_rule_expr *e, uint16_t type, uint32_t *data_len) { - struct nft_expr_bitwise *bitwise = nft_expr_data(e); + struct nftnl_expr_bitwise *bitwise = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_BITWISE_SREG: + case NFTNL_EXPR_BITWISE_SREG: *data_len = sizeof(bitwise->sreg); return &bitwise->sreg; - case NFT_EXPR_BITWISE_DREG: + case NFTNL_EXPR_BITWISE_DREG: *data_len = sizeof(bitwise->dreg); return &bitwise->dreg; - case NFT_EXPR_BITWISE_LEN: + case NFTNL_EXPR_BITWISE_LEN: *data_len = sizeof(bitwise->len); return &bitwise->len; - case NFT_EXPR_BITWISE_MASK: + case NFTNL_EXPR_BITWISE_MASK: *data_len = bitwise->mask.len; return &bitwise->mask.val; - case NFT_EXPR_BITWISE_XOR: + case NFTNL_EXPR_BITWISE_XOR: *data_len = bitwise->xor.len; return &bitwise->xor.val; } return NULL; } -static int nft_rule_expr_bitwise_cb(const struct nlattr *attr, void *data) +static int nftnl_rule_expr_bitwise_cb(const struct nlattr *attr, void *data) { const struct nlattr **tb = data; int type = mnl_attr_get_type(attr); @@ -112,17 +112,17 @@ static int nft_rule_expr_bitwise_cb(const struct nlattr *attr, void *data) } static void -nft_rule_expr_bitwise_build(struct nlmsghdr *nlh, struct nft_rule_expr *e) +nftnl_rule_expr_bitwise_build(struct nlmsghdr *nlh, struct nftnl_rule_expr *e) { - struct nft_expr_bitwise *bitwise = nft_expr_data(e); + struct nftnl_expr_bitwise *bitwise = nftnl_expr_data(e); - if (e->flags & (1 << NFT_EXPR_BITWISE_SREG)) + if (e->flags & (1 << NFTNL_EXPR_BITWISE_SREG)) mnl_attr_put_u32(nlh, NFTA_BITWISE_SREG, htonl(bitwise->sreg)); - if (e->flags & (1 << NFT_EXPR_BITWISE_DREG)) + if (e->flags & (1 << NFTNL_EXPR_BITWISE_DREG)) mnl_attr_put_u32(nlh, NFTA_BITWISE_DREG, htonl(bitwise->dreg)); - if (e->flags & (1 << NFT_EXPR_BITWISE_LEN)) + if (e->flags & (1 << NFTNL_EXPR_BITWISE_LEN)) mnl_attr_put_u32(nlh, NFTA_BITWISE_LEN, htonl(bitwise->len)); - if (e->flags & (1 << NFT_EXPR_BITWISE_MASK)) { + if (e->flags & (1 << NFTNL_EXPR_BITWISE_MASK)) { struct nlattr *nest; nest = mnl_attr_nest_start(nlh, NFTA_BITWISE_MASK); @@ -130,7 +130,7 @@ nft_rule_expr_bitwise_build(struct nlmsghdr *nlh, struct nft_rule_expr *e) bitwise->mask.val); mnl_attr_nest_end(nlh, nest); } - if (e->flags & (1 << NFT_EXPR_BITWISE_XOR)) { + if (e->flags & (1 << NFTNL_EXPR_BITWISE_XOR)) { struct nlattr *nest; nest = mnl_attr_nest_start(nlh, NFTA_BITWISE_XOR); @@ -141,33 +141,33 @@ nft_rule_expr_bitwise_build(struct nlmsghdr *nlh, struct nft_rule_expr *e) } static int -nft_rule_expr_bitwise_parse(struct nft_rule_expr *e, struct nlattr *attr) +nftnl_rule_expr_bitwise_parse(struct nftnl_rule_expr *e, struct nlattr *attr) { - struct nft_expr_bitwise *bitwise = nft_expr_data(e); + struct nftnl_expr_bitwise *bitwise = nftnl_expr_data(e); struct nlattr *tb[NFTA_BITWISE_MAX+1] = {}; int ret = 0; - if (mnl_attr_parse_nested(attr, nft_rule_expr_bitwise_cb, tb) < 0) + if (mnl_attr_parse_nested(attr, nftnl_rule_expr_bitwise_cb, tb) < 0) return -1; if (tb[NFTA_BITWISE_SREG]) { bitwise->sreg = ntohl(mnl_attr_get_u32(tb[NFTA_BITWISE_SREG])); - e->flags |= (1 << NFT_EXPR_BITWISE_SREG); + e->flags |= (1 << NFTNL_EXPR_BITWISE_SREG); } if (tb[NFTA_BITWISE_DREG]) { bitwise->dreg = ntohl(mnl_attr_get_u32(tb[NFTA_BITWISE_DREG])); - e->flags |= (1 << NFT_EXPR_BITWISE_DREG); + e->flags |= (1 << NFTNL_EXPR_BITWISE_DREG); } if (tb[NFTA_BITWISE_LEN]) { bitwise->len = ntohl(mnl_attr_get_u32(tb[NFTA_BITWISE_LEN])); - e->flags |= (1 << NFT_EXPR_BITWISE_LEN); + e->flags |= (1 << NFTNL_EXPR_BITWISE_LEN); } if (tb[NFTA_BITWISE_MASK]) { - ret = nft_parse_data(&bitwise->mask, tb[NFTA_BITWISE_MASK], NULL); + ret = nftnl_parse_data(&bitwise->mask, tb[NFTA_BITWISE_MASK], NULL); e->flags |= (1 << NFTA_BITWISE_MASK); } if (tb[NFTA_BITWISE_XOR]) { - ret = nft_parse_data(&bitwise->xor, tb[NFTA_BITWISE_XOR], NULL); + ret = nftnl_parse_data(&bitwise->xor, tb[NFTA_BITWISE_XOR], NULL); e->flags |= (1 << NFTA_BITWISE_XOR); } @@ -175,29 +175,29 @@ nft_rule_expr_bitwise_parse(struct nft_rule_expr *e, struct nlattr *attr) } static int -nft_rule_expr_bitwise_json_parse(struct nft_rule_expr *e, json_t *root, - struct nft_parse_err *err) +nftnl_rule_expr_bitwise_json_parse(struct nftnl_rule_expr *e, json_t *root, + struct nftnl_parse_err *err) { #ifdef JSON_PARSING - struct nft_expr_bitwise *bitwise = nft_expr_data(e); + struct nftnl_expr_bitwise *bitwise = nftnl_expr_data(e); uint32_t reg, len; - if (nft_jansson_parse_reg(root, "sreg", NFT_TYPE_U32, ®, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_BITWISE_SREG, reg); + if (nftnl_jansson_parse_reg(root, "sreg", NFTNL_TYPE_U32, ®, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_BITWISE_SREG, reg); - if (nft_jansson_parse_reg(root, "dreg", NFT_TYPE_U32, ®, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_BITWISE_DREG, reg); + if (nftnl_jansson_parse_reg(root, "dreg", NFTNL_TYPE_U32, ®, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_BITWISE_DREG, reg); - if (nft_jansson_parse_val(root, "len", NFT_TYPE_U32, &len, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_BITWISE_LEN, len); + if (nftnl_jansson_parse_val(root, "len", NFTNL_TYPE_U32, &len, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_BITWISE_LEN, len); - if (nft_jansson_data_reg_parse(root, "mask", &bitwise->mask, + if (nftnl_jansson_data_reg_parse(root, "mask", &bitwise->mask, err) == DATA_VALUE) - e->flags |= (1 << NFT_EXPR_BITWISE_MASK); + e->flags |= (1 << NFTNL_EXPR_BITWISE_MASK); - if (nft_jansson_data_reg_parse(root, "xor", &bitwise->xor, + if (nftnl_jansson_data_reg_parse(root, "xor", &bitwise->xor, err) == DATA_VALUE) - e->flags |= (1 << NFT_EXPR_BITWISE_XOR); + e->flags |= (1 << NFTNL_EXPR_BITWISE_XOR); if (bitwise->mask.len != bitwise->xor.len) return -1; @@ -210,32 +210,32 @@ nft_rule_expr_bitwise_json_parse(struct nft_rule_expr *e, json_t *root, } static int -nft_rule_expr_bitwise_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, - struct nft_parse_err *err) +nftnl_rule_expr_bitwise_xml_parse(struct nftnl_rule_expr *e, mxml_node_t *tree, + struct nftnl_parse_err *err) { #ifdef XML_PARSING - struct nft_expr_bitwise *bitwise = nft_expr_data(e); + struct nftnl_expr_bitwise *bitwise = nftnl_expr_data(e); uint32_t sreg, dreg, len; - if (nft_mxml_reg_parse(tree, "sreg", &sreg, MXML_DESCEND_FIRST, - NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_BITWISE_SREG, sreg); + if (nftnl_mxml_reg_parse(tree, "sreg", &sreg, MXML_DESCEND_FIRST, + NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_BITWISE_SREG, sreg); - if (nft_mxml_reg_parse(tree, "dreg", &dreg, MXML_DESCEND_FIRST, - NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_BITWISE_DREG, dreg); + if (nftnl_mxml_reg_parse(tree, "dreg", &dreg, MXML_DESCEND_FIRST, + NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_BITWISE_DREG, dreg); - if (nft_mxml_num_parse(tree, "len", MXML_DESCEND_FIRST, BASE_DEC, - &len, NFT_TYPE_U32, NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_BITWISE_LEN, len); + if (nftnl_mxml_num_parse(tree, "len", MXML_DESCEND_FIRST, BASE_DEC, + &len, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_BITWISE_LEN, len); - if (nft_mxml_data_reg_parse(tree, "mask", &bitwise->mask, NFT_XML_MAND, + if (nftnl_mxml_data_reg_parse(tree, "mask", &bitwise->mask, NFTNL_XML_MAND, err) == DATA_VALUE) - e->flags |= (1 << NFT_EXPR_BITWISE_MASK); + e->flags |= (1 << NFTNL_EXPR_BITWISE_MASK); - if (nft_mxml_data_reg_parse(tree, "xor", &bitwise->xor, NFT_XML_MAND, + if (nftnl_mxml_data_reg_parse(tree, "xor", &bitwise->xor, NFTNL_XML_MAND, err) == DATA_VALUE) - e->flags |= (1 << NFT_EXPR_BITWISE_XOR); + e->flags |= (1 << NFTNL_EXPR_BITWISE_XOR); /* Additional validation: mask and xor must use the same number of * data registers. @@ -250,60 +250,60 @@ nft_rule_expr_bitwise_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, #endif } -static int nft_rule_expr_bitwise_export(char *buf, size_t size, - struct nft_rule_expr *e, int type) +static int nftnl_rule_expr_bitwise_export(char *buf, size_t size, + struct nftnl_rule_expr *e, int type) { - struct nft_expr_bitwise *bitwise = nft_expr_data(e); - NFT_BUF_INIT(b, buf, size); - - if (e->flags & (1 << NFT_EXPR_BITWISE_SREG)) - nft_buf_u32(&b, type, bitwise->sreg, SREG); - if (e->flags & (1 << NFT_EXPR_BITWISE_DREG)) - nft_buf_u32(&b, type, bitwise->dreg, DREG); - if (e->flags & (1 << NFT_EXPR_BITWISE_LEN)) - nft_buf_u32(&b, type, bitwise->len, LEN); - if (e->flags & (1 << NFT_EXPR_BITWISE_MASK)) - nft_buf_reg(&b, type, &bitwise->mask, DATA_VALUE, MASK); - if (e->flags & (1 << NFT_EXPR_BITWISE_XOR)) - nft_buf_reg(&b, type, &bitwise->xor, DATA_VALUE, XOR); - - return nft_buf_done(&b); + struct nftnl_expr_bitwise *bitwise = nftnl_expr_data(e); + NFTNL_BUF_INIT(b, buf, size); + + if (e->flags & (1 << NFTNL_EXPR_BITWISE_SREG)) + nftnl_buf_u32(&b, type, bitwise->sreg, SREG); + if (e->flags & (1 << NFTNL_EXPR_BITWISE_DREG)) + nftnl_buf_u32(&b, type, bitwise->dreg, DREG); + if (e->flags & (1 << NFTNL_EXPR_BITWISE_LEN)) + nftnl_buf_u32(&b, type, bitwise->len, LEN); + if (e->flags & (1 << NFTNL_EXPR_BITWISE_MASK)) + nftnl_buf_reg(&b, type, &bitwise->mask, DATA_VALUE, MASK); + if (e->flags & (1 << NFTNL_EXPR_BITWISE_XOR)) + nftnl_buf_reg(&b, type, &bitwise->xor, DATA_VALUE, XOR); + + return nftnl_buf_done(&b); } -static int nft_rule_expr_bitwise_snprintf_default(char *buf, size_t size, - struct nft_rule_expr *e) +static int nftnl_rule_expr_bitwise_snprintf_default(char *buf, size_t size, + struct nftnl_rule_expr *e) { - struct nft_expr_bitwise *bitwise = nft_expr_data(e); + struct nftnl_expr_bitwise *bitwise = nftnl_expr_data(e); int len = size, offset = 0, ret; ret = snprintf(buf, len, "reg %u = (reg=%u & ", bitwise->dreg, bitwise->sreg); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - ret = nft_data_reg_snprintf(buf+offset, len, &bitwise->mask, - NFT_OUTPUT_DEFAULT, 0, DATA_VALUE); + ret = nftnl_data_reg_snprintf(buf+offset, len, &bitwise->mask, + NFTNL_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_OUTPUT_DEFAULT, 0, DATA_VALUE); + ret = nftnl_data_reg_snprintf(buf+offset, len, &bitwise->xor, + NFTNL_OUTPUT_DEFAULT, 0, DATA_VALUE); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); return offset; } static int -nft_rule_expr_bitwise_snprintf(char *buf, size_t size, uint32_t type, - uint32_t flags, struct nft_rule_expr *e) +nftnl_rule_expr_bitwise_snprintf(char *buf, size_t size, uint32_t type, + uint32_t flags, struct nftnl_rule_expr *e) { switch (type) { - case NFT_OUTPUT_DEFAULT: - return nft_rule_expr_bitwise_snprintf_default(buf, size, e); - case NFT_OUTPUT_XML: - case NFT_OUTPUT_JSON: - return nft_rule_expr_bitwise_export(buf, size, e, type); + case NFTNL_OUTPUT_DEFAULT: + return nftnl_rule_expr_bitwise_snprintf_default(buf, size, e); + case NFTNL_OUTPUT_XML: + case NFTNL_OUTPUT_JSON: + return nftnl_rule_expr_bitwise_export(buf, size, e, type); default: break; } @@ -312,13 +312,13 @@ nft_rule_expr_bitwise_snprintf(char *buf, size_t size, uint32_t type, struct expr_ops expr_ops_bitwise = { .name = "bitwise", - .alloc_len = sizeof(struct nft_expr_bitwise), + .alloc_len = sizeof(struct nftnl_expr_bitwise), .max_attr = NFTA_BITWISE_MAX, - .set = nft_rule_expr_bitwise_set, - .get = nft_rule_expr_bitwise_get, - .parse = nft_rule_expr_bitwise_parse, - .build = nft_rule_expr_bitwise_build, - .snprintf = nft_rule_expr_bitwise_snprintf, - .xml_parse = nft_rule_expr_bitwise_xml_parse, - .json_parse = nft_rule_expr_bitwise_json_parse, + .set = nftnl_rule_expr_bitwise_set, + .get = nftnl_rule_expr_bitwise_get, + .parse = nftnl_rule_expr_bitwise_parse, + .build = nftnl_rule_expr_bitwise_build, + .snprintf = nftnl_rule_expr_bitwise_snprintf, + .xml_parse = nftnl_rule_expr_bitwise_xml_parse, + .json_parse = nftnl_rule_expr_bitwise_json_parse, }; diff --git a/src/expr/byteorder.c b/src/expr/byteorder.c index 81e5278..c37e56d 100644 --- a/src/expr/byteorder.c +++ b/src/expr/byteorder.c @@ -21,7 +21,7 @@ #include <libnftnl/expr.h> #include <libnftnl/rule.h> -struct nft_expr_byteorder { +struct nftnl_expr_byteorder { enum nft_registers sreg; enum nft_registers dreg; enum nft_byteorder_ops op; @@ -30,25 +30,25 @@ struct nft_expr_byteorder { }; static int -nft_rule_expr_byteorder_set(struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_byteorder_set(struct nftnl_rule_expr *e, uint16_t type, const void *data, uint32_t data_len) { - struct nft_expr_byteorder *byteorder = nft_expr_data(e); + struct nftnl_expr_byteorder *byteorder = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_BYTEORDER_SREG: + case NFTNL_EXPR_BYTEORDER_SREG: byteorder->sreg = *((uint32_t *)data); break; - case NFT_EXPR_BYTEORDER_DREG: + case NFTNL_EXPR_BYTEORDER_DREG: byteorder->dreg = *((uint32_t *)data); break; - case NFT_EXPR_BYTEORDER_OP: + case NFTNL_EXPR_BYTEORDER_OP: byteorder->op = *((uint32_t *)data); break; - case NFT_EXPR_BYTEORDER_LEN: + case NFTNL_EXPR_BYTEORDER_LEN: byteorder->len = *((unsigned int *)data); break; - case NFT_EXPR_BYTEORDER_SIZE: + case NFTNL_EXPR_BYTEORDER_SIZE: byteorder->size = *((unsigned int *)data); break; default: @@ -58,32 +58,32 @@ nft_rule_expr_byteorder_set(struct nft_rule_expr *e, uint16_t type, } static const void * -nft_rule_expr_byteorder_get(const struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_byteorder_get(const struct nftnl_rule_expr *e, uint16_t type, uint32_t *data_len) { - struct nft_expr_byteorder *byteorder = nft_expr_data(e); + struct nftnl_expr_byteorder *byteorder = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_BYTEORDER_SREG: + case NFTNL_EXPR_BYTEORDER_SREG: *data_len = sizeof(byteorder->sreg); return &byteorder->sreg; - case NFT_EXPR_BYTEORDER_DREG: + case NFTNL_EXPR_BYTEORDER_DREG: *data_len = sizeof(byteorder->dreg); return &byteorder->dreg; - case NFT_EXPR_BYTEORDER_OP: + case NFTNL_EXPR_BYTEORDER_OP: *data_len = sizeof(byteorder->op); return &byteorder->op; - case NFT_EXPR_BYTEORDER_LEN: + case NFTNL_EXPR_BYTEORDER_LEN: *data_len = sizeof(byteorder->len); return &byteorder->len; - case NFT_EXPR_BYTEORDER_SIZE: + case NFTNL_EXPR_BYTEORDER_SIZE: *data_len = sizeof(byteorder->size); return &byteorder->size; } return NULL; } -static int nft_rule_expr_byteorder_cb(const struct nlattr *attr, void *data) +static int nftnl_rule_expr_byteorder_cb(const struct nlattr *attr, void *data) { const struct nlattr **tb = data; int type = mnl_attr_get_type(attr); @@ -107,66 +107,66 @@ static int nft_rule_expr_byteorder_cb(const struct nlattr *attr, void *data) } static void -nft_rule_expr_byteorder_build(struct nlmsghdr *nlh, struct nft_rule_expr *e) +nftnl_rule_expr_byteorder_build(struct nlmsghdr *nlh, struct nftnl_rule_expr *e) { - struct nft_expr_byteorder *byteorder = nft_expr_data(e); + struct nftnl_expr_byteorder *byteorder = nftnl_expr_data(e); - if (e->flags & (1 << NFT_EXPR_BYTEORDER_SREG)) { + if (e->flags & (1 << NFTNL_EXPR_BYTEORDER_SREG)) { mnl_attr_put_u32(nlh, NFTA_BYTEORDER_SREG, htonl(byteorder->sreg)); } - if (e->flags & (1 << NFT_EXPR_BYTEORDER_DREG)) { + if (e->flags & (1 << NFTNL_EXPR_BYTEORDER_DREG)) { mnl_attr_put_u32(nlh, NFTA_BYTEORDER_DREG, htonl(byteorder->dreg)); } - if (e->flags & (1 << NFT_EXPR_BYTEORDER_OP)) { + if (e->flags & (1 << NFTNL_EXPR_BYTEORDER_OP)) { mnl_attr_put_u32(nlh, NFTA_BYTEORDER_OP, htonl(byteorder->op)); } - if (e->flags & (1 << NFT_EXPR_BYTEORDER_LEN)) { + if (e->flags & (1 << NFTNL_EXPR_BYTEORDER_LEN)) { mnl_attr_put_u32(nlh, NFTA_BYTEORDER_LEN, htonl(byteorder->len)); } - if (e->flags & (1 << NFT_EXPR_BYTEORDER_SIZE)) { + if (e->flags & (1 << NFTNL_EXPR_BYTEORDER_SIZE)) { mnl_attr_put_u32(nlh, NFTA_BYTEORDER_SIZE, htonl(byteorder->size)); } } static int -nft_rule_expr_byteorder_parse(struct nft_rule_expr *e, struct nlattr *attr) +nftnl_rule_expr_byteorder_parse(struct nftnl_rule_expr *e, struct nlattr *attr) { - struct nft_expr_byteorder *byteorder = nft_expr_data(e); + struct nftnl_expr_byteorder *byteorder = nftnl_expr_data(e); struct nlattr *tb[NFTA_BYTEORDER_MAX+1] = {}; int ret = 0; - if (mnl_attr_parse_nested(attr, nft_rule_expr_byteorder_cb, tb) < 0) + if (mnl_attr_parse_nested(attr, nftnl_rule_expr_byteorder_cb, tb) < 0) return -1; if (tb[NFTA_BYTEORDER_SREG]) { byteorder->sreg = ntohl(mnl_attr_get_u32(tb[NFTA_BYTEORDER_SREG])); - e->flags |= (1 << NFT_EXPR_BYTEORDER_SREG); + e->flags |= (1 << NFTNL_EXPR_BYTEORDER_SREG); } if (tb[NFTA_BYTEORDER_DREG]) { byteorder->dreg = ntohl(mnl_attr_get_u32(tb[NFTA_BYTEORDER_DREG])); - e->flags |= (1 << NFT_EXPR_BYTEORDER_DREG); + e->flags |= (1 << NFTNL_EXPR_BYTEORDER_DREG); } if (tb[NFTA_BYTEORDER_OP]) { byteorder->op = ntohl(mnl_attr_get_u32(tb[NFTA_BYTEORDER_OP])); - e->flags |= (1 << NFT_EXPR_BYTEORDER_OP); + e->flags |= (1 << NFTNL_EXPR_BYTEORDER_OP); } if (tb[NFTA_BYTEORDER_LEN]) { byteorder->len = ntohl(mnl_attr_get_u32(tb[NFTA_BYTEORDER_LEN])); - e->flags |= (1 << NFT_EXPR_BYTEORDER_LEN); + e->flags |= (1 << NFTNL_EXPR_BYTEORDER_LEN); } if (tb[NFTA_BYTEORDER_SIZE]) { byteorder->size = ntohl(mnl_attr_get_u32(tb[NFTA_BYTEORDER_SIZE])); - e->flags |= (1 << NFT_EXPR_BYTEORDER_SIZE); + e->flags |= (1 << NFTNL_EXPR_BYTEORDER_SIZE); } return ret; @@ -185,7 +185,7 @@ static const char *bo2str(uint32_t type) return expr_byteorder_str[type]; } -static inline int nft_str2ntoh(const char *op) +static inline int nftnl_str2ntoh(const char *op) { if (strcmp(op, "ntoh") == 0) return NFT_BYTEORDER_NTOH; @@ -198,34 +198,34 @@ static inline int nft_str2ntoh(const char *op) } static int -nft_rule_expr_byteorder_json_parse(struct nft_rule_expr *e, json_t *root, - struct nft_parse_err *err) +nftnl_rule_expr_byteorder_json_parse(struct nftnl_rule_expr *e, json_t *root, + struct nftnl_parse_err *err) { #ifdef JSON_PARSING const char *op; uint32_t sreg, dreg, len, size; int ntoh; - if (nft_jansson_parse_reg(root, "sreg", NFT_TYPE_U32, &sreg, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_BYTEORDER_SREG, sreg); + if (nftnl_jansson_parse_reg(root, "sreg", NFTNL_TYPE_U32, &sreg, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_BYTEORDER_SREG, sreg); - if (nft_jansson_parse_reg(root, "dreg", NFT_TYPE_U32, &dreg, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_BYTEORDER_DREG, dreg); + if (nftnl_jansson_parse_reg(root, "dreg", NFTNL_TYPE_U32, &dreg, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_BYTEORDER_DREG, dreg); - op = nft_jansson_parse_str(root, "op", err); + op = nftnl_jansson_parse_str(root, "op", err); if (op != NULL) { - ntoh = nft_str2ntoh(op); + ntoh = nftnl_str2ntoh(op); if (ntoh < 0) return -1; - nft_rule_expr_set_u32(e, NFT_EXPR_BYTEORDER_OP, ntoh); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_BYTEORDER_OP, ntoh); } - if (nft_jansson_parse_val(root, "len", NFT_TYPE_U32, &len, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_BYTEORDER_LEN, len); + if (nftnl_jansson_parse_val(root, "len", NFTNL_TYPE_U32, &len, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_BYTEORDER_LEN, len); - if (nft_jansson_parse_val(root, "size", NFT_TYPE_U32, &size, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_BYTEORDER_SIZE, size); + if (nftnl_jansson_parse_val(root, "size", NFTNL_TYPE_U32, &size, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_BYTEORDER_SIZE, size); return 0; #else @@ -235,39 +235,39 @@ nft_rule_expr_byteorder_json_parse(struct nft_rule_expr *e, json_t *root, } static int -nft_rule_expr_byteorder_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, - struct nft_parse_err *err) +nftnl_rule_expr_byteorder_xml_parse(struct nftnl_rule_expr *e, mxml_node_t *tree, + struct nftnl_parse_err *err) { #ifdef XML_PARSING const char *op; int32_t ntoh; uint32_t sreg, dreg, len, size; - if (nft_mxml_reg_parse(tree, "sreg", &sreg, MXML_DESCEND_FIRST, - NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_BYTEORDER_SREG, sreg); + if (nftnl_mxml_reg_parse(tree, "sreg", &sreg, MXML_DESCEND_FIRST, + NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_BYTEORDER_SREG, sreg); - if (nft_mxml_reg_parse(tree, "dreg", &dreg, MXML_DESCEND, NFT_XML_MAND, + if (nftnl_mxml_reg_parse(tree, "dreg", &dreg, MXML_DESCEND, NFTNL_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_BYTEORDER_DREG, dreg); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_BYTEORDER_DREG, dreg); - op = nft_mxml_str_parse(tree, "op", MXML_DESCEND_FIRST, NFT_XML_MAND, + op = nftnl_mxml_str_parse(tree, "op", MXML_DESCEND_FIRST, NFTNL_XML_MAND, err); if (op != NULL) { - ntoh = nft_str2ntoh(op); + ntoh = nftnl_str2ntoh(op); if (ntoh < 0) return -1; - nft_rule_expr_set_u32(e, NFT_EXPR_BYTEORDER_OP, ntoh); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_BYTEORDER_OP, ntoh); } - if (nft_mxml_num_parse(tree, "len", MXML_DESCEND_FIRST, BASE_DEC, - &len, NFT_TYPE_U32, NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_BYTEORDER_LEN, len); + if (nftnl_mxml_num_parse(tree, "len", MXML_DESCEND_FIRST, BASE_DEC, + &len, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_BYTEORDER_LEN, len); - if (nft_mxml_num_parse(tree, "size", MXML_DESCEND_FIRST, BASE_DEC, - &size, NFT_TYPE_U32, NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_BYTEORDER_SIZE, size); + if (nftnl_mxml_num_parse(tree, "size", MXML_DESCEND_FIRST, BASE_DEC, + &size, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_BYTEORDER_SIZE, size); return 0; #else @@ -276,30 +276,30 @@ nft_rule_expr_byteorder_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, #endif } -static int nft_rule_expr_byteorder_export(char *buf, size_t size, - struct nft_rule_expr *e, int type) +static int nftnl_rule_expr_byteorder_export(char *buf, size_t size, + struct nftnl_rule_expr *e, int type) { - struct nft_expr_byteorder *byteorder = nft_expr_data(e); - NFT_BUF_INIT(b, buf, size); - - if (e->flags & (1 << NFT_EXPR_BYTEORDER_SREG)) - nft_buf_u32(&b, type, byteorder->sreg, SREG); - if (e->flags & (1 << NFT_EXPR_BYTEORDER_DREG)) - nft_buf_u32(&b, type, byteorder->dreg, DREG); - if (e->flags & (1 << NFT_EXPR_BYTEORDER_OP)) - nft_buf_str(&b, type, bo2str(byteorder->op), OP); - if (e->flags & (1 << NFT_EXPR_BYTEORDER_LEN)) - nft_buf_u32(&b, type, byteorder->len, LEN); - if (e->flags & (1 << NFT_EXPR_BYTEORDER_SIZE)) - nft_buf_u32(&b, type, byteorder->size, SIZE); - - return nft_buf_done(&b); + struct nftnl_expr_byteorder *byteorder = nftnl_expr_data(e); + NFTNL_BUF_INIT(b, buf, size); + + if (e->flags & (1 << NFTNL_EXPR_BYTEORDER_SREG)) + nftnl_buf_u32(&b, type, byteorder->sreg, SREG); + if (e->flags & (1 << NFTNL_EXPR_BYTEORDER_DREG)) + nftnl_buf_u32(&b, type, byteorder->dreg, DREG); + if (e->flags & (1 << NFTNL_EXPR_BYTEORDER_OP)) + nftnl_buf_str(&b, type, bo2str(byteorder->op), OP); + if (e->flags & (1 << NFTNL_EXPR_BYTEORDER_LEN)) + nftnl_buf_u32(&b, type, byteorder->len, LEN); + if (e->flags & (1 << NFTNL_EXPR_BYTEORDER_SIZE)) + nftnl_buf_u32(&b, type, byteorder->size, SIZE); + + return nftnl_buf_done(&b); } -static int nft_rule_expr_byteorder_snprintf_default(char *buf, size_t size, - struct nft_rule_expr *e) +static int nftnl_rule_expr_byteorder_snprintf_default(char *buf, size_t size, + struct nftnl_rule_expr *e) { - struct nft_expr_byteorder *byteorder = nft_expr_data(e); + struct nftnl_expr_byteorder *byteorder = nftnl_expr_data(e); int len = size, offset = 0, ret; ret = snprintf(buf, len, "reg %u = %s(reg %u, %u, %u) ", @@ -311,15 +311,15 @@ static int nft_rule_expr_byteorder_snprintf_default(char *buf, size_t size, } static int -nft_rule_expr_byteorder_snprintf(char *buf, size_t size, uint32_t type, - uint32_t flags, struct nft_rule_expr *e) +nftnl_rule_expr_byteorder_snprintf(char *buf, size_t size, uint32_t type, + uint32_t flags, struct nftnl_rule_expr *e) { switch (type) { - case NFT_OUTPUT_DEFAULT: - return nft_rule_expr_byteorder_snprintf_default(buf, size, e); - case NFT_OUTPUT_XML: - case NFT_OUTPUT_JSON: - return nft_rule_expr_byteorder_export(buf, size, e, type); + case NFTNL_OUTPUT_DEFAULT: + return nftnl_rule_expr_byteorder_snprintf_default(buf, size, e); + case NFTNL_OUTPUT_XML: + case NFTNL_OUTPUT_JSON: + return nftnl_rule_expr_byteorder_export(buf, size, e, type); default: break; } @@ -328,13 +328,13 @@ nft_rule_expr_byteorder_snprintf(char *buf, size_t size, uint32_t type, struct expr_ops expr_ops_byteorder = { .name = "byteorder", - .alloc_len = sizeof(struct nft_expr_byteorder), + .alloc_len = sizeof(struct nftnl_expr_byteorder), .max_attr = NFTA_BYTEORDER_MAX, - .set = nft_rule_expr_byteorder_set, - .get = nft_rule_expr_byteorder_get, - .parse = nft_rule_expr_byteorder_parse, - .build = nft_rule_expr_byteorder_build, - .snprintf = nft_rule_expr_byteorder_snprintf, - .xml_parse = nft_rule_expr_byteorder_xml_parse, - .json_parse = nft_rule_expr_byteorder_json_parse, + .set = nftnl_rule_expr_byteorder_set, + .get = nftnl_rule_expr_byteorder_get, + .parse = nftnl_rule_expr_byteorder_parse, + .build = nftnl_rule_expr_byteorder_build, + .snprintf = nftnl_rule_expr_byteorder_snprintf, + .xml_parse = nftnl_rule_expr_byteorder_xml_parse, + .json_parse = nftnl_rule_expr_byteorder_json_parse, }; diff --git a/src/expr/cmp.c b/src/expr/cmp.c index 3536332..83b9afc 100644 --- a/src/expr/cmp.c +++ b/src/expr/cmp.c @@ -22,26 +22,26 @@ #include <libnftnl/expr.h> #include <libnftnl/rule.h> -struct nft_expr_cmp { - union nft_data_reg data; +struct nftnl_expr_cmp { + union nftnl_data_reg data; enum nft_registers sreg; enum nft_cmp_ops op; }; static int -nft_rule_expr_cmp_set(struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_cmp_set(struct nftnl_rule_expr *e, uint16_t type, const void *data, uint32_t data_len) { - struct nft_expr_cmp *cmp = nft_expr_data(e); + struct nftnl_expr_cmp *cmp = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_CMP_SREG: + case NFTNL_EXPR_CMP_SREG: cmp->sreg = *((uint32_t *)data); break; - case NFT_EXPR_CMP_OP: + case NFTNL_EXPR_CMP_OP: cmp->op = *((uint32_t *)data); break; - case NFT_EXPR_CMP_DATA: + case NFTNL_EXPR_CMP_DATA: memcpy(&cmp->data.val, data, data_len); cmp->data.len = data_len; break; @@ -52,26 +52,26 @@ nft_rule_expr_cmp_set(struct nft_rule_expr *e, uint16_t type, } static const void * -nft_rule_expr_cmp_get(const struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_cmp_get(const struct nftnl_rule_expr *e, uint16_t type, uint32_t *data_len) { - struct nft_expr_cmp *cmp = nft_expr_data(e); + struct nftnl_expr_cmp *cmp = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_CMP_SREG: + case NFTNL_EXPR_CMP_SREG: *data_len = sizeof(cmp->sreg); return &cmp->sreg; - case NFT_EXPR_CMP_OP: + case NFTNL_EXPR_CMP_OP: *data_len = sizeof(cmp->op); return &cmp->op; - case NFT_EXPR_CMP_DATA: + case NFTNL_EXPR_CMP_DATA: *data_len = cmp->data.len; return &cmp->data.val; } return NULL; } -static int nft_rule_expr_cmp_cb(const struct nlattr *attr, void *data) +static int nftnl_rule_expr_cmp_cb(const struct nlattr *attr, void *data) { const struct nlattr **tb = data; int type = mnl_attr_get_type(attr); @@ -96,15 +96,15 @@ static int nft_rule_expr_cmp_cb(const struct nlattr *attr, void *data) } static void -nft_rule_expr_cmp_build(struct nlmsghdr *nlh, struct nft_rule_expr *e) +nftnl_rule_expr_cmp_build(struct nlmsghdr *nlh, struct nftnl_rule_expr *e) { - struct nft_expr_cmp *cmp = nft_expr_data(e); + struct nftnl_expr_cmp *cmp = nftnl_expr_data(e); - if (e->flags & (1 << NFT_EXPR_CMP_SREG)) + if (e->flags & (1 << NFTNL_EXPR_CMP_SREG)) mnl_attr_put_u32(nlh, NFTA_CMP_SREG, htonl(cmp->sreg)); - if (e->flags & (1 << NFT_EXPR_CMP_OP)) + if (e->flags & (1 << NFTNL_EXPR_CMP_OP)) mnl_attr_put_u32(nlh, NFTA_CMP_OP, htonl(cmp->op)); - if (e->flags & (1 << NFT_EXPR_CMP_DATA)) { + if (e->flags & (1 << NFTNL_EXPR_CMP_DATA)) { struct nlattr *nest; nest = mnl_attr_nest_start(nlh, NFTA_CMP_DATA); @@ -114,13 +114,13 @@ nft_rule_expr_cmp_build(struct nlmsghdr *nlh, struct nft_rule_expr *e) } static int -nft_rule_expr_cmp_parse(struct nft_rule_expr *e, struct nlattr *attr) +nftnl_rule_expr_cmp_parse(struct nftnl_rule_expr *e, struct nlattr *attr) { - struct nft_expr_cmp *cmp = nft_expr_data(e); + struct nftnl_expr_cmp *cmp = nftnl_expr_data(e); struct nlattr *tb[NFTA_CMP_MAX+1] = {}; int ret = 0; - if (mnl_attr_parse_nested(attr, nft_rule_expr_cmp_cb, tb) < 0) + if (mnl_attr_parse_nested(attr, nftnl_rule_expr_cmp_cb, tb) < 0) return -1; if (tb[NFTA_CMP_SREG]) { @@ -132,7 +132,7 @@ nft_rule_expr_cmp_parse(struct nft_rule_expr *e, struct nlattr *attr) e->flags |= (1 << NFTA_CMP_OP); } if (tb[NFTA_CMP_DATA]) { - ret = nft_parse_data(&cmp->data, tb[NFTA_CMP_DATA], NULL); + ret = nftnl_parse_data(&cmp->data, tb[NFTA_CMP_DATA], NULL); e->flags |= (1 << NFTA_CMP_DATA); } @@ -156,7 +156,7 @@ static const char *cmp2str(uint32_t op) return expr_cmp_str[op]; } -static inline int nft_str2cmp(const char *op) +static inline int nftnl_str2cmp(const char *op) { if (strcmp(op, "eq") == 0) return NFT_CMP_EQ; @@ -176,31 +176,31 @@ static inline int nft_str2cmp(const char *op) } } -static int nft_rule_expr_cmp_json_parse(struct nft_rule_expr *e, json_t *root, - struct nft_parse_err *err) +static int nftnl_rule_expr_cmp_json_parse(struct nftnl_rule_expr *e, json_t *root, + struct nftnl_parse_err *err) { #ifdef JSON_PARSING - struct nft_expr_cmp *cmp = nft_expr_data(e); + struct nftnl_expr_cmp *cmp = nftnl_expr_data(e); const char *op; uint32_t uval32; int base; - if (nft_jansson_parse_val(root, "sreg", NFT_TYPE_U32, &uval32, + if (nftnl_jansson_parse_val(root, "sreg", NFTNL_TYPE_U32, &uval32, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_CMP_SREG, uval32); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_CMP_SREG, uval32); - op = nft_jansson_parse_str(root, "op", err); + op = nftnl_jansson_parse_str(root, "op", err); if (op != NULL) { - base = nft_str2cmp(op); + base = nftnl_str2cmp(op); if (base < 0) return -1; - nft_rule_expr_set_u32(e, NFT_EXPR_CMP_OP, base); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_CMP_OP, base); } - if (nft_jansson_data_reg_parse(root, "data", + if (nftnl_jansson_data_reg_parse(root, "data", &cmp->data, err) == DATA_VALUE) - e->flags |= (1 << NFT_EXPR_CMP_DATA); + e->flags |= (1 << NFTNL_EXPR_CMP_DATA); return 0; #else @@ -209,33 +209,33 @@ static int nft_rule_expr_cmp_json_parse(struct nft_rule_expr *e, json_t *root, #endif } -static int nft_rule_expr_cmp_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, - struct nft_parse_err *err) +static int nftnl_rule_expr_cmp_xml_parse(struct nftnl_rule_expr *e, mxml_node_t *tree, + struct nftnl_parse_err *err) { #ifdef XML_PARSING - struct nft_expr_cmp *cmp = nft_expr_data(e); + struct nftnl_expr_cmp *cmp = nftnl_expr_data(e); const char *op; int32_t op_value; uint32_t sreg; - if (nft_mxml_reg_parse(tree, "sreg", &sreg, MXML_DESCEND_FIRST, - NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_CMP_SREG, sreg); + if (nftnl_mxml_reg_parse(tree, "sreg", &sreg, MXML_DESCEND_FIRST, + NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_CMP_SREG, sreg); - op = nft_mxml_str_parse(tree, "op", MXML_DESCEND_FIRST, NFT_XML_MAND, + op = nftnl_mxml_str_parse(tree, "op", MXML_DESCEND_FIRST, NFTNL_XML_MAND, err); if (op != NULL) { - op_value = nft_str2cmp(op); + op_value = nftnl_str2cmp(op); if (op_value < 0) return -1; - nft_rule_expr_set_u32(e, NFT_EXPR_CMP_OP, op_value); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_CMP_OP, op_value); } - if (nft_mxml_data_reg_parse(tree, "data", - &cmp->data, NFT_XML_MAND, + if (nftnl_mxml_data_reg_parse(tree, "data", + &cmp->data, NFTNL_XML_MAND, err) == DATA_VALUE) - e->flags |= (1 << NFT_EXPR_CMP_DATA); + e->flags |= (1 << NFTNL_EXPR_CMP_DATA); return 0; #else @@ -244,49 +244,49 @@ static int nft_rule_expr_cmp_xml_parse(struct nft_rule_expr *e, mxml_node_t *tre #endif } -static int nft_rule_expr_cmp_export(char *buf, size_t size, - struct nft_rule_expr *e, int type) +static int nftnl_rule_expr_cmp_export(char *buf, size_t size, + struct nftnl_rule_expr *e, int type) { - struct nft_expr_cmp *cmp = nft_expr_data(e); - NFT_BUF_INIT(b, buf, size); + struct nftnl_expr_cmp *cmp = nftnl_expr_data(e); + NFTNL_BUF_INIT(b, buf, size); - if (e->flags & (1 << NFT_EXPR_CMP_SREG)) - nft_buf_u32(&b, type, cmp->sreg, SREG); - if (e->flags & (1 << NFT_EXPR_CMP_OP)) - nft_buf_str(&b, type, cmp2str(cmp->op), OP); - if (e->flags & (1 << NFT_EXPR_CMP_DATA)) - nft_buf_reg(&b, type, &cmp->data, DATA_VALUE, DATA); + if (e->flags & (1 << NFTNL_EXPR_CMP_SREG)) + nftnl_buf_u32(&b, type, cmp->sreg, SREG); + if (e->flags & (1 << NFTNL_EXPR_CMP_OP)) + nftnl_buf_str(&b, type, cmp2str(cmp->op), OP); + if (e->flags & (1 << NFTNL_EXPR_CMP_DATA)) + nftnl_buf_reg(&b, type, &cmp->data, DATA_VALUE, DATA); - return nft_buf_done(&b); + return nftnl_buf_done(&b); } -static int nft_rule_expr_cmp_snprintf_default(char *buf, size_t size, - struct nft_rule_expr *e) +static int nftnl_rule_expr_cmp_snprintf_default(char *buf, size_t size, + struct nftnl_rule_expr *e) { - struct nft_expr_cmp *cmp = nft_expr_data(e); + struct nftnl_expr_cmp *cmp = nftnl_expr_data(e); int len = size, offset = 0, ret; ret = snprintf(buf, len, "%s reg %u ", expr_cmp_str[cmp->op], cmp->sreg); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - ret = nft_data_reg_snprintf(buf+offset, len, &cmp->data, - NFT_OUTPUT_DEFAULT, 0, DATA_VALUE); + ret = nftnl_data_reg_snprintf(buf+offset, len, &cmp->data, + NFTNL_OUTPUT_DEFAULT, 0, DATA_VALUE); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); return offset; } static int -nft_rule_expr_cmp_snprintf(char *buf, size_t size, uint32_t type, - uint32_t flags, struct nft_rule_expr *e) +nftnl_rule_expr_cmp_snprintf(char *buf, size_t size, uint32_t type, + uint32_t flags, struct nftnl_rule_expr *e) { switch (type) { - case NFT_OUTPUT_DEFAULT: - return nft_rule_expr_cmp_snprintf_default(buf, size, e); - case NFT_OUTPUT_XML: - case NFT_OUTPUT_JSON: - return nft_rule_expr_cmp_export(buf, size, e, type); + case NFTNL_OUTPUT_DEFAULT: + return nftnl_rule_expr_cmp_snprintf_default(buf, size, e); + case NFTNL_OUTPUT_XML: + case NFTNL_OUTPUT_JSON: + return nftnl_rule_expr_cmp_export(buf, size, e, type); default: break; } @@ -295,13 +295,13 @@ nft_rule_expr_cmp_snprintf(char *buf, size_t size, uint32_t type, struct expr_ops expr_ops_cmp = { .name = "cmp", - .alloc_len = sizeof(struct nft_expr_cmp), + .alloc_len = sizeof(struct nftnl_expr_cmp), .max_attr = NFTA_CMP_MAX, - .set = nft_rule_expr_cmp_set, - .get = nft_rule_expr_cmp_get, - .parse = nft_rule_expr_cmp_parse, - .build = nft_rule_expr_cmp_build, - .snprintf = nft_rule_expr_cmp_snprintf, - .xml_parse = nft_rule_expr_cmp_xml_parse, - .json_parse = nft_rule_expr_cmp_json_parse, + .set = nftnl_rule_expr_cmp_set, + .get = nftnl_rule_expr_cmp_get, + .parse = nftnl_rule_expr_cmp_parse, + .build = nftnl_rule_expr_cmp_build, + .snprintf = nftnl_rule_expr_cmp_snprintf, + .xml_parse = nftnl_rule_expr_cmp_xml_parse, + .json_parse = nftnl_rule_expr_cmp_json_parse, }; diff --git a/src/expr/counter.c b/src/expr/counter.c index 55fe526..b5a9644 100644 --- a/src/expr/counter.c +++ b/src/expr/counter.c @@ -22,22 +22,22 @@ #include <libnftnl/expr.h> #include <libnftnl/rule.h> -struct nft_expr_counter { +struct nftnl_expr_counter { uint64_t pkts; uint64_t bytes; }; static int -nft_rule_expr_counter_set(struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_counter_set(struct nftnl_rule_expr *e, uint16_t type, const void *data, uint32_t data_len) { - struct nft_expr_counter *ctr = nft_expr_data(e); + struct nftnl_expr_counter *ctr = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_CTR_BYTES: + case NFTNL_EXPR_CTR_BYTES: ctr->bytes = *((uint64_t *)data); break; - case NFT_EXPR_CTR_PACKETS: + case NFTNL_EXPR_CTR_PACKETS: ctr->pkts = *((uint64_t *)data); break; default: @@ -47,23 +47,23 @@ nft_rule_expr_counter_set(struct nft_rule_expr *e, uint16_t type, } static const void * -nft_rule_expr_counter_get(const struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_counter_get(const struct nftnl_rule_expr *e, uint16_t type, uint32_t *data_len) { - struct nft_expr_counter *ctr = nft_expr_data(e); + struct nftnl_expr_counter *ctr = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_CTR_BYTES: + case NFTNL_EXPR_CTR_BYTES: *data_len = sizeof(ctr->bytes); return &ctr->bytes; - case NFT_EXPR_CTR_PACKETS: + case NFTNL_EXPR_CTR_PACKETS: *data_len = sizeof(ctr->pkts); return &ctr->pkts; } return NULL; } -static int nft_rule_expr_counter_cb(const struct nlattr *attr, void *data) +static int nftnl_rule_expr_counter_cb(const struct nlattr *attr, void *data) { const struct nlattr **tb = data; int type = mnl_attr_get_type(attr); @@ -84,51 +84,51 @@ static int nft_rule_expr_counter_cb(const struct nlattr *attr, void *data) } static void -nft_rule_expr_counter_build(struct nlmsghdr *nlh, struct nft_rule_expr *e) +nftnl_rule_expr_counter_build(struct nlmsghdr *nlh, struct nftnl_rule_expr *e) { - struct nft_expr_counter *ctr = nft_expr_data(e); + struct nftnl_expr_counter *ctr = nftnl_expr_data(e); - if (e->flags & (1 << NFT_EXPR_CTR_BYTES)) + if (e->flags & (1 << NFTNL_EXPR_CTR_BYTES)) mnl_attr_put_u64(nlh, NFTA_COUNTER_BYTES, htobe64(ctr->bytes)); - if (e->flags & (1 << NFT_EXPR_CTR_PACKETS)) + if (e->flags & (1 << NFTNL_EXPR_CTR_PACKETS)) mnl_attr_put_u64(nlh, NFTA_COUNTER_PACKETS, htobe64(ctr->pkts)); } static int -nft_rule_expr_counter_parse(struct nft_rule_expr *e, struct nlattr *attr) +nftnl_rule_expr_counter_parse(struct nftnl_rule_expr *e, struct nlattr *attr) { - struct nft_expr_counter *ctr = nft_expr_data(e); + struct nftnl_expr_counter *ctr = nftnl_expr_data(e); struct nlattr *tb[NFTA_COUNTER_MAX+1] = {}; - if (mnl_attr_parse_nested(attr, nft_rule_expr_counter_cb, tb) < 0) + if (mnl_attr_parse_nested(attr, nftnl_rule_expr_counter_cb, tb) < 0) return -1; if (tb[NFTA_COUNTER_BYTES]) { ctr->bytes = be64toh(mnl_attr_get_u64(tb[NFTA_COUNTER_BYTES])); - e->flags |= (1 << NFT_EXPR_CTR_BYTES); + e->flags |= (1 << NFTNL_EXPR_CTR_BYTES); } if (tb[NFTA_COUNTER_PACKETS]) { ctr->pkts = be64toh(mnl_attr_get_u64(tb[NFTA_COUNTER_PACKETS])); - e->flags |= (1 << NFT_EXPR_CTR_PACKETS); + e->flags |= (1 << NFTNL_EXPR_CTR_PACKETS); } return 0; } static int -nft_rule_expr_counter_json_parse(struct nft_rule_expr *e, json_t *root, - struct nft_parse_err *err) +nftnl_rule_expr_counter_json_parse(struct nftnl_rule_expr *e, json_t *root, + struct nftnl_parse_err *err) { #ifdef JSON_PARSING uint64_t uval64; - if (nft_jansson_parse_val(root, "pkts", NFT_TYPE_U64, &uval64, + if (nftnl_jansson_parse_val(root, "pkts", NFTNL_TYPE_U64, &uval64, err) == 0) - nft_rule_expr_set_u64(e, NFT_EXPR_CTR_PACKETS, uval64); + nftnl_rule_expr_set_u64(e, NFTNL_EXPR_CTR_PACKETS, uval64); - if (nft_jansson_parse_val(root, "bytes", NFT_TYPE_U64, &uval64, + if (nftnl_jansson_parse_val(root, "bytes", NFTNL_TYPE_U64, &uval64, err) == 0) - nft_rule_expr_set_u64(e, NFT_EXPR_CTR_BYTES, uval64); + nftnl_rule_expr_set_u64(e, NFTNL_EXPR_CTR_BYTES, uval64); return 0; #else @@ -138,19 +138,19 @@ nft_rule_expr_counter_json_parse(struct nft_rule_expr *e, json_t *root, } static int -nft_rule_expr_counter_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, - struct nft_parse_err *err) +nftnl_rule_expr_counter_xml_parse(struct nftnl_rule_expr *e, mxml_node_t *tree, + struct nftnl_parse_err *err) { #ifdef XML_PARSING uint64_t pkts, bytes; - if (nft_mxml_num_parse(tree, "pkts", MXML_DESCEND_FIRST, BASE_DEC, - &pkts, NFT_TYPE_U64, NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u64(e, NFT_EXPR_CTR_PACKETS, pkts); + if (nftnl_mxml_num_parse(tree, "pkts", MXML_DESCEND_FIRST, BASE_DEC, + &pkts, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u64(e, NFTNL_EXPR_CTR_PACKETS, pkts); - if (nft_mxml_num_parse(tree, "bytes", MXML_DESCEND_FIRST, BASE_DEC, - &bytes, NFT_TYPE_U64, NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u64(e, NFT_EXPR_CTR_BYTES, bytes); + if (nftnl_mxml_num_parse(tree, "bytes", MXML_DESCEND_FIRST, BASE_DEC, + &bytes, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u64(e, NFTNL_EXPR_CTR_BYTES, bytes); return 0; #else @@ -159,39 +159,39 @@ nft_rule_expr_counter_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, #endif } -static int nft_rule_expr_counter_export(char *buf, size_t size, - struct nft_rule_expr *e, int type) +static int nftnl_rule_expr_counter_export(char *buf, size_t size, + struct nftnl_rule_expr *e, int type) { - struct nft_expr_counter *ctr = nft_expr_data(e); - NFT_BUF_INIT(b, buf, size); + struct nftnl_expr_counter *ctr = nftnl_expr_data(e); + NFTNL_BUF_INIT(b, buf, size); - if (e->flags & (1 << NFT_EXPR_CTR_PACKETS)) - nft_buf_u64(&b, type, ctr->pkts, PKTS); - if (e->flags & (1 << NFT_EXPR_CTR_BYTES)) - nft_buf_u64(&b, type, ctr->bytes, BYTES); + if (e->flags & (1 << NFTNL_EXPR_CTR_PACKETS)) + nftnl_buf_u64(&b, type, ctr->pkts, PKTS); + if (e->flags & (1 << NFTNL_EXPR_CTR_BYTES)) + nftnl_buf_u64(&b, type, ctr->bytes, BYTES); - return nft_buf_done(&b); + return nftnl_buf_done(&b); } -static int nft_rule_expr_counter_snprintf_default(char *buf, size_t len, - struct nft_rule_expr *e) +static int nftnl_rule_expr_counter_snprintf_default(char *buf, size_t len, + struct nftnl_rule_expr *e) { - struct nft_expr_counter *ctr = nft_expr_data(e); + struct nftnl_expr_counter *ctr = nftnl_expr_data(e); return snprintf(buf, len, "pkts %"PRIu64" bytes %"PRIu64" ", ctr->pkts, ctr->bytes); } -static int nft_rule_expr_counter_snprintf(char *buf, size_t len, uint32_t type, +static int nftnl_rule_expr_counter_snprintf(char *buf, size_t len, uint32_t type, uint32_t flags, - struct nft_rule_expr *e) + struct nftnl_rule_expr *e) { switch (type) { - case NFT_OUTPUT_DEFAULT: - return nft_rule_expr_counter_snprintf_default(buf, len, e); - case NFT_OUTPUT_XML: - case NFT_OUTPUT_JSON: - return nft_rule_expr_counter_export(buf, len, e, type); + case NFTNL_OUTPUT_DEFAULT: + return nftnl_rule_expr_counter_snprintf_default(buf, len, e); + case NFTNL_OUTPUT_XML: + case NFTNL_OUTPUT_JSON: + return nftnl_rule_expr_counter_export(buf, len, e, type); default: break; } @@ -200,13 +200,13 @@ static int nft_rule_expr_counter_snprintf(char *buf, size_t len, uint32_t type, struct expr_ops expr_ops_counter = { .name = "counter", - .alloc_len = sizeof(struct nft_expr_counter), + .alloc_len = sizeof(struct nftnl_expr_counter), .max_attr = NFTA_COUNTER_MAX, - .set = nft_rule_expr_counter_set, - .get = nft_rule_expr_counter_get, - .parse = nft_rule_expr_counter_parse, - .build = nft_rule_expr_counter_build, - .snprintf = nft_rule_expr_counter_snprintf, - .xml_parse = nft_rule_expr_counter_xml_parse, - .json_parse = nft_rule_expr_counter_json_parse, + .set = nftnl_rule_expr_counter_set, + .get = nftnl_rule_expr_counter_get, + .parse = nftnl_rule_expr_counter_parse, + .build = nftnl_rule_expr_counter_build, + .snprintf = nftnl_rule_expr_counter_snprintf, + .xml_parse = nftnl_rule_expr_counter_xml_parse, + .json_parse = nftnl_rule_expr_counter_json_parse, }; diff --git a/src/expr/ct.c b/src/expr/ct.c index b808e03..73ae33a 100644 --- a/src/expr/ct.c +++ b/src/expr/ct.c @@ -21,7 +21,7 @@ #include <libnftnl/expr.h> #include <libnftnl/rule.h> -struct nft_expr_ct { +struct nftnl_expr_ct { enum nft_ct_keys key; enum nft_registers dreg; enum nft_registers sreg; @@ -36,22 +36,22 @@ struct nft_expr_ct { #endif static int -nft_rule_expr_ct_set(struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_ct_set(struct nftnl_rule_expr *e, uint16_t type, const void *data, uint32_t data_len) { - struct nft_expr_ct *ct = nft_expr_data(e); + struct nftnl_expr_ct *ct = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_CT_KEY: + case NFTNL_EXPR_CT_KEY: ct->key = *((uint32_t *)data); break; - case NFT_EXPR_CT_DIR: + case NFTNL_EXPR_CT_DIR: ct->dir = *((uint8_t *)data); break; - case NFT_EXPR_CT_DREG: + case NFTNL_EXPR_CT_DREG: ct->dreg = *((uint32_t *)data); break; - case NFT_EXPR_CT_SREG: + case NFTNL_EXPR_CT_SREG: ct->sreg = *((uint32_t *)data); break; default: @@ -61,29 +61,29 @@ nft_rule_expr_ct_set(struct nft_rule_expr *e, uint16_t type, } static const void * -nft_rule_expr_ct_get(const struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_ct_get(const struct nftnl_rule_expr *e, uint16_t type, uint32_t *data_len) { - struct nft_expr_ct *ct = nft_expr_data(e); + struct nftnl_expr_ct *ct = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_CT_KEY: + case NFTNL_EXPR_CT_KEY: *data_len = sizeof(ct->key); return &ct->key; - case NFT_EXPR_CT_DIR: + case NFTNL_EXPR_CT_DIR: *data_len = sizeof(ct->dir); return &ct->dir; - case NFT_EXPR_CT_DREG: + case NFTNL_EXPR_CT_DREG: *data_len = sizeof(ct->dreg); return &ct->dreg; - case NFT_EXPR_CT_SREG: + case NFTNL_EXPR_CT_SREG: *data_len = sizeof(ct->sreg); return &ct->sreg; } return NULL; } -static int nft_rule_expr_ct_cb(const struct nlattr *attr, void *data) +static int nftnl_rule_expr_ct_cb(const struct nlattr *attr, void *data) { const struct nlattr **tb = data; int type = mnl_attr_get_type(attr); @@ -109,44 +109,44 @@ static int nft_rule_expr_ct_cb(const struct nlattr *attr, void *data) } static void -nft_rule_expr_ct_build(struct nlmsghdr *nlh, struct nft_rule_expr *e) +nftnl_rule_expr_ct_build(struct nlmsghdr *nlh, struct nftnl_rule_expr *e) { - struct nft_expr_ct *ct = nft_expr_data(e); + struct nftnl_expr_ct *ct = nftnl_expr_data(e); - if (e->flags & (1 << NFT_EXPR_CT_KEY)) + if (e->flags & (1 << NFTNL_EXPR_CT_KEY)) mnl_attr_put_u32(nlh, NFTA_CT_KEY, htonl(ct->key)); - if (e->flags & (1 << NFT_EXPR_CT_DREG)) + if (e->flags & (1 << NFTNL_EXPR_CT_DREG)) mnl_attr_put_u32(nlh, NFTA_CT_DREG, htonl(ct->dreg)); - if (e->flags & (1 << NFT_EXPR_CT_DIR)) + if (e->flags & (1 << NFTNL_EXPR_CT_DIR)) mnl_attr_put_u8(nlh, NFTA_CT_DIRECTION, ct->dir); - if (e->flags & (1 << NFT_EXPR_CT_SREG)) + if (e->flags & (1 << NFTNL_EXPR_CT_SREG)) mnl_attr_put_u32(nlh, NFTA_CT_SREG, htonl(ct->sreg)); } static int -nft_rule_expr_ct_parse(struct nft_rule_expr *e, struct nlattr *attr) +nftnl_rule_expr_ct_parse(struct nftnl_rule_expr *e, struct nlattr *attr) { - struct nft_expr_ct *ct = nft_expr_data(e); + struct nftnl_expr_ct *ct = nftnl_expr_data(e); struct nlattr *tb[NFTA_CT_MAX+1] = {}; - if (mnl_attr_parse_nested(attr, nft_rule_expr_ct_cb, tb) < 0) + if (mnl_attr_parse_nested(attr, nftnl_rule_expr_ct_cb, tb) < 0) return -1; if (tb[NFTA_CT_KEY]) { ct->key = ntohl(mnl_attr_get_u32(tb[NFTA_CT_KEY])); - e->flags |= (1 << NFT_EXPR_CT_KEY); + e->flags |= (1 << NFTNL_EXPR_CT_KEY); } if (tb[NFTA_CT_DREG]) { ct->dreg = ntohl(mnl_attr_get_u32(tb[NFTA_CT_DREG])); - e->flags |= (1 << NFT_EXPR_CT_DREG); + e->flags |= (1 << NFTNL_EXPR_CT_DREG); } if (tb[NFTA_CT_SREG]) { ct->sreg = ntohl(mnl_attr_get_u32(tb[NFTA_CT_SREG])); - e->flags |= (1 << NFT_EXPR_CT_SREG); + e->flags |= (1 << NFTNL_EXPR_CT_SREG); } if (tb[NFTA_CT_DIRECTION]) { ct->dir = mnl_attr_get_u8(tb[NFTA_CT_DIRECTION]); - e->flags |= (1 << NFT_EXPR_CT_DIR); + e->flags |= (1 << NFTNL_EXPR_CT_DIR); } return 0; @@ -216,8 +216,8 @@ static inline int str2ctdir(const char *str, uint8_t *ctdir) return -1; } -static int nft_rule_expr_ct_json_parse(struct nft_rule_expr *e, json_t *root, - struct nft_parse_err *err) +static int nftnl_rule_expr_ct_json_parse(struct nftnl_rule_expr *e, json_t *root, + struct nftnl_parse_err *err) { #ifdef JSON_PARSING const char *key_str, *dir_str; @@ -225,29 +225,29 @@ static int nft_rule_expr_ct_json_parse(struct nft_rule_expr *e, json_t *root, uint8_t dir; int key; - if (nft_jansson_parse_reg(root, "dreg", NFT_TYPE_U32, ®, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_CT_DREG, reg); + if (nftnl_jansson_parse_reg(root, "dreg", NFTNL_TYPE_U32, ®, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_CT_DREG, reg); - if (nft_jansson_parse_reg(root, "sreg", NFT_TYPE_U32, ®, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_CT_SREG, reg); + if (nftnl_jansson_parse_reg(root, "sreg", NFTNL_TYPE_U32, ®, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_CT_SREG, reg); - key_str = nft_jansson_parse_str(root, "key", err); + key_str = nftnl_jansson_parse_str(root, "key", err); if (key_str != NULL) { key = str2ctkey(key_str); if (key < 0) return -1; - nft_rule_expr_set_u32(e, NFT_EXPR_CT_KEY, key); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_CT_KEY, key); } - dir_str = nft_jansson_parse_str(root, "dir", err); + dir_str = nftnl_jansson_parse_str(root, "dir", err); if (dir_str != NULL) { if (str2ctdir(dir_str, &dir) != 0) { err->node_name = "dir"; - err->error = NFT_PARSE_EBADTYPE; + err->error = NFTNL_PARSE_EBADTYPE; goto err; } - nft_rule_expr_set_u8(e, NFT_EXPR_CT_DIR, dir); + nftnl_rule_expr_set_u8(e, NFTNL_EXPR_CT_DIR, dir); } return 0; @@ -261,8 +261,8 @@ err: } -static int nft_rule_expr_ct_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, - struct nft_parse_err *err) +static int nftnl_rule_expr_ct_xml_parse(struct nftnl_rule_expr *e, mxml_node_t *tree, + struct nftnl_parse_err *err) { #ifdef XML_PARSING const char *key_str, *dir_str; @@ -270,32 +270,32 @@ static int nft_rule_expr_ct_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree uint8_t dir; uint32_t dreg, sreg; - if (nft_mxml_reg_parse(tree, "dreg", &dreg, MXML_DESCEND_FIRST, - NFT_XML_OPT, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_CT_DREG, dreg); + if (nftnl_mxml_reg_parse(tree, "dreg", &dreg, MXML_DESCEND_FIRST, + NFTNL_XML_OPT, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_CT_DREG, dreg); - if (nft_mxml_reg_parse(tree, "sreg", &sreg, MXML_DESCEND_FIRST, - NFT_XML_OPT, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_CT_SREG, sreg); + if (nftnl_mxml_reg_parse(tree, "sreg", &sreg, MXML_DESCEND_FIRST, + NFTNL_XML_OPT, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_CT_SREG, sreg); - key_str = nft_mxml_str_parse(tree, "key", MXML_DESCEND_FIRST, - NFT_XML_MAND, err); + key_str = nftnl_mxml_str_parse(tree, "key", MXML_DESCEND_FIRST, + NFTNL_XML_MAND, err); if (key_str != NULL) { key = str2ctkey(key_str); if (key < 0) return -1; - nft_rule_expr_set_u32(e, NFT_EXPR_CT_KEY, key); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_CT_KEY, key); } - dir_str = nft_mxml_str_parse(tree, "dir", MXML_DESCEND_FIRST, - NFT_XML_OPT, err); + dir_str = nftnl_mxml_str_parse(tree, "dir", MXML_DESCEND_FIRST, + NFTNL_XML_OPT, err); if (dir_str != NULL) { if (str2ctdir(dir_str, &dir) != 0) { err->node_name = "dir"; - err->error = NFT_PARSE_EBADTYPE; + err->error = NFTNL_PARSE_EBADTYPE; goto err; } - nft_rule_expr_set_u8(e, NFT_EXPR_CT_DIR, dir); + nftnl_rule_expr_set_u8(e, NFTNL_EXPR_CT_DIR, dir); } return 0; @@ -309,42 +309,42 @@ err: } static int -nft_expr_ct_export(char *buf, size_t size, struct nft_rule_expr *e, int type) +nftnl_expr_ct_export(char *buf, size_t size, struct nftnl_rule_expr *e, int type) { - struct nft_expr_ct *ct = nft_expr_data(e); - NFT_BUF_INIT(b, buf, size); - - if (e->flags & (1 << NFT_EXPR_CT_SREG)) - nft_buf_u32(&b, type, ct->sreg, SREG); - if (e->flags & (1 << NFT_EXPR_CT_DREG)) - nft_buf_u32(&b, type, ct->dreg, DREG); - if (e->flags & (1 << NFT_EXPR_CT_KEY)) - nft_buf_str(&b, type, ctkey2str(ct->key), KEY); - if (e->flags & (1 << NFT_EXPR_CT_DIR)) - nft_buf_str(&b, type, ctdir2str(ct->dir), DIR); - - return nft_buf_done(&b); + struct nftnl_expr_ct *ct = nftnl_expr_data(e); + NFTNL_BUF_INIT(b, buf, size); + + if (e->flags & (1 << NFTNL_EXPR_CT_SREG)) + nftnl_buf_u32(&b, type, ct->sreg, SREG); + if (e->flags & (1 << NFTNL_EXPR_CT_DREG)) + nftnl_buf_u32(&b, type, ct->dreg, DREG); + if (e->flags & (1 << NFTNL_EXPR_CT_KEY)) + nftnl_buf_str(&b, type, ctkey2str(ct->key), KEY); + if (e->flags & (1 << NFTNL_EXPR_CT_DIR)) + nftnl_buf_str(&b, type, ctdir2str(ct->dir), DIR); + + return nftnl_buf_done(&b); } static int -nft_expr_ct_snprintf_default(char *buf, size_t size, struct nft_rule_expr *e) +nftnl_expr_ct_snprintf_default(char *buf, size_t size, struct nftnl_rule_expr *e) { int ret, len = size, offset = 0; - struct nft_expr_ct *ct = nft_expr_data(e); + struct nftnl_expr_ct *ct = nftnl_expr_data(e); - if (e->flags & (1 << NFT_EXPR_CT_SREG)) { + if (e->flags & (1 << NFTNL_EXPR_CT_SREG)) { ret = snprintf(buf, size, "set %s with reg %u ", ctkey2str(ct->key), ct->sreg); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (e->flags & (1 << NFT_EXPR_CT_DREG)) { + if (e->flags & (1 << NFTNL_EXPR_CT_DREG)) { ret = snprintf(buf, len, "load %s => reg %u ", ctkey2str(ct->key), ct->dreg); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (nft_rule_expr_is_set(e, NFT_EXPR_CT_DIR)) { + if (nftnl_rule_expr_is_set(e, NFTNL_EXPR_CT_DIR)) { ret = snprintf(buf+offset, len, ", dir %s ", ctdir2str(ct->dir)); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); @@ -354,15 +354,15 @@ nft_expr_ct_snprintf_default(char *buf, size_t size, struct nft_rule_expr *e) } static int -nft_rule_expr_ct_snprintf(char *buf, size_t len, uint32_t type, - uint32_t flags, struct nft_rule_expr *e) +nftnl_rule_expr_ct_snprintf(char *buf, size_t len, uint32_t type, + uint32_t flags, struct nftnl_rule_expr *e) { switch (type) { - case NFT_OUTPUT_DEFAULT: - return nft_expr_ct_snprintf_default(buf, len, e); - case NFT_OUTPUT_XML: - case NFT_OUTPUT_JSON: - return nft_expr_ct_export(buf, len, e, type); + case NFTNL_OUTPUT_DEFAULT: + return nftnl_expr_ct_snprintf_default(buf, len, e); + case NFTNL_OUTPUT_XML: + case NFTNL_OUTPUT_JSON: + return nftnl_expr_ct_export(buf, len, e, type); default: break; } @@ -371,13 +371,13 @@ nft_rule_expr_ct_snprintf(char *buf, size_t len, uint32_t type, struct expr_ops expr_ops_ct = { .name = "ct", - .alloc_len = sizeof(struct nft_expr_ct), + .alloc_len = sizeof(struct nftnl_expr_ct), .max_attr = NFTA_CT_MAX, - .set = nft_rule_expr_ct_set, - .get = nft_rule_expr_ct_get, - .parse = nft_rule_expr_ct_parse, - .build = nft_rule_expr_ct_build, - .snprintf = nft_rule_expr_ct_snprintf, - .xml_parse = nft_rule_expr_ct_xml_parse, - .json_parse = nft_rule_expr_ct_json_parse, + .set = nftnl_rule_expr_ct_set, + .get = nftnl_rule_expr_ct_get, + .parse = nftnl_rule_expr_ct_parse, + .build = nftnl_rule_expr_ct_build, + .snprintf = nftnl_rule_expr_ct_snprintf, + .xml_parse = nftnl_rule_expr_ct_xml_parse, + .json_parse = nftnl_rule_expr_ct_json_parse, }; diff --git a/src/expr/data_reg.c b/src/expr/data_reg.c index b375db4..b85d2ef 100644 --- a/src/expr/data_reg.c +++ b/src/expr/data_reg.c @@ -25,28 +25,28 @@ #include "internal.h" #ifdef JSON_PARSING -static int nft_data_reg_verdict_json_parse(union nft_data_reg *reg, json_t *data, - struct nft_parse_err *err) +static int nftnl_data_reg_verdict_json_parse(union nftnl_data_reg *reg, json_t *data, + struct nftnl_parse_err *err) { int verdict; const char *verdict_str; const char *chain; - verdict_str = nft_jansson_parse_str(data, "verdict", err); + verdict_str = nftnl_jansson_parse_str(data, "verdict", err); if (verdict_str == NULL) return DATA_NONE; - if (nft_str2verdict(verdict_str, &verdict) != 0) { + if (nftnl_str2verdict(verdict_str, &verdict) != 0) { err->node_name = "verdict"; - err->error = NFT_PARSE_EBADTYPE; + err->error = NFTNL_PARSE_EBADTYPE; errno = EINVAL; return -1; } reg->verdict = (uint32_t)verdict; - if (nft_jansson_node_exist(data, "chain")) { - chain = nft_jansson_parse_str(data, "chain", err); + if (nftnl_jansson_node_exist(data, "chain")) { + chain = nftnl_jansson_parse_str(data, "chain", err); if (chain == NULL) return DATA_NONE; @@ -56,71 +56,71 @@ static int nft_data_reg_verdict_json_parse(union nft_data_reg *reg, json_t *data return DATA_VERDICT; } -static int nft_data_reg_value_json_parse(union nft_data_reg *reg, json_t *data, - struct nft_parse_err *err) +static int nftnl_data_reg_value_json_parse(union nftnl_data_reg *reg, json_t *data, + struct nftnl_parse_err *err) { int i; char node_name[6]; - if (nft_jansson_parse_val(data, "len", NFT_TYPE_U8, ®->len, err) < 0) + if (nftnl_jansson_parse_val(data, "len", NFTNL_TYPE_U8, ®->len, err) < 0) return DATA_NONE; for (i = 0; i < div_round_up(reg->len, sizeof(uint32_t)); i++) { sprintf(node_name, "data%d", i); - if (nft_jansson_str2num(data, node_name, BASE_HEX, - ®->val[i], NFT_TYPE_U32, err) != 0) + if (nftnl_jansson_str2num(data, node_name, BASE_HEX, + ®->val[i], NFTNL_TYPE_U32, err) != 0) return DATA_NONE; } return DATA_VALUE; } -int nft_data_reg_json_parse(union nft_data_reg *reg, json_t *data, - struct nft_parse_err *err) +int nftnl_data_reg_json_parse(union nftnl_data_reg *reg, json_t *data, + struct nftnl_parse_err *err) { const char *type; - type = nft_jansson_parse_str(data, "type", err); + type = nftnl_jansson_parse_str(data, "type", err); if (type == NULL) return -1; /* Select what type of parsing is needed */ if (strcmp(type, "value") == 0) - return nft_data_reg_value_json_parse(reg, data, err); + return nftnl_data_reg_value_json_parse(reg, data, err); else if (strcmp(type, "verdict") == 0) - return nft_data_reg_verdict_json_parse(reg, data, err); + return nftnl_data_reg_verdict_json_parse(reg, data, err); return DATA_NONE; } #endif #ifdef XML_PARSING -static int nft_data_reg_verdict_xml_parse(union nft_data_reg *reg, +static int nftnl_data_reg_verdict_xml_parse(union nftnl_data_reg *reg, mxml_node_t *tree, - struct nft_parse_err *err) + struct nftnl_parse_err *err) { int verdict; const char *verdict_str; const char *chain; - verdict_str = nft_mxml_str_parse(tree, "verdict", MXML_DESCEND_FIRST, - NFT_XML_MAND, err); + verdict_str = nftnl_mxml_str_parse(tree, "verdict", MXML_DESCEND_FIRST, + NFTNL_XML_MAND, err); if (verdict_str == NULL) return DATA_NONE; - if (nft_str2verdict(verdict_str, &verdict) != 0) { + if (nftnl_str2verdict(verdict_str, &verdict) != 0) { err->node_name = "verdict"; - err->error = NFT_PARSE_EBADTYPE; + err->error = NFTNL_PARSE_EBADTYPE; errno = EINVAL; return DATA_NONE; } reg->verdict = (uint32_t)verdict; - chain = nft_mxml_str_parse(tree, "chain", MXML_DESCEND_FIRST, - NFT_XML_OPT, err); + chain = nftnl_mxml_str_parse(tree, "chain", MXML_DESCEND_FIRST, + NFTNL_XML_OPT, err); if (chain != NULL) { if (reg->chain) xfree(reg->chain); @@ -131,31 +131,31 @@ static int nft_data_reg_verdict_xml_parse(union nft_data_reg *reg, return DATA_VERDICT; } -static int nft_data_reg_value_xml_parse(union nft_data_reg *reg, +static int nftnl_data_reg_value_xml_parse(union nftnl_data_reg *reg, mxml_node_t *tree, - struct nft_parse_err *err) + struct nftnl_parse_err *err) { int i; char node_name[6]; - if (nft_mxml_num_parse(tree, "len", MXML_DESCEND_FIRST, BASE_DEC, - ®->len, NFT_TYPE_U8, NFT_XML_MAND, err) != 0) + if (nftnl_mxml_num_parse(tree, "len", MXML_DESCEND_FIRST, BASE_DEC, + ®->len, NFTNL_TYPE_U8, NFTNL_XML_MAND, err) != 0) return DATA_NONE; for (i = 0; i < div_round_up(reg->len, sizeof(uint32_t)); i++) { sprintf(node_name, "data%d", i); - if (nft_mxml_num_parse(tree, node_name, MXML_DESCEND_FIRST, - BASE_HEX, ®->val[i], NFT_TYPE_U32, - NFT_XML_MAND, err) != 0) + if (nftnl_mxml_num_parse(tree, node_name, MXML_DESCEND_FIRST, + BASE_HEX, ®->val[i], NFTNL_TYPE_U32, + NFTNL_XML_MAND, err) != 0) return DATA_NONE; } return DATA_VALUE; } -int nft_data_reg_xml_parse(union nft_data_reg *reg, mxml_node_t *tree, - struct nft_parse_err *err) +int nftnl_data_reg_xml_parse(union nftnl_data_reg *reg, mxml_node_t *tree, + struct nftnl_parse_err *err) { const char *type; mxml_node_t *node; @@ -171,22 +171,22 @@ int nft_data_reg_xml_parse(union nft_data_reg *reg, mxml_node_t *tree, goto err; if (strcmp(type, "value") == 0) - return nft_data_reg_value_xml_parse(reg, node, err); + return nftnl_data_reg_value_xml_parse(reg, node, err); else if (strcmp(type, "verdict") == 0) - return nft_data_reg_verdict_xml_parse(reg, node, err); + return nftnl_data_reg_verdict_xml_parse(reg, node, err); return DATA_NONE; err: errno = EINVAL; err->node_name = "reg"; - err->error = NFT_PARSE_EMISSINGNODE; + err->error = NFTNL_PARSE_EMISSINGNODE; return DATA_NONE; } #endif static int -nft_data_reg_value_snprintf_json(char *buf, size_t size, - union nft_data_reg *reg, +nftnl_data_reg_value_snprintf_json(char *buf, size_t size, + union nftnl_data_reg *reg, uint32_t flags) { int len = size, offset = 0, ret, i, j; @@ -222,8 +222,8 @@ nft_data_reg_value_snprintf_json(char *buf, size_t size, } static -int nft_data_reg_value_snprintf_xml(char *buf, size_t size, - union nft_data_reg *reg, uint32_t flags) +int nftnl_data_reg_value_snprintf_xml(char *buf, size_t size, + union nftnl_data_reg *reg, uint32_t flags) { int len = size, offset = 0, ret, i, j; uint32_t be; @@ -258,8 +258,8 @@ int nft_data_reg_value_snprintf_xml(char *buf, size_t size, } static int -nft_data_reg_value_snprintf_default(char *buf, size_t size, - union nft_data_reg *reg, uint32_t flags) +nftnl_data_reg_value_snprintf_default(char *buf, size_t size, + union nftnl_data_reg *reg, uint32_t flags) { int len = size, offset = 0, ret, i; @@ -272,12 +272,12 @@ nft_data_reg_value_snprintf_default(char *buf, size_t size, } static int -nft_data_reg_verdict_snprintf_def(char *buf, size_t size, - union nft_data_reg *reg, uint32_t flags) +nftnl_data_reg_verdict_snprintf_def(char *buf, size_t size, + union nftnl_data_reg *reg, uint32_t flags) { int len = size, offset = 0, ret = 0; - ret = snprintf(buf, size, "%s ", nft_verdict2str(reg->verdict)); + ret = snprintf(buf, size, "%s ", nftnl_verdict2str(reg->verdict)); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); if (reg->chain != NULL) { @@ -289,13 +289,13 @@ nft_data_reg_verdict_snprintf_def(char *buf, size_t size, } static int -nft_data_reg_verdict_snprintf_xml(char *buf, size_t size, - union nft_data_reg *reg, uint32_t flags) +nftnl_data_reg_verdict_snprintf_xml(char *buf, size_t size, + union nftnl_data_reg *reg, uint32_t flags) { int len = size, offset = 0, ret = 0; ret = snprintf(buf, size, "<reg type=\"verdict\">" - "<verdict>%s</verdict>", nft_verdict2str(reg->verdict)); + "<verdict>%s</verdict>", nftnl_verdict2str(reg->verdict)); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); if (reg->chain != NULL) { @@ -311,13 +311,13 @@ nft_data_reg_verdict_snprintf_xml(char *buf, size_t size, } static int -nft_data_reg_verdict_snprintf_json(char *buf, size_t size, - union nft_data_reg *reg, uint32_t flags) +nftnl_data_reg_verdict_snprintf_json(char *buf, size_t size, + union nftnl_data_reg *reg, uint32_t flags) { int len = size, offset = 0, ret = 0; ret = snprintf(buf, size, "\"reg\":{\"type\":\"verdict\"," - "\"verdict\":\"%s\"", nft_verdict2str(reg->verdict)); + "\"verdict\":\"%s\"", nftnl_verdict2str(reg->verdict)); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); if (reg->chain != NULL) { @@ -332,20 +332,20 @@ nft_data_reg_verdict_snprintf_json(char *buf, size_t size, return offset; } -int nft_data_reg_snprintf(char *buf, size_t size, union nft_data_reg *reg, +int nftnl_data_reg_snprintf(char *buf, size_t size, union nftnl_data_reg *reg, uint32_t output_format, uint32_t flags, int reg_type) { switch(reg_type) { case DATA_VALUE: switch(output_format) { - case NFT_OUTPUT_DEFAULT: - return nft_data_reg_value_snprintf_default(buf, size, + case NFTNL_OUTPUT_DEFAULT: + return nftnl_data_reg_value_snprintf_default(buf, size, reg, flags); - case NFT_OUTPUT_XML: - return nft_data_reg_value_snprintf_xml(buf, size, + case NFTNL_OUTPUT_XML: + return nftnl_data_reg_value_snprintf_xml(buf, size, reg, flags); - case NFT_OUTPUT_JSON: - return nft_data_reg_value_snprintf_json(buf, size, + case NFTNL_OUTPUT_JSON: + return nftnl_data_reg_value_snprintf_json(buf, size, reg, flags); default: break; @@ -353,14 +353,14 @@ int nft_data_reg_snprintf(char *buf, size_t size, union nft_data_reg *reg, case DATA_VERDICT: case DATA_CHAIN: switch(output_format) { - case NFT_OUTPUT_DEFAULT: - return nft_data_reg_verdict_snprintf_def(buf, size, + case NFTNL_OUTPUT_DEFAULT: + return nftnl_data_reg_verdict_snprintf_def(buf, size, reg, flags); - case NFT_OUTPUT_XML: - return nft_data_reg_verdict_snprintf_xml(buf, size, + case NFTNL_OUTPUT_XML: + return nftnl_data_reg_verdict_snprintf_xml(buf, size, reg, flags); - case NFT_OUTPUT_JSON: - return nft_data_reg_verdict_snprintf_json(buf, size, + case NFTNL_OUTPUT_JSON: + return nftnl_data_reg_verdict_snprintf_json(buf, size, reg, flags); default: break; @@ -372,7 +372,7 @@ int nft_data_reg_snprintf(char *buf, size_t size, union nft_data_reg *reg, return -1; } -static int nft_data_parse_cb(const struct nlattr *attr, void *data) +static int nftnl_data_parse_cb(const struct nlattr *attr, void *data) { const struct nlattr **tb = data; int type = mnl_attr_get_type(attr); @@ -394,7 +394,7 @@ static int nft_data_parse_cb(const struct nlattr *attr, void *data) return MNL_CB_OK; } -static int nft_verdict_parse_cb(const struct nlattr *attr, void *data) +static int nftnl_verdict_parse_cb(const struct nlattr *attr, void *data) { const struct nlattr **tb = data; int type = mnl_attr_get_type(attr); @@ -417,11 +417,11 @@ static int nft_verdict_parse_cb(const struct nlattr *attr, void *data) } static int -nft_parse_verdict(union nft_data_reg *data, const struct nlattr *attr, int *type) +nftnl_parse_verdict(union nftnl_data_reg *data, const struct nlattr *attr, int *type) { struct nlattr *tb[NFTA_VERDICT_MAX+1]; - if (mnl_attr_parse_nested(attr, nft_verdict_parse_cb, tb) < 0) { + if (mnl_attr_parse_nested(attr, nftnl_verdict_parse_cb, tb) < 0) { perror("mnl_attr_parse_nested"); return -1; } @@ -459,7 +459,7 @@ nft_parse_verdict(union nft_data_reg *data, const struct nlattr *attr, int *type } static int -__nft_parse_data(union nft_data_reg *data, const struct nlattr *attr) +__nftnl_parse_data(union nftnl_data_reg *data, const struct nlattr *attr) { void *orig = mnl_attr_get_payload(attr); uint32_t data_len = mnl_attr_get_payload_len(attr); @@ -476,12 +476,12 @@ __nft_parse_data(union nft_data_reg *data, const struct nlattr *attr) return 0; } -int nft_parse_data(union nft_data_reg *data, struct nlattr *attr, int *type) +int nftnl_parse_data(union nftnl_data_reg *data, struct nlattr *attr, int *type) { struct nlattr *tb[NFTA_DATA_MAX+1] = {}; int ret = 0; - if (mnl_attr_parse_nested(attr, nft_data_parse_cb, tb) < 0) { + if (mnl_attr_parse_nested(attr, nftnl_data_parse_cb, tb) < 0) { perror("mnl_attr_parse_nested"); return -1; } @@ -489,17 +489,17 @@ int nft_parse_data(union nft_data_reg *data, struct nlattr *attr, int *type) if (type) *type = DATA_VALUE; - ret = __nft_parse_data(data, tb[NFTA_DATA_VALUE]); + ret = __nftnl_parse_data(data, tb[NFTA_DATA_VALUE]); if (ret < 0) return ret; } if (tb[NFTA_DATA_VERDICT]) - ret = nft_parse_verdict(data, tb[NFTA_DATA_VERDICT], type); + ret = nftnl_parse_verdict(data, tb[NFTA_DATA_VERDICT], type); return ret; } -void nft_free_verdict(union nft_data_reg *data) +void nftnl_free_verdict(union nftnl_data_reg *data) { switch(data->verdict) { case NFT_JUMP: diff --git a/src/expr/dynset.c b/src/expr/dynset.c index e3fecf5..ffb3882 100644 --- a/src/expr/dynset.c +++ b/src/expr/dynset.c @@ -26,43 +26,43 @@ #define IFNAMSIZ 16 #endif -struct nft_expr_dynset { +struct nftnl_expr_dynset { enum nft_registers sreg_key; enum nft_registers sreg_data; enum nft_dynset_ops op; uint64_t timeout; - struct nft_rule_expr *expr; + struct nftnl_rule_expr *expr; char set_name[IFNAMSIZ]; uint32_t set_id; }; static int -nft_rule_expr_dynset_set(struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_dynset_set(struct nftnl_rule_expr *e, uint16_t type, const void *data, uint32_t data_len) { - struct nft_expr_dynset *dynset = nft_expr_data(e); + struct nftnl_expr_dynset *dynset = nftnl_expr_data(e); switch (type) { - case NFT_EXPR_DYNSET_SREG_KEY: + case NFTNL_EXPR_DYNSET_SREG_KEY: dynset->sreg_key = *((uint32_t *)data); break; - case NFT_EXPR_DYNSET_SREG_DATA: + case NFTNL_EXPR_DYNSET_SREG_DATA: dynset->sreg_data = *((uint32_t *)data); break; - case NFT_EXPR_DYNSET_OP: + case NFTNL_EXPR_DYNSET_OP: dynset->op = *((uint32_t *)data); break; - case NFT_EXPR_DYNSET_TIMEOUT: + case NFTNL_EXPR_DYNSET_TIMEOUT: dynset->timeout = *((uint64_t *)data); break; - case NFT_EXPR_DYNSET_SET_NAME: + case NFTNL_EXPR_DYNSET_SET_NAME: snprintf(dynset->set_name, sizeof(dynset->set_name), "%s", (const char *)data); break; - case NFT_EXPR_DYNSET_SET_ID: + case NFTNL_EXPR_DYNSET_SET_ID: dynset->set_id = *((uint32_t *)data); break; - case NFT_EXPR_DYNSET_EXPR: + case NFTNL_EXPR_DYNSET_EXPR: dynset->expr = (void *)data; break; default: @@ -72,35 +72,35 @@ nft_rule_expr_dynset_set(struct nft_rule_expr *e, uint16_t type, } static const void * -nft_rule_expr_dynset_get(const struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_dynset_get(const struct nftnl_rule_expr *e, uint16_t type, uint32_t *data_len) { - struct nft_expr_dynset *dynset = nft_expr_data(e); + struct nftnl_expr_dynset *dynset = nftnl_expr_data(e); switch (type) { - case NFT_EXPR_DYNSET_SREG_KEY: + case NFTNL_EXPR_DYNSET_SREG_KEY: *data_len = sizeof(dynset->sreg_key); return &dynset->sreg_key; - case NFT_EXPR_DYNSET_SREG_DATA: + case NFTNL_EXPR_DYNSET_SREG_DATA: *data_len = sizeof(dynset->sreg_data); return &dynset->sreg_data; - case NFT_EXPR_DYNSET_OP: + case NFTNL_EXPR_DYNSET_OP: *data_len = sizeof(dynset->op); return &dynset->op; - case NFT_EXPR_DYNSET_TIMEOUT: + case NFTNL_EXPR_DYNSET_TIMEOUT: *data_len = sizeof(dynset->timeout); return &dynset->timeout; - case NFT_EXPR_DYNSET_SET_NAME: + case NFTNL_EXPR_DYNSET_SET_NAME: return dynset->set_name; - case NFT_EXPR_DYNSET_SET_ID: + case NFTNL_EXPR_DYNSET_SET_ID: return &dynset->set_id; - case NFT_EXPR_DYNSET_EXPR: + case NFTNL_EXPR_DYNSET_EXPR: return dynset->expr; } return NULL; } -static int nft_rule_expr_dynset_cb(const struct nlattr *attr, void *data) +static int nftnl_rule_expr_dynset_cb(const struct nlattr *attr, void *data) { const struct nlattr **tb = data; int type = mnl_attr_get_type(attr); @@ -135,67 +135,67 @@ static int nft_rule_expr_dynset_cb(const struct nlattr *attr, void *data) } static void -nft_rule_expr_dynset_build(struct nlmsghdr *nlh, struct nft_rule_expr *e) +nftnl_rule_expr_dynset_build(struct nlmsghdr *nlh, struct nftnl_rule_expr *e) { - struct nft_expr_dynset *dynset = nft_expr_data(e); + struct nftnl_expr_dynset *dynset = nftnl_expr_data(e); struct nlattr *nest; - if (e->flags & (1 << NFT_EXPR_DYNSET_SREG_KEY)) + if (e->flags & (1 << NFTNL_EXPR_DYNSET_SREG_KEY)) mnl_attr_put_u32(nlh, NFTA_DYNSET_SREG_KEY, htonl(dynset->sreg_key)); - if (e->flags & (1 << NFT_EXPR_DYNSET_SREG_DATA)) + if (e->flags & (1 << NFTNL_EXPR_DYNSET_SREG_DATA)) mnl_attr_put_u32(nlh, NFTA_DYNSET_SREG_DATA, htonl(dynset->sreg_data)); - if (e->flags & (1 << NFT_EXPR_DYNSET_OP)) + if (e->flags & (1 << NFTNL_EXPR_DYNSET_OP)) mnl_attr_put_u32(nlh, NFTA_DYNSET_OP, htonl(dynset->op)); - if (e->flags & (1 << NFT_EXPR_DYNSET_TIMEOUT)) + if (e->flags & (1 << NFTNL_EXPR_DYNSET_TIMEOUT)) mnl_attr_put_u64(nlh, NFTA_DYNSET_TIMEOUT, htobe64(dynset->timeout)); - if (e->flags & (1 << NFT_EXPR_DYNSET_SET_NAME)) + if (e->flags & (1 << NFTNL_EXPR_DYNSET_SET_NAME)) mnl_attr_put_strz(nlh, NFTA_DYNSET_SET_NAME, dynset->set_name); - if (e->flags & (1 << NFT_EXPR_DYNSET_SET_ID)) + if (e->flags & (1 << NFTNL_EXPR_DYNSET_SET_ID)) mnl_attr_put_u32(nlh, NFTA_DYNSET_SET_ID, htonl(dynset->set_id)); - if (e->flags & (1 << NFT_EXPR_DYNSET_EXPR)) { + if (e->flags & (1 << NFTNL_EXPR_DYNSET_EXPR)) { nest = mnl_attr_nest_start(nlh, NFTA_DYNSET_EXPR); - nft_rule_expr_build_payload(nlh, dynset->expr); + nftnl_rule_expr_build_payload(nlh, dynset->expr); mnl_attr_nest_end(nlh, nest); } } static int -nft_rule_expr_dynset_parse(struct nft_rule_expr *e, struct nlattr *attr) +nftnl_rule_expr_dynset_parse(struct nftnl_rule_expr *e, struct nlattr *attr) { - struct nft_expr_dynset *dynset = nft_expr_data(e); + struct nftnl_expr_dynset *dynset = nftnl_expr_data(e); struct nlattr *tb[NFTA_SET_MAX+1] = {}; int ret = 0; - if (mnl_attr_parse_nested(attr, nft_rule_expr_dynset_cb, tb) < 0) + if (mnl_attr_parse_nested(attr, nftnl_rule_expr_dynset_cb, tb) < 0) return -1; if (tb[NFTA_DYNSET_SREG_KEY]) { dynset->sreg_key = ntohl(mnl_attr_get_u32(tb[NFTA_DYNSET_SREG_KEY])); - e->flags |= (1 << NFT_EXPR_DYNSET_SREG_KEY); + e->flags |= (1 << NFTNL_EXPR_DYNSET_SREG_KEY); } if (tb[NFTA_DYNSET_SREG_DATA]) { dynset->sreg_data = ntohl(mnl_attr_get_u32(tb[NFTA_DYNSET_SREG_DATA])); - e->flags |= (1 << NFT_EXPR_DYNSET_SREG_DATA); + e->flags |= (1 << NFTNL_EXPR_DYNSET_SREG_DATA); } if (tb[NFTA_DYNSET_OP]) { dynset->op = ntohl(mnl_attr_get_u32(tb[NFTA_DYNSET_OP])); - e->flags |= (1 << NFT_EXPR_DYNSET_OP); + e->flags |= (1 << NFTNL_EXPR_DYNSET_OP); } if (tb[NFTA_DYNSET_TIMEOUT]) { dynset->timeout = be64toh(mnl_attr_get_u64(tb[NFTA_DYNSET_TIMEOUT])); - e->flags |= (1 << NFT_EXPR_DYNSET_TIMEOUT); + e->flags |= (1 << NFTNL_EXPR_DYNSET_TIMEOUT); } if (tb[NFTA_DYNSET_SET_NAME]) { strcpy(dynset->set_name, mnl_attr_get_str(tb[NFTA_DYNSET_SET_NAME])); - e->flags |= (1 << NFT_EXPR_DYNSET_SET_NAME); + e->flags |= (1 << NFTNL_EXPR_DYNSET_SET_NAME); } if (tb[NFTA_DYNSET_SET_ID]) { dynset->set_id = ntohl(mnl_attr_get_u32(tb[NFTA_DYNSET_SET_ID])); - e->flags |= (1 << NFT_EXPR_DYNSET_SET_ID); + e->flags |= (1 << NFTNL_EXPR_DYNSET_SET_ID); } if (tb[NFTA_DYNSET_EXPR]) { - e->flags |= (1 << NFT_EXPR_DYNSET_EXPR); - dynset->expr = nft_rule_expr_parse(tb[NFTA_DYNSET_EXPR]); + e->flags |= (1 << NFTNL_EXPR_DYNSET_EXPR); + dynset->expr = nftnl_rule_expr_parse(tb[NFTA_DYNSET_EXPR]); if (dynset->expr == NULL) return -1; } @@ -204,33 +204,33 @@ nft_rule_expr_dynset_parse(struct nft_rule_expr *e, struct nlattr *attr) } static int -nft_rule_expr_dynset_json_parse(struct nft_rule_expr *e, json_t *root, - struct nft_parse_err *err) +nftnl_rule_expr_dynset_json_parse(struct nftnl_rule_expr *e, json_t *root, + struct nftnl_parse_err *err) { #ifdef JSON_PARSING const char *set_name; uint32_t uval32; uint64_t uval64; - set_name = nft_jansson_parse_str(root, "set", err); + set_name = nftnl_jansson_parse_str(root, "set", err); if (set_name != NULL) - nft_rule_expr_set_str(e, NFT_EXPR_DYNSET_SET_NAME, set_name); + nftnl_rule_expr_set_str(e, NFTNL_EXPR_DYNSET_SET_NAME, set_name); - if (nft_jansson_parse_reg(root, "sreg_key", - NFT_TYPE_U32, &uval32, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_DYNSET_SREG_KEY, uval32); + if (nftnl_jansson_parse_reg(root, "sreg_key", + NFTNL_TYPE_U32, &uval32, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_DYNSET_SREG_KEY, uval32); - if (nft_jansson_parse_reg(root, "sreg_data", - NFT_TYPE_U32, &uval32, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_DYNSET_SREG_DATA, uval32); + if (nftnl_jansson_parse_reg(root, "sreg_data", + NFTNL_TYPE_U32, &uval32, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_DYNSET_SREG_DATA, uval32); - if (nft_jansson_parse_val(root, "op", NFT_TYPE_U32, &uval32, + if (nftnl_jansson_parse_val(root, "op", NFTNL_TYPE_U32, &uval32, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_DYNSET_OP, uval32); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_DYNSET_OP, uval32); - if (nft_jansson_parse_val(root, "timeout", NFT_TYPE_U64, &uval64, + if (nftnl_jansson_parse_val(root, "timeout", NFTNL_TYPE_U64, &uval64, err) == 0) - nft_rule_expr_set_u64(e, NFT_EXPR_DYNSET_TIMEOUT, uval64); + nftnl_rule_expr_set_u64(e, NFTNL_EXPR_DYNSET_TIMEOUT, uval64); return 0; #else @@ -240,34 +240,34 @@ nft_rule_expr_dynset_json_parse(struct nft_rule_expr *e, json_t *root, } static int -nft_rule_expr_dynset_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, - struct nft_parse_err *err) +nftnl_rule_expr_dynset_xml_parse(struct nftnl_rule_expr *e, mxml_node_t *tree, + struct nftnl_parse_err *err) { #ifdef XML_PARSING const char *set_name; uint32_t uval32; uint64_t uval64; - set_name = nft_mxml_str_parse(tree, "set", MXML_DESCEND_FIRST, - NFT_XML_MAND, err); + set_name = nftnl_mxml_str_parse(tree, "set", MXML_DESCEND_FIRST, + NFTNL_XML_MAND, err); if (set_name != NULL) - nft_rule_expr_set_str(e, NFT_EXPR_DYNSET_SET_NAME, set_name); + nftnl_rule_expr_set_str(e, NFTNL_EXPR_DYNSET_SET_NAME, set_name); - if (nft_mxml_reg_parse(tree, "sreg_key", &uval32, MXML_DESCEND, - NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_DYNSET_SREG_KEY, uval32); + if (nftnl_mxml_reg_parse(tree, "sreg_key", &uval32, MXML_DESCEND, + NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_DYNSET_SREG_KEY, uval32); - if (nft_mxml_reg_parse(tree, "sreg_data", &uval32, MXML_DESCEND, - NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_DYNSET_SREG_DATA, uval32); + if (nftnl_mxml_reg_parse(tree, "sreg_data", &uval32, MXML_DESCEND, + NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_DYNSET_SREG_DATA, uval32); - if (nft_mxml_num_parse(tree, "op", MXML_DESCEND_FIRST, BASE_DEC, - &uval32, NFT_TYPE_U32, NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_DYNSET_OP, uval32); + if (nftnl_mxml_num_parse(tree, "op", MXML_DESCEND_FIRST, BASE_DEC, + &uval32, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_DYNSET_OP, uval32); - if (nft_mxml_num_parse(tree, "timeout", MXML_DESCEND_FIRST, BASE_DEC, - &uval64, NFT_TYPE_U64, NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u64(e, NFT_EXPR_DYNSET_TIMEOUT, uval64); + if (nftnl_mxml_num_parse(tree, "timeout", MXML_DESCEND_FIRST, BASE_DEC, + &uval64, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u64(e, NFTNL_EXPR_DYNSET_TIMEOUT, uval64); return 0; #else @@ -277,20 +277,20 @@ nft_rule_expr_dynset_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, } static int -nft_rule_expr_dynset_export(char *buf, size_t size, - struct nft_rule_expr *e, int type) +nftnl_rule_expr_dynset_export(char *buf, size_t size, + struct nftnl_rule_expr *e, int type) { - struct nft_expr_dynset *dynset = nft_expr_data(e); - NFT_BUF_INIT(b, buf, size); + struct nftnl_expr_dynset *dynset = nftnl_expr_data(e); + NFTNL_BUF_INIT(b, buf, size); - if (e->flags & (1 << NFT_EXPR_DYNSET_SET_NAME)) - nft_buf_str(&b, type, dynset->set_name, SET_NAME); - if (e->flags & (1 << NFT_EXPR_DYNSET_SREG_KEY)) - nft_buf_u32(&b, type, dynset->sreg_key, SREG_KEY); - if (e->flags & (1 << NFT_EXPR_DYNSET_SREG_DATA)) - nft_buf_u32(&b, type, dynset->sreg_data, SREG_DATA); + if (e->flags & (1 << NFTNL_EXPR_DYNSET_SET_NAME)) + nftnl_buf_str(&b, type, dynset->set_name, SET_NAME); + if (e->flags & (1 << NFTNL_EXPR_DYNSET_SREG_KEY)) + nftnl_buf_u32(&b, type, dynset->sreg_key, SREG_KEY); + if (e->flags & (1 << NFTNL_EXPR_DYNSET_SREG_DATA)) + nftnl_buf_u32(&b, type, dynset->sreg_data, SREG_DATA); - return nft_buf_done(&b); + return nftnl_buf_done(&b); } static char *op2str_array[] = { @@ -306,35 +306,35 @@ static const char *op2str(enum nft_dynset_ops op) } static int -nft_rule_expr_dynset_snprintf_default(char *buf, size_t size, - struct nft_rule_expr *e) +nftnl_rule_expr_dynset_snprintf_default(char *buf, size_t size, + struct nftnl_rule_expr *e) { - struct nft_expr_dynset *dynset = nft_expr_data(e); - struct nft_rule_expr *expr; + struct nftnl_expr_dynset *dynset = nftnl_expr_data(e); + struct nftnl_rule_expr *expr; int len = size, offset = 0, ret; ret = snprintf(buf, len, "%s reg_key %u set %s ", op2str(dynset->op), dynset->sreg_key, dynset->set_name); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - if (e->flags & (1 << NFT_EXPR_DYNSET_SREG_DATA)) { + if (e->flags & (1 << NFTNL_EXPR_DYNSET_SREG_DATA)) { ret = snprintf(buf+offset, len, "sreg_data %u ", dynset->sreg_data); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (e->flags & (1 << NFT_EXPR_DYNSET_TIMEOUT)) { + if (e->flags & (1 << NFTNL_EXPR_DYNSET_TIMEOUT)) { ret = snprintf(buf+offset, len, "timeout %"PRIu64"ms ", dynset->timeout); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (e->flags & (1 << NFT_EXPR_DYNSET_EXPR)) { + if (e->flags & (1 << NFTNL_EXPR_DYNSET_EXPR)) { expr = dynset->expr; ret = snprintf(buf+offset, len, "expr [ %s ", expr->ops->name); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - ret = nft_rule_expr_snprintf(buf+offset, len, expr, - NFT_OUTPUT_DEFAULT, - NFT_OF_EVENT_ANY); + ret = nftnl_rule_expr_snprintf(buf+offset, len, expr, + NFTNL_OUTPUT_DEFAULT, + NFTNL_OF_EVENT_ANY); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = snprintf(buf+offset, len, "] "); @@ -345,16 +345,16 @@ nft_rule_expr_dynset_snprintf_default(char *buf, size_t size, } static int -nft_rule_expr_dynset_snprintf(char *buf, size_t size, uint32_t type, - uint32_t flags, struct nft_rule_expr *e) +nftnl_rule_expr_dynset_snprintf(char *buf, size_t size, uint32_t type, + uint32_t flags, struct nftnl_rule_expr *e) { switch (type) { - case NFT_OUTPUT_DEFAULT: - return nft_rule_expr_dynset_snprintf_default(buf, size, e); - case NFT_OUTPUT_XML: - case NFT_OUTPUT_JSON: - return nft_rule_expr_dynset_export(buf, size, e, type); + case NFTNL_OUTPUT_DEFAULT: + return nftnl_rule_expr_dynset_snprintf_default(buf, size, e); + case NFTNL_OUTPUT_XML: + case NFTNL_OUTPUT_JSON: + return nftnl_rule_expr_dynset_export(buf, size, e, type); default: break; } @@ -363,13 +363,13 @@ nft_rule_expr_dynset_snprintf(char *buf, size_t size, uint32_t type, struct expr_ops expr_ops_dynset = { .name = "dynset", - .alloc_len = sizeof(struct nft_expr_dynset), + .alloc_len = sizeof(struct nftnl_expr_dynset), .max_attr = NFTA_DYNSET_MAX, - .set = nft_rule_expr_dynset_set, - .get = nft_rule_expr_dynset_get, - .parse = nft_rule_expr_dynset_parse, - .build = nft_rule_expr_dynset_build, - .snprintf = nft_rule_expr_dynset_snprintf, - .xml_parse = nft_rule_expr_dynset_xml_parse, - .json_parse = nft_rule_expr_dynset_json_parse, + .set = nftnl_rule_expr_dynset_set, + .get = nftnl_rule_expr_dynset_get, + .parse = nftnl_rule_expr_dynset_parse, + .build = nftnl_rule_expr_dynset_build, + .snprintf = nftnl_rule_expr_dynset_snprintf, + .xml_parse = nftnl_rule_expr_dynset_xml_parse, + .json_parse = nftnl_rule_expr_dynset_json_parse, }; diff --git a/src/expr/exthdr.c b/src/expr/exthdr.c index a2541b4..0187f96 100644 --- a/src/expr/exthdr.c +++ b/src/expr/exthdr.c @@ -28,7 +28,7 @@ #define IPPROTO_MH 135 #endif -struct nft_expr_exthdr { +struct nftnl_expr_exthdr { enum nft_registers dreg; uint32_t offset; uint32_t len; @@ -36,22 +36,22 @@ struct nft_expr_exthdr { }; static int -nft_rule_expr_exthdr_set(struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_exthdr_set(struct nftnl_rule_expr *e, uint16_t type, const void *data, uint32_t data_len) { - struct nft_expr_exthdr *exthdr = nft_expr_data(e); + struct nftnl_expr_exthdr *exthdr = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_EXTHDR_DREG: + case NFTNL_EXPR_EXTHDR_DREG: exthdr->dreg = *((uint32_t *)data); break; - case NFT_EXPR_EXTHDR_TYPE: + case NFTNL_EXPR_EXTHDR_TYPE: exthdr->type = *((uint8_t *)data); break; - case NFT_EXPR_EXTHDR_OFFSET: + case NFTNL_EXPR_EXTHDR_OFFSET: exthdr->offset = *((uint32_t *)data); break; - case NFT_EXPR_EXTHDR_LEN: + case NFTNL_EXPR_EXTHDR_LEN: exthdr->len = *((uint32_t *)data); break; default: @@ -61,29 +61,29 @@ nft_rule_expr_exthdr_set(struct nft_rule_expr *e, uint16_t type, } static const void * -nft_rule_expr_exthdr_get(const struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_exthdr_get(const struct nftnl_rule_expr *e, uint16_t type, uint32_t *data_len) { - struct nft_expr_exthdr *exthdr = nft_expr_data(e); + struct nftnl_expr_exthdr *exthdr = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_EXTHDR_DREG: + case NFTNL_EXPR_EXTHDR_DREG: *data_len = sizeof(exthdr->dreg); return &exthdr->dreg; - case NFT_EXPR_EXTHDR_TYPE: + case NFTNL_EXPR_EXTHDR_TYPE: *data_len = sizeof(exthdr->type); return &exthdr->type; - case NFT_EXPR_EXTHDR_OFFSET: + case NFTNL_EXPR_EXTHDR_OFFSET: *data_len = sizeof(exthdr->offset); return &exthdr->offset; - case NFT_EXPR_EXTHDR_LEN: + case NFTNL_EXPR_EXTHDR_LEN: *data_len = sizeof(exthdr->len); return &exthdr->len; } return NULL; } -static int nft_rule_expr_exthdr_cb(const struct nlattr *attr, void *data) +static int nftnl_rule_expr_exthdr_cb(const struct nlattr *attr, void *data) { const struct nlattr **tb = data; int type = mnl_attr_get_type(attr); @@ -109,44 +109,44 @@ static int nft_rule_expr_exthdr_cb(const struct nlattr *attr, void *data) } static void -nft_rule_expr_exthdr_build(struct nlmsghdr *nlh, struct nft_rule_expr *e) +nftnl_rule_expr_exthdr_build(struct nlmsghdr *nlh, struct nftnl_rule_expr *e) { - struct nft_expr_exthdr *exthdr = nft_expr_data(e); + struct nftnl_expr_exthdr *exthdr = nftnl_expr_data(e); - if (e->flags & (1 << NFT_EXPR_EXTHDR_DREG)) + if (e->flags & (1 << NFTNL_EXPR_EXTHDR_DREG)) mnl_attr_put_u32(nlh, NFTA_EXTHDR_DREG, htonl(exthdr->dreg)); - if (e->flags & (1 << NFT_EXPR_EXTHDR_TYPE)) + if (e->flags & (1 << NFTNL_EXPR_EXTHDR_TYPE)) mnl_attr_put_u8(nlh, NFTA_EXTHDR_TYPE, exthdr->type); - if (e->flags & (1 << NFT_EXPR_EXTHDR_OFFSET)) + if (e->flags & (1 << NFTNL_EXPR_EXTHDR_OFFSET)) mnl_attr_put_u32(nlh, NFTA_EXTHDR_OFFSET, htonl(exthdr->offset)); - if (e->flags & (1 << NFT_EXPR_EXTHDR_LEN)) + if (e->flags & (1 << NFTNL_EXPR_EXTHDR_LEN)) mnl_attr_put_u32(nlh, NFTA_EXTHDR_LEN, htonl(exthdr->len)); } static int -nft_rule_expr_exthdr_parse(struct nft_rule_expr *e, struct nlattr *attr) +nftnl_rule_expr_exthdr_parse(struct nftnl_rule_expr *e, struct nlattr *attr) { - struct nft_expr_exthdr *exthdr = nft_expr_data(e); + struct nftnl_expr_exthdr *exthdr = nftnl_expr_data(e); struct nlattr *tb[NFTA_EXTHDR_MAX+1] = {}; - if (mnl_attr_parse_nested(attr, nft_rule_expr_exthdr_cb, tb) < 0) + if (mnl_attr_parse_nested(attr, nftnl_rule_expr_exthdr_cb, tb) < 0) return -1; if (tb[NFTA_EXTHDR_DREG]) { exthdr->dreg = ntohl(mnl_attr_get_u32(tb[NFTA_EXTHDR_DREG])); - e->flags |= (1 << NFT_EXPR_EXTHDR_DREG); + e->flags |= (1 << NFTNL_EXPR_EXTHDR_DREG); } if (tb[NFTA_EXTHDR_TYPE]) { exthdr->type = mnl_attr_get_u8(tb[NFTA_EXTHDR_TYPE]); - e->flags |= (1 << NFT_EXPR_EXTHDR_TYPE); + e->flags |= (1 << NFTNL_EXPR_EXTHDR_TYPE); } if (tb[NFTA_EXTHDR_OFFSET]) { exthdr->offset = ntohl(mnl_attr_get_u32(tb[NFTA_EXTHDR_OFFSET])); - e->flags |= (1 << NFT_EXPR_EXTHDR_OFFSET); + e->flags |= (1 << NFTNL_EXPR_EXTHDR_OFFSET); } if (tb[NFTA_EXTHDR_LEN]) { exthdr->len = ntohl(mnl_attr_get_u32(tb[NFTA_EXTHDR_LEN])); - e->flags |= (1 << NFT_EXPR_EXTHDR_LEN); + e->flags |= (1 << NFTNL_EXPR_EXTHDR_LEN); } return 0; @@ -187,32 +187,32 @@ static inline int str2exthdr_type(const char *str) } static int -nft_rule_expr_exthdr_json_parse(struct nft_rule_expr *e, json_t *root, - struct nft_parse_err *err) +nftnl_rule_expr_exthdr_json_parse(struct nftnl_rule_expr *e, json_t *root, + struct nftnl_parse_err *err) { #ifdef JSON_PARSING const char *exthdr_type; uint32_t uval32; int type; - if (nft_jansson_parse_reg(root, "dreg", NFT_TYPE_U32, &uval32, + if (nftnl_jansson_parse_reg(root, "dreg", NFTNL_TYPE_U32, &uval32, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_EXTHDR_DREG, uval32); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_EXTHDR_DREG, uval32); - exthdr_type = nft_jansson_parse_str(root, "exthdr_type", err); + exthdr_type = nftnl_jansson_parse_str(root, "exthdr_type", err); if (exthdr_type != NULL) { type = str2exthdr_type(exthdr_type); if (type < 0) return -1; - nft_rule_expr_set_u32(e, NFT_EXPR_EXTHDR_TYPE, type); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_EXTHDR_TYPE, type); } - if (nft_jansson_parse_val(root, "offset", NFT_TYPE_U32, &uval32, + if (nftnl_jansson_parse_val(root, "offset", NFTNL_TYPE_U32, &uval32, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_EXTHDR_OFFSET, uval32); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_EXTHDR_OFFSET, uval32); - if (nft_jansson_parse_val(root, "len", NFT_TYPE_U32, &uval32, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_EXTHDR_LEN, uval32); + if (nftnl_jansson_parse_val(root, "len", NFTNL_TYPE_U32, &uval32, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_EXTHDR_LEN, uval32); return 0; #else @@ -222,36 +222,36 @@ nft_rule_expr_exthdr_json_parse(struct nft_rule_expr *e, json_t *root, } static int -nft_rule_expr_exthdr_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, - struct nft_parse_err *err) +nftnl_rule_expr_exthdr_xml_parse(struct nftnl_rule_expr *e, mxml_node_t *tree, + struct nftnl_parse_err *err) { #ifdef XML_PARSING const char *exthdr_type; int type; uint32_t dreg, len, offset; - if (nft_mxml_reg_parse(tree, "dreg", &dreg, MXML_DESCEND_FIRST, - NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_EXTHDR_DREG, dreg); + if (nftnl_mxml_reg_parse(tree, "dreg", &dreg, MXML_DESCEND_FIRST, + NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_EXTHDR_DREG, dreg); - exthdr_type = nft_mxml_str_parse(tree, "exthdr_type", - MXML_DESCEND_FIRST, NFT_XML_MAND, err); + exthdr_type = nftnl_mxml_str_parse(tree, "exthdr_type", + MXML_DESCEND_FIRST, NFTNL_XML_MAND, err); if (exthdr_type != NULL) { type = str2exthdr_type(exthdr_type); if (type < 0) return -1; - nft_rule_expr_set_u8(e, NFT_EXPR_EXTHDR_TYPE, type); + nftnl_rule_expr_set_u8(e, NFTNL_EXPR_EXTHDR_TYPE, type); } /* Get and set <offset> */ - if (nft_mxml_num_parse(tree, "offset", MXML_DESCEND_FIRST, BASE_DEC, - &offset, NFT_TYPE_U32, NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_EXTHDR_OFFSET, offset); + if (nftnl_mxml_num_parse(tree, "offset", MXML_DESCEND_FIRST, BASE_DEC, + &offset, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_EXTHDR_OFFSET, offset); /* Get and set <len> */ - if (nft_mxml_num_parse(tree, "len", MXML_DESCEND_FIRST, BASE_DEC, - &len, NFT_TYPE_U32, NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_EXTHDR_LEN, len); + if (nftnl_mxml_num_parse(tree, "len", MXML_DESCEND_FIRST, BASE_DEC, + &len, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_EXTHDR_LEN, len); return 0; #else @@ -260,28 +260,28 @@ nft_rule_expr_exthdr_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, #endif } -static int nft_rule_expr_exthdr_export(char *buf, size_t len, - struct nft_rule_expr *e, int type) +static int nftnl_rule_expr_exthdr_export(char *buf, size_t len, + struct nftnl_rule_expr *e, int type) { - struct nft_expr_exthdr *exthdr = nft_expr_data(e); - NFT_BUF_INIT(b, buf, len); - - if (e->flags & (1 << NFT_EXPR_EXTHDR_DREG)) - nft_buf_u32(&b, type, exthdr->dreg, DREG); - if (e->flags & (1 << NFT_EXPR_EXTHDR_TYPE)) - nft_buf_str(&b, type, type2str(exthdr->type), EXTHDR_TYPE); - if (e->flags & (1 << NFT_EXPR_EXTHDR_OFFSET)) - nft_buf_u32(&b, type, exthdr->offset, OFFSET); - if (e->flags & (1 << NFT_EXPR_EXTHDR_LEN)) - nft_buf_u32(&b, type, exthdr->len, LEN); - - return nft_buf_done(&b); + struct nftnl_expr_exthdr *exthdr = nftnl_expr_data(e); + NFTNL_BUF_INIT(b, buf, len); + + if (e->flags & (1 << NFTNL_EXPR_EXTHDR_DREG)) + nftnl_buf_u32(&b, type, exthdr->dreg, DREG); + if (e->flags & (1 << NFTNL_EXPR_EXTHDR_TYPE)) + nftnl_buf_str(&b, type, type2str(exthdr->type), EXTHDR_TYPE); + if (e->flags & (1 << NFTNL_EXPR_EXTHDR_OFFSET)) + nftnl_buf_u32(&b, type, exthdr->offset, OFFSET); + if (e->flags & (1 << NFTNL_EXPR_EXTHDR_LEN)) + nftnl_buf_u32(&b, type, exthdr->len, LEN); + + return nftnl_buf_done(&b); } -static int nft_rule_expr_exthdr_snprintf_default(char *buf, size_t len, - struct nft_rule_expr *e) +static int nftnl_rule_expr_exthdr_snprintf_default(char *buf, size_t len, + struct nftnl_rule_expr *e) { - struct nft_expr_exthdr *exthdr = nft_expr_data(e); + struct nftnl_expr_exthdr *exthdr = nftnl_expr_data(e); return snprintf(buf, len, "load %ub @ %u + %u => reg %u ", exthdr->len, exthdr->type, exthdr->offset, @@ -289,15 +289,15 @@ static int nft_rule_expr_exthdr_snprintf_default(char *buf, size_t len, } static int -nft_rule_expr_exthdr_snprintf(char *buf, size_t len, uint32_t type, - uint32_t flags, struct nft_rule_expr *e) +nftnl_rule_expr_exthdr_snprintf(char *buf, size_t len, uint32_t type, + uint32_t flags, struct nftnl_rule_expr *e) { switch (type) { - case NFT_OUTPUT_DEFAULT: - return nft_rule_expr_exthdr_snprintf_default(buf, len, e); - case NFT_OUTPUT_XML: - case NFT_OUTPUT_JSON: - return nft_rule_expr_exthdr_export(buf, len, e, type); + case NFTNL_OUTPUT_DEFAULT: + return nftnl_rule_expr_exthdr_snprintf_default(buf, len, e); + case NFTNL_OUTPUT_XML: + case NFTNL_OUTPUT_JSON: + return nftnl_rule_expr_exthdr_export(buf, len, e, type); default: break; } @@ -306,13 +306,13 @@ nft_rule_expr_exthdr_snprintf(char *buf, size_t len, uint32_t type, struct expr_ops expr_ops_exthdr = { .name = "exthdr", - .alloc_len = sizeof(struct nft_expr_exthdr), + .alloc_len = sizeof(struct nftnl_expr_exthdr), .max_attr = NFTA_EXTHDR_MAX, - .set = nft_rule_expr_exthdr_set, - .get = nft_rule_expr_exthdr_get, - .parse = nft_rule_expr_exthdr_parse, - .build = nft_rule_expr_exthdr_build, - .snprintf = nft_rule_expr_exthdr_snprintf, - .xml_parse = nft_rule_expr_exthdr_xml_parse, - .json_parse = nft_rule_expr_exthdr_json_parse, + .set = nftnl_rule_expr_exthdr_set, + .get = nftnl_rule_expr_exthdr_get, + .parse = nftnl_rule_expr_exthdr_parse, + .build = nftnl_rule_expr_exthdr_build, + .snprintf = nftnl_rule_expr_exthdr_snprintf, + .xml_parse = nftnl_rule_expr_exthdr_xml_parse, + .json_parse = nftnl_rule_expr_exthdr_json_parse, }; diff --git a/src/expr/immediate.c b/src/expr/immediate.c index cf06190..4f3960a 100644 --- a/src/expr/immediate.c +++ b/src/expr/immediate.c @@ -20,29 +20,29 @@ #include <libnftnl/expr.h> #include <libnftnl/rule.h> -struct nft_expr_immediate { - union nft_data_reg data; +struct nftnl_expr_immediate { + union nftnl_data_reg data; enum nft_registers dreg; }; static int -nft_rule_expr_immediate_set(struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_immediate_set(struct nftnl_rule_expr *e, uint16_t type, const void *data, uint32_t data_len) { - struct nft_expr_immediate *imm = nft_expr_data(e); + struct nftnl_expr_immediate *imm = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_IMM_DREG: + case NFTNL_EXPR_IMM_DREG: imm->dreg = *((uint32_t *)data); break; - case NFT_EXPR_IMM_DATA: + case NFTNL_EXPR_IMM_DATA: memcpy(&imm->data.val, data, data_len); imm->data.len = data_len; break; - case NFT_EXPR_IMM_VERDICT: + case NFTNL_EXPR_IMM_VERDICT: imm->data.verdict = *((uint32_t *)data); break; - case NFT_EXPR_IMM_CHAIN: + case NFTNL_EXPR_IMM_CHAIN: if (imm->data.chain) xfree(imm->data.chain); @@ -55,29 +55,29 @@ nft_rule_expr_immediate_set(struct nft_rule_expr *e, uint16_t type, } static const void * -nft_rule_expr_immediate_get(const struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_immediate_get(const struct nftnl_rule_expr *e, uint16_t type, uint32_t *data_len) { - struct nft_expr_immediate *imm = nft_expr_data(e); + struct nftnl_expr_immediate *imm = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_IMM_DREG: + case NFTNL_EXPR_IMM_DREG: *data_len = sizeof(imm->dreg); return &imm->dreg; - case NFT_EXPR_IMM_DATA: + case NFTNL_EXPR_IMM_DATA: *data_len = imm->data.len; return &imm->data.val; - case NFT_EXPR_IMM_VERDICT: + case NFTNL_EXPR_IMM_VERDICT: *data_len = sizeof(imm->data.verdict); return &imm->data.verdict; - case NFT_EXPR_IMM_CHAIN: + case NFTNL_EXPR_IMM_CHAIN: *data_len = strlen(imm->data.chain)+1; return imm->data.chain; } return NULL; } -static int nft_rule_expr_immediate_cb(const struct nlattr *attr, void *data) +static int nftnl_rule_expr_immediate_cb(const struct nlattr *attr, void *data) { const struct nlattr **tb = data; int type = mnl_attr_get_type(attr); @@ -101,28 +101,28 @@ static int nft_rule_expr_immediate_cb(const struct nlattr *attr, void *data) } static void -nft_rule_expr_immediate_build(struct nlmsghdr *nlh, struct nft_rule_expr *e) +nftnl_rule_expr_immediate_build(struct nlmsghdr *nlh, struct nftnl_rule_expr *e) { - struct nft_expr_immediate *imm = nft_expr_data(e); + struct nftnl_expr_immediate *imm = nftnl_expr_data(e); - if (e->flags & (1 << NFT_EXPR_IMM_DREG)) + if (e->flags & (1 << NFTNL_EXPR_IMM_DREG)) mnl_attr_put_u32(nlh, NFTA_IMMEDIATE_DREG, htonl(imm->dreg)); /* Sane configurations allows you to set ONLY one of these two below */ - if (e->flags & (1 << NFT_EXPR_IMM_DATA)) { + if (e->flags & (1 << NFTNL_EXPR_IMM_DATA)) { struct nlattr *nest; nest = mnl_attr_nest_start(nlh, NFTA_IMMEDIATE_DATA); mnl_attr_put(nlh, NFTA_DATA_VALUE, imm->data.len, imm->data.val); mnl_attr_nest_end(nlh, nest); - } else if (e->flags & (1 << NFT_EXPR_IMM_VERDICT)) { + } else if (e->flags & (1 << NFTNL_EXPR_IMM_VERDICT)) { struct nlattr *nest1, *nest2; nest1 = mnl_attr_nest_start(nlh, NFTA_IMMEDIATE_DATA); nest2 = mnl_attr_nest_start(nlh, NFTA_DATA_VERDICT); mnl_attr_put_u32(nlh, NFTA_VERDICT_CODE, htonl(imm->data.verdict)); - if (e->flags & (1 << NFT_EXPR_IMM_CHAIN)) + if (e->flags & (1 << NFTNL_EXPR_IMM_CHAIN)) mnl_attr_put_strz(nlh, NFTA_VERDICT_CHAIN, imm->data.chain); mnl_attr_nest_end(nlh, nest1); @@ -131,39 +131,39 @@ nft_rule_expr_immediate_build(struct nlmsghdr *nlh, struct nft_rule_expr *e) } static int -nft_rule_expr_immediate_parse(struct nft_rule_expr *e, struct nlattr *attr) +nftnl_rule_expr_immediate_parse(struct nftnl_rule_expr *e, struct nlattr *attr) { - struct nft_expr_immediate *imm = nft_expr_data(e); + struct nftnl_expr_immediate *imm = nftnl_expr_data(e); struct nlattr *tb[NFTA_IMMEDIATE_MAX+1] = {}; int ret = 0; - if (mnl_attr_parse_nested(attr, nft_rule_expr_immediate_cb, tb) < 0) + if (mnl_attr_parse_nested(attr, nftnl_rule_expr_immediate_cb, tb) < 0) return -1; if (tb[NFTA_IMMEDIATE_DREG]) { imm->dreg = ntohl(mnl_attr_get_u32(tb[NFTA_IMMEDIATE_DREG])); - e->flags |= (1 << NFT_EXPR_IMM_DREG); + e->flags |= (1 << NFTNL_EXPR_IMM_DREG); } if (tb[NFTA_IMMEDIATE_DATA]) { int type; - ret = nft_parse_data(&imm->data, tb[NFTA_IMMEDIATE_DATA], &type); + ret = nftnl_parse_data(&imm->data, tb[NFTA_IMMEDIATE_DATA], &type); if (ret < 0) return ret; switch(type) { case DATA_VALUE: /* real immediate data to be loaded to destination */ - e->flags |= (1 << NFT_EXPR_IMM_DATA); + e->flags |= (1 << NFTNL_EXPR_IMM_DATA); break; case DATA_VERDICT: - /* NF_ACCEPT, NF_DROP, NF_QUEUE and NFT_RETURN case */ - e->flags |= (1 << NFT_EXPR_IMM_VERDICT); + /* NF_ACCEPT, NF_DROP, NF_QUEUE and NFTNL_RETURN case */ + e->flags |= (1 << NFTNL_EXPR_IMM_VERDICT); break; case DATA_CHAIN: - /* NFT_GOTO and NFT_JUMP case */ - e->flags |= (1 << NFT_EXPR_IMM_VERDICT) | - (1 << NFT_EXPR_IMM_CHAIN); + /* NFTNL_GOTO and NFTNL_JUMP case */ + e->flags |= (1 << NFTNL_EXPR_IMM_VERDICT) | + (1 << NFTNL_EXPR_IMM_CHAIN); break; } } @@ -172,29 +172,29 @@ nft_rule_expr_immediate_parse(struct nft_rule_expr *e, struct nlattr *attr) } static int -nft_rule_expr_immediate_json_parse(struct nft_rule_expr *e, json_t *root, - struct nft_parse_err *err) +nftnl_rule_expr_immediate_json_parse(struct nftnl_rule_expr *e, json_t *root, + struct nftnl_parse_err *err) { #ifdef JSON_PARSING - struct nft_expr_immediate *imm = nft_expr_data(e); + struct nftnl_expr_immediate *imm = nftnl_expr_data(e); int datareg_type; uint32_t reg; - if (nft_jansson_parse_reg(root, "dreg", NFT_TYPE_U32, ®, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_IMM_DREG, reg); + if (nftnl_jansson_parse_reg(root, "dreg", NFTNL_TYPE_U32, ®, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_IMM_DREG, reg); - datareg_type = nft_jansson_data_reg_parse(root, "data", + datareg_type = nftnl_jansson_data_reg_parse(root, "data", &imm->data, err); if (datareg_type >= 0) { switch (datareg_type) { case DATA_VALUE: - e->flags |= (1 << NFT_EXPR_IMM_DATA); + e->flags |= (1 << NFTNL_EXPR_IMM_DATA); break; case DATA_VERDICT: - e->flags |= (1 << NFT_EXPR_IMM_VERDICT); + e->flags |= (1 << NFTNL_EXPR_IMM_VERDICT); break; case DATA_CHAIN: - e->flags |= (1 << NFT_EXPR_IMM_CHAIN); + e->flags |= (1 << NFTNL_EXPR_IMM_CHAIN); break; default: return -1; @@ -208,30 +208,30 @@ nft_rule_expr_immediate_json_parse(struct nft_rule_expr *e, json_t *root, } static int -nft_rule_expr_immediate_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, - struct nft_parse_err *err) +nftnl_rule_expr_immediate_xml_parse(struct nftnl_rule_expr *e, mxml_node_t *tree, + struct nftnl_parse_err *err) { #ifdef XML_PARSING - struct nft_expr_immediate *imm = nft_expr_data(e); + struct nftnl_expr_immediate *imm = nftnl_expr_data(e); int datareg_type; uint32_t reg; - if (nft_mxml_reg_parse(tree, "dreg", ®, MXML_DESCEND_FIRST, - NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_IMM_DREG, reg); + if (nftnl_mxml_reg_parse(tree, "dreg", ®, MXML_DESCEND_FIRST, + NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_IMM_DREG, reg); - datareg_type = nft_mxml_data_reg_parse(tree, "data", - &imm->data, NFT_XML_MAND, err); + datareg_type = nftnl_mxml_data_reg_parse(tree, "data", + &imm->data, NFTNL_XML_MAND, err); if (datareg_type >= 0) { switch (datareg_type) { case DATA_VALUE: - e->flags |= (1 << NFT_EXPR_IMM_DATA); + e->flags |= (1 << NFTNL_EXPR_IMM_DATA); break; case DATA_VERDICT: - e->flags |= (1 << NFT_EXPR_IMM_VERDICT); + e->flags |= (1 << NFTNL_EXPR_IMM_VERDICT); break; case DATA_CHAIN: - e->flags |= (1 << NFT_EXPR_IMM_CHAIN); + e->flags |= (1 << NFTNL_EXPR_IMM_CHAIN); break; default: return -1; @@ -246,47 +246,47 @@ nft_rule_expr_immediate_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, } static int -nft_rule_expr_immediate_export(char *buf, size_t size, struct nft_rule_expr *e, +nftnl_rule_expr_immediate_export(char *buf, size_t size, struct nftnl_rule_expr *e, int type) { - struct nft_expr_immediate *imm = nft_expr_data(e); - NFT_BUF_INIT(b, buf, size); - - if (e->flags & (1 << NFT_EXPR_IMM_DREG)) - nft_buf_u32(&b, type, imm->dreg, DREG); - if (e->flags & (1 << NFT_EXPR_IMM_DATA)) - nft_buf_reg(&b, type, &imm->data, DATA_VALUE, DATA); - if (e->flags & (1 << NFT_EXPR_IMM_VERDICT)) - nft_buf_reg(&b, type, &imm->data, DATA_VERDICT, DATA); - if (e->flags & (1 << NFT_EXPR_IMM_CHAIN)) - nft_buf_reg(&b, type, &imm->data, DATA_CHAIN, DATA); - - return nft_buf_done(&b); + struct nftnl_expr_immediate *imm = nftnl_expr_data(e); + NFTNL_BUF_INIT(b, buf, size); + + if (e->flags & (1 << NFTNL_EXPR_IMM_DREG)) + nftnl_buf_u32(&b, type, imm->dreg, DREG); + if (e->flags & (1 << NFTNL_EXPR_IMM_DATA)) + nftnl_buf_reg(&b, type, &imm->data, DATA_VALUE, DATA); + if (e->flags & (1 << NFTNL_EXPR_IMM_VERDICT)) + nftnl_buf_reg(&b, type, &imm->data, DATA_VERDICT, DATA); + if (e->flags & (1 << NFTNL_EXPR_IMM_CHAIN)) + nftnl_buf_reg(&b, type, &imm->data, DATA_CHAIN, DATA); + + return nftnl_buf_done(&b); } static int -nft_rule_expr_immediate_snprintf_default(char *buf, size_t len, - struct nft_rule_expr *e, uint32_t flags) +nftnl_rule_expr_immediate_snprintf_default(char *buf, size_t len, + struct nftnl_rule_expr *e, uint32_t flags) { int size = len, offset = 0, ret; - struct nft_expr_immediate *imm = nft_expr_data(e); + struct nftnl_expr_immediate *imm = nftnl_expr_data(e); ret = snprintf(buf, len, "reg %u ", imm->dreg); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - if (e->flags & (1 << NFT_EXPR_IMM_DATA)) { - ret = nft_data_reg_snprintf(buf+offset, len, &imm->data, - NFT_OUTPUT_DEFAULT, flags, DATA_VALUE); + if (e->flags & (1 << NFTNL_EXPR_IMM_DATA)) { + ret = nftnl_data_reg_snprintf(buf+offset, len, &imm->data, + NFTNL_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_OUTPUT_DEFAULT, flags, DATA_VERDICT); + } else if (e->flags & (1 << NFTNL_EXPR_IMM_VERDICT)) { + ret = nftnl_data_reg_snprintf(buf+offset, len, &imm->data, + NFTNL_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_OUTPUT_DEFAULT, flags, DATA_CHAIN); + } else if (e->flags & (1 << NFTNL_EXPR_IMM_CHAIN)) { + ret = nftnl_data_reg_snprintf(buf+offset, len, &imm->data, + NFTNL_OUTPUT_DEFAULT, flags, DATA_CHAIN); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } @@ -294,39 +294,39 @@ nft_rule_expr_immediate_snprintf_default(char *buf, size_t len, } static int -nft_rule_expr_immediate_snprintf(char *buf, size_t len, uint32_t type, - uint32_t flags, struct nft_rule_expr *e) +nftnl_rule_expr_immediate_snprintf(char *buf, size_t len, uint32_t type, + uint32_t flags, struct nftnl_rule_expr *e) { switch(type) { - case NFT_OUTPUT_DEFAULT: - return nft_rule_expr_immediate_snprintf_default(buf, len, e, flags); - case NFT_OUTPUT_XML: - case NFT_OUTPUT_JSON: - return nft_rule_expr_immediate_export(buf, len, e, type); + case NFTNL_OUTPUT_DEFAULT: + return nftnl_rule_expr_immediate_snprintf_default(buf, len, e, flags); + case NFTNL_OUTPUT_XML: + case NFTNL_OUTPUT_JSON: + return nftnl_rule_expr_immediate_export(buf, len, e, type); default: break; } return -1; } -static void nft_rule_expr_immediate_free(struct nft_rule_expr *e) +static void nftnl_rule_expr_immediate_free(struct nftnl_rule_expr *e) { - struct nft_expr_immediate *imm = nft_expr_data(e); + struct nftnl_expr_immediate *imm = nftnl_expr_data(e); - if (e->flags & (1 << NFT_EXPR_IMM_VERDICT)) - nft_free_verdict(&imm->data); + if (e->flags & (1 << NFTNL_EXPR_IMM_VERDICT)) + nftnl_free_verdict(&imm->data); } struct expr_ops expr_ops_immediate = { .name = "immediate", - .alloc_len = sizeof(struct nft_expr_immediate), + .alloc_len = sizeof(struct nftnl_expr_immediate), .max_attr = NFTA_IMMEDIATE_MAX, - .free = nft_rule_expr_immediate_free, - .set = nft_rule_expr_immediate_set, - .get = nft_rule_expr_immediate_get, - .parse = nft_rule_expr_immediate_parse, - .build = nft_rule_expr_immediate_build, - .snprintf = nft_rule_expr_immediate_snprintf, - .xml_parse = nft_rule_expr_immediate_xml_parse, - .json_parse = nft_rule_expr_immediate_json_parse, + .free = nftnl_rule_expr_immediate_free, + .set = nftnl_rule_expr_immediate_set, + .get = nftnl_rule_expr_immediate_get, + .parse = nftnl_rule_expr_immediate_parse, + .build = nftnl_rule_expr_immediate_build, + .snprintf = nftnl_rule_expr_immediate_snprintf, + .xml_parse = nftnl_rule_expr_immediate_xml_parse, + .json_parse = nftnl_rule_expr_immediate_json_parse, }; diff --git a/src/expr/limit.c b/src/expr/limit.c index 3ad246e..b323c5c 100644 --- a/src/expr/limit.c +++ b/src/expr/limit.c @@ -22,22 +22,22 @@ #include <libnftnl/expr.h> #include <libnftnl/rule.h> -struct nft_expr_limit { +struct nftnl_expr_limit { uint64_t rate; uint64_t unit; }; static int -nft_rule_expr_limit_set(struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_limit_set(struct nftnl_rule_expr *e, uint16_t type, const void *data, uint32_t data_len) { - struct nft_expr_limit *limit = nft_expr_data(e); + struct nftnl_expr_limit *limit = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_LIMIT_RATE: + case NFTNL_EXPR_LIMIT_RATE: limit->rate = *((uint64_t *)data); break; - case NFT_EXPR_LIMIT_UNIT: + case NFTNL_EXPR_LIMIT_UNIT: limit->unit = *((uint64_t *)data); break; default: @@ -47,23 +47,23 @@ nft_rule_expr_limit_set(struct nft_rule_expr *e, uint16_t type, } static const void * -nft_rule_expr_limit_get(const struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_limit_get(const struct nftnl_rule_expr *e, uint16_t type, uint32_t *data_len) { - struct nft_expr_limit *limit = nft_expr_data(e); + struct nftnl_expr_limit *limit = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_LIMIT_RATE: + case NFTNL_EXPR_LIMIT_RATE: *data_len = sizeof(uint64_t); return &limit->rate; - case NFT_EXPR_LIMIT_UNIT: + case NFTNL_EXPR_LIMIT_UNIT: *data_len = sizeof(uint64_t); return &limit->unit; } return NULL; } -static int nft_rule_expr_limit_cb(const struct nlattr *attr, void *data) +static int nftnl_rule_expr_limit_cb(const struct nlattr *attr, void *data) { const struct nlattr **tb = data; int type = mnl_attr_get_type(attr); @@ -84,48 +84,48 @@ static int nft_rule_expr_limit_cb(const struct nlattr *attr, void *data) } static void -nft_rule_expr_limit_build(struct nlmsghdr *nlh, struct nft_rule_expr *e) +nftnl_rule_expr_limit_build(struct nlmsghdr *nlh, struct nftnl_rule_expr *e) { - struct nft_expr_limit *limit = nft_expr_data(e); + struct nftnl_expr_limit *limit = nftnl_expr_data(e); - if (e->flags & (1 << NFT_EXPR_LIMIT_RATE)) + if (e->flags & (1 << NFTNL_EXPR_LIMIT_RATE)) mnl_attr_put_u64(nlh, NFTA_LIMIT_RATE, htobe64(limit->rate)); - if (e->flags & (1 << NFT_EXPR_LIMIT_UNIT)) + if (e->flags & (1 << NFTNL_EXPR_LIMIT_UNIT)) mnl_attr_put_u64(nlh, NFTA_LIMIT_UNIT, htobe64(limit->unit)); } static int -nft_rule_expr_limit_parse(struct nft_rule_expr *e, struct nlattr *attr) +nftnl_rule_expr_limit_parse(struct nftnl_rule_expr *e, struct nlattr *attr) { - struct nft_expr_limit *limit = nft_expr_data(e); + struct nftnl_expr_limit *limit = nftnl_expr_data(e); struct nlattr *tb[NFTA_LIMIT_MAX+1] = {}; - if (mnl_attr_parse_nested(attr, nft_rule_expr_limit_cb, tb) < 0) + if (mnl_attr_parse_nested(attr, nftnl_rule_expr_limit_cb, tb) < 0) return -1; if (tb[NFTA_LIMIT_RATE]) { limit->rate = be64toh(mnl_attr_get_u64(tb[NFTA_LIMIT_RATE])); - e->flags |= (1 << NFT_EXPR_LIMIT_RATE); + e->flags |= (1 << NFTNL_EXPR_LIMIT_RATE); } if (tb[NFTA_LIMIT_UNIT]) { limit->unit = be64toh(mnl_attr_get_u64(tb[NFTA_LIMIT_UNIT])); - e->flags |= (1 << NFT_EXPR_LIMIT_UNIT); + e->flags |= (1 << NFTNL_EXPR_LIMIT_UNIT); } return 0; } -static int nft_rule_expr_limit_json_parse(struct nft_rule_expr *e, json_t *root, - struct nft_parse_err *err) +static int nftnl_rule_expr_limit_json_parse(struct nftnl_rule_expr *e, json_t *root, + struct nftnl_parse_err *err) { #ifdef JSON_PARSING uint64_t uval64; - if (nft_jansson_parse_val(root, "rate", NFT_TYPE_U64, &uval64, err) == 0) - nft_rule_expr_set_u64(e, NFT_EXPR_LIMIT_RATE, uval64); + if (nftnl_jansson_parse_val(root, "rate", NFTNL_TYPE_U64, &uval64, err) == 0) + nftnl_rule_expr_set_u64(e, NFTNL_EXPR_LIMIT_RATE, uval64); - if (nft_jansson_parse_val(root, "unit", NFT_TYPE_U64, &uval64, err) == 0) - nft_rule_expr_set_u64(e, NFT_EXPR_LIMIT_UNIT, uval64); + if (nftnl_jansson_parse_val(root, "unit", NFTNL_TYPE_U64, &uval64, err) == 0) + nftnl_rule_expr_set_u64(e, NFTNL_EXPR_LIMIT_UNIT, uval64); return 0; #else @@ -134,20 +134,20 @@ static int nft_rule_expr_limit_json_parse(struct nft_rule_expr *e, json_t *root, #endif } -static int nft_rule_expr_limit_xml_parse(struct nft_rule_expr *e, +static int nftnl_rule_expr_limit_xml_parse(struct nftnl_rule_expr *e, mxml_node_t *tree, - struct nft_parse_err *err) + struct nftnl_parse_err *err) { #ifdef XML_PARSING uint64_t rate, unit; - if (nft_mxml_num_parse(tree, "rate", MXML_DESCEND_FIRST, BASE_DEC, - &rate, NFT_TYPE_U64, NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u64(e, NFT_EXPR_LIMIT_RATE, rate); + if (nftnl_mxml_num_parse(tree, "rate", MXML_DESCEND_FIRST, BASE_DEC, + &rate, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u64(e, NFTNL_EXPR_LIMIT_RATE, rate); - if (nft_mxml_num_parse(tree, "unit", MXML_DESCEND_FIRST, BASE_DEC, - &unit, NFT_TYPE_U64, NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u64(e, NFT_EXPR_LIMIT_UNIT, unit); + if (nftnl_mxml_num_parse(tree, "unit", MXML_DESCEND_FIRST, BASE_DEC, + &unit, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u64(e, NFTNL_EXPR_LIMIT_UNIT, unit); return 0; #else @@ -168,40 +168,40 @@ static const char *get_unit(uint64_t u) return "error"; } -static int nft_rule_expr_limit_export(char *buf, size_t size, - struct nft_rule_expr *e, int type) +static int nftnl_rule_expr_limit_export(char *buf, size_t size, + struct nftnl_rule_expr *e, int type) { - struct nft_expr_limit *limit = nft_expr_data(e); - NFT_BUF_INIT(b, buf, size); + struct nftnl_expr_limit *limit = nftnl_expr_data(e); + NFTNL_BUF_INIT(b, buf, size); - if (e->flags & (1 << NFT_EXPR_LIMIT_RATE)) - nft_buf_u64(&b, type, limit->rate, RATE); - if (e->flags & (1 << NFT_EXPR_LIMIT_UNIT)) - nft_buf_u64(&b, type, limit->unit, UNIT); + if (e->flags & (1 << NFTNL_EXPR_LIMIT_RATE)) + nftnl_buf_u64(&b, type, limit->rate, RATE); + if (e->flags & (1 << NFTNL_EXPR_LIMIT_UNIT)) + nftnl_buf_u64(&b, type, limit->unit, UNIT); - return nft_buf_done(&b); + return nftnl_buf_done(&b); } -static int nft_rule_expr_limit_snprintf_default(char *buf, size_t len, - struct nft_rule_expr *e) +static int nftnl_rule_expr_limit_snprintf_default(char *buf, size_t len, + struct nftnl_rule_expr *e) { - struct nft_expr_limit *limit = nft_expr_data(e); + struct nftnl_expr_limit *limit = nftnl_expr_data(e); return snprintf(buf, len, "rate %"PRIu64"/%s ", limit->rate, get_unit(limit->unit)); } static int -nft_rule_expr_limit_snprintf(char *buf, size_t len, uint32_t type, - uint32_t flags, struct nft_rule_expr *e) +nftnl_rule_expr_limit_snprintf(char *buf, size_t len, uint32_t type, + uint32_t flags, struct nftnl_rule_expr *e) { switch(type) { - case NFT_OUTPUT_DEFAULT: - return nft_rule_expr_limit_snprintf_default(buf, len, e); - case NFT_OUTPUT_XML: - case NFT_OUTPUT_JSON: - return nft_rule_expr_limit_export(buf, len, e, type); + case NFTNL_OUTPUT_DEFAULT: + return nftnl_rule_expr_limit_snprintf_default(buf, len, e); + case NFTNL_OUTPUT_XML: + case NFTNL_OUTPUT_JSON: + return nftnl_rule_expr_limit_export(buf, len, e, type); default: break; } @@ -210,13 +210,13 @@ nft_rule_expr_limit_snprintf(char *buf, size_t len, uint32_t type, struct expr_ops expr_ops_limit = { .name = "limit", - .alloc_len = sizeof(struct nft_expr_limit), + .alloc_len = sizeof(struct nftnl_expr_limit), .max_attr = NFTA_LIMIT_MAX, - .set = nft_rule_expr_limit_set, - .get = nft_rule_expr_limit_get, - .parse = nft_rule_expr_limit_parse, - .build = nft_rule_expr_limit_build, - .snprintf = nft_rule_expr_limit_snprintf, - .xml_parse = nft_rule_expr_limit_xml_parse, - .json_parse = nft_rule_expr_limit_json_parse, + .set = nftnl_rule_expr_limit_set, + .get = nftnl_rule_expr_limit_get, + .parse = nftnl_rule_expr_limit_parse, + .build = nftnl_rule_expr_limit_build, + .snprintf = nftnl_rule_expr_limit_snprintf, + .xml_parse = nftnl_rule_expr_limit_xml_parse, + .json_parse = nftnl_rule_expr_limit_json_parse, }; diff --git a/src/expr/log.c b/src/expr/log.c index 19bef56..2f1f705 100644 --- a/src/expr/log.c +++ b/src/expr/log.c @@ -21,7 +21,7 @@ #include <libnftnl/expr.h> #include <libnftnl/rule.h> -struct nft_expr_log { +struct nftnl_expr_log { uint32_t snaplen; uint16_t group; uint16_t qthreshold; @@ -30,31 +30,31 @@ struct nft_expr_log { const char *prefix; }; -static int nft_rule_expr_log_set(struct nft_rule_expr *e, uint16_t type, +static int nftnl_rule_expr_log_set(struct nftnl_rule_expr *e, uint16_t type, const void *data, uint32_t data_len) { - struct nft_expr_log *log = nft_expr_data(e); + struct nftnl_expr_log *log = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_LOG_PREFIX: + case NFTNL_EXPR_LOG_PREFIX: if (log->prefix) xfree(log->prefix); log->prefix = strdup(data); break; - case NFT_EXPR_LOG_GROUP: + case NFTNL_EXPR_LOG_GROUP: log->group = *((uint16_t *)data); break; - case NFT_EXPR_LOG_SNAPLEN: + case NFTNL_EXPR_LOG_SNAPLEN: log->snaplen = *((uint32_t *)data); break; - case NFT_EXPR_LOG_QTHRESHOLD: + case NFTNL_EXPR_LOG_QTHRESHOLD: log->qthreshold = *((uint16_t *)data); break; - case NFT_EXPR_LOG_LEVEL: + case NFTNL_EXPR_LOG_LEVEL: log->level = *((uint32_t *)data); break; - case NFT_EXPR_LOG_FLAGS: + case NFTNL_EXPR_LOG_FLAGS: log->flags = *((uint32_t *)data); break; default: @@ -64,35 +64,35 @@ static int nft_rule_expr_log_set(struct nft_rule_expr *e, uint16_t type, } static const void * -nft_rule_expr_log_get(const struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_log_get(const struct nftnl_rule_expr *e, uint16_t type, uint32_t *data_len) { - struct nft_expr_log *log = nft_expr_data(e); + struct nftnl_expr_log *log = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_LOG_PREFIX: + case NFTNL_EXPR_LOG_PREFIX: *data_len = strlen(log->prefix)+1; return log->prefix; - case NFT_EXPR_LOG_GROUP: + case NFTNL_EXPR_LOG_GROUP: *data_len = sizeof(log->group); return &log->group; - case NFT_EXPR_LOG_SNAPLEN: + case NFTNL_EXPR_LOG_SNAPLEN: *data_len = sizeof(log->snaplen); return &log->snaplen; - case NFT_EXPR_LOG_QTHRESHOLD: + case NFTNL_EXPR_LOG_QTHRESHOLD: *data_len = sizeof(log->qthreshold); return &log->qthreshold; - case NFT_EXPR_LOG_LEVEL: + case NFTNL_EXPR_LOG_LEVEL: *data_len = sizeof(log->level); return &log->level; - case NFT_EXPR_LOG_FLAGS: + case NFTNL_EXPR_LOG_FLAGS: *data_len = sizeof(log->flags); return &log->flags; } return NULL; } -static int nft_rule_expr_log_cb(const struct nlattr *attr, void *data) +static int nftnl_rule_expr_log_cb(const struct nlattr *attr, void *data) { const struct nlattr **tb = data; int type = mnl_attr_get_type(attr); @@ -123,31 +123,31 @@ static int nft_rule_expr_log_cb(const struct nlattr *attr, void *data) } static void -nft_rule_expr_log_build(struct nlmsghdr *nlh, struct nft_rule_expr *e) +nftnl_rule_expr_log_build(struct nlmsghdr *nlh, struct nftnl_rule_expr *e) { - struct nft_expr_log *log = nft_expr_data(e); + struct nftnl_expr_log *log = nftnl_expr_data(e); - if (e->flags & (1 << NFT_EXPR_LOG_PREFIX)) + if (e->flags & (1 << NFTNL_EXPR_LOG_PREFIX)) mnl_attr_put_strz(nlh, NFTA_LOG_PREFIX, log->prefix); - if (e->flags & (1 << NFT_EXPR_LOG_GROUP)) + if (e->flags & (1 << NFTNL_EXPR_LOG_GROUP)) mnl_attr_put_u16(nlh, NFTA_LOG_GROUP, htons(log->group)); - if (e->flags & (1 << NFT_EXPR_LOG_SNAPLEN)) + if (e->flags & (1 << NFTNL_EXPR_LOG_SNAPLEN)) mnl_attr_put_u32(nlh, NFTA_LOG_SNAPLEN, htonl(log->snaplen)); - if (e->flags & (1 << NFT_EXPR_LOG_QTHRESHOLD)) + if (e->flags & (1 << NFTNL_EXPR_LOG_QTHRESHOLD)) mnl_attr_put_u16(nlh, NFTA_LOG_QTHRESHOLD, htons(log->qthreshold)); - if (e->flags & (1 << NFT_EXPR_LOG_LEVEL)) + if (e->flags & (1 << NFTNL_EXPR_LOG_LEVEL)) mnl_attr_put_u32(nlh, NFTA_LOG_LEVEL, htonl(log->level)); - if (e->flags & (1 << NFT_EXPR_LOG_FLAGS)) + if (e->flags & (1 << NFTNL_EXPR_LOG_FLAGS)) mnl_attr_put_u32(nlh, NFTA_LOG_FLAGS, htonl(log->flags)); } static int -nft_rule_expr_log_parse(struct nft_rule_expr *e, struct nlattr *attr) +nftnl_rule_expr_log_parse(struct nftnl_rule_expr *e, struct nlattr *attr) { - struct nft_expr_log *log = nft_expr_data(e); + struct nftnl_expr_log *log = nftnl_expr_data(e); struct nlattr *tb[NFTA_LOG_MAX+1] = {}; - if (mnl_attr_parse_nested(attr, nft_rule_expr_log_cb, tb) < 0) + if (mnl_attr_parse_nested(attr, nftnl_rule_expr_log_cb, tb) < 0) return -1; if (tb[NFTA_LOG_PREFIX]) { @@ -155,63 +155,63 @@ nft_rule_expr_log_parse(struct nft_rule_expr *e, struct nlattr *attr) xfree(log->prefix); log->prefix = strdup(mnl_attr_get_str(tb[NFTA_LOG_PREFIX])); - e->flags |= (1 << NFT_EXPR_LOG_PREFIX); + e->flags |= (1 << NFTNL_EXPR_LOG_PREFIX); } if (tb[NFTA_LOG_GROUP]) { log->group = ntohs(mnl_attr_get_u16(tb[NFTA_LOG_GROUP])); - e->flags |= (1 << NFT_EXPR_LOG_GROUP); + e->flags |= (1 << NFTNL_EXPR_LOG_GROUP); } if (tb[NFTA_LOG_SNAPLEN]) { log->snaplen = ntohl(mnl_attr_get_u32(tb[NFTA_LOG_SNAPLEN])); - e->flags |= (1 << NFT_EXPR_LOG_SNAPLEN); + e->flags |= (1 << NFTNL_EXPR_LOG_SNAPLEN); } if (tb[NFTA_LOG_QTHRESHOLD]) { log->qthreshold = ntohs(mnl_attr_get_u16(tb[NFTA_LOG_QTHRESHOLD])); - e->flags |= (1 << NFT_EXPR_LOG_QTHRESHOLD); + e->flags |= (1 << NFTNL_EXPR_LOG_QTHRESHOLD); } if (tb[NFTA_LOG_LEVEL]) { log->level = ntohl(mnl_attr_get_u32(tb[NFTA_LOG_LEVEL])); - e->flags |= (1 << NFT_EXPR_LOG_LEVEL); + e->flags |= (1 << NFTNL_EXPR_LOG_LEVEL); } if (tb[NFTA_LOG_FLAGS]) { log->flags = ntohl(mnl_attr_get_u32(tb[NFTA_LOG_FLAGS])); - e->flags |= (1 << NFT_EXPR_LOG_FLAGS); + e->flags |= (1 << NFTNL_EXPR_LOG_FLAGS); } return 0; } -static int nft_rule_expr_log_json_parse(struct nft_rule_expr *e, json_t *root, - struct nft_parse_err *err) +static int nftnl_rule_expr_log_json_parse(struct nftnl_rule_expr *e, json_t *root, + struct nftnl_parse_err *err) { #ifdef JSON_PARSING const char *prefix; uint32_t snaplen, level, flags; uint16_t group, qthreshold; - prefix = nft_jansson_parse_str(root, "prefix", err); + prefix = nftnl_jansson_parse_str(root, "prefix", err); if (prefix != NULL) - nft_rule_expr_set_str(e, NFT_EXPR_LOG_PREFIX, prefix); + nftnl_rule_expr_set_str(e, NFTNL_EXPR_LOG_PREFIX, prefix); - if (nft_jansson_parse_val(root, "group", NFT_TYPE_U16, &group, + if (nftnl_jansson_parse_val(root, "group", NFTNL_TYPE_U16, &group, err) == 0) - nft_rule_expr_set_u16(e, NFT_EXPR_LOG_GROUP, group); + nftnl_rule_expr_set_u16(e, NFTNL_EXPR_LOG_GROUP, group); - if (nft_jansson_parse_val(root, "snaplen", NFT_TYPE_U32, &snaplen, + if (nftnl_jansson_parse_val(root, "snaplen", NFTNL_TYPE_U32, &snaplen, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_LOG_SNAPLEN, snaplen); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_LOG_SNAPLEN, snaplen); - if (nft_jansson_parse_val(root, "qthreshold", NFT_TYPE_U16, + if (nftnl_jansson_parse_val(root, "qthreshold", NFTNL_TYPE_U16, &qthreshold, err) == 0) - nft_rule_expr_set_u16(e, NFT_EXPR_LOG_QTHRESHOLD, qthreshold); + nftnl_rule_expr_set_u16(e, NFTNL_EXPR_LOG_QTHRESHOLD, qthreshold); - if (nft_jansson_parse_val(root, "level", NFT_TYPE_U32, &level, + if (nftnl_jansson_parse_val(root, "level", NFTNL_TYPE_U32, &level, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_LOG_LEVEL, level); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_LOG_LEVEL, level); - if (nft_jansson_parse_val(root, "flags", NFT_TYPE_U32, &flags, + if (nftnl_jansson_parse_val(root, "flags", NFTNL_TYPE_U32, &flags, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_LOG_FLAGS, flags); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_LOG_FLAGS, flags); return 0; #else @@ -220,42 +220,42 @@ static int nft_rule_expr_log_json_parse(struct nft_rule_expr *e, json_t *root, #endif } -static int nft_rule_expr_log_xml_parse(struct nft_rule_expr *e, +static int nftnl_rule_expr_log_xml_parse(struct nftnl_rule_expr *e, mxml_node_t *tree, - struct nft_parse_err *err) + struct nftnl_parse_err *err) { #ifdef XML_PARSING const char *prefix; uint32_t snaplen, level, flags; uint16_t group, qthreshold; - prefix = nft_mxml_str_parse(tree, "prefix", MXML_DESCEND_FIRST, - NFT_XML_MAND, err); + prefix = nftnl_mxml_str_parse(tree, "prefix", MXML_DESCEND_FIRST, + NFTNL_XML_MAND, err); if (prefix != NULL) - nft_rule_expr_set_str(e, NFT_EXPR_LOG_PREFIX, prefix); + nftnl_rule_expr_set_str(e, NFTNL_EXPR_LOG_PREFIX, prefix); - if (nft_mxml_num_parse(tree, "group", MXML_DESCEND_FIRST, BASE_DEC, - &group, NFT_TYPE_U16, NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u16(e, NFT_EXPR_LOG_GROUP, group); + if (nftnl_mxml_num_parse(tree, "group", MXML_DESCEND_FIRST, BASE_DEC, + &group, NFTNL_TYPE_U16, NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u16(e, NFTNL_EXPR_LOG_GROUP, group); - if (nft_mxml_num_parse(tree, "snaplen", MXML_DESCEND_FIRST, BASE_DEC, - &snaplen, NFT_TYPE_U32, NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_LOG_SNAPLEN, snaplen); + if (nftnl_mxml_num_parse(tree, "snaplen", MXML_DESCEND_FIRST, BASE_DEC, + &snaplen, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_LOG_SNAPLEN, snaplen); - if (nft_mxml_num_parse(tree, "qthreshold", MXML_DESCEND_FIRST, BASE_DEC, - &qthreshold, NFT_TYPE_U16, NFT_XML_MAND, + if (nftnl_mxml_num_parse(tree, "qthreshold", MXML_DESCEND_FIRST, BASE_DEC, + &qthreshold, NFTNL_TYPE_U16, NFTNL_XML_MAND, err) == 0) - nft_rule_expr_set_u16(e, NFT_EXPR_LOG_QTHRESHOLD, qthreshold); + nftnl_rule_expr_set_u16(e, NFTNL_EXPR_LOG_QTHRESHOLD, qthreshold); - if (nft_mxml_num_parse(tree, "level", MXML_DESCEND_FIRST, BASE_DEC, - &level, NFT_TYPE_U16, NFT_XML_MAND, + if (nftnl_mxml_num_parse(tree, "level", MXML_DESCEND_FIRST, BASE_DEC, + &level, NFTNL_TYPE_U16, NFTNL_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_LOG_LEVEL, level); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_LOG_LEVEL, level); - if (nft_mxml_num_parse(tree, "flags", MXML_DESCEND_FIRST, BASE_DEC, - &flags, NFT_TYPE_U16, NFT_XML_MAND, + if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND_FIRST, BASE_DEC, + &flags, NFTNL_TYPE_U16, NFTNL_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_LOG_FLAGS, flags); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_LOG_FLAGS, flags); return 0; #else @@ -264,21 +264,21 @@ static int nft_rule_expr_log_xml_parse(struct nft_rule_expr *e, #endif } -static int nft_rule_expr_log_snprintf_default(char *buf, size_t size, - struct nft_rule_expr *e) +static int nftnl_rule_expr_log_snprintf_default(char *buf, size_t size, + struct nftnl_rule_expr *e) { - struct nft_expr_log *log = nft_expr_data(e); + struct nftnl_expr_log *log = nftnl_expr_data(e); int ret, offset = 0, len = size; ret = snprintf(buf, len, "prefix %s ", log->prefix); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - if (e->flags & (1 << NFT_EXPR_LOG_GROUP)) { + if (e->flags & (1 << NFTNL_EXPR_LOG_GROUP)) { ret = snprintf(buf + offset, len, "group %u snaplen %u qthreshold %u", log->group, log->snaplen, log->qthreshold); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - } else if (e->flags & (1 << NFT_EXPR_LOG_LEVEL)) { + } else if (e->flags & (1 << NFTNL_EXPR_LOG_LEVEL)) { ret = snprintf(buf + offset, len, "level %u flags %u", log->level, log->flags); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); @@ -287,61 +287,61 @@ static int nft_rule_expr_log_snprintf_default(char *buf, size_t size, return offset; } -static int nft_rule_expr_log_export(char *buf, size_t size, - struct nft_rule_expr *e, int type) +static int nftnl_rule_expr_log_export(char *buf, size_t size, + struct nftnl_rule_expr *e, int type) { - struct nft_expr_log *log = nft_expr_data(e); - NFT_BUF_INIT(b, buf, size); - - if (e->flags & (1 << NFT_EXPR_LOG_PREFIX)) - nft_buf_str(&b, type, log->prefix, PREFIX); - if (e->flags & (1 << NFT_EXPR_LOG_GROUP)) - nft_buf_u32(&b, type, log->group, GROUP); - if (e->flags & (1 << NFT_EXPR_LOG_SNAPLEN)) - nft_buf_u32(&b, type, log->snaplen, SNAPLEN); - if (e->flags & (1 << NFT_EXPR_LOG_QTHRESHOLD)) - nft_buf_u32(&b, type, log->qthreshold, QTHRESH); - if (e->flags & (1 << NFT_EXPR_LOG_LEVEL)) - nft_buf_u32(&b, type, log->level, LEVEL); - if (e->flags & (1 << NFT_EXPR_LOG_FLAGS)) - nft_buf_u32(&b, type, log->level, FLAGS); - - return nft_buf_done(&b); + struct nftnl_expr_log *log = nftnl_expr_data(e); + NFTNL_BUF_INIT(b, buf, size); + + if (e->flags & (1 << NFTNL_EXPR_LOG_PREFIX)) + nftnl_buf_str(&b, type, log->prefix, PREFIX); + if (e->flags & (1 << NFTNL_EXPR_LOG_GROUP)) + nftnl_buf_u32(&b, type, log->group, GROUP); + if (e->flags & (1 << NFTNL_EXPR_LOG_SNAPLEN)) + nftnl_buf_u32(&b, type, log->snaplen, SNAPLEN); + if (e->flags & (1 << NFTNL_EXPR_LOG_QTHRESHOLD)) + nftnl_buf_u32(&b, type, log->qthreshold, QTHRESH); + if (e->flags & (1 << NFTNL_EXPR_LOG_LEVEL)) + nftnl_buf_u32(&b, type, log->level, LEVEL); + if (e->flags & (1 << NFTNL_EXPR_LOG_FLAGS)) + nftnl_buf_u32(&b, type, log->level, FLAGS); + + return nftnl_buf_done(&b); } static int -nft_rule_expr_log_snprintf(char *buf, size_t len, uint32_t type, - uint32_t flags, struct nft_rule_expr *e) +nftnl_rule_expr_log_snprintf(char *buf, size_t len, uint32_t type, + uint32_t flags, struct nftnl_rule_expr *e) { switch(type) { - case NFT_OUTPUT_DEFAULT: - return nft_rule_expr_log_snprintf_default(buf, len, e); - case NFT_OUTPUT_XML: - case NFT_OUTPUT_JSON: - return nft_rule_expr_log_export(buf, len, e, type); + case NFTNL_OUTPUT_DEFAULT: + return nftnl_rule_expr_log_snprintf_default(buf, len, e); + case NFTNL_OUTPUT_XML: + case NFTNL_OUTPUT_JSON: + return nftnl_rule_expr_log_export(buf, len, e, type); default: break; } return -1; } -static void nft_rule_expr_log_free(struct nft_rule_expr *e) +static void nftnl_rule_expr_log_free(struct nftnl_rule_expr *e) { - struct nft_expr_log *log = nft_expr_data(e); + struct nftnl_expr_log *log = nftnl_expr_data(e); xfree(log->prefix); } struct expr_ops expr_ops_log = { .name = "log", - .alloc_len = sizeof(struct nft_expr_log), + .alloc_len = sizeof(struct nftnl_expr_log), .max_attr = NFTA_LOG_MAX, - .free = nft_rule_expr_log_free, - .set = nft_rule_expr_log_set, - .get = nft_rule_expr_log_get, - .parse = nft_rule_expr_log_parse, - .build = nft_rule_expr_log_build, - .snprintf = nft_rule_expr_log_snprintf, - .xml_parse = nft_rule_expr_log_xml_parse, - .json_parse = nft_rule_expr_log_json_parse, + .free = nftnl_rule_expr_log_free, + .set = nftnl_rule_expr_log_set, + .get = nftnl_rule_expr_log_get, + .parse = nftnl_rule_expr_log_parse, + .build = nftnl_rule_expr_log_build, + .snprintf = nftnl_rule_expr_log_snprintf, + .xml_parse = nftnl_rule_expr_log_xml_parse, + .json_parse = nftnl_rule_expr_log_json_parse, }; diff --git a/src/expr/lookup.c b/src/expr/lookup.c index b2f0aa4..98ac1ad 100644 --- a/src/expr/lookup.c +++ b/src/expr/lookup.c @@ -25,7 +25,7 @@ #define IFNAMSIZ 16 #endif -struct nft_expr_lookup { +struct nftnl_expr_lookup { enum nft_registers sreg; enum nft_registers dreg; char set_name[IFNAMSIZ]; @@ -33,23 +33,23 @@ struct nft_expr_lookup { }; static int -nft_rule_expr_lookup_set(struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_lookup_set(struct nftnl_rule_expr *e, uint16_t type, const void *data, uint32_t data_len) { - struct nft_expr_lookup *lookup = nft_expr_data(e); + struct nftnl_expr_lookup *lookup = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_LOOKUP_SREG: + case NFTNL_EXPR_LOOKUP_SREG: lookup->sreg = *((uint32_t *)data); break; - case NFT_EXPR_LOOKUP_DREG: + case NFTNL_EXPR_LOOKUP_DREG: lookup->dreg = *((uint32_t *)data); break; - case NFT_EXPR_LOOKUP_SET: + case NFTNL_EXPR_LOOKUP_SET: snprintf(lookup->set_name, sizeof(lookup->set_name), "%s", (const char *)data); break; - case NFT_EXPR_LOOKUP_SET_ID: + case NFTNL_EXPR_LOOKUP_SET_ID: lookup->set_id = *((uint32_t *)data); break; default: @@ -59,27 +59,27 @@ nft_rule_expr_lookup_set(struct nft_rule_expr *e, uint16_t type, } static const void * -nft_rule_expr_lookup_get(const struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_lookup_get(const struct nftnl_rule_expr *e, uint16_t type, uint32_t *data_len) { - struct nft_expr_lookup *lookup = nft_expr_data(e); + struct nftnl_expr_lookup *lookup = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_LOOKUP_SREG: + case NFTNL_EXPR_LOOKUP_SREG: *data_len = sizeof(lookup->sreg); return &lookup->sreg; - case NFT_EXPR_LOOKUP_DREG: + case NFTNL_EXPR_LOOKUP_DREG: *data_len = sizeof(lookup->dreg); return &lookup->dreg; - case NFT_EXPR_LOOKUP_SET: + case NFTNL_EXPR_LOOKUP_SET: return lookup->set_name; - case NFT_EXPR_LOOKUP_SET_ID: + case NFTNL_EXPR_LOOKUP_SET_ID: return &lookup->set_id; } return NULL; } -static int nft_rule_expr_lookup_cb(const struct nlattr *attr, void *data) +static int nftnl_rule_expr_lookup_cb(const struct nlattr *attr, void *data) { const struct nlattr **tb = data; int type = mnl_attr_get_type(attr); @@ -105,70 +105,70 @@ static int nft_rule_expr_lookup_cb(const struct nlattr *attr, void *data) } static void -nft_rule_expr_lookup_build(struct nlmsghdr *nlh, struct nft_rule_expr *e) +nftnl_rule_expr_lookup_build(struct nlmsghdr *nlh, struct nftnl_rule_expr *e) { - struct nft_expr_lookup *lookup = nft_expr_data(e); + struct nftnl_expr_lookup *lookup = nftnl_expr_data(e); - if (e->flags & (1 << NFT_EXPR_LOOKUP_SREG)) + if (e->flags & (1 << NFTNL_EXPR_LOOKUP_SREG)) mnl_attr_put_u32(nlh, NFTA_LOOKUP_SREG, htonl(lookup->sreg)); - if (e->flags & (1 << NFT_EXPR_LOOKUP_DREG)) + if (e->flags & (1 << NFTNL_EXPR_LOOKUP_DREG)) mnl_attr_put_u32(nlh, NFTA_LOOKUP_DREG, htonl(lookup->dreg)); - if (e->flags & (1 << NFT_EXPR_LOOKUP_SET)) + if (e->flags & (1 << NFTNL_EXPR_LOOKUP_SET)) mnl_attr_put_strz(nlh, NFTA_LOOKUP_SET, lookup->set_name); - if (e->flags & (1 << NFT_EXPR_LOOKUP_SET_ID)) { + if (e->flags & (1 << NFTNL_EXPR_LOOKUP_SET_ID)) { mnl_attr_put_u32(nlh, NFTA_LOOKUP_SET_ID, htonl(lookup->set_id)); } } static int -nft_rule_expr_lookup_parse(struct nft_rule_expr *e, struct nlattr *attr) +nftnl_rule_expr_lookup_parse(struct nftnl_rule_expr *e, struct nlattr *attr) { - struct nft_expr_lookup *lookup = nft_expr_data(e); + struct nftnl_expr_lookup *lookup = nftnl_expr_data(e); struct nlattr *tb[NFTA_LOOKUP_MAX+1] = {}; int ret = 0; - if (mnl_attr_parse_nested(attr, nft_rule_expr_lookup_cb, tb) < 0) + if (mnl_attr_parse_nested(attr, nftnl_rule_expr_lookup_cb, tb) < 0) return -1; if (tb[NFTA_LOOKUP_SREG]) { lookup->sreg = ntohl(mnl_attr_get_u32(tb[NFTA_LOOKUP_SREG])); - e->flags |= (1 << NFT_EXPR_LOOKUP_SREG); + e->flags |= (1 << NFTNL_EXPR_LOOKUP_SREG); } if (tb[NFTA_LOOKUP_DREG]) { lookup->dreg = ntohl(mnl_attr_get_u32(tb[NFTA_LOOKUP_DREG])); - e->flags |= (1 << NFT_EXPR_LOOKUP_DREG); + e->flags |= (1 << NFTNL_EXPR_LOOKUP_DREG); } if (tb[NFTA_LOOKUP_SET]) { strcpy(lookup->set_name, mnl_attr_get_str(tb[NFTA_LOOKUP_SET])); - e->flags |= (1 << NFT_EXPR_LOOKUP_SET); + e->flags |= (1 << NFTNL_EXPR_LOOKUP_SET); } if (tb[NFTA_LOOKUP_SET_ID]) { lookup->set_id = ntohl(mnl_attr_get_u32(tb[NFTA_LOOKUP_SET_ID])); - e->flags |= (1 << NFT_EXPR_LOOKUP_SET_ID); + e->flags |= (1 << NFTNL_EXPR_LOOKUP_SET_ID); } return ret; } static int -nft_rule_expr_lookup_json_parse(struct nft_rule_expr *e, json_t *root, - struct nft_parse_err *err) +nftnl_rule_expr_lookup_json_parse(struct nftnl_rule_expr *e, json_t *root, + struct nftnl_parse_err *err) { #ifdef JSON_PARSING const char *set_name; uint32_t sreg, dreg; - set_name = nft_jansson_parse_str(root, "set", err); + set_name = nftnl_jansson_parse_str(root, "set", err); if (set_name != NULL) - nft_rule_expr_set_str(e, NFT_EXPR_LOOKUP_SET, set_name); + nftnl_rule_expr_set_str(e, NFTNL_EXPR_LOOKUP_SET, set_name); - if (nft_jansson_parse_reg(root, "sreg", NFT_TYPE_U32, &sreg, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_LOOKUP_SREG, sreg); + if (nftnl_jansson_parse_reg(root, "sreg", NFTNL_TYPE_U32, &sreg, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_LOOKUP_SREG, sreg); - if (nft_jansson_parse_reg(root, "dreg", NFT_TYPE_U32, &dreg, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_LOOKUP_DREG, dreg); + if (nftnl_jansson_parse_reg(root, "dreg", NFTNL_TYPE_U32, &dreg, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_LOOKUP_DREG, dreg); return 0; #else @@ -178,25 +178,25 @@ nft_rule_expr_lookup_json_parse(struct nft_rule_expr *e, json_t *root, } static int -nft_rule_expr_lookup_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, - struct nft_parse_err *err) +nftnl_rule_expr_lookup_xml_parse(struct nftnl_rule_expr *e, mxml_node_t *tree, + struct nftnl_parse_err *err) { #ifdef XML_PARSING const char *set_name; uint32_t sreg, dreg; - set_name = nft_mxml_str_parse(tree, "set", MXML_DESCEND_FIRST, - NFT_XML_MAND, err); + set_name = nftnl_mxml_str_parse(tree, "set", MXML_DESCEND_FIRST, + NFTNL_XML_MAND, err); if (set_name != NULL) - nft_rule_expr_set_str(e, NFT_EXPR_LOOKUP_SET, set_name); + nftnl_rule_expr_set_str(e, NFTNL_EXPR_LOOKUP_SET, set_name); - if (nft_mxml_reg_parse(tree, "sreg", &sreg, MXML_DESCEND, NFT_XML_MAND, + if (nftnl_mxml_reg_parse(tree, "sreg", &sreg, MXML_DESCEND, NFTNL_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_LOOKUP_SREG, sreg); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_LOOKUP_SREG, sreg); - if (nft_mxml_reg_parse(tree, "dreg", &dreg, MXML_DESCEND, NFT_XML_OPT, + if (nftnl_mxml_reg_parse(tree, "dreg", &dreg, MXML_DESCEND, NFTNL_XML_OPT, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_LOOKUP_DREG, dreg); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_LOOKUP_DREG, dreg); return 0; #else @@ -206,34 +206,34 @@ nft_rule_expr_lookup_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, } static int -nft_rule_expr_lookup_export(char *buf, size_t size, - struct nft_rule_expr *e, int type) +nftnl_rule_expr_lookup_export(char *buf, size_t size, + struct nftnl_rule_expr *e, int type) { - struct nft_expr_lookup *l = nft_expr_data(e); - NFT_BUF_INIT(b, buf, size); + struct nftnl_expr_lookup *l = nftnl_expr_data(e); + NFTNL_BUF_INIT(b, buf, size); - if (e->flags & (1 << NFT_EXPR_LOOKUP_SET)) - nft_buf_str(&b, type, l->set_name, SET); - if (e->flags & (1 << NFT_EXPR_LOOKUP_SREG)) - nft_buf_u32(&b, type, l->sreg, SREG); - if (e->flags & (1 << NFT_EXPR_LOOKUP_DREG)) - nft_buf_u32(&b, type, l->dreg, DREG); + if (e->flags & (1 << NFTNL_EXPR_LOOKUP_SET)) + nftnl_buf_str(&b, type, l->set_name, SET); + if (e->flags & (1 << NFTNL_EXPR_LOOKUP_SREG)) + nftnl_buf_u32(&b, type, l->sreg, SREG); + if (e->flags & (1 << NFTNL_EXPR_LOOKUP_DREG)) + nftnl_buf_u32(&b, type, l->dreg, DREG); - return nft_buf_done(&b); + return nftnl_buf_done(&b); } static int -nft_rule_expr_lookup_snprintf_default(char *buf, size_t size, - struct nft_rule_expr *e) +nftnl_rule_expr_lookup_snprintf_default(char *buf, size_t size, + struct nftnl_rule_expr *e) { int len = size, offset = 0, ret; - struct nft_expr_lookup *l = nft_expr_data(e); + struct nftnl_expr_lookup *l = nftnl_expr_data(e); ret = snprintf(buf, len, "reg %u set %s ", l->sreg, l->set_name); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - if (e->flags & (1 << NFT_EXPR_LOOKUP_DREG)) { + if (e->flags & (1 << NFTNL_EXPR_LOOKUP_DREG)) { ret = snprintf(buf+offset, len, "dreg %u ", l->dreg); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } @@ -242,16 +242,16 @@ nft_rule_expr_lookup_snprintf_default(char *buf, size_t size, } static int -nft_rule_expr_lookup_snprintf(char *buf, size_t size, uint32_t type, - uint32_t flags, struct nft_rule_expr *e) +nftnl_rule_expr_lookup_snprintf(char *buf, size_t size, uint32_t type, + uint32_t flags, struct nftnl_rule_expr *e) { switch(type) { - case NFT_OUTPUT_DEFAULT: - return nft_rule_expr_lookup_snprintf_default(buf, size, e); - case NFT_OUTPUT_XML: - case NFT_OUTPUT_JSON: - return nft_rule_expr_lookup_export(buf, size, e, type); + case NFTNL_OUTPUT_DEFAULT: + return nftnl_rule_expr_lookup_snprintf_default(buf, size, e); + case NFTNL_OUTPUT_XML: + case NFTNL_OUTPUT_JSON: + return nftnl_rule_expr_lookup_export(buf, size, e, type); default: break; } @@ -260,13 +260,13 @@ nft_rule_expr_lookup_snprintf(char *buf, size_t size, uint32_t type, struct expr_ops expr_ops_lookup = { .name = "lookup", - .alloc_len = sizeof(struct nft_expr_lookup), + .alloc_len = sizeof(struct nftnl_expr_lookup), .max_attr = NFTA_LOOKUP_MAX, - .set = nft_rule_expr_lookup_set, - .get = nft_rule_expr_lookup_get, - .parse = nft_rule_expr_lookup_parse, - .build = nft_rule_expr_lookup_build, - .snprintf = nft_rule_expr_lookup_snprintf, - .xml_parse = nft_rule_expr_lookup_xml_parse, - .json_parse = nft_rule_expr_lookup_json_parse, + .set = nftnl_rule_expr_lookup_set, + .get = nftnl_rule_expr_lookup_get, + .parse = nftnl_rule_expr_lookup_parse, + .build = nftnl_rule_expr_lookup_build, + .snprintf = nftnl_rule_expr_lookup_snprintf, + .xml_parse = nftnl_rule_expr_lookup_xml_parse, + .json_parse = nftnl_rule_expr_lookup_json_parse, }; diff --git a/src/expr/masq.c b/src/expr/masq.c index e25587f..ee49151 100644 --- a/src/expr/masq.c +++ b/src/expr/masq.c @@ -20,18 +20,18 @@ #include <libnftnl/expr.h> #include <libnftnl/rule.h> -struct nft_expr_masq { +struct nftnl_expr_masq { uint32_t flags; }; static int -nft_rule_expr_masq_set(struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_masq_set(struct nftnl_rule_expr *e, uint16_t type, const void *data, uint32_t data_len) { - struct nft_expr_masq *masq = nft_expr_data(e); + struct nftnl_expr_masq *masq = nftnl_expr_data(e); switch (type) { - case NFT_EXPR_MASQ_FLAGS: + case NFTNL_EXPR_MASQ_FLAGS: masq->flags = *((uint32_t *)data); break; default: @@ -41,20 +41,20 @@ nft_rule_expr_masq_set(struct nft_rule_expr *e, uint16_t type, } static const void * -nft_rule_expr_masq_get(const struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_masq_get(const struct nftnl_rule_expr *e, uint16_t type, uint32_t *data_len) { - struct nft_expr_masq *masq = nft_expr_data(e); + struct nftnl_expr_masq *masq = nftnl_expr_data(e); switch (type) { - case NFT_EXPR_MASQ_FLAGS: + case NFTNL_EXPR_MASQ_FLAGS: *data_len = sizeof(masq->flags); return &masq->flags; } return NULL; } -static int nft_rule_expr_masq_cb(const struct nlattr *attr, void *data) +static int nftnl_rule_expr_masq_cb(const struct nlattr *attr, void *data) { const struct nlattr **tb = data; int type = mnl_attr_get_type(attr); @@ -74,41 +74,41 @@ static int nft_rule_expr_masq_cb(const struct nlattr *attr, void *data) } static void -nft_rule_expr_masq_build(struct nlmsghdr *nlh, struct nft_rule_expr *e) +nftnl_rule_expr_masq_build(struct nlmsghdr *nlh, struct nftnl_rule_expr *e) { - struct nft_expr_masq *masq = nft_expr_data(e); + struct nftnl_expr_masq *masq = nftnl_expr_data(e); - if (e->flags & (1 << NFT_EXPR_MASQ_FLAGS)) + if (e->flags & (1 << NFTNL_EXPR_MASQ_FLAGS)) mnl_attr_put_u32(nlh, NFTA_MASQ_FLAGS, htobe32(masq->flags)); } static int -nft_rule_expr_masq_parse(struct nft_rule_expr *e, struct nlattr *attr) +nftnl_rule_expr_masq_parse(struct nftnl_rule_expr *e, struct nlattr *attr) { - struct nft_expr_masq *masq = nft_expr_data(e); + struct nftnl_expr_masq *masq = nftnl_expr_data(e); struct nlattr *tb[NFTA_MASQ_MAX+1] = {}; - if (mnl_attr_parse_nested(attr, nft_rule_expr_masq_cb, tb) < 0) + if (mnl_attr_parse_nested(attr, nftnl_rule_expr_masq_cb, tb) < 0) return -1; if (tb[NFTA_MASQ_FLAGS]) { masq->flags = be32toh(mnl_attr_get_u32(tb[NFTA_MASQ_FLAGS])); - e->flags |= (1 << NFT_EXPR_MASQ_FLAGS); + e->flags |= (1 << NFTNL_EXPR_MASQ_FLAGS); } return 0; } static int -nft_rule_expr_masq_json_parse(struct nft_rule_expr *e, json_t *root, - struct nft_parse_err *err) +nftnl_rule_expr_masq_json_parse(struct nftnl_rule_expr *e, json_t *root, + struct nftnl_parse_err *err) { #ifdef JSON_PARSING uint32_t flags; - if (nft_jansson_parse_val(root, "flags", NFT_TYPE_U32, &flags, + if (nftnl_jansson_parse_val(root, "flags", NFTNL_TYPE_U32, &flags, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_MASQ_FLAGS, flags); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_MASQ_FLAGS, flags); return 0; #else @@ -118,15 +118,15 @@ nft_rule_expr_masq_json_parse(struct nft_rule_expr *e, json_t *root, } static int -nft_rule_expr_masq_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, - struct nft_parse_err *err) +nftnl_rule_expr_masq_xml_parse(struct nftnl_rule_expr *e, mxml_node_t *tree, + struct nftnl_parse_err *err) { #ifdef XML_PARSING uint32_t flags; - if (nft_mxml_num_parse(tree, "flags", MXML_DESCEND_FIRST, BASE_DEC, - &flags, NFT_TYPE_U32, NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_MASQ_FLAGS, flags); + if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND_FIRST, BASE_DEC, + &flags, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_MASQ_FLAGS, flags); return 0; #else @@ -134,38 +134,38 @@ nft_rule_expr_masq_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, return -1; #endif } -static int nft_rule_expr_masq_export(char *buf, size_t size, - struct nft_rule_expr *e, int type) +static int nftnl_rule_expr_masq_export(char *buf, size_t size, + struct nftnl_rule_expr *e, int type) { - struct nft_expr_masq *masq = nft_expr_data(e); - NFT_BUF_INIT(b, buf, size); + struct nftnl_expr_masq *masq = nftnl_expr_data(e); + NFTNL_BUF_INIT(b, buf, size); - if (e->flags & (1 << NFT_EXPR_MASQ_FLAGS)) - nft_buf_u32(&b, type, masq->flags, FLAGS); + if (e->flags & (1 << NFTNL_EXPR_MASQ_FLAGS)) + nftnl_buf_u32(&b, type, masq->flags, FLAGS); - return nft_buf_done(&b); + return nftnl_buf_done(&b); } -static int nft_rule_expr_masq_snprintf_default(char *buf, size_t len, - struct nft_rule_expr *e) +static int nftnl_rule_expr_masq_snprintf_default(char *buf, size_t len, + struct nftnl_rule_expr *e) { - struct nft_expr_masq *masq = nft_expr_data(e); + struct nftnl_expr_masq *masq = nftnl_expr_data(e); - if (e->flags & (1 << NFT_EXPR_MASQ_FLAGS)) + if (e->flags & (1 << NFTNL_EXPR_MASQ_FLAGS)) return snprintf(buf, len, "flags 0x%x ", masq->flags); return 0; } -static int nft_rule_expr_masq_snprintf(char *buf, size_t len, uint32_t type, - uint32_t flags, struct nft_rule_expr *e) +static int nftnl_rule_expr_masq_snprintf(char *buf, size_t len, uint32_t type, + uint32_t flags, struct nftnl_rule_expr *e) { switch (type) { - case NFT_OUTPUT_DEFAULT: - return nft_rule_expr_masq_snprintf_default(buf, len, e); - case NFT_OUTPUT_XML: - case NFT_OUTPUT_JSON: - return nft_rule_expr_masq_export(buf, len, e, type); + case NFTNL_OUTPUT_DEFAULT: + return nftnl_rule_expr_masq_snprintf_default(buf, len, e); + case NFTNL_OUTPUT_XML: + case NFTNL_OUTPUT_JSON: + return nftnl_rule_expr_masq_export(buf, len, e, type); default: break; } @@ -174,13 +174,13 @@ static int nft_rule_expr_masq_snprintf(char *buf, size_t len, uint32_t type, struct expr_ops expr_ops_masq = { .name = "masq", - .alloc_len = sizeof(struct nft_expr_masq), + .alloc_len = sizeof(struct nftnl_expr_masq), .max_attr = NFTA_MASQ_MAX, - .set = nft_rule_expr_masq_set, - .get = nft_rule_expr_masq_get, - .parse = nft_rule_expr_masq_parse, - .build = nft_rule_expr_masq_build, - .snprintf = nft_rule_expr_masq_snprintf, - .xml_parse = nft_rule_expr_masq_xml_parse, - .json_parse = nft_rule_expr_masq_json_parse, + .set = nftnl_rule_expr_masq_set, + .get = nftnl_rule_expr_masq_get, + .parse = nftnl_rule_expr_masq_parse, + .build = nftnl_rule_expr_masq_build, + .snprintf = nftnl_rule_expr_masq_snprintf, + .xml_parse = nftnl_rule_expr_masq_xml_parse, + .json_parse = nftnl_rule_expr_masq_json_parse, }; diff --git a/src/expr/match.c b/src/expr/match.c index e101c1f..1a550cc 100644 --- a/src/expr/match.c +++ b/src/expr/match.c @@ -27,7 +27,7 @@ /* From include/linux/netfilter/x_tables.h */ #define XT_EXTENSION_MAXNAMELEN 29 -struct nft_expr_match { +struct nftnl_expr_match { char name[XT_EXTENSION_MAXNAMELEN]; uint32_t rev; uint32_t data_len; @@ -35,20 +35,20 @@ struct nft_expr_match { }; static int -nft_rule_expr_match_set(struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_match_set(struct nftnl_rule_expr *e, uint16_t type, const void *data, uint32_t data_len) { - struct nft_expr_match *mt = nft_expr_data(e); + struct nftnl_expr_match *mt = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_MT_NAME: + case NFTNL_EXPR_MT_NAME: snprintf(mt->name, sizeof(mt->name), "%.*s", data_len, (const char *)data); break; - case NFT_EXPR_MT_REV: + case NFTNL_EXPR_MT_REV: mt->rev = *((uint32_t *)data); break; - case NFT_EXPR_MT_INFO: + case NFTNL_EXPR_MT_INFO: if (mt->data) xfree(mt->data); @@ -62,26 +62,26 @@ nft_rule_expr_match_set(struct nft_rule_expr *e, uint16_t type, } static const void * -nft_rule_expr_match_get(const struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_match_get(const struct nftnl_rule_expr *e, uint16_t type, uint32_t *data_len) { - struct nft_expr_match *mt = nft_expr_data(e); + struct nftnl_expr_match *mt = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_MT_NAME: + case NFTNL_EXPR_MT_NAME: *data_len = sizeof(mt->name); return mt->name; - case NFT_EXPR_MT_REV: + case NFTNL_EXPR_MT_REV: *data_len = sizeof(mt->rev); return &mt->rev; - case NFT_EXPR_MT_INFO: + case NFTNL_EXPR_MT_INFO: *data_len = mt->data_len; return mt->data; } return NULL; } -static int nft_rule_expr_match_cb(const struct nlattr *attr, void *data) +static int nftnl_rule_expr_match_cb(const struct nlattr *attr, void *data) { const struct nlattr **tb = data; int type = mnl_attr_get_type(attr); @@ -109,24 +109,24 @@ static int nft_rule_expr_match_cb(const struct nlattr *attr, void *data) } static void -nft_rule_expr_match_build(struct nlmsghdr *nlh, struct nft_rule_expr *e) +nftnl_rule_expr_match_build(struct nlmsghdr *nlh, struct nftnl_rule_expr *e) { - struct nft_expr_match *mt = nft_expr_data(e); + struct nftnl_expr_match *mt = nftnl_expr_data(e); - if (e->flags & (1 << NFT_EXPR_MT_NAME)) + if (e->flags & (1 << NFTNL_EXPR_MT_NAME)) mnl_attr_put_strz(nlh, NFTA_MATCH_NAME, mt->name); - if (e->flags & (1 << NFT_EXPR_MT_REV)) + if (e->flags & (1 << NFTNL_EXPR_MT_REV)) mnl_attr_put_u32(nlh, NFTA_MATCH_REV, htonl(mt->rev)); - if (e->flags & (1 << NFT_EXPR_MT_INFO)) + if (e->flags & (1 << NFTNL_EXPR_MT_INFO)) mnl_attr_put(nlh, NFTA_MATCH_INFO, mt->data_len, mt->data); } -static int nft_rule_expr_match_parse(struct nft_rule_expr *e, struct nlattr *attr) +static int nftnl_rule_expr_match_parse(struct nftnl_rule_expr *e, struct nlattr *attr) { - struct nft_expr_match *match = nft_expr_data(e); + struct nftnl_expr_match *match = nftnl_expr_data(e); struct nlattr *tb[NFTA_MATCH_MAX+1] = {}; - if (mnl_attr_parse_nested(attr, nft_rule_expr_match_cb, tb) < 0) + if (mnl_attr_parse_nested(attr, nftnl_rule_expr_match_cb, tb) < 0) return -1; if (tb[NFTA_MATCH_NAME]) { @@ -134,12 +134,12 @@ static int nft_rule_expr_match_parse(struct nft_rule_expr *e, struct nlattr *att mnl_attr_get_str(tb[NFTA_MATCH_NAME])); match->name[XT_EXTENSION_MAXNAMELEN-1] = '\0'; - e->flags |= (1 << NFT_EXPR_MT_NAME); + e->flags |= (1 << NFTNL_EXPR_MT_NAME); } if (tb[NFTA_MATCH_REV]) { match->rev = ntohl(mnl_attr_get_u32(tb[NFTA_MATCH_REV])); - e->flags |= (1 << NFT_EXPR_MT_REV); + e->flags |= (1 << NFTNL_EXPR_MT_REV); } if (tb[NFTA_MATCH_INFO]) { @@ -158,21 +158,21 @@ static int nft_rule_expr_match_parse(struct nft_rule_expr *e, struct nlattr *att match->data = match_data; match->data_len = len; - e->flags |= (1 << NFT_EXPR_MT_INFO); + e->flags |= (1 << NFTNL_EXPR_MT_INFO); } return 0; } -static int nft_rule_expr_match_json_parse(struct nft_rule_expr *e, json_t *root, - struct nft_parse_err *err) +static int nftnl_rule_expr_match_json_parse(struct nftnl_rule_expr *e, json_t *root, + struct nftnl_parse_err *err) { #ifdef JSON_PARSING const char *name; - name = nft_jansson_parse_str(root, "name", err); + name = nftnl_jansson_parse_str(root, "name", err); if (name != NULL) - nft_rule_expr_set_str(e, NFT_EXPR_MT_NAME, name); + nftnl_rule_expr_set_str(e, NFTNL_EXPR_MT_NAME, name); return 0; #else @@ -182,16 +182,16 @@ static int nft_rule_expr_match_json_parse(struct nft_rule_expr *e, json_t *root, } -static int nft_rule_expr_match_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, - struct nft_parse_err *err) +static int nftnl_rule_expr_match_xml_parse(struct nftnl_rule_expr *e, mxml_node_t *tree, + struct nftnl_parse_err *err) { #ifdef XML_PARSING const char *name; - name = nft_mxml_str_parse(tree, "name", MXML_DESCEND_FIRST, - NFT_XML_MAND, err); + name = nftnl_mxml_str_parse(tree, "name", MXML_DESCEND_FIRST, + NFTNL_XML_MAND, err); if (name != NULL) - nft_rule_expr_set_str(e, NFT_EXPR_MT_NAME, name); + nftnl_rule_expr_set_str(e, NFTNL_EXPR_MT_NAME, name); /* mt->info is ignored until other solution is reached */ @@ -202,54 +202,54 @@ static int nft_rule_expr_match_xml_parse(struct nft_rule_expr *e, mxml_node_t *t #endif } -static int nft_rule_expr_match_export(char *buf, size_t size, - struct nft_rule_expr *e, int type) +static int nftnl_rule_expr_match_export(char *buf, size_t size, + struct nftnl_rule_expr *e, int type) { - struct nft_expr_match *mt = nft_expr_data(e); - NFT_BUF_INIT(b, buf, size); + struct nftnl_expr_match *mt = nftnl_expr_data(e); + NFTNL_BUF_INIT(b, buf, size); - if (e->flags & (1 << NFT_EXPR_MT_NAME)) - nft_buf_str(&b, type, mt->name, NAME); + if (e->flags & (1 << NFTNL_EXPR_MT_NAME)) + nftnl_buf_str(&b, type, mt->name, NAME); - return nft_buf_done(&b); + return nftnl_buf_done(&b); } static int -nft_rule_expr_match_snprintf(char *buf, size_t len, uint32_t type, - uint32_t flags, struct nft_rule_expr *e) +nftnl_rule_expr_match_snprintf(char *buf, size_t len, uint32_t type, + uint32_t flags, struct nftnl_rule_expr *e) { - struct nft_expr_match *match = nft_expr_data(e); + struct nftnl_expr_match *match = nftnl_expr_data(e); switch (type) { - case NFT_OUTPUT_DEFAULT: + case NFTNL_OUTPUT_DEFAULT: return snprintf(buf, len, "name %s rev %u ", match->name, match->rev); - case NFT_OUTPUT_XML: - case NFT_OUTPUT_JSON: - return nft_rule_expr_match_export(buf, len, e, type); + case NFTNL_OUTPUT_XML: + case NFTNL_OUTPUT_JSON: + return nftnl_rule_expr_match_export(buf, len, e, type); default: break; } return -1; } -static void nft_rule_expr_match_free(struct nft_rule_expr *e) +static void nftnl_rule_expr_match_free(struct nftnl_rule_expr *e) { - struct nft_expr_match *match = nft_expr_data(e); + struct nftnl_expr_match *match = nftnl_expr_data(e); xfree(match->data); } struct expr_ops expr_ops_match = { .name = "match", - .alloc_len = sizeof(struct nft_expr_match), + .alloc_len = sizeof(struct nftnl_expr_match), .max_attr = NFTA_MATCH_MAX, - .free = nft_rule_expr_match_free, - .set = nft_rule_expr_match_set, - .get = nft_rule_expr_match_get, - .parse = nft_rule_expr_match_parse, - .build = nft_rule_expr_match_build, - .snprintf = nft_rule_expr_match_snprintf, - .xml_parse = nft_rule_expr_match_xml_parse, - .json_parse = nft_rule_expr_match_json_parse, + .free = nftnl_rule_expr_match_free, + .set = nftnl_rule_expr_match_set, + .get = nftnl_rule_expr_match_get, + .parse = nftnl_rule_expr_match_parse, + .build = nftnl_rule_expr_match_build, + .snprintf = nftnl_rule_expr_match_snprintf, + .xml_parse = nftnl_rule_expr_match_xml_parse, + .json_parse = nftnl_rule_expr_match_json_parse, }; diff --git a/src/expr/meta.c b/src/expr/meta.c index cee09dd..98f7588 100644 --- a/src/expr/meta.c +++ b/src/expr/meta.c @@ -25,26 +25,26 @@ #define NFT_META_MAX (NFT_META_CGROUP + 1) #endif -struct nft_expr_meta { +struct nftnl_expr_meta { enum nft_meta_keys key; enum nft_registers dreg; enum nft_registers sreg; }; static int -nft_rule_expr_meta_set(struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_meta_set(struct nftnl_rule_expr *e, uint16_t type, const void *data, uint32_t data_len) { - struct nft_expr_meta *meta = nft_expr_data(e); + struct nftnl_expr_meta *meta = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_META_KEY: + case NFTNL_EXPR_META_KEY: meta->key = *((uint32_t *)data); break; - case NFT_EXPR_META_DREG: + case NFTNL_EXPR_META_DREG: meta->dreg = *((uint32_t *)data); break; - case NFT_EXPR_META_SREG: + case NFTNL_EXPR_META_SREG: meta->sreg = *((uint32_t *)data); break; default: @@ -54,26 +54,26 @@ nft_rule_expr_meta_set(struct nft_rule_expr *e, uint16_t type, } static const void * -nft_rule_expr_meta_get(const struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_meta_get(const struct nftnl_rule_expr *e, uint16_t type, uint32_t *data_len) { - struct nft_expr_meta *meta = nft_expr_data(e); + struct nftnl_expr_meta *meta = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_META_KEY: + case NFTNL_EXPR_META_KEY: *data_len = sizeof(meta->key); return &meta->key; - case NFT_EXPR_META_DREG: + case NFTNL_EXPR_META_DREG: *data_len = sizeof(meta->dreg); return &meta->dreg; - case NFT_EXPR_META_SREG: + case NFTNL_EXPR_META_SREG: *data_len = sizeof(meta->sreg); return &meta->sreg; } return NULL; } -static int nft_rule_expr_meta_cb(const struct nlattr *attr, void *data) +static int nftnl_rule_expr_meta_cb(const struct nlattr *attr, void *data) { const struct nlattr **tb = data; int type = mnl_attr_get_type(attr); @@ -95,38 +95,38 @@ static int nft_rule_expr_meta_cb(const struct nlattr *attr, void *data) } static void -nft_rule_expr_meta_build(struct nlmsghdr *nlh, struct nft_rule_expr *e) +nftnl_rule_expr_meta_build(struct nlmsghdr *nlh, struct nftnl_rule_expr *e) { - struct nft_expr_meta *meta = nft_expr_data(e); + struct nftnl_expr_meta *meta = nftnl_expr_data(e); - if (e->flags & (1 << NFT_EXPR_META_KEY)) + if (e->flags & (1 << NFTNL_EXPR_META_KEY)) mnl_attr_put_u32(nlh, NFTA_META_KEY, htonl(meta->key)); - if (e->flags & (1 << NFT_EXPR_META_DREG)) + if (e->flags & (1 << NFTNL_EXPR_META_DREG)) mnl_attr_put_u32(nlh, NFTA_META_DREG, htonl(meta->dreg)); - if (e->flags & (1 << NFT_EXPR_META_SREG)) + if (e->flags & (1 << NFTNL_EXPR_META_SREG)) mnl_attr_put_u32(nlh, NFTA_META_SREG, htonl(meta->sreg)); } static int -nft_rule_expr_meta_parse(struct nft_rule_expr *e, struct nlattr *attr) +nftnl_rule_expr_meta_parse(struct nftnl_rule_expr *e, struct nlattr *attr) { - struct nft_expr_meta *meta = nft_expr_data(e); + struct nftnl_expr_meta *meta = nftnl_expr_data(e); struct nlattr *tb[NFTA_META_MAX+1] = {}; - if (mnl_attr_parse_nested(attr, nft_rule_expr_meta_cb, tb) < 0) + if (mnl_attr_parse_nested(attr, nftnl_rule_expr_meta_cb, tb) < 0) return -1; if (tb[NFTA_META_KEY]) { meta->key = ntohl(mnl_attr_get_u32(tb[NFTA_META_KEY])); - e->flags |= (1 << NFT_EXPR_META_KEY); + e->flags |= (1 << NFTNL_EXPR_META_KEY); } if (tb[NFTA_META_DREG]) { meta->dreg = ntohl(mnl_attr_get_u32(tb[NFTA_META_DREG])); - e->flags |= (1 << NFT_EXPR_META_DREG); + e->flags |= (1 << NFTNL_EXPR_META_DREG); } if (tb[NFTA_META_SREG]) { meta->sreg = ntohl(mnl_attr_get_u32(tb[NFTA_META_SREG])); - e->flags |= (1 << NFT_EXPR_META_SREG); + e->flags |= (1 << NFTNL_EXPR_META_SREG); } return 0; @@ -180,31 +180,31 @@ static inline int str2meta_key(const char *str) return -1; } -static int nft_rule_expr_meta_json_parse(struct nft_rule_expr *e, json_t *root, - struct nft_parse_err *err) +static int nftnl_rule_expr_meta_json_parse(struct nftnl_rule_expr *e, json_t *root, + struct nftnl_parse_err *err) { #ifdef JSON_PARSING const char *key_str; uint32_t reg; int key; - key_str = nft_jansson_parse_str(root, "key", err); + key_str = nftnl_jansson_parse_str(root, "key", err); if (key_str != NULL) { key = str2meta_key(key_str); if (key >= 0) - nft_rule_expr_set_u32(e, NFT_EXPR_META_KEY, key); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_META_KEY, key); } - if (nft_jansson_node_exist(root, "dreg")) { - if (nft_jansson_parse_reg(root, "dreg", NFT_TYPE_U32, ®, + if (nftnl_jansson_node_exist(root, "dreg")) { + if (nftnl_jansson_parse_reg(root, "dreg", NFTNL_TYPE_U32, ®, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_META_DREG, reg); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_META_DREG, reg); } - if (nft_jansson_node_exist(root, "sreg")) { - if (nft_jansson_parse_reg(root, "sreg", NFT_TYPE_U32, ®, + if (nftnl_jansson_node_exist(root, "sreg")) { + if (nftnl_jansson_parse_reg(root, "sreg", NFTNL_TYPE_U32, ®, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_META_SREG, reg); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_META_SREG, reg); } return 0; @@ -215,29 +215,29 @@ static int nft_rule_expr_meta_json_parse(struct nft_rule_expr *e, json_t *root, } -static int nft_rule_expr_meta_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, - struct nft_parse_err *err) +static int nftnl_rule_expr_meta_xml_parse(struct nftnl_rule_expr *e, mxml_node_t *tree, + struct nftnl_parse_err *err) { #ifdef XML_PARSING const char *key_str; int key; uint32_t dreg, sreg; - key_str = nft_mxml_str_parse(tree, "key", MXML_DESCEND_FIRST, - NFT_XML_MAND, err); + key_str = nftnl_mxml_str_parse(tree, "key", MXML_DESCEND_FIRST, + NFTNL_XML_MAND, err); if (key_str != NULL) { key = str2meta_key(key_str); if (key >= 0) - nft_rule_expr_set_u32(e, NFT_EXPR_META_KEY, key); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_META_KEY, key); } - if (nft_mxml_reg_parse(tree, "dreg", &dreg, MXML_DESCEND_FIRST, - NFT_XML_OPT, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_META_DREG, dreg); + if (nftnl_mxml_reg_parse(tree, "dreg", &dreg, MXML_DESCEND_FIRST, + NFTNL_XML_OPT, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_META_DREG, dreg); - if (nft_mxml_reg_parse(tree, "sreg", &sreg, MXML_DESCEND_FIRST, - NFT_XML_OPT, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_META_SREG, sreg); + if (nftnl_mxml_reg_parse(tree, "sreg", &sreg, MXML_DESCEND_FIRST, + NFTNL_XML_OPT, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_META_SREG, sreg); return 0; #else @@ -247,48 +247,48 @@ static int nft_rule_expr_meta_xml_parse(struct nft_rule_expr *e, mxml_node_t *tr } static int -nft_rule_expr_meta_snprintf_default(char *buf, size_t len, - struct nft_rule_expr *e) +nftnl_rule_expr_meta_snprintf_default(char *buf, size_t len, + struct nftnl_rule_expr *e) { - struct nft_expr_meta *meta = nft_expr_data(e); + struct nftnl_expr_meta *meta = nftnl_expr_data(e); - if (e->flags & (1 << NFT_EXPR_META_SREG)) { + if (e->flags & (1 << NFTNL_EXPR_META_SREG)) { return snprintf(buf, len, "set %s with reg %u ", meta_key2str(meta->key), meta->sreg); } - if (e->flags & (1 << NFT_EXPR_META_DREG)) { + if (e->flags & (1 << NFTNL_EXPR_META_DREG)) { return snprintf(buf, len, "load %s => reg %u ", meta_key2str(meta->key), meta->dreg); } return 0; } -static int nft_rule_expr_meta_export(char *buf, size_t size, - struct nft_rule_expr *e, int type) +static int nftnl_rule_expr_meta_export(char *buf, size_t size, + struct nftnl_rule_expr *e, int type) { - struct nft_expr_meta *meta = nft_expr_data(e); - NFT_BUF_INIT(b, buf, size); + struct nftnl_expr_meta *meta = nftnl_expr_data(e); + NFTNL_BUF_INIT(b, buf, size); - if (e->flags & (1 << NFT_EXPR_META_DREG)) - nft_buf_u32(&b, type, meta->dreg, DREG); - if (e->flags & (1 << NFT_EXPR_META_KEY)) - nft_buf_str(&b, type, meta_key2str(meta->key), KEY); - if (e->flags & (1 << NFT_EXPR_META_SREG)) - nft_buf_u32(&b, type, meta->sreg, SREG); + if (e->flags & (1 << NFTNL_EXPR_META_DREG)) + nftnl_buf_u32(&b, type, meta->dreg, DREG); + if (e->flags & (1 << NFTNL_EXPR_META_KEY)) + nftnl_buf_str(&b, type, meta_key2str(meta->key), KEY); + if (e->flags & (1 << NFTNL_EXPR_META_SREG)) + nftnl_buf_u32(&b, type, meta->sreg, SREG); - return nft_buf_done(&b); + return nftnl_buf_done(&b); } static int -nft_rule_expr_meta_snprintf(char *buf, size_t len, uint32_t type, - uint32_t flags, struct nft_rule_expr *e) +nftnl_rule_expr_meta_snprintf(char *buf, size_t len, uint32_t type, + uint32_t flags, struct nftnl_rule_expr *e) { switch (type) { - case NFT_OUTPUT_DEFAULT: - return nft_rule_expr_meta_snprintf_default(buf, len, e); - case NFT_OUTPUT_XML: - case NFT_OUTPUT_JSON: - return nft_rule_expr_meta_export(buf, len, e, type); + case NFTNL_OUTPUT_DEFAULT: + return nftnl_rule_expr_meta_snprintf_default(buf, len, e); + case NFTNL_OUTPUT_XML: + case NFTNL_OUTPUT_JSON: + return nftnl_rule_expr_meta_export(buf, len, e, type); default: break; } @@ -297,13 +297,13 @@ nft_rule_expr_meta_snprintf(char *buf, size_t len, uint32_t type, struct expr_ops expr_ops_meta = { .name = "meta", - .alloc_len = sizeof(struct nft_expr_meta), + .alloc_len = sizeof(struct nftnl_expr_meta), .max_attr = NFTA_META_MAX, - .set = nft_rule_expr_meta_set, - .get = nft_rule_expr_meta_get, - .parse = nft_rule_expr_meta_parse, - .build = nft_rule_expr_meta_build, - .snprintf = nft_rule_expr_meta_snprintf, - .xml_parse = nft_rule_expr_meta_xml_parse, - .json_parse = nft_rule_expr_meta_json_parse, + .set = nftnl_rule_expr_meta_set, + .get = nftnl_rule_expr_meta_get, + .parse = nftnl_rule_expr_meta_parse, + .build = nftnl_rule_expr_meta_build, + .snprintf = nftnl_rule_expr_meta_snprintf, + .xml_parse = nftnl_rule_expr_meta_xml_parse, + .json_parse = nftnl_rule_expr_meta_json_parse, }; diff --git a/src/expr/nat.c b/src/expr/nat.c index f888dfa..3b61344 100644 --- a/src/expr/nat.c +++ b/src/expr/nat.c @@ -24,7 +24,7 @@ #include <libnftnl/expr.h> #include <libnftnl/rule.h> -struct nft_expr_nat { +struct nftnl_expr_nat { enum nft_registers sreg_addr_min; enum nft_registers sreg_addr_max; enum nft_registers sreg_proto_min; @@ -35,31 +35,31 @@ struct nft_expr_nat { }; static int -nft_rule_expr_nat_set(struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_nat_set(struct nftnl_rule_expr *e, uint16_t type, const void *data, uint32_t data_len) { - struct nft_expr_nat *nat = nft_expr_data(e); + struct nftnl_expr_nat *nat = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_NAT_TYPE: + case NFTNL_EXPR_NAT_TYPE: nat->type = *((uint32_t *)data); break; - case NFT_EXPR_NAT_FAMILY: + case NFTNL_EXPR_NAT_FAMILY: nat->family = *((uint32_t *)data); break; - case NFT_EXPR_NAT_REG_ADDR_MIN: + case NFTNL_EXPR_NAT_REG_ADDR_MIN: nat->sreg_addr_min = *((uint32_t *)data); break; - case NFT_EXPR_NAT_REG_ADDR_MAX: + case NFTNL_EXPR_NAT_REG_ADDR_MAX: nat->sreg_addr_max = *((uint32_t *)data); break; - case NFT_EXPR_NAT_REG_PROTO_MIN: + case NFTNL_EXPR_NAT_REG_PROTO_MIN: nat->sreg_proto_min = *((uint32_t *)data); break; - case NFT_EXPR_NAT_REG_PROTO_MAX: + case NFTNL_EXPR_NAT_REG_PROTO_MAX: nat->sreg_proto_max = *((uint32_t *)data); break; - case NFT_EXPR_NAT_FLAGS: + case NFTNL_EXPR_NAT_FLAGS: nat->flags = *((uint32_t *)data); break; default: @@ -70,38 +70,38 @@ nft_rule_expr_nat_set(struct nft_rule_expr *e, uint16_t type, } static const void * -nft_rule_expr_nat_get(const struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_nat_get(const struct nftnl_rule_expr *e, uint16_t type, uint32_t *data_len) { - struct nft_expr_nat *nat = nft_expr_data(e); + struct nftnl_expr_nat *nat = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_NAT_TYPE: + case NFTNL_EXPR_NAT_TYPE: *data_len = sizeof(nat->type); return &nat->type; - case NFT_EXPR_NAT_FAMILY: + case NFTNL_EXPR_NAT_FAMILY: *data_len = sizeof(nat->family); return &nat->family; - case NFT_EXPR_NAT_REG_ADDR_MIN: + case NFTNL_EXPR_NAT_REG_ADDR_MIN: *data_len = sizeof(nat->sreg_addr_min); return &nat->sreg_addr_min; - case NFT_EXPR_NAT_REG_ADDR_MAX: + case NFTNL_EXPR_NAT_REG_ADDR_MAX: *data_len = sizeof(nat->sreg_addr_max); return &nat->sreg_addr_max; - case NFT_EXPR_NAT_REG_PROTO_MIN: + case NFTNL_EXPR_NAT_REG_PROTO_MIN: *data_len = sizeof(nat->sreg_proto_min); return &nat->sreg_proto_min; - case NFT_EXPR_NAT_REG_PROTO_MAX: + case NFTNL_EXPR_NAT_REG_PROTO_MAX: *data_len = sizeof(nat->sreg_proto_max); return &nat->sreg_proto_max; - case NFT_EXPR_NAT_FLAGS: + case NFTNL_EXPR_NAT_FLAGS: *data_len = sizeof(nat->flags); return &nat->flags; } return NULL; } -static int nft_rule_expr_nat_cb(const struct nlattr *attr, void *data) +static int nftnl_rule_expr_nat_cb(const struct nlattr *attr, void *data) { const struct nlattr **tb = data; int type = mnl_attr_get_type(attr); @@ -127,72 +127,72 @@ static int nft_rule_expr_nat_cb(const struct nlattr *attr, void *data) } static int -nft_rule_expr_nat_parse(struct nft_rule_expr *e, struct nlattr *attr) +nftnl_rule_expr_nat_parse(struct nftnl_rule_expr *e, struct nlattr *attr) { - struct nft_expr_nat *nat = nft_expr_data(e); + struct nftnl_expr_nat *nat = nftnl_expr_data(e); struct nlattr *tb[NFTA_NAT_MAX+1] = {}; - if (mnl_attr_parse_nested(attr, nft_rule_expr_nat_cb, tb) < 0) + if (mnl_attr_parse_nested(attr, nftnl_rule_expr_nat_cb, tb) < 0) return -1; if (tb[NFTA_NAT_TYPE]) { nat->type = ntohl(mnl_attr_get_u32(tb[NFTA_NAT_TYPE])); - e->flags |= (1 << NFT_EXPR_NAT_TYPE); + e->flags |= (1 << NFTNL_EXPR_NAT_TYPE); } if (tb[NFTA_NAT_FAMILY]) { nat->family = ntohl(mnl_attr_get_u32(tb[NFTA_NAT_FAMILY])); - e->flags |= (1 << NFT_EXPR_NAT_FAMILY); + e->flags |= (1 << NFTNL_EXPR_NAT_FAMILY); } if (tb[NFTA_NAT_REG_ADDR_MIN]) { nat->sreg_addr_min = ntohl(mnl_attr_get_u32(tb[NFTA_NAT_REG_ADDR_MIN])); - e->flags |= (1 << NFT_EXPR_NAT_REG_ADDR_MIN); + e->flags |= (1 << NFTNL_EXPR_NAT_REG_ADDR_MIN); } if (tb[NFTA_NAT_REG_ADDR_MAX]) { nat->sreg_addr_max = ntohl(mnl_attr_get_u32(tb[NFTA_NAT_REG_ADDR_MAX])); - e->flags |= (1 << NFT_EXPR_NAT_REG_ADDR_MAX); + e->flags |= (1 << NFTNL_EXPR_NAT_REG_ADDR_MAX); } if (tb[NFTA_NAT_REG_PROTO_MIN]) { nat->sreg_proto_min = ntohl(mnl_attr_get_u32(tb[NFTA_NAT_REG_PROTO_MIN])); - e->flags |= (1 << NFT_EXPR_NAT_REG_PROTO_MIN); + e->flags |= (1 << NFTNL_EXPR_NAT_REG_PROTO_MIN); } if (tb[NFTA_NAT_REG_PROTO_MAX]) { nat->sreg_proto_max = ntohl(mnl_attr_get_u32(tb[NFTA_NAT_REG_PROTO_MAX])); - e->flags |= (1 << NFT_EXPR_NAT_REG_PROTO_MAX); + e->flags |= (1 << NFTNL_EXPR_NAT_REG_PROTO_MAX); } if (tb[NFTA_NAT_FLAGS]) { nat->flags = ntohl(mnl_attr_get_u32(tb[NFTA_NAT_FLAGS])); - e->flags |= (1 << NFT_EXPR_NAT_FLAGS); + e->flags |= (1 << NFTNL_EXPR_NAT_FLAGS); } return 0; } static void -nft_rule_expr_nat_build(struct nlmsghdr *nlh, struct nft_rule_expr *e) +nftnl_rule_expr_nat_build(struct nlmsghdr *nlh, struct nftnl_rule_expr *e) { - struct nft_expr_nat *nat = nft_expr_data(e); + struct nftnl_expr_nat *nat = nftnl_expr_data(e); - if (e->flags & (1 << NFT_EXPR_NAT_TYPE)) + if (e->flags & (1 << NFTNL_EXPR_NAT_TYPE)) mnl_attr_put_u32(nlh, NFTA_NAT_TYPE, htonl(nat->type)); - if (e->flags & (1 << NFT_EXPR_NAT_FAMILY)) + if (e->flags & (1 << NFTNL_EXPR_NAT_FAMILY)) mnl_attr_put_u32(nlh, NFTA_NAT_FAMILY, htonl(nat->family)); - if (e->flags & (1 << NFT_EXPR_NAT_REG_ADDR_MIN)) + if (e->flags & (1 << NFTNL_EXPR_NAT_REG_ADDR_MIN)) mnl_attr_put_u32(nlh, NFTA_NAT_REG_ADDR_MIN, htonl(nat->sreg_addr_min)); - if (e->flags & (1 << NFT_EXPR_NAT_REG_ADDR_MAX)) + if (e->flags & (1 << NFTNL_EXPR_NAT_REG_ADDR_MAX)) mnl_attr_put_u32(nlh, NFTA_NAT_REG_ADDR_MAX, htonl(nat->sreg_addr_max)); - if (e->flags & (1 << NFT_EXPR_NAT_REG_PROTO_MIN)) + if (e->flags & (1 << NFTNL_EXPR_NAT_REG_PROTO_MIN)) mnl_attr_put_u32(nlh, NFTA_NAT_REG_PROTO_MIN, htonl(nat->sreg_proto_min)); - if (e->flags & (1 << NFT_EXPR_NAT_REG_PROTO_MAX)) + if (e->flags & (1 << NFTNL_EXPR_NAT_REG_PROTO_MAX)) mnl_attr_put_u32(nlh, NFTA_NAT_REG_PROTO_MAX, htonl(nat->sreg_proto_max)); - if (e->flags & (1 << NFT_EXPR_NAT_FLAGS)) + if (e->flags & (1 << NFTNL_EXPR_NAT_FLAGS)) mnl_attr_put_u32(nlh, NFTA_NAT_FLAGS, htonl(nat->flags)); } @@ -208,7 +208,7 @@ static inline const char *nat2str(uint16_t nat) } } -static inline int nft_str2nat(const char *nat) +static inline int nftnl_str2nat(const char *nat) { if (strcmp(nat, "snat") == 0) return NFT_NAT_SNAT; @@ -220,53 +220,53 @@ static inline int nft_str2nat(const char *nat) } } -static int nft_rule_expr_nat_json_parse(struct nft_rule_expr *e, json_t *root, - struct nft_parse_err *err) +static int nftnl_rule_expr_nat_json_parse(struct nftnl_rule_expr *e, json_t *root, + struct nftnl_parse_err *err) { #ifdef JSON_PARSING const char *nat_type, *family_str; uint32_t reg, flags; int val32; - nat_type = nft_jansson_parse_str(root, "nat_type", err); + nat_type = nftnl_jansson_parse_str(root, "nat_type", err); if (nat_type == NULL) return -1; - val32 = nft_str2nat(nat_type); + val32 = nftnl_str2nat(nat_type); if (val32 < 0) return -1; - nft_rule_expr_set_u32(e, NFT_EXPR_NAT_TYPE, val32); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_NAT_TYPE, val32); - family_str = nft_jansson_parse_str(root, "family", err); + family_str = nftnl_jansson_parse_str(root, "family", err); if (family_str == NULL) return -1; - val32 = nft_str2family(family_str); + val32 = nftnl_str2family(family_str); if (val32 < 0) return -1; - nft_rule_expr_set_u32(e, NFT_EXPR_NAT_FAMILY, val32); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_NAT_FAMILY, val32); - if (nft_jansson_parse_reg(root, "sreg_addr_min", NFT_TYPE_U32, + if (nftnl_jansson_parse_reg(root, "sreg_addr_min", NFTNL_TYPE_U32, ®, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_NAT_REG_ADDR_MIN, reg); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_NAT_REG_ADDR_MIN, reg); - if (nft_jansson_parse_reg(root, "sreg_addr_max", NFT_TYPE_U32, + if (nftnl_jansson_parse_reg(root, "sreg_addr_max", NFTNL_TYPE_U32, ®, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_NAT_REG_ADDR_MAX, reg); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_NAT_REG_ADDR_MAX, reg); - if (nft_jansson_parse_reg(root, "sreg_proto_min", NFT_TYPE_U32, + if (nftnl_jansson_parse_reg(root, "sreg_proto_min", NFTNL_TYPE_U32, ®, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_NAT_REG_PROTO_MIN, reg); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_NAT_REG_PROTO_MIN, reg); - if (nft_jansson_parse_reg(root, "sreg_proto_max", NFT_TYPE_U32, + if (nftnl_jansson_parse_reg(root, "sreg_proto_max", NFTNL_TYPE_U32, ®, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_NAT_REG_PROTO_MAX, reg); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_NAT_REG_PROTO_MAX, reg); - if (nft_jansson_parse_val(root, "flags", NFT_TYPE_U32, + if (nftnl_jansson_parse_val(root, "flags", NFTNL_TYPE_U32, &flags, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_NAT_FLAGS, flags); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_NAT_FLAGS, flags); return 0; #else @@ -275,8 +275,8 @@ static int nft_rule_expr_nat_json_parse(struct nft_rule_expr *e, json_t *root, #endif } -static int nft_rule_expr_nat_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, - struct nft_parse_err *err) +static int nftnl_rule_expr_nat_xml_parse(struct nftnl_rule_expr *e, mxml_node_t *tree, + struct nftnl_parse_err *err) { #ifdef XML_PARSING const char *nat_type; @@ -284,43 +284,43 @@ static int nft_rule_expr_nat_xml_parse(struct nft_rule_expr *e, mxml_node_t *tre uint32_t reg_addr_min, reg_addr_max; uint32_t reg_proto_min, reg_proto_max; - nat_type = nft_mxml_str_parse(tree, "nat_type", MXML_DESCEND_FIRST, - NFT_XML_MAND, err); + nat_type = nftnl_mxml_str_parse(tree, "nat_type", MXML_DESCEND_FIRST, + NFTNL_XML_MAND, err); if (nat_type == NULL) return -1; - nat_type_value = nft_str2nat(nat_type); + nat_type_value = nftnl_str2nat(nat_type); if (nat_type_value < 0) return -1; - nft_rule_expr_set_u32(e, NFT_EXPR_NAT_TYPE, nat_type_value); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_NAT_TYPE, nat_type_value); - family = nft_mxml_family_parse(tree, "family", MXML_DESCEND_FIRST, - NFT_XML_MAND, err); + family = nftnl_mxml_family_parse(tree, "family", MXML_DESCEND_FIRST, + NFTNL_XML_MAND, err); if (family < 0) { mxmlDelete(tree); return -1; } - nft_rule_expr_set_u32(e, NFT_EXPR_NAT_FAMILY, family); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_NAT_FAMILY, family); - if (nft_mxml_reg_parse(tree, "sreg_addr_min", ®_addr_min, - MXML_DESCEND, NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_NAT_REG_ADDR_MIN, reg_addr_min); + if (nftnl_mxml_reg_parse(tree, "sreg_addr_min", ®_addr_min, + MXML_DESCEND, NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_NAT_REG_ADDR_MIN, reg_addr_min); - if (nft_mxml_reg_parse(tree, "sreg_addr_max", ®_addr_max, - MXML_DESCEND, NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_NAT_REG_ADDR_MAX, reg_addr_max); + if (nftnl_mxml_reg_parse(tree, "sreg_addr_max", ®_addr_max, + MXML_DESCEND, NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_NAT_REG_ADDR_MAX, reg_addr_max); - if (nft_mxml_reg_parse(tree, "sreg_proto_min", ®_proto_min, - MXML_DESCEND, NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_NAT_REG_PROTO_MIN, reg_proto_min); + if (nftnl_mxml_reg_parse(tree, "sreg_proto_min", ®_proto_min, + MXML_DESCEND, NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_NAT_REG_PROTO_MIN, reg_proto_min); - if (nft_mxml_reg_parse(tree, "sreg_proto_max", ®_proto_max, - MXML_DESCEND, NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_NAT_REG_PROTO_MAX, reg_proto_max); + if (nftnl_mxml_reg_parse(tree, "sreg_proto_max", ®_proto_max, + MXML_DESCEND, NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_NAT_REG_PROTO_MAX, reg_proto_max); - if (nft_mxml_num_parse(tree, "flags", MXML_DESCEND, BASE_DEC, &flags, - NFT_TYPE_U32, NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_NAT_FLAGS, flags); + if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND, BASE_DEC, &flags, + NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_NAT_FLAGS, flags); return 0; #else @@ -329,58 +329,58 @@ static int nft_rule_expr_nat_xml_parse(struct nft_rule_expr *e, mxml_node_t *tre #endif } -static int nft_rule_expr_nat_export(char *buf, size_t size, - struct nft_rule_expr *e, int type) +static int nftnl_rule_expr_nat_export(char *buf, size_t size, + struct nftnl_rule_expr *e, int type) { - struct nft_expr_nat *nat = nft_expr_data(e); - NFT_BUF_INIT(b, buf, size); - - if (e->flags & (1 << NFT_EXPR_NAT_TYPE)) - nft_buf_str(&b, type, nat2str(nat->type), NAT_TYPE); - if (e->flags & (1 << NFT_EXPR_NAT_FAMILY)) - nft_buf_str(&b, type, nft_family2str(nat->family), FAMILY); - if (e->flags & (1 << NFT_EXPR_NAT_REG_ADDR_MIN)) - nft_buf_u32(&b, type, nat->sreg_addr_min, SREG_ADDR_MIN); - if (e->flags & (1 << NFT_EXPR_NAT_REG_ADDR_MAX)) - nft_buf_u32(&b, type, nat->sreg_addr_max, SREG_ADDR_MAX); - if (e->flags & (1 << NFT_EXPR_NAT_REG_PROTO_MIN)) - nft_buf_u32(&b, type, nat->sreg_proto_min, SREG_PROTO_MIN); - if (e->flags & (1 << NFT_EXPR_NAT_REG_PROTO_MAX)) - nft_buf_u32(&b, type, nat->sreg_proto_max, SREG_PROTO_MAX); - if (e->flags & (1 << NFT_EXPR_NAT_FLAGS)) - nft_buf_u32(&b, type, nat->flags, FLAGS); - - return nft_buf_done(&b); + struct nftnl_expr_nat *nat = nftnl_expr_data(e); + NFTNL_BUF_INIT(b, buf, size); + + if (e->flags & (1 << NFTNL_EXPR_NAT_TYPE)) + nftnl_buf_str(&b, type, nat2str(nat->type), NAT_TYPE); + if (e->flags & (1 << NFTNL_EXPR_NAT_FAMILY)) + nftnl_buf_str(&b, type, nftnl_family2str(nat->family), FAMILY); + if (e->flags & (1 << NFTNL_EXPR_NAT_REG_ADDR_MIN)) + nftnl_buf_u32(&b, type, nat->sreg_addr_min, SREG_ADDR_MIN); + if (e->flags & (1 << NFTNL_EXPR_NAT_REG_ADDR_MAX)) + nftnl_buf_u32(&b, type, nat->sreg_addr_max, SREG_ADDR_MAX); + if (e->flags & (1 << NFTNL_EXPR_NAT_REG_PROTO_MIN)) + nftnl_buf_u32(&b, type, nat->sreg_proto_min, SREG_PROTO_MIN); + if (e->flags & (1 << NFTNL_EXPR_NAT_REG_PROTO_MAX)) + nftnl_buf_u32(&b, type, nat->sreg_proto_max, SREG_PROTO_MAX); + if (e->flags & (1 << NFTNL_EXPR_NAT_FLAGS)) + nftnl_buf_u32(&b, type, nat->flags, FLAGS); + + return nftnl_buf_done(&b); } static int -nft_rule_expr_nat_snprintf_default(char *buf, size_t size, - struct nft_rule_expr *e) +nftnl_rule_expr_nat_snprintf_default(char *buf, size_t size, + struct nftnl_rule_expr *e) { - struct nft_expr_nat *nat = nft_expr_data(e); + struct nftnl_expr_nat *nat = nftnl_expr_data(e); int len = size, offset = 0, ret = 0; ret = snprintf(buf, len, "%s ", nat2str(nat->type)); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - ret = snprintf(buf+offset, len, "%s ", nft_family2str(nat->family)); + ret = snprintf(buf+offset, len, "%s ", nftnl_family2str(nat->family)); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - if (e->flags & (1 << NFT_EXPR_NAT_REG_ADDR_MIN)) { + if (e->flags & (1 << NFTNL_EXPR_NAT_REG_ADDR_MIN)) { ret = snprintf(buf+offset, len, "addr_min reg %u addr_max reg %u ", nat->sreg_addr_min, nat->sreg_addr_max); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (e->flags & (1 << NFT_EXPR_NAT_REG_PROTO_MIN)) { + if (e->flags & (1 << NFTNL_EXPR_NAT_REG_PROTO_MIN)) { ret = snprintf(buf+offset, len, "proto_min reg %u proto_max reg %u ", nat->sreg_proto_min, nat->sreg_proto_max); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (e->flags & (1 << NFT_EXPR_NAT_FLAGS)) { + if (e->flags & (1 << NFTNL_EXPR_NAT_FLAGS)) { ret = snprintf(buf+offset, len, "flags %u", nat->flags); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } @@ -389,15 +389,15 @@ nft_rule_expr_nat_snprintf_default(char *buf, size_t size, } static int -nft_rule_expr_nat_snprintf(char *buf, size_t size, uint32_t type, - uint32_t flags, struct nft_rule_expr *e) +nftnl_rule_expr_nat_snprintf(char *buf, size_t size, uint32_t type, + uint32_t flags, struct nftnl_rule_expr *e) { switch (type) { - case NFT_OUTPUT_DEFAULT: - return nft_rule_expr_nat_snprintf_default(buf, size, e); - case NFT_OUTPUT_XML: - case NFT_OUTPUT_JSON: - return nft_rule_expr_nat_export(buf, size, e, type); + case NFTNL_OUTPUT_DEFAULT: + return nftnl_rule_expr_nat_snprintf_default(buf, size, e); + case NFTNL_OUTPUT_XML: + case NFTNL_OUTPUT_JSON: + return nftnl_rule_expr_nat_export(buf, size, e, type); default: break; } @@ -406,13 +406,13 @@ nft_rule_expr_nat_snprintf(char *buf, size_t size, uint32_t type, struct expr_ops expr_ops_nat = { .name = "nat", - .alloc_len = sizeof(struct nft_expr_nat), + .alloc_len = sizeof(struct nftnl_expr_nat), .max_attr = NFTA_NAT_MAX, - .set = nft_rule_expr_nat_set, - .get = nft_rule_expr_nat_get, - .parse = nft_rule_expr_nat_parse, - .build = nft_rule_expr_nat_build, - .snprintf = nft_rule_expr_nat_snprintf, - .xml_parse = nft_rule_expr_nat_xml_parse, - .json_parse = nft_rule_expr_nat_json_parse, + .set = nftnl_rule_expr_nat_set, + .get = nftnl_rule_expr_nat_get, + .parse = nftnl_rule_expr_nat_parse, + .build = nftnl_rule_expr_nat_build, + .snprintf = nftnl_rule_expr_nat_snprintf, + .xml_parse = nftnl_rule_expr_nat_xml_parse, + .json_parse = nftnl_rule_expr_nat_json_parse, }; diff --git a/src/expr/payload.c b/src/expr/payload.c index 52bea19..eda96f7 100644 --- a/src/expr/payload.c +++ b/src/expr/payload.c @@ -24,7 +24,7 @@ #include <libnftnl/expr.h> #include <libnftnl/rule.h> -struct nft_expr_payload { +struct nftnl_expr_payload { enum nft_registers dreg; enum nft_payload_bases base; uint32_t offset; @@ -32,22 +32,22 @@ struct nft_expr_payload { }; static int -nft_rule_expr_payload_set(struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_payload_set(struct nftnl_rule_expr *e, uint16_t type, const void *data, uint32_t data_len) { - struct nft_expr_payload *payload = nft_expr_data(e); + struct nftnl_expr_payload *payload = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_PAYLOAD_DREG: + case NFTNL_EXPR_PAYLOAD_DREG: payload->dreg = *((uint32_t *)data); break; - case NFT_EXPR_PAYLOAD_BASE: + case NFTNL_EXPR_PAYLOAD_BASE: payload->base = *((uint32_t *)data); break; - case NFT_EXPR_PAYLOAD_OFFSET: + case NFTNL_EXPR_PAYLOAD_OFFSET: payload->offset = *((unsigned int *)data); break; - case NFT_EXPR_PAYLOAD_LEN: + case NFTNL_EXPR_PAYLOAD_LEN: payload->len = *((unsigned int *)data); break; default: @@ -57,29 +57,29 @@ nft_rule_expr_payload_set(struct nft_rule_expr *e, uint16_t type, } static const void * -nft_rule_expr_payload_get(const struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_payload_get(const struct nftnl_rule_expr *e, uint16_t type, uint32_t *data_len) { - struct nft_expr_payload *payload = nft_expr_data(e); + struct nftnl_expr_payload *payload = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_PAYLOAD_DREG: + case NFTNL_EXPR_PAYLOAD_DREG: *data_len = sizeof(payload->dreg); return &payload->dreg; - case NFT_EXPR_PAYLOAD_BASE: + case NFTNL_EXPR_PAYLOAD_BASE: *data_len = sizeof(payload->base); return &payload->base; - case NFT_EXPR_PAYLOAD_OFFSET: + case NFTNL_EXPR_PAYLOAD_OFFSET: *data_len = sizeof(payload->offset); return &payload->offset; - case NFT_EXPR_PAYLOAD_LEN: + case NFTNL_EXPR_PAYLOAD_LEN: *data_len = sizeof(payload->len); return &payload->len; } return NULL; } -static int nft_rule_expr_payload_cb(const struct nlattr *attr, void *data) +static int nftnl_rule_expr_payload_cb(const struct nlattr *attr, void *data) { const struct nlattr **tb = data; int type = mnl_attr_get_type(attr); @@ -102,44 +102,44 @@ static int nft_rule_expr_payload_cb(const struct nlattr *attr, void *data) } static void -nft_rule_expr_payload_build(struct nlmsghdr *nlh, struct nft_rule_expr *e) +nftnl_rule_expr_payload_build(struct nlmsghdr *nlh, struct nftnl_rule_expr *e) { - struct nft_expr_payload *payload = nft_expr_data(e); + struct nftnl_expr_payload *payload = nftnl_expr_data(e); - if (e->flags & (1 << NFT_EXPR_PAYLOAD_DREG)) + if (e->flags & (1 << NFTNL_EXPR_PAYLOAD_DREG)) mnl_attr_put_u32(nlh, NFTA_PAYLOAD_DREG, htonl(payload->dreg)); - if (e->flags & (1 << NFT_EXPR_PAYLOAD_BASE)) + if (e->flags & (1 << NFTNL_EXPR_PAYLOAD_BASE)) mnl_attr_put_u32(nlh, NFTA_PAYLOAD_BASE, htonl(payload->base)); - if (e->flags & (1 << NFT_EXPR_PAYLOAD_OFFSET)) + if (e->flags & (1 << NFTNL_EXPR_PAYLOAD_OFFSET)) mnl_attr_put_u32(nlh, NFTA_PAYLOAD_OFFSET, htonl(payload->offset)); - if (e->flags & (1 << NFT_EXPR_PAYLOAD_LEN)) + if (e->flags & (1 << NFTNL_EXPR_PAYLOAD_LEN)) mnl_attr_put_u32(nlh, NFTA_PAYLOAD_LEN, htonl(payload->len)); } static int -nft_rule_expr_payload_parse(struct nft_rule_expr *e, struct nlattr *attr) +nftnl_rule_expr_payload_parse(struct nftnl_rule_expr *e, struct nlattr *attr) { - struct nft_expr_payload *payload = nft_expr_data(e); + struct nftnl_expr_payload *payload = nftnl_expr_data(e); struct nlattr *tb[NFTA_PAYLOAD_MAX+1] = {}; - if (mnl_attr_parse_nested(attr, nft_rule_expr_payload_cb, tb) < 0) + if (mnl_attr_parse_nested(attr, nftnl_rule_expr_payload_cb, tb) < 0) return -1; if (tb[NFTA_PAYLOAD_DREG]) { payload->dreg = ntohl(mnl_attr_get_u32(tb[NFTA_PAYLOAD_DREG])); - e->flags |= (1 << NFT_EXPR_PAYLOAD_DREG); + e->flags |= (1 << NFTNL_EXPR_PAYLOAD_DREG); } if (tb[NFTA_PAYLOAD_BASE]) { payload->base = ntohl(mnl_attr_get_u32(tb[NFTA_PAYLOAD_BASE])); - e->flags |= (1 << NFT_EXPR_PAYLOAD_BASE); + e->flags |= (1 << NFTNL_EXPR_PAYLOAD_BASE); } if (tb[NFTA_PAYLOAD_OFFSET]) { payload->offset = ntohl(mnl_attr_get_u32(tb[NFTA_PAYLOAD_OFFSET])); - e->flags |= (1 << NFT_EXPR_PAYLOAD_OFFSET); + e->flags |= (1 << NFTNL_EXPR_PAYLOAD_OFFSET); } if (tb[NFTA_PAYLOAD_LEN]) { payload->len = ntohl(mnl_attr_get_u32(tb[NFTA_PAYLOAD_LEN])); - e->flags |= (1 << NFT_EXPR_PAYLOAD_LEN); + e->flags |= (1 << NFTNL_EXPR_PAYLOAD_LEN); } return 0; @@ -159,7 +159,7 @@ static const char *base2str(enum nft_payload_bases base) return base2str_array[base]; } -static inline int nft_str2base(const char *base) +static inline int nftnl_str2base(const char *base) { if (strcmp(base, "link") == 0) return NFT_PAYLOAD_LL_HEADER; @@ -174,32 +174,32 @@ static inline int nft_str2base(const char *base) } static int -nft_rule_expr_payload_json_parse(struct nft_rule_expr *e, json_t *root, - struct nft_parse_err *err) +nftnl_rule_expr_payload_json_parse(struct nftnl_rule_expr *e, json_t *root, + struct nftnl_parse_err *err) { #ifdef JSON_PARSING const char *base_str; uint32_t reg, uval32; int base; - if (nft_jansson_parse_reg(root, "dreg", NFT_TYPE_U32, ®, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_PAYLOAD_DREG, reg); + if (nftnl_jansson_parse_reg(root, "dreg", NFTNL_TYPE_U32, ®, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_PAYLOAD_DREG, reg); - base_str = nft_jansson_parse_str(root, "base", err); + base_str = nftnl_jansson_parse_str(root, "base", err); if (base_str != NULL) { - base = nft_str2base(base_str); + base = nftnl_str2base(base_str); if (base < 0) return -1; - nft_rule_expr_set_u32(e, NFT_EXPR_PAYLOAD_BASE, base); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_PAYLOAD_BASE, base); } - if (nft_jansson_parse_val(root, "offset", NFT_TYPE_U32, &uval32, + if (nftnl_jansson_parse_val(root, "offset", NFTNL_TYPE_U32, &uval32, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_PAYLOAD_OFFSET, uval32); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_PAYLOAD_OFFSET, uval32); - if (nft_jansson_parse_val(root, "len", NFT_TYPE_U32, &uval32, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_PAYLOAD_LEN, uval32); + if (nftnl_jansson_parse_val(root, "len", NFTNL_TYPE_U32, &uval32, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_PAYLOAD_LEN, uval32); return 0; #else @@ -209,36 +209,36 @@ nft_rule_expr_payload_json_parse(struct nft_rule_expr *e, json_t *root, } static int -nft_rule_expr_payload_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, - struct nft_parse_err *err) +nftnl_rule_expr_payload_xml_parse(struct nftnl_rule_expr *e, mxml_node_t *tree, + struct nftnl_parse_err *err) { #ifdef XML_PARSING const char *base_str; int32_t base; uint32_t dreg, offset, len; - if (nft_mxml_reg_parse(tree, "dreg", &dreg, MXML_DESCEND_FIRST, - NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_PAYLOAD_DREG, dreg); + if (nftnl_mxml_reg_parse(tree, "dreg", &dreg, MXML_DESCEND_FIRST, + NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_PAYLOAD_DREG, dreg); - base_str = nft_mxml_str_parse(tree, "base", MXML_DESCEND_FIRST, - NFT_XML_MAND, err); + base_str = nftnl_mxml_str_parse(tree, "base", MXML_DESCEND_FIRST, + NFTNL_XML_MAND, err); if (base_str != NULL) { - base = nft_str2base(base_str); + base = nftnl_str2base(base_str); if (base < 0) return -1; - nft_rule_expr_set_u32(e, NFT_EXPR_PAYLOAD_BASE, base); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_PAYLOAD_BASE, base); } - if (nft_mxml_num_parse(tree, "offset", MXML_DESCEND_FIRST, BASE_DEC, - &offset, NFT_TYPE_U32, NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_PAYLOAD_OFFSET, offset); + if (nftnl_mxml_num_parse(tree, "offset", MXML_DESCEND_FIRST, BASE_DEC, + &offset, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_PAYLOAD_OFFSET, offset); - if (nft_mxml_num_parse(tree, "len", MXML_DESCEND_FIRST, BASE_DEC, - &len, NFT_TYPE_U32, NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_PAYLOAD_LEN, len); + if (nftnl_mxml_num_parse(tree, "len", MXML_DESCEND_FIRST, BASE_DEC, + &len, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_PAYLOAD_LEN, len); return 0; #else @@ -247,38 +247,38 @@ nft_rule_expr_payload_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, #endif } -static int nft_rule_expr_payload_export(char *buf, size_t size, uint32_t flags, - struct nft_rule_expr *e, int type) +static int nftnl_rule_expr_payload_export(char *buf, size_t size, uint32_t flags, + struct nftnl_rule_expr *e, int type) { - struct nft_expr_payload *payload = nft_expr_data(e); - NFT_BUF_INIT(b, buf, size); - - if (e->flags & (1 << NFT_EXPR_PAYLOAD_DREG)) - nft_buf_u32(&b, type, payload->dreg, DREG); - if (e->flags & (1 << NFT_EXPR_PAYLOAD_OFFSET)) - nft_buf_u32(&b, type, payload->offset, OFFSET); - if (e->flags & (1 << NFT_EXPR_PAYLOAD_LEN)) - nft_buf_u32(&b, type, payload->len, LEN); - if (e->flags & (1 << NFT_EXPR_PAYLOAD_BASE)) - nft_buf_str(&b, type, base2str(payload->base), BASE); - - return nft_buf_done(&b); + struct nftnl_expr_payload *payload = nftnl_expr_data(e); + NFTNL_BUF_INIT(b, buf, size); + + if (e->flags & (1 << NFTNL_EXPR_PAYLOAD_DREG)) + nftnl_buf_u32(&b, type, payload->dreg, DREG); + if (e->flags & (1 << NFTNL_EXPR_PAYLOAD_OFFSET)) + nftnl_buf_u32(&b, type, payload->offset, OFFSET); + if (e->flags & (1 << NFTNL_EXPR_PAYLOAD_LEN)) + nftnl_buf_u32(&b, type, payload->len, LEN); + if (e->flags & (1 << NFTNL_EXPR_PAYLOAD_BASE)) + nftnl_buf_str(&b, type, base2str(payload->base), BASE); + + return nftnl_buf_done(&b); } static int -nft_rule_expr_payload_snprintf(char *buf, size_t len, uint32_t type, - uint32_t flags, struct nft_rule_expr *e) +nftnl_rule_expr_payload_snprintf(char *buf, size_t len, uint32_t type, + uint32_t flags, struct nftnl_rule_expr *e) { - struct nft_expr_payload *payload = nft_expr_data(e); + struct nftnl_expr_payload *payload = nftnl_expr_data(e); switch (type) { - case NFT_OUTPUT_DEFAULT: + case NFTNL_OUTPUT_DEFAULT: return snprintf(buf, len, "load %ub @ %s header + %u => reg %u ", payload->len, base2str(payload->base), payload->offset, payload->dreg); - case NFT_OUTPUT_XML: - case NFT_OUTPUT_JSON: - return nft_rule_expr_payload_export(buf, len, flags, e, type); + case NFTNL_OUTPUT_XML: + case NFTNL_OUTPUT_JSON: + return nftnl_rule_expr_payload_export(buf, len, flags, e, type); default: break; } @@ -287,13 +287,13 @@ nft_rule_expr_payload_snprintf(char *buf, size_t len, uint32_t type, struct expr_ops expr_ops_payload = { .name = "payload", - .alloc_len = sizeof(struct nft_expr_payload), + .alloc_len = sizeof(struct nftnl_expr_payload), .max_attr = NFTA_PAYLOAD_MAX, - .set = nft_rule_expr_payload_set, - .get = nft_rule_expr_payload_get, - .parse = nft_rule_expr_payload_parse, - .build = nft_rule_expr_payload_build, - .snprintf = nft_rule_expr_payload_snprintf, - .xml_parse = nft_rule_expr_payload_xml_parse, - .json_parse = nft_rule_expr_payload_json_parse, + .set = nftnl_rule_expr_payload_set, + .get = nftnl_rule_expr_payload_get, + .parse = nftnl_rule_expr_payload_parse, + .build = nftnl_rule_expr_payload_build, + .snprintf = nftnl_rule_expr_payload_snprintf, + .xml_parse = nftnl_rule_expr_payload_xml_parse, + .json_parse = nftnl_rule_expr_payload_json_parse, }; diff --git a/src/expr/queue.c b/src/expr/queue.c index 5e2a49e..e388968 100644 --- a/src/expr/queue.c +++ b/src/expr/queue.c @@ -20,25 +20,25 @@ #include <libnftnl/expr.h> #include <libnftnl/rule.h> -struct nft_expr_queue { +struct nftnl_expr_queue { uint16_t queuenum; uint16_t queues_total; uint16_t flags; }; -static int nft_rule_expr_queue_set(struct nft_rule_expr *e, uint16_t type, +static int nftnl_rule_expr_queue_set(struct nftnl_rule_expr *e, uint16_t type, const void *data, uint32_t data_len) { - struct nft_expr_queue *queue = nft_expr_data(e); + struct nftnl_expr_queue *queue = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_QUEUE_NUM: + case NFTNL_EXPR_QUEUE_NUM: queue->queuenum = *((uint16_t *)data); break; - case NFT_EXPR_QUEUE_TOTAL: + case NFTNL_EXPR_QUEUE_TOTAL: queue->queues_total = *((uint16_t *)data); break; - case NFT_EXPR_QUEUE_FLAGS: + case NFTNL_EXPR_QUEUE_FLAGS: queue->flags = *((uint16_t *)data); break; default: @@ -48,26 +48,26 @@ static int nft_rule_expr_queue_set(struct nft_rule_expr *e, uint16_t type, } static const void * -nft_rule_expr_queue_get(const struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_queue_get(const struct nftnl_rule_expr *e, uint16_t type, uint32_t *data_len) { - struct nft_expr_queue *queue = nft_expr_data(e); + struct nftnl_expr_queue *queue = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_QUEUE_NUM: + case NFTNL_EXPR_QUEUE_NUM: *data_len = sizeof(queue->queuenum); return &queue->queuenum; - case NFT_EXPR_QUEUE_TOTAL: + case NFTNL_EXPR_QUEUE_TOTAL: *data_len = sizeof(queue->queues_total); return &queue->queues_total; - case NFT_EXPR_QUEUE_FLAGS: + case NFTNL_EXPR_QUEUE_FLAGS: *data_len = sizeof(queue->flags); return &queue->flags; } return NULL; } -static int nft_rule_expr_queue_cb(const struct nlattr *attr, void *data) +static int nftnl_rule_expr_queue_cb(const struct nlattr *attr, void *data) { const struct nlattr **tb = data; int type = mnl_attr_get_type(attr); @@ -89,60 +89,60 @@ static int nft_rule_expr_queue_cb(const struct nlattr *attr, void *data) } static void -nft_rule_expr_queue_build(struct nlmsghdr *nlh, struct nft_rule_expr *e) +nftnl_rule_expr_queue_build(struct nlmsghdr *nlh, struct nftnl_rule_expr *e) { - struct nft_expr_queue *queue = nft_expr_data(e); + struct nftnl_expr_queue *queue = nftnl_expr_data(e); - if (e->flags & (1 << NFT_EXPR_QUEUE_NUM)) + if (e->flags & (1 << NFTNL_EXPR_QUEUE_NUM)) mnl_attr_put_u16(nlh, NFTA_QUEUE_NUM, htons(queue->queuenum)); - if (e->flags & (1 << NFT_EXPR_QUEUE_TOTAL)) + if (e->flags & (1 << NFTNL_EXPR_QUEUE_TOTAL)) mnl_attr_put_u16(nlh, NFTA_QUEUE_TOTAL, htons(queue->queues_total)); - if (e->flags & (1 << NFT_EXPR_QUEUE_FLAGS)) + if (e->flags & (1 << NFTNL_EXPR_QUEUE_FLAGS)) mnl_attr_put_u16(nlh, NFTA_QUEUE_FLAGS, htons(queue->flags)); } static int -nft_rule_expr_queue_parse(struct nft_rule_expr *e, struct nlattr *attr) +nftnl_rule_expr_queue_parse(struct nftnl_rule_expr *e, struct nlattr *attr) { - struct nft_expr_queue *queue = nft_expr_data(e); + struct nftnl_expr_queue *queue = nftnl_expr_data(e); struct nlattr *tb[NFTA_QUEUE_MAX+1] = {}; - if (mnl_attr_parse_nested(attr, nft_rule_expr_queue_cb, tb) < 0) + if (mnl_attr_parse_nested(attr, nftnl_rule_expr_queue_cb, tb) < 0) return -1; if (tb[NFTA_QUEUE_NUM]) { queue->queuenum = ntohs(mnl_attr_get_u16(tb[NFTA_QUEUE_NUM])); - e->flags |= (1 << NFT_EXPR_QUEUE_NUM); + e->flags |= (1 << NFTNL_EXPR_QUEUE_NUM); } if (tb[NFTA_QUEUE_TOTAL]) { queue->queues_total = ntohs(mnl_attr_get_u16(tb[NFTA_QUEUE_TOTAL])); - e->flags |= (1 << NFT_EXPR_QUEUE_TOTAL); + e->flags |= (1 << NFTNL_EXPR_QUEUE_TOTAL); } if (tb[NFTA_QUEUE_FLAGS]) { queue->flags = ntohs(mnl_attr_get_u16(tb[NFTA_QUEUE_FLAGS])); - e->flags |= (1 << NFT_EXPR_QUEUE_FLAGS); + e->flags |= (1 << NFTNL_EXPR_QUEUE_FLAGS); } return 0; } static int -nft_rule_expr_queue_json_parse(struct nft_rule_expr *e, json_t *root, - struct nft_parse_err *err) +nftnl_rule_expr_queue_json_parse(struct nftnl_rule_expr *e, json_t *root, + struct nftnl_parse_err *err) { #ifdef JSON_PARSING uint16_t type; uint16_t code; - if (nft_jansson_parse_val(root, "num", NFT_TYPE_U16, &type, err) == 0) - nft_rule_expr_set_u16(e, NFT_EXPR_QUEUE_NUM, type); - nft_rule_expr_set_u16(e, NFT_EXPR_QUEUE_NUM, type); + if (nftnl_jansson_parse_val(root, "num", NFTNL_TYPE_U16, &type, err) == 0) + nftnl_rule_expr_set_u16(e, NFTNL_EXPR_QUEUE_NUM, type); + nftnl_rule_expr_set_u16(e, NFTNL_EXPR_QUEUE_NUM, type); - if (nft_jansson_parse_val(root, "total", NFT_TYPE_U16, &code, err) == 0) - nft_rule_expr_set_u16(e, NFT_EXPR_QUEUE_TOTAL, code); + if (nftnl_jansson_parse_val(root, "total", NFTNL_TYPE_U16, &code, err) == 0) + nftnl_rule_expr_set_u16(e, NFTNL_EXPR_QUEUE_TOTAL, code); - if (nft_jansson_parse_val(root, "flags", NFT_TYPE_U16, &code, err) == 0) - nft_rule_expr_set_u16(e, NFT_EXPR_QUEUE_FLAGS, code); + if (nftnl_jansson_parse_val(root, "flags", NFTNL_TYPE_U16, &code, err) == 0) + nftnl_rule_expr_set_u16(e, NFTNL_EXPR_QUEUE_FLAGS, code); return 0; #else @@ -152,26 +152,26 @@ nft_rule_expr_queue_json_parse(struct nft_rule_expr *e, json_t *root, } static int -nft_rule_expr_queue_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, - struct nft_parse_err *err) +nftnl_rule_expr_queue_xml_parse(struct nftnl_rule_expr *e, mxml_node_t *tree, + struct nftnl_parse_err *err) { #ifdef XML_PARSING uint16_t queue_num, queue_total, flags; - if (nft_mxml_num_parse(tree, "num", MXML_DESCEND_FIRST, BASE_DEC, - &queue_num, NFT_TYPE_U16, NFT_XML_MAND, + if (nftnl_mxml_num_parse(tree, "num", MXML_DESCEND_FIRST, BASE_DEC, + &queue_num, NFTNL_TYPE_U16, NFTNL_XML_MAND, err) == 0) - nft_rule_expr_set_u16(e, NFT_EXPR_QUEUE_NUM, queue_num); + nftnl_rule_expr_set_u16(e, NFTNL_EXPR_QUEUE_NUM, queue_num); - if (nft_mxml_num_parse(tree, "total", MXML_DESCEND_FIRST, BASE_DEC, - &queue_total, NFT_TYPE_U16, - NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u16(e, NFT_EXPR_QUEUE_TOTAL, queue_total); + if (nftnl_mxml_num_parse(tree, "total", MXML_DESCEND_FIRST, BASE_DEC, + &queue_total, NFTNL_TYPE_U16, + NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u16(e, NFTNL_EXPR_QUEUE_TOTAL, queue_total); - if (nft_mxml_num_parse(tree, "flags", MXML_DESCEND_FIRST, BASE_DEC, - &flags, NFT_TYPE_U16, - NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u16(e, NFT_EXPR_QUEUE_FLAGS, flags); + if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND_FIRST, BASE_DEC, + &flags, NFTNL_TYPE_U16, + NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u16(e, NFTNL_EXPR_QUEUE_FLAGS, flags); return 0; #else @@ -180,10 +180,10 @@ nft_rule_expr_queue_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, #endif } -static int nft_rule_expr_queue_snprintf_default(char *buf, size_t len, - struct nft_rule_expr *e) +static int nftnl_rule_expr_queue_snprintf_default(char *buf, size_t len, + struct nftnl_rule_expr *e) { - struct nft_expr_queue *queue = nft_expr_data(e); + struct nftnl_expr_queue *queue = nftnl_expr_data(e); int ret, size = len, offset = 0; uint16_t total_queues; @@ -197,7 +197,7 @@ static int nft_rule_expr_queue_snprintf_default(char *buf, size_t len, SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (e->flags & (1 << NFT_EXPR_QUEUE_FLAGS)) { + if (e->flags & (1 << NFTNL_EXPR_QUEUE_FLAGS)) { if (queue->flags & (NFT_QUEUE_FLAG_BYPASS)) { ret = snprintf(buf + offset, len, " bypass"); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); @@ -210,33 +210,33 @@ static int nft_rule_expr_queue_snprintf_default(char *buf, size_t len, return offset; } -static int nft_rule_expr_queue_export(char *buf, size_t size, - struct nft_rule_expr *e, int type) +static int nftnl_rule_expr_queue_export(char *buf, size_t size, + struct nftnl_rule_expr *e, int type) { - struct nft_expr_queue *queue = nft_expr_data(e); - NFT_BUF_INIT(b, buf, size); + struct nftnl_expr_queue *queue = nftnl_expr_data(e); + NFTNL_BUF_INIT(b, buf, size); - if (e->flags & (1 << NFT_EXPR_QUEUE_NUM)) - nft_buf_u32(&b, type, queue->queuenum, NUM); - if (e->flags & (1 << NFT_EXPR_QUEUE_TOTAL)) - nft_buf_u32(&b, type, queue->queues_total, TOTAL); - if (e->flags & (1 << NFT_EXPR_QUEUE_FLAGS)) - nft_buf_u32(&b, type, queue->flags, FLAGS); + if (e->flags & (1 << NFTNL_EXPR_QUEUE_NUM)) + nftnl_buf_u32(&b, type, queue->queuenum, NUM); + if (e->flags & (1 << NFTNL_EXPR_QUEUE_TOTAL)) + nftnl_buf_u32(&b, type, queue->queues_total, TOTAL); + if (e->flags & (1 << NFTNL_EXPR_QUEUE_FLAGS)) + nftnl_buf_u32(&b, type, queue->flags, FLAGS); - return nft_buf_done(&b); + return nftnl_buf_done(&b); } static int -nft_rule_expr_queue_snprintf(char *buf, size_t len, uint32_t type, - uint32_t flags, struct nft_rule_expr *e) +nftnl_rule_expr_queue_snprintf(char *buf, size_t len, uint32_t type, + uint32_t flags, struct nftnl_rule_expr *e) { switch (type) { - case NFT_OUTPUT_DEFAULT: - return nft_rule_expr_queue_snprintf_default(buf, len, e); - case NFT_OUTPUT_XML: - case NFT_OUTPUT_JSON: - return nft_rule_expr_queue_export(buf, len, e, type); + case NFTNL_OUTPUT_DEFAULT: + return nftnl_rule_expr_queue_snprintf_default(buf, len, e); + case NFTNL_OUTPUT_XML: + case NFTNL_OUTPUT_JSON: + return nftnl_rule_expr_queue_export(buf, len, e, type); default: break; } @@ -245,13 +245,13 @@ nft_rule_expr_queue_snprintf(char *buf, size_t len, uint32_t type, struct expr_ops expr_ops_queue = { .name = "queue", - .alloc_len = sizeof(struct nft_expr_queue), + .alloc_len = sizeof(struct nftnl_expr_queue), .max_attr = NFTA_QUEUE_MAX, - .set = nft_rule_expr_queue_set, - .get = nft_rule_expr_queue_get, - .parse = nft_rule_expr_queue_parse, - .build = nft_rule_expr_queue_build, - .snprintf = nft_rule_expr_queue_snprintf, - .xml_parse = nft_rule_expr_queue_xml_parse, - .json_parse = nft_rule_expr_queue_json_parse, + .set = nftnl_rule_expr_queue_set, + .get = nftnl_rule_expr_queue_get, + .parse = nftnl_rule_expr_queue_parse, + .build = nftnl_rule_expr_queue_build, + .snprintf = nftnl_rule_expr_queue_snprintf, + .xml_parse = nftnl_rule_expr_queue_xml_parse, + .json_parse = nftnl_rule_expr_queue_json_parse, }; diff --git a/src/expr/redir.c b/src/expr/redir.c index 69bd94f..d73730d 100644 --- a/src/expr/redir.c +++ b/src/expr/redir.c @@ -20,26 +20,26 @@ #include <libnftnl/expr.h> #include <libnftnl/rule.h> -struct nft_expr_redir { +struct nftnl_expr_redir { enum nft_registers sreg_proto_min; enum nft_registers sreg_proto_max; uint32_t flags; }; static int -nft_rule_expr_redir_set(struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_redir_set(struct nftnl_rule_expr *e, uint16_t type, const void *data, uint32_t data_len) { - struct nft_expr_redir *redir = nft_expr_data(e); + struct nftnl_expr_redir *redir = nftnl_expr_data(e); switch (type) { - case NFT_EXPR_REDIR_REG_PROTO_MIN: + case NFTNL_EXPR_REDIR_REG_PROTO_MIN: redir->sreg_proto_min = *((uint32_t *)data); break; - case NFT_EXPR_REDIR_REG_PROTO_MAX: + case NFTNL_EXPR_REDIR_REG_PROTO_MAX: redir->sreg_proto_max = *((uint32_t *)data); break; - case NFT_EXPR_REDIR_FLAGS: + case NFTNL_EXPR_REDIR_FLAGS: redir->flags = *((uint32_t *)data); break; default: @@ -49,26 +49,26 @@ nft_rule_expr_redir_set(struct nft_rule_expr *e, uint16_t type, } static const void * -nft_rule_expr_redir_get(const struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_redir_get(const struct nftnl_rule_expr *e, uint16_t type, uint32_t *data_len) { - struct nft_expr_redir *redir = nft_expr_data(e); + struct nftnl_expr_redir *redir = nftnl_expr_data(e); switch (type) { - case NFT_EXPR_REDIR_REG_PROTO_MIN: + case NFTNL_EXPR_REDIR_REG_PROTO_MIN: *data_len = sizeof(redir->sreg_proto_min); return &redir->sreg_proto_min; - case NFT_EXPR_REDIR_REG_PROTO_MAX: + case NFTNL_EXPR_REDIR_REG_PROTO_MAX: *data_len = sizeof(redir->sreg_proto_max); return &redir->sreg_proto_max; - case NFT_EXPR_REDIR_FLAGS: + case NFTNL_EXPR_REDIR_FLAGS: *data_len = sizeof(redir->flags); return &redir->flags; } return NULL; } -static int nft_rule_expr_redir_cb(const struct nlattr *attr, void *data) +static int nftnl_rule_expr_redir_cb(const struct nlattr *attr, void *data) { const struct nlattr **tb = data; int type = mnl_attr_get_type(attr); @@ -90,65 +90,65 @@ static int nft_rule_expr_redir_cb(const struct nlattr *attr, void *data) } static void -nft_rule_expr_redir_build(struct nlmsghdr *nlh, struct nft_rule_expr *e) +nftnl_rule_expr_redir_build(struct nlmsghdr *nlh, struct nftnl_rule_expr *e) { - struct nft_expr_redir *redir = nft_expr_data(e); + struct nftnl_expr_redir *redir = nftnl_expr_data(e); - if (e->flags & (1 << NFT_EXPR_REDIR_REG_PROTO_MIN)) + if (e->flags & (1 << NFTNL_EXPR_REDIR_REG_PROTO_MIN)) mnl_attr_put_u32(nlh, NFTA_REDIR_REG_PROTO_MIN, htobe32(redir->sreg_proto_min)); - if (e->flags & (1 << NFT_EXPR_REDIR_REG_PROTO_MAX)) + if (e->flags & (1 << NFTNL_EXPR_REDIR_REG_PROTO_MAX)) mnl_attr_put_u32(nlh, NFTA_REDIR_REG_PROTO_MAX, htobe32(redir->sreg_proto_max)); - if (e->flags & (1 << NFT_EXPR_REDIR_FLAGS)) + if (e->flags & (1 << NFTNL_EXPR_REDIR_FLAGS)) mnl_attr_put_u32(nlh, NFTA_REDIR_FLAGS, htobe32(redir->flags)); } static int -nft_rule_expr_redir_parse(struct nft_rule_expr *e, struct nlattr *attr) +nftnl_rule_expr_redir_parse(struct nftnl_rule_expr *e, struct nlattr *attr) { - struct nft_expr_redir *redir = nft_expr_data(e); + struct nftnl_expr_redir *redir = nftnl_expr_data(e); struct nlattr *tb[NFTA_REDIR_MAX + 1] = {}; - if (mnl_attr_parse_nested(attr, nft_rule_expr_redir_cb, tb) < 0) + if (mnl_attr_parse_nested(attr, nftnl_rule_expr_redir_cb, tb) < 0) return -1; if (tb[NFTA_REDIR_REG_PROTO_MIN]) { redir->sreg_proto_min = ntohl(mnl_attr_get_u32(tb[NFTA_REDIR_REG_PROTO_MIN])); - e->flags |= (1 << NFT_EXPR_REDIR_REG_PROTO_MIN); + e->flags |= (1 << NFTNL_EXPR_REDIR_REG_PROTO_MIN); } if (tb[NFTA_REDIR_REG_PROTO_MAX]) { redir->sreg_proto_max = ntohl(mnl_attr_get_u32(tb[NFTA_REDIR_REG_PROTO_MAX])); - e->flags |= (1 << NFT_EXPR_REDIR_REG_PROTO_MAX); + e->flags |= (1 << NFTNL_EXPR_REDIR_REG_PROTO_MAX); } if (tb[NFTA_REDIR_FLAGS]) { redir->flags = be32toh(mnl_attr_get_u32(tb[NFTA_REDIR_FLAGS])); - e->flags |= (1 << NFT_EXPR_REDIR_FLAGS); + e->flags |= (1 << NFTNL_EXPR_REDIR_FLAGS); } return 0; } static int -nft_rule_expr_redir_json_parse(struct nft_rule_expr *e, json_t *root, - struct nft_parse_err *err) +nftnl_rule_expr_redir_json_parse(struct nftnl_rule_expr *e, json_t *root, + struct nftnl_parse_err *err) { #ifdef JSON_PARSING uint32_t reg, flags; - if (nft_jansson_parse_reg(root, "sreg_proto_min", NFT_TYPE_U32, + if (nftnl_jansson_parse_reg(root, "sreg_proto_min", NFTNL_TYPE_U32, ®, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_REDIR_REG_PROTO_MIN, reg); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_REDIR_REG_PROTO_MIN, reg); - if (nft_jansson_parse_reg(root, "sreg_proto_max", NFT_TYPE_U32, + if (nftnl_jansson_parse_reg(root, "sreg_proto_max", NFTNL_TYPE_U32, ®, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_REDIR_REG_PROTO_MAX, reg); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_REDIR_REG_PROTO_MAX, reg); - if (nft_jansson_parse_val(root, "flags", NFT_TYPE_U32, &flags, + if (nftnl_jansson_parse_val(root, "flags", NFTNL_TYPE_U32, &flags, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_REDIR_FLAGS, flags); + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_REDIR_FLAGS, flags); return 0; #else @@ -158,23 +158,23 @@ nft_rule_expr_redir_json_parse(struct nft_rule_expr *e, json_t *root, } static int -nft_rule_expr_redir_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, - struct nft_parse_err *err) +nftnl_rule_expr_redir_xml_parse(struct nftnl_rule_expr *e, mxml_node_t *tree, + struct nftnl_parse_err *err) { #ifdef XML_PARSING uint32_t reg, flags; - if (nft_mxml_reg_parse(tree, "sreg_proto_min", ®, - MXML_DESCEND, NFT_XML_OPT, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_REDIR_REG_PROTO_MIN, reg); + if (nftnl_mxml_reg_parse(tree, "sreg_proto_min", ®, + MXML_DESCEND, NFTNL_XML_OPT, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_REDIR_REG_PROTO_MIN, reg); - if (nft_mxml_reg_parse(tree, "sreg_proto_max", ®, - MXML_DESCEND, NFT_XML_OPT, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_REDIR_REG_PROTO_MAX, reg); + if (nftnl_mxml_reg_parse(tree, "sreg_proto_max", ®, + MXML_DESCEND, NFTNL_XML_OPT, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_REDIR_REG_PROTO_MAX, reg); - if (nft_mxml_num_parse(tree, "flags", MXML_DESCEND_FIRST, BASE_DEC, - &flags, NFT_TYPE_U32, NFT_XML_OPT, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_REDIR_FLAGS, flags); + if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND_FIRST, BASE_DEC, + &flags, NFTNL_TYPE_U32, NFTNL_XML_OPT, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_REDIR_FLAGS, flags); return 0; #else @@ -183,41 +183,41 @@ nft_rule_expr_redir_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, #endif } -static int nft_rule_expr_redir_export(char *buf, size_t size, - struct nft_rule_expr *e, int type) +static int nftnl_rule_expr_redir_export(char *buf, size_t size, + struct nftnl_rule_expr *e, int type) { - struct nft_expr_redir *redir = nft_expr_data(e); - NFT_BUF_INIT(b, buf, size); + struct nftnl_expr_redir *redir = nftnl_expr_data(e); + NFTNL_BUF_INIT(b, buf, size); - if (e->flags & (1 << NFT_EXPR_REDIR_REG_PROTO_MIN)) - nft_buf_u32(&b, type, redir->sreg_proto_min, SREG_PROTO_MIN); - if (e->flags & (1 << NFT_EXPR_REDIR_REG_PROTO_MAX)) - nft_buf_u32(&b, type, redir->sreg_proto_max, SREG_PROTO_MAX); - if (e->flags & (1 << NFT_EXPR_REDIR_FLAGS)) - nft_buf_u32(&b, type, redir->flags, FLAGS); + if (e->flags & (1 << NFTNL_EXPR_REDIR_REG_PROTO_MIN)) + nftnl_buf_u32(&b, type, redir->sreg_proto_min, SREG_PROTO_MIN); + if (e->flags & (1 << NFTNL_EXPR_REDIR_REG_PROTO_MAX)) + nftnl_buf_u32(&b, type, redir->sreg_proto_max, SREG_PROTO_MAX); + if (e->flags & (1 << NFTNL_EXPR_REDIR_FLAGS)) + nftnl_buf_u32(&b, type, redir->flags, FLAGS); - return nft_buf_done(&b); + return nftnl_buf_done(&b); } -static int nft_rule_expr_redir_snprintf_default(char *buf, size_t len, - struct nft_rule_expr *e) +static int nftnl_rule_expr_redir_snprintf_default(char *buf, size_t len, + struct nftnl_rule_expr *e) { int ret, size = len, offset = 0; - struct nft_expr_redir *redir = nft_expr_data(e); + struct nftnl_expr_redir *redir = nftnl_expr_data(e); - if (nft_rule_expr_is_set(e, NFT_EXPR_REDIR_REG_PROTO_MIN)) { + if (nftnl_rule_expr_is_set(e, NFTNL_EXPR_REDIR_REG_PROTO_MIN)) { ret = snprintf(buf + offset, len, "proto_min reg %u ", redir->sreg_proto_min); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (nft_rule_expr_is_set(e, NFT_EXPR_REDIR_REG_PROTO_MAX)) { + if (nftnl_rule_expr_is_set(e, NFTNL_EXPR_REDIR_REG_PROTO_MAX)) { ret = snprintf(buf + offset, len, "proto_max reg %u ", redir->sreg_proto_max); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (nft_rule_expr_is_set(e, NFT_EXPR_REDIR_FLAGS)) { + if (nftnl_rule_expr_is_set(e, NFTNL_EXPR_REDIR_FLAGS)) { ret = snprintf(buf + offset , len, "flags 0x%x ", redir->flags); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); @@ -227,15 +227,15 @@ static int nft_rule_expr_redir_snprintf_default(char *buf, size_t len, } static int -nft_rule_expr_redir_snprintf(char *buf, size_t len, uint32_t type, - uint32_t flags, struct nft_rule_expr *e) +nftnl_rule_expr_redir_snprintf(char *buf, size_t len, uint32_t type, + uint32_t flags, struct nftnl_rule_expr *e) { switch (type) { - case NFT_OUTPUT_DEFAULT: - return nft_rule_expr_redir_snprintf_default(buf, len, e); - case NFT_OUTPUT_XML: - case NFT_OUTPUT_JSON: - return nft_rule_expr_redir_export(buf, len, e, type); + case NFTNL_OUTPUT_DEFAULT: + return nftnl_rule_expr_redir_snprintf_default(buf, len, e); + case NFTNL_OUTPUT_XML: + case NFTNL_OUTPUT_JSON: + return nftnl_rule_expr_redir_export(buf, len, e, type); default: break; } @@ -244,13 +244,13 @@ nft_rule_expr_redir_snprintf(char *buf, size_t len, uint32_t type, struct expr_ops expr_ops_redir = { .name = "redir", - .alloc_len = sizeof(struct nft_expr_redir), + .alloc_len = sizeof(struct nftnl_expr_redir), .max_attr = NFTA_REDIR_MAX, - .set = nft_rule_expr_redir_set, - .get = nft_rule_expr_redir_get, - .parse = nft_rule_expr_redir_parse, - .build = nft_rule_expr_redir_build, - .snprintf = nft_rule_expr_redir_snprintf, - .xml_parse = nft_rule_expr_redir_xml_parse, - .json_parse = nft_rule_expr_redir_json_parse, + .set = nftnl_rule_expr_redir_set, + .get = nftnl_rule_expr_redir_get, + .parse = nftnl_rule_expr_redir_parse, + .build = nftnl_rule_expr_redir_build, + .snprintf = nftnl_rule_expr_redir_snprintf, + .xml_parse = nftnl_rule_expr_redir_xml_parse, + .json_parse = nftnl_rule_expr_redir_json_parse, }; diff --git a/src/expr/reject.c b/src/expr/reject.c index a9c13d5..e0bfc71 100644 --- a/src/expr/reject.c +++ b/src/expr/reject.c @@ -21,21 +21,21 @@ #include <libnftnl/expr.h> #include <libnftnl/rule.h> -struct nft_expr_reject { +struct nftnl_expr_reject { uint32_t type; uint8_t icmp_code; }; -static int nft_rule_expr_reject_set(struct nft_rule_expr *e, uint16_t type, +static int nftnl_rule_expr_reject_set(struct nftnl_rule_expr *e, uint16_t type, const void *data, uint32_t data_len) { - struct nft_expr_reject *reject = nft_expr_data(e); + struct nftnl_expr_reject *reject = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_REJECT_TYPE: + case NFTNL_EXPR_REJECT_TYPE: reject->type = *((uint32_t *)data); break; - case NFT_EXPR_REJECT_CODE: + case NFTNL_EXPR_REJECT_CODE: reject->icmp_code = *((uint8_t *)data); break; default: @@ -45,23 +45,23 @@ static int nft_rule_expr_reject_set(struct nft_rule_expr *e, uint16_t type, } static const void * -nft_rule_expr_reject_get(const struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_reject_get(const struct nftnl_rule_expr *e, uint16_t type, uint32_t *data_len) { - struct nft_expr_reject *reject = nft_expr_data(e); + struct nftnl_expr_reject *reject = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_REJECT_TYPE: + case NFTNL_EXPR_REJECT_TYPE: *data_len = sizeof(reject->type); return &reject->type; - case NFT_EXPR_REJECT_CODE: + case NFTNL_EXPR_REJECT_CODE: *data_len = sizeof(reject->icmp_code); return &reject->icmp_code; } return NULL; } -static int nft_rule_expr_reject_cb(const struct nlattr *attr, void *data) +static int nftnl_rule_expr_reject_cb(const struct nlattr *attr, void *data) { const struct nlattr **tb = data; int type = mnl_attr_get_type(attr); @@ -85,50 +85,50 @@ static int nft_rule_expr_reject_cb(const struct nlattr *attr, void *data) } static void -nft_rule_expr_reject_build(struct nlmsghdr *nlh, struct nft_rule_expr *e) +nftnl_rule_expr_reject_build(struct nlmsghdr *nlh, struct nftnl_rule_expr *e) { - struct nft_expr_reject *reject = nft_expr_data(e); + struct nftnl_expr_reject *reject = nftnl_expr_data(e); - if (e->flags & (1 << NFT_EXPR_REJECT_TYPE)) + if (e->flags & (1 << NFTNL_EXPR_REJECT_TYPE)) mnl_attr_put_u32(nlh, NFTA_REJECT_TYPE, htonl(reject->type)); - if (e->flags & (1 << NFT_EXPR_REJECT_CODE)) + if (e->flags & (1 << NFTNL_EXPR_REJECT_CODE)) mnl_attr_put_u8(nlh, NFTA_REJECT_ICMP_CODE, reject->icmp_code); } static int -nft_rule_expr_reject_parse(struct nft_rule_expr *e, struct nlattr *attr) +nftnl_rule_expr_reject_parse(struct nftnl_rule_expr *e, struct nlattr *attr) { - struct nft_expr_reject *reject = nft_expr_data(e); + struct nftnl_expr_reject *reject = nftnl_expr_data(e); struct nlattr *tb[NFTA_REJECT_MAX+1] = {}; - if (mnl_attr_parse_nested(attr, nft_rule_expr_reject_cb, tb) < 0) + if (mnl_attr_parse_nested(attr, nftnl_rule_expr_reject_cb, tb) < 0) return -1; if (tb[NFTA_REJECT_TYPE]) { reject->type = ntohl(mnl_attr_get_u32(tb[NFTA_REJECT_TYPE])); - e->flags |= (1 << NFT_EXPR_REJECT_TYPE); + e->flags |= (1 << NFTNL_EXPR_REJECT_TYPE); } if (tb[NFTA_REJECT_ICMP_CODE]) { reject->icmp_code = mnl_attr_get_u8(tb[NFTA_REJECT_ICMP_CODE]); - e->flags |= (1 << NFT_EXPR_REJECT_CODE); + e->flags |= (1 << NFTNL_EXPR_REJECT_CODE); } return 0; } static int -nft_rule_expr_reject_json_parse(struct nft_rule_expr *e, json_t *root, - struct nft_parse_err *err) +nftnl_rule_expr_reject_json_parse(struct nftnl_rule_expr *e, json_t *root, + struct nftnl_parse_err *err) { #ifdef JSON_PARSING uint32_t type; uint8_t code; - if (nft_jansson_parse_val(root, "type", NFT_TYPE_U32, &type, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_REJECT_TYPE, type); + if (nftnl_jansson_parse_val(root, "type", NFTNL_TYPE_U32, &type, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_REJECT_TYPE, type); - if (nft_jansson_parse_val(root, "code", NFT_TYPE_U8, &code, err) == 0) - nft_rule_expr_set_u8(e, NFT_EXPR_REJECT_CODE, code); + if (nftnl_jansson_parse_val(root, "code", NFTNL_TYPE_U8, &code, err) == 0) + nftnl_rule_expr_set_u8(e, NFTNL_EXPR_REJECT_CODE, code); return 0; #else @@ -138,20 +138,20 @@ nft_rule_expr_reject_json_parse(struct nft_rule_expr *e, json_t *root, } static int -nft_rule_expr_reject_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, - struct nft_parse_err *err) +nftnl_rule_expr_reject_xml_parse(struct nftnl_rule_expr *e, mxml_node_t *tree, + struct nftnl_parse_err *err) { #ifdef XML_PARSING uint32_t type; uint8_t code; - if (nft_mxml_num_parse(tree, "type", MXML_DESCEND_FIRST, BASE_DEC, - &type, NFT_TYPE_U32, NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u32(e, NFT_EXPR_REJECT_TYPE, type); + if (nftnl_mxml_num_parse(tree, "type", MXML_DESCEND_FIRST, BASE_DEC, + &type, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u32(e, NFTNL_EXPR_REJECT_TYPE, type); - if (nft_mxml_num_parse(tree, "code", MXML_DESCEND_FIRST, BASE_DEC, - &code, NFT_TYPE_U8, NFT_XML_MAND, err) == 0) - nft_rule_expr_set_u8(e, NFT_EXPR_REJECT_CODE, code); + if (nftnl_mxml_num_parse(tree, "code", MXML_DESCEND_FIRST, BASE_DEC, + &code, NFTNL_TYPE_U8, NFTNL_XML_MAND, err) == 0) + nftnl_rule_expr_set_u8(e, NFTNL_EXPR_REJECT_CODE, code); return 0; #else @@ -160,39 +160,39 @@ nft_rule_expr_reject_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, #endif } -static int nft_rule_expr_reject_snprintf_default(char *buf, size_t len, - struct nft_rule_expr *e) +static int nftnl_rule_expr_reject_snprintf_default(char *buf, size_t len, + struct nftnl_rule_expr *e) { - struct nft_expr_reject *reject = nft_expr_data(e); + struct nftnl_expr_reject *reject = nftnl_expr_data(e); return snprintf(buf, len, "type %u code %u ", reject->type, reject->icmp_code); } -static int nft_rule_expr_reject_export(char *buf, size_t size, - struct nft_rule_expr *e, int type) +static int nftnl_rule_expr_reject_export(char *buf, size_t size, + struct nftnl_rule_expr *e, int type) { - struct nft_expr_reject *reject = nft_expr_data(e); - NFT_BUF_INIT(b, buf, size); + struct nftnl_expr_reject *reject = nftnl_expr_data(e); + NFTNL_BUF_INIT(b, buf, size); - if (e->flags & (1 << NFT_EXPR_REJECT_TYPE)) - nft_buf_u32(&b, type, reject->type, TYPE); - if (e->flags & (1 << NFT_EXPR_REJECT_CODE)) - nft_buf_u32(&b, type, reject->icmp_code, CODE); + if (e->flags & (1 << NFTNL_EXPR_REJECT_TYPE)) + nftnl_buf_u32(&b, type, reject->type, TYPE); + if (e->flags & (1 << NFTNL_EXPR_REJECT_CODE)) + nftnl_buf_u32(&b, type, reject->icmp_code, CODE); - return nft_buf_done(&b); + return nftnl_buf_done(&b); } static int -nft_rule_expr_reject_snprintf(char *buf, size_t len, uint32_t type, - uint32_t flags, struct nft_rule_expr *e) +nftnl_rule_expr_reject_snprintf(char *buf, size_t len, uint32_t type, + uint32_t flags, struct nftnl_rule_expr *e) { switch (type) { - case NFT_OUTPUT_DEFAULT: - return nft_rule_expr_reject_snprintf_default(buf, len, e); - case NFT_OUTPUT_XML: - case NFT_OUTPUT_JSON: - return nft_rule_expr_reject_export(buf, len, e, type); + case NFTNL_OUTPUT_DEFAULT: + return nftnl_rule_expr_reject_snprintf_default(buf, len, e); + case NFTNL_OUTPUT_XML: + case NFTNL_OUTPUT_JSON: + return nftnl_rule_expr_reject_export(buf, len, e, type); default: break; } @@ -201,13 +201,13 @@ nft_rule_expr_reject_snprintf(char *buf, size_t len, uint32_t type, struct expr_ops expr_ops_reject = { .name = "reject", - .alloc_len = sizeof(struct nft_expr_reject), + .alloc_len = sizeof(struct nftnl_expr_reject), .max_attr = NFTA_REJECT_MAX, - .set = nft_rule_expr_reject_set, - .get = nft_rule_expr_reject_get, - .parse = nft_rule_expr_reject_parse, - .build = nft_rule_expr_reject_build, - .snprintf = nft_rule_expr_reject_snprintf, - .xml_parse = nft_rule_expr_reject_xml_parse, - .json_parse = nft_rule_expr_reject_json_parse, + .set = nftnl_rule_expr_reject_set, + .get = nftnl_rule_expr_reject_get, + .parse = nftnl_rule_expr_reject_parse, + .build = nftnl_rule_expr_reject_build, + .snprintf = nftnl_rule_expr_reject_snprintf, + .xml_parse = nftnl_rule_expr_reject_xml_parse, + .json_parse = nftnl_rule_expr_reject_json_parse, }; diff --git a/src/expr/target.c b/src/expr/target.c index 65c1ce0..57d03ea 100644 --- a/src/expr/target.c +++ b/src/expr/target.c @@ -27,7 +27,7 @@ /* From include/linux/netfilter/x_tables.h */ #define XT_EXTENSION_MAXNAMELEN 29 -struct nft_expr_target { +struct nftnl_expr_target { char name[XT_EXTENSION_MAXNAMELEN]; uint32_t rev; uint32_t data_len; @@ -35,20 +35,20 @@ struct nft_expr_target { }; static int -nft_rule_expr_target_set(struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_target_set(struct nftnl_rule_expr *e, uint16_t type, const void *data, uint32_t data_len) { - struct nft_expr_target *tg = nft_expr_data(e); + struct nftnl_expr_target *tg = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_TG_NAME: + case NFTNL_EXPR_TG_NAME: snprintf(tg->name, sizeof(tg->name), "%.*s", data_len, (const char *) data); break; - case NFT_EXPR_TG_REV: + case NFTNL_EXPR_TG_REV: tg->rev = *((uint32_t *)data); break; - case NFT_EXPR_TG_INFO: + case NFTNL_EXPR_TG_INFO: if (tg->data) xfree(tg->data); @@ -62,26 +62,26 @@ nft_rule_expr_target_set(struct nft_rule_expr *e, uint16_t type, } static const void * -nft_rule_expr_target_get(const struct nft_rule_expr *e, uint16_t type, +nftnl_rule_expr_target_get(const struct nftnl_rule_expr *e, uint16_t type, uint32_t *data_len) { - struct nft_expr_target *tg = nft_expr_data(e); + struct nftnl_expr_target *tg = nftnl_expr_data(e); switch(type) { - case NFT_EXPR_TG_NAME: + case NFTNL_EXPR_TG_NAME: *data_len = sizeof(tg->name); return tg->name; - case NFT_EXPR_TG_REV: + case NFTNL_EXPR_TG_REV: *data_len = sizeof(tg->rev); return &tg->rev; - case NFT_EXPR_TG_INFO: + case NFTNL_EXPR_TG_INFO: *data_len = tg->data_len; return tg->data; } return NULL; } -static int nft_rule_expr_target_cb(const struct nlattr *attr, void *data) +static int nftnl_rule_expr_target_cb(const struct nlattr *attr, void *data) { const struct nlattr **tb = data; int type = mnl_attr_get_type(attr); @@ -109,24 +109,24 @@ static int nft_rule_expr_target_cb(const struct nlattr *attr, void *data) } static void -nft_rule_expr_target_build(struct nlmsghdr *nlh, struct nft_rule_expr *e) +nftnl_rule_expr_target_build(struct nlmsghdr *nlh, struct nftnl_rule_expr *e) { - struct nft_expr_target *tg = nft_expr_data(e); + struct nftnl_expr_target *tg = nftnl_expr_data(e); - if (e->flags & (1 << NFT_EXPR_TG_NAME)) + if (e->flags & (1 << NFTNL_EXPR_TG_NAME)) mnl_attr_put_strz(nlh, NFTA_TARGET_NAME, tg->name); - if (e->flags & (1 << NFT_EXPR_TG_REV)) + if (e->flags & (1 << NFTNL_EXPR_TG_REV)) mnl_attr_put_u32(nlh, NFTA_TARGET_REV, htonl(tg->rev)); - if (e->flags & (1 << NFT_EXPR_TG_INFO)) + if (e->flags & (1 << NFTNL_EXPR_TG_INFO)) mnl_attr_put(nlh, NFTA_TARGET_INFO, tg->data_len, tg->data); } -static int nft_rule_expr_target_parse(struct nft_rule_expr *e, struct nlattr *attr) +static int nftnl_rule_expr_target_parse(struct nftnl_rule_expr *e, struct nlattr *attr) { - struct nft_expr_target *target = nft_expr_data(e); + struct nftnl_expr_target *target = nftnl_expr_data(e); struct nlattr *tb[NFTA_TARGET_MAX+1] = {}; - if (mnl_attr_parse_nested(attr, nft_rule_expr_target_cb, tb) < 0) + if (mnl_attr_parse_nested(attr, nftnl_rule_expr_target_cb, tb) < 0) return -1; if (tb[NFTA_TARGET_NAME]) { @@ -134,12 +134,12 @@ static int nft_rule_expr_target_parse(struct nft_rule_expr *e, struct nlattr *at mnl_attr_get_str(tb[NFTA_TARGET_NAME])); target->name[XT_EXTENSION_MAXNAMELEN-1] = '\0'; - e->flags |= (1 << NFT_EXPR_TG_NAME); + e->flags |= (1 << NFTNL_EXPR_TG_NAME); } if (tb[NFTA_TARGET_REV]) { target->rev = ntohl(mnl_attr_get_u32(tb[NFTA_TARGET_REV])); - e->flags |= (1 << NFT_EXPR_TG_REV); + e->flags |= (1 << NFTNL_EXPR_TG_REV); } if (tb[NFTA_TARGET_INFO]) { @@ -158,22 +158,22 @@ static int nft_rule_expr_target_parse(struct nft_rule_expr *e, struct nlattr *at target->data = target_data; target->data_len = len; - e->flags |= (1 << NFT_EXPR_TG_INFO); + e->flags |= (1 << NFTNL_EXPR_TG_INFO); } return 0; } static int -nft_rule_expr_target_json_parse(struct nft_rule_expr *e, json_t *root, - struct nft_parse_err *err) +nftnl_rule_expr_target_json_parse(struct nftnl_rule_expr *e, json_t *root, + struct nftnl_parse_err *err) { #ifdef JSON_PARSING const char *name; - name = nft_jansson_parse_str(root, "name", err); + name = nftnl_jansson_parse_str(root, "name", err); if (name != NULL) - nft_rule_expr_set_str(e, NFT_EXPR_TG_NAME, name); + nftnl_rule_expr_set_str(e, NFTNL_EXPR_TG_NAME, name); return 0; #else @@ -183,16 +183,16 @@ nft_rule_expr_target_json_parse(struct nft_rule_expr *e, json_t *root, } static int -nft_rule_expr_target_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, - struct nft_parse_err *err) +nftnl_rule_expr_target_xml_parse(struct nftnl_rule_expr *e, mxml_node_t *tree, + struct nftnl_parse_err *err) { #ifdef XML_PARSING const char *name; - name = nft_mxml_str_parse(tree, "name", MXML_DESCEND_FIRST, - NFT_XML_MAND, err); + name = nftnl_mxml_str_parse(tree, "name", MXML_DESCEND_FIRST, + NFTNL_XML_MAND, err); if (name != NULL) - nft_rule_expr_set_str(e, NFT_EXPR_TG_NAME, name); + nftnl_rule_expr_set_str(e, NFTNL_EXPR_TG_NAME, name); /* tg->info is ignored until other solution is reached */ @@ -203,54 +203,54 @@ nft_rule_expr_target_xml_parse(struct nft_rule_expr *e, mxml_node_t *tree, #endif } -static int nft_rule_exp_target_export(char *buf, size_t size, - struct nft_rule_expr *e, int type) +static int nftnl_rule_exp_target_export(char *buf, size_t size, + struct nftnl_rule_expr *e, int type) { - struct nft_expr_target *target = nft_expr_data(e); - NFT_BUF_INIT(b, buf, size); + struct nftnl_expr_target *target = nftnl_expr_data(e); + NFTNL_BUF_INIT(b, buf, size); - if (e->flags & (1 << NFT_EXPR_TG_NAME)) - nft_buf_str(&b, type, target->name, NAME); + if (e->flags & (1 << NFTNL_EXPR_TG_NAME)) + nftnl_buf_str(&b, type, target->name, NAME); - return nft_buf_done(&b); + return nftnl_buf_done(&b); } static int -nft_rule_expr_target_snprintf(char *buf, size_t len, uint32_t type, - uint32_t flags, struct nft_rule_expr *e) +nftnl_rule_expr_target_snprintf(char *buf, size_t len, uint32_t type, + uint32_t flags, struct nftnl_rule_expr *e) { - struct nft_expr_target *target = nft_expr_data(e); + struct nftnl_expr_target *target = nftnl_expr_data(e); switch (type) { - case NFT_OUTPUT_DEFAULT: + case NFTNL_OUTPUT_DEFAULT: return snprintf(buf, len, "name %s rev %u ", target->name, target->rev); - case NFT_OUTPUT_XML: - case NFT_OUTPUT_JSON: - return nft_rule_exp_target_export(buf, len, e, type); + case NFTNL_OUTPUT_XML: + case NFTNL_OUTPUT_JSON: + return nftnl_rule_exp_target_export(buf, len, e, type); default: break; } return -1; } -static void nft_rule_expr_target_free(struct nft_rule_expr *e) +static void nftnl_rule_expr_target_free(struct nftnl_rule_expr *e) { - struct nft_expr_target *target = nft_expr_data(e); + struct nftnl_expr_target *target = nftnl_expr_data(e); xfree(target->data); } struct expr_ops expr_ops_target = { .name = "target", - .alloc_len = sizeof(struct nft_expr_target), + .alloc_len = sizeof(struct nftnl_expr_target), .max_attr = NFTA_TARGET_MAX, - .free = nft_rule_expr_target_free, - .set = nft_rule_expr_target_set, - .get = nft_rule_expr_target_get, - .parse = nft_rule_expr_target_parse, - .build = nft_rule_expr_target_build, - .snprintf = nft_rule_expr_target_snprintf, - .xml_parse = nft_rule_expr_target_xml_parse, - .json_parse = nft_rule_expr_target_json_parse, + .free = nftnl_rule_expr_target_free, + .set = nftnl_rule_expr_target_set, + .get = nftnl_rule_expr_target_get, + .parse = nftnl_rule_expr_target_parse, + .build = nftnl_rule_expr_target_build, + .snprintf = nftnl_rule_expr_target_snprintf, + .xml_parse = nftnl_rule_expr_target_xml_parse, + .json_parse = nftnl_rule_expr_target_json_parse, }; |