summaryrefslogtreecommitdiffstats
path: root/src/expr
diff options
context:
space:
mode:
Diffstat (limited to 'src/expr')
-rw-r--r--src/expr/bitwise.c202
-rw-r--r--src/expr/byteorder.c192
-rw-r--r--src/expr/cmp.c152
-rw-r--r--src/expr/counter.c120
-rw-r--r--src/expr/ct.c174
-rw-r--r--src/expr/data_reg.c150
-rw-r--r--src/expr/dynset.c218
-rw-r--r--src/expr/exthdr.c168
-rw-r--r--src/expr/immediate.c196
-rw-r--r--src/expr/limit.c120
-rw-r--r--src/expr/log.c222
-rw-r--r--src/expr/lookup.c148
-rw-r--r--src/expr/masq.c100
-rw-r--r--src/expr/match.c114
-rw-r--r--src/expr/meta.c150
-rw-r--r--src/expr/nat.c250
-rw-r--r--src/expr/payload.c168
-rw-r--r--src/expr/queue.c150
-rw-r--r--src/expr/redir.c148
-rw-r--r--src/expr/reject.c120
-rw-r--r--src/expr/target.c114
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, &reg, err) == 0)
- nft_rule_expr_set_u32(e, NFT_EXPR_BITWISE_SREG, reg);
+ if (nftnl_jansson_parse_reg(root, "sreg", NFTNL_TYPE_U32, &reg, err) == 0)
+ nftnl_rule_expr_set_u32(e, NFTNL_EXPR_BITWISE_SREG, reg);
- if (nft_jansson_parse_reg(root, "dreg", NFT_TYPE_U32, &reg, err) == 0)
- nft_rule_expr_set_u32(e, NFT_EXPR_BITWISE_DREG, reg);
+ if (nftnl_jansson_parse_reg(root, "dreg", NFTNL_TYPE_U32, &reg, 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, &reg, err) == 0)
- nft_rule_expr_set_u32(e, NFT_EXPR_CT_DREG, reg);
+ if (nftnl_jansson_parse_reg(root, "dreg", NFTNL_TYPE_U32, &reg, err) == 0)
+ nftnl_rule_expr_set_u32(e, NFTNL_EXPR_CT_DREG, reg);
- if (nft_jansson_parse_reg(root, "sreg", NFT_TYPE_U32, &reg, err) == 0)
- nft_rule_expr_set_u32(e, NFT_EXPR_CT_SREG, reg);
+ if (nftnl_jansson_parse_reg(root, "sreg", NFTNL_TYPE_U32, &reg, 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, &reg->len, err) < 0)
+ if (nftnl_jansson_parse_val(data, "len", NFTNL_TYPE_U8, &reg->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,
- &reg->val[i], NFT_TYPE_U32, err) != 0)
+ if (nftnl_jansson_str2num(data, node_name, BASE_HEX,
+ &reg->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,
- &reg->len, NFT_TYPE_U8, NFT_XML_MAND, err) != 0)
+ if (nftnl_mxml_num_parse(tree, "len", MXML_DESCEND_FIRST, BASE_DEC,
+ &reg->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, &reg->val[i], NFT_TYPE_U32,
- NFT_XML_MAND, err) != 0)
+ if (nftnl_mxml_num_parse(tree, node_name, MXML_DESCEND_FIRST,
+ BASE_HEX, &reg->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, &reg, err) == 0)
- nft_rule_expr_set_u32(e, NFT_EXPR_IMM_DREG, reg);
+ if (nftnl_jansson_parse_reg(root, "dreg", NFTNL_TYPE_U32, &reg, 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", &reg, 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", &reg, 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, &reg,
+ if (nftnl_jansson_node_exist(root, "dreg")) {
+ if (nftnl_jansson_parse_reg(root, "dreg", NFTNL_TYPE_U32, &reg,
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, &reg,
+ if (nftnl_jansson_node_exist(root, "sreg")) {
+ if (nftnl_jansson_parse_reg(root, "sreg", NFTNL_TYPE_U32, &reg,
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,
&reg, 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,
&reg, 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,
&reg, 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,
&reg, 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", &reg_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", &reg_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", &reg_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", &reg_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", &reg_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", &reg_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", &reg_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", &reg_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, &reg, err) == 0)
- nft_rule_expr_set_u32(e, NFT_EXPR_PAYLOAD_DREG, reg);
+ if (nftnl_jansson_parse_reg(root, "dreg", NFTNL_TYPE_U32, &reg, 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,
&reg, 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,
&reg, 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", &reg,
- 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", &reg,
+ 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", &reg,
- 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", &reg,
+ 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,
};