summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/chain.c214
-rw-r--r--src/jansson.c10
-rw-r--r--src/rule.c158
-rw-r--r--src/ruleset.c66
-rw-r--r--src/set.c252
-rw-r--r--src/set_elem.c136
-rw-r--r--src/table.c70
7 files changed, 453 insertions, 453 deletions
diff --git a/src/chain.c b/src/chain.c
index 63cb91a..f40e6a3 100644
--- a/src/chain.c
+++ b/src/chain.c
@@ -118,30 +118,30 @@ void nftnl_chain_attr_unset(struct nftnl_chain *c, uint16_t attr)
return;
switch (attr) {
- case NFTNL_CHAIN_ATTR_TABLE:
+ case NFTNL_CHAIN_TABLE:
if (c->table) {
xfree(c->table);
c->table = NULL;
}
break;
- case NFTNL_CHAIN_ATTR_USE:
+ case NFTNL_CHAIN_USE:
break;
- case NFTNL_CHAIN_ATTR_TYPE:
+ case NFTNL_CHAIN_TYPE:
if (c->type) {
xfree(c->type);
c->type = NULL;
}
break;
- case NFTNL_CHAIN_ATTR_NAME:
- case NFTNL_CHAIN_ATTR_HOOKNUM:
- case NFTNL_CHAIN_ATTR_PRIO:
- case NFTNL_CHAIN_ATTR_POLICY:
- case NFTNL_CHAIN_ATTR_BYTES:
- case NFTNL_CHAIN_ATTR_PACKETS:
- case NFTNL_CHAIN_ATTR_HANDLE:
- case NFTNL_CHAIN_ATTR_FAMILY:
+ case NFTNL_CHAIN_NAME:
+ case NFTNL_CHAIN_HOOKNUM:
+ case NFTNL_CHAIN_PRIO:
+ case NFTNL_CHAIN_POLICY:
+ case NFTNL_CHAIN_BYTES:
+ case NFTNL_CHAIN_PACKETS:
+ case NFTNL_CHAIN_HANDLE:
+ case NFTNL_CHAIN_FAMILY:
break;
- case NFTNL_CHAIN_ATTR_DEV:
+ case NFTNL_CHAIN_DEV:
if (c->dev) {
xfree(c->dev);
c->dev = NULL;
@@ -155,65 +155,65 @@ void nftnl_chain_attr_unset(struct nftnl_chain *c, uint16_t attr)
}
EXPORT_SYMBOL(nftnl_chain_attr_unset, nft_chain_attr_unset);
-static uint32_t nftnl_chain_attr_validate[NFTNL_CHAIN_ATTR_MAX + 1] = {
- [NFTNL_CHAIN_ATTR_HOOKNUM] = sizeof(uint32_t),
- [NFTNL_CHAIN_ATTR_PRIO] = sizeof(int32_t),
- [NFTNL_CHAIN_ATTR_POLICY] = sizeof(uint32_t),
- [NFTNL_CHAIN_ATTR_BYTES] = sizeof(uint64_t),
- [NFTNL_CHAIN_ATTR_PACKETS] = sizeof(uint64_t),
- [NFTNL_CHAIN_ATTR_HANDLE] = sizeof(uint64_t),
- [NFTNL_CHAIN_ATTR_FAMILY] = sizeof(uint32_t),
+static uint32_t nftnl_chain_attr_validate[NFTNL_CHAIN_MAX + 1] = {
+ [NFTNL_CHAIN_HOOKNUM] = sizeof(uint32_t),
+ [NFTNL_CHAIN_PRIO] = sizeof(int32_t),
+ [NFTNL_CHAIN_POLICY] = sizeof(uint32_t),
+ [NFTNL_CHAIN_BYTES] = sizeof(uint64_t),
+ [NFTNL_CHAIN_PACKETS] = sizeof(uint64_t),
+ [NFTNL_CHAIN_HANDLE] = sizeof(uint64_t),
+ [NFTNL_CHAIN_FAMILY] = sizeof(uint32_t),
};
void nftnl_chain_attr_set_data(struct nftnl_chain *c, uint16_t attr,
const void *data, uint32_t data_len)
{
- if (attr > NFTNL_CHAIN_ATTR_MAX)
+ if (attr > NFTNL_CHAIN_MAX)
return;
nftnl_assert_validate(data, nftnl_chain_attr_validate, attr, data_len);
switch(attr) {
- case NFTNL_CHAIN_ATTR_NAME:
+ case NFTNL_CHAIN_NAME:
strncpy(c->name, data, NFT_CHAIN_MAXNAMELEN);
break;
- case NFTNL_CHAIN_ATTR_TABLE:
+ case NFTNL_CHAIN_TABLE:
if (c->table)
xfree(c->table);
c->table = strdup(data);
break;
- case NFTNL_CHAIN_ATTR_HOOKNUM:
+ case NFTNL_CHAIN_HOOKNUM:
memcpy(&c->hooknum, data, sizeof(c->hooknum));
break;
- case NFTNL_CHAIN_ATTR_PRIO:
+ case NFTNL_CHAIN_PRIO:
memcpy(&c->prio, data, sizeof(c->prio));
break;
- case NFTNL_CHAIN_ATTR_POLICY:
+ case NFTNL_CHAIN_POLICY:
c->policy = *((uint32_t *)data);
break;
- case NFTNL_CHAIN_ATTR_USE:
+ case NFTNL_CHAIN_USE:
c->use = *((uint32_t *)data);
break;
- case NFTNL_CHAIN_ATTR_BYTES:
+ case NFTNL_CHAIN_BYTES:
c->bytes = *((uint64_t *)data);
break;
- case NFTNL_CHAIN_ATTR_PACKETS:
+ case NFTNL_CHAIN_PACKETS:
c->packets = *((uint64_t *)data);
break;
- case NFTNL_CHAIN_ATTR_HANDLE:
+ case NFTNL_CHAIN_HANDLE:
c->handle = *((uint64_t *)data);
break;
- case NFTNL_CHAIN_ATTR_FAMILY:
+ case NFTNL_CHAIN_FAMILY:
c->family = *((uint32_t *)data);
break;
- case NFTNL_CHAIN_ATTR_TYPE:
+ case NFTNL_CHAIN_TYPE:
if (c->type)
xfree(c->type);
c->type = strdup(data);
break;
- case NFTNL_CHAIN_ATTR_DEV:
+ case NFTNL_CHAIN_DEV:
if (c->dev)
xfree(c->dev);
@@ -267,38 +267,38 @@ const void *nftnl_chain_attr_get_data(struct nftnl_chain *c, uint16_t attr,
return NULL;
switch(attr) {
- case NFTNL_CHAIN_ATTR_NAME:
+ case NFTNL_CHAIN_NAME:
return c->name;
- case NFTNL_CHAIN_ATTR_TABLE:
+ case NFTNL_CHAIN_TABLE:
return c->table;
- case NFTNL_CHAIN_ATTR_HOOKNUM:
+ case NFTNL_CHAIN_HOOKNUM:
*data_len = sizeof(uint32_t);
return &c->hooknum;
- case NFTNL_CHAIN_ATTR_PRIO:
+ case NFTNL_CHAIN_PRIO:
*data_len = sizeof(int32_t);
return &c->prio;
- case NFTNL_CHAIN_ATTR_POLICY:
+ case NFTNL_CHAIN_POLICY:
*data_len = sizeof(uint32_t);
return &c->policy;
- case NFTNL_CHAIN_ATTR_USE:
+ case NFTNL_CHAIN_USE:
*data_len = sizeof(uint32_t);
return &c->use;
- case NFTNL_CHAIN_ATTR_BYTES:
+ case NFTNL_CHAIN_BYTES:
*data_len = sizeof(uint64_t);
return &c->bytes;
- case NFTNL_CHAIN_ATTR_PACKETS:
+ case NFTNL_CHAIN_PACKETS:
*data_len = sizeof(uint64_t);
return &c->packets;
- case NFTNL_CHAIN_ATTR_HANDLE:
+ case NFTNL_CHAIN_HANDLE:
*data_len = sizeof(uint64_t);
return &c->handle;
- case NFTNL_CHAIN_ATTR_FAMILY:
+ case NFTNL_CHAIN_FAMILY:
*data_len = sizeof(uint32_t);
return &c->family;
- case NFTNL_CHAIN_ATTR_TYPE:
+ case NFTNL_CHAIN_TYPE:
*data_len = sizeof(uint32_t);
return c->type;
- case NFTNL_CHAIN_ATTR_DEV:
+ case NFTNL_CHAIN_DEV:
return c->dev;
}
return NULL;
@@ -364,27 +364,27 @@ EXPORT_SYMBOL(nftnl_chain_attr_get_u8, nft_chain_attr_get_u8);
void nftnl_chain_nlmsg_build_payload(struct nlmsghdr *nlh, const struct nftnl_chain *c)
{
- if (c->flags & (1 << NFTNL_CHAIN_ATTR_TABLE))
+ if (c->flags & (1 << NFTNL_CHAIN_TABLE))
mnl_attr_put_strz(nlh, NFTA_CHAIN_TABLE, c->table);
- if (c->flags & (1 << NFTNL_CHAIN_ATTR_NAME))
+ if (c->flags & (1 << NFTNL_CHAIN_NAME))
mnl_attr_put_strz(nlh, NFTA_CHAIN_NAME, c->name);
- if ((c->flags & (1 << NFTNL_CHAIN_ATTR_HOOKNUM)) &&
- (c->flags & (1 << NFTNL_CHAIN_ATTR_PRIO))) {
+ if ((c->flags & (1 << NFTNL_CHAIN_HOOKNUM)) &&
+ (c->flags & (1 << NFTNL_CHAIN_PRIO))) {
struct nlattr *nest;
nest = mnl_attr_nest_start(nlh, NFTA_CHAIN_HOOK);
mnl_attr_put_u32(nlh, NFTA_HOOK_HOOKNUM, htonl(c->hooknum));
mnl_attr_put_u32(nlh, NFTA_HOOK_PRIORITY, htonl(c->prio));
- if (c->flags & (1 << NFTNL_CHAIN_ATTR_DEV))
+ if (c->flags & (1 << NFTNL_CHAIN_DEV))
mnl_attr_put_strz(nlh, NFTA_HOOK_DEV, c->dev);
mnl_attr_nest_end(nlh, nest);
}
- if (c->flags & (1 << NFTNL_CHAIN_ATTR_POLICY))
+ if (c->flags & (1 << NFTNL_CHAIN_POLICY))
mnl_attr_put_u32(nlh, NFTA_CHAIN_POLICY, htonl(c->policy));
- if (c->flags & (1 << NFTNL_CHAIN_ATTR_USE))
+ if (c->flags & (1 << NFTNL_CHAIN_USE))
mnl_attr_put_u32(nlh, NFTA_CHAIN_USE, htonl(c->use));
- if ((c->flags & (1 << NFTNL_CHAIN_ATTR_PACKETS)) &&
- (c->flags & (1 << NFTNL_CHAIN_ATTR_BYTES))) {
+ if ((c->flags & (1 << NFTNL_CHAIN_PACKETS)) &&
+ (c->flags & (1 << NFTNL_CHAIN_BYTES))) {
struct nlattr *nest;
nest = mnl_attr_nest_start(nlh, NFTA_CHAIN_COUNTERS);
@@ -392,9 +392,9 @@ void nftnl_chain_nlmsg_build_payload(struct nlmsghdr *nlh, const struct nftnl_ch
mnl_attr_put_u64(nlh, NFTA_COUNTER_BYTES, be64toh(c->bytes));
mnl_attr_nest_end(nlh, nest);
}
- if (c->flags & (1 << NFTNL_CHAIN_ATTR_HANDLE))
+ if (c->flags & (1 << NFTNL_CHAIN_HANDLE))
mnl_attr_put_u64(nlh, NFTA_CHAIN_HANDLE, be64toh(c->handle));
- if (c->flags & (1 << NFTNL_CHAIN_ATTR_TYPE))
+ if (c->flags & (1 << NFTNL_CHAIN_TYPE))
mnl_attr_put_strz(nlh, NFTA_CHAIN_TYPE, c->type);
}
EXPORT_SYMBOL(nftnl_chain_nlmsg_build_payload, nft_chain_nlmsg_build_payload);
@@ -463,11 +463,11 @@ static int nftnl_chain_parse_counters(struct nlattr *attr, struct nftnl_chain *c
if (tb[NFTA_COUNTER_PACKETS]) {
c->packets = be64toh(mnl_attr_get_u64(tb[NFTA_COUNTER_PACKETS]));
- c->flags |= (1 << NFTNL_CHAIN_ATTR_PACKETS);
+ c->flags |= (1 << NFTNL_CHAIN_PACKETS);
}
if (tb[NFTA_COUNTER_BYTES]) {
c->bytes = be64toh(mnl_attr_get_u64(tb[NFTA_COUNTER_BYTES]));
- c->flags |= (1 << NFTNL_CHAIN_ATTR_BYTES);
+ c->flags |= (1 << NFTNL_CHAIN_BYTES);
}
return 0;
@@ -506,15 +506,15 @@ static int nftnl_chain_parse_hook(struct nlattr *attr, struct nftnl_chain *c)
if (tb[NFTA_HOOK_HOOKNUM]) {
c->hooknum = ntohl(mnl_attr_get_u32(tb[NFTA_HOOK_HOOKNUM]));
- c->flags |= (1 << NFTNL_CHAIN_ATTR_HOOKNUM);
+ c->flags |= (1 << NFTNL_CHAIN_HOOKNUM);
}
if (tb[NFTA_HOOK_PRIORITY]) {
c->prio = ntohl(mnl_attr_get_u32(tb[NFTA_HOOK_PRIORITY]));
- c->flags |= (1 << NFTNL_CHAIN_ATTR_PRIO);
+ c->flags |= (1 << NFTNL_CHAIN_PRIO);
}
if (tb[NFTA_HOOK_DEV]) {
c->dev = strdup(mnl_attr_get_str(tb[NFTA_HOOK_DEV]));
- c->flags |= (1 << NFTNL_CHAIN_ATTR_DEV);
+ c->flags |= (1 << NFTNL_CHAIN_DEV);
}
return 0;
@@ -532,12 +532,12 @@ int nftnl_chain_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_chain *c)
if (tb[NFTA_CHAIN_NAME]) {
strncpy(c->name, mnl_attr_get_str(tb[NFTA_CHAIN_NAME]),
NFT_CHAIN_MAXNAMELEN);
- c->flags |= (1 << NFTNL_CHAIN_ATTR_NAME);
+ c->flags |= (1 << NFTNL_CHAIN_NAME);
}
if (tb[NFTA_CHAIN_TABLE]) {
xfree(c->table);
c->table = strdup(mnl_attr_get_str(tb[NFTA_CHAIN_TABLE]));
- c->flags |= (1 << NFTNL_CHAIN_ATTR_TABLE);
+ c->flags |= (1 << NFTNL_CHAIN_TABLE);
}
if (tb[NFTA_CHAIN_HOOK]) {
ret = nftnl_chain_parse_hook(tb[NFTA_CHAIN_HOOK], c);
@@ -546,11 +546,11 @@ int nftnl_chain_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_chain *c)
}
if (tb[NFTA_CHAIN_POLICY]) {
c->policy = ntohl(mnl_attr_get_u32(tb[NFTA_CHAIN_POLICY]));
- c->flags |= (1 << NFTNL_CHAIN_ATTR_POLICY);
+ c->flags |= (1 << NFTNL_CHAIN_POLICY);
}
if (tb[NFTA_CHAIN_USE]) {
c->use = ntohl(mnl_attr_get_u32(tb[NFTA_CHAIN_USE]));
- c->flags |= (1 << NFTNL_CHAIN_ATTR_USE);
+ c->flags |= (1 << NFTNL_CHAIN_USE);
}
if (tb[NFTA_CHAIN_COUNTERS]) {
ret = nftnl_chain_parse_counters(tb[NFTA_CHAIN_COUNTERS], c);
@@ -559,16 +559,16 @@ int nftnl_chain_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_chain *c)
}
if (tb[NFTA_CHAIN_HANDLE]) {
c->handle = be64toh(mnl_attr_get_u64(tb[NFTA_CHAIN_HANDLE]));
- c->flags |= (1 << NFTNL_CHAIN_ATTR_HANDLE);
+ c->flags |= (1 << NFTNL_CHAIN_HANDLE);
}
if (tb[NFTA_CHAIN_TYPE]) {
xfree(c->type);
c->type = strdup(mnl_attr_get_str(tb[NFTA_CHAIN_TYPE]));
- c->flags |= (1 << NFTNL_CHAIN_ATTR_TYPE);
+ c->flags |= (1 << NFTNL_CHAIN_TYPE);
}
c->family = nfg->nfgen_family;
- c->flags |= (1 << NFTNL_CHAIN_ATTR_FAMILY);
+ c->flags |= (1 << NFTNL_CHAIN_FAMILY);
return ret;
}
@@ -601,47 +601,47 @@ int nftnl_jansson_parse_chain(struct nftnl_chain *c, json_t *tree,
name = nftnl_jansson_parse_str(root, "name", err);
if (name != NULL)
- nftnl_chain_attr_set_str(c, NFTNL_CHAIN_ATTR_NAME, name);
+ nftnl_chain_attr_set_str(c, NFTNL_CHAIN_NAME, name);
if (nftnl_jansson_parse_val(root, "handle", NFTNL_TYPE_U64, &handle,
err) == 0)
- nftnl_chain_attr_set_u64(c,NFTNL_CHAIN_ATTR_HANDLE, handle);
+ nftnl_chain_attr_set_u64(c,NFTNL_CHAIN_HANDLE, handle);
if (nftnl_jansson_parse_val(root, "bytes", NFTNL_TYPE_U64, &bytes,
err) == 0)
- nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_ATTR_BYTES, bytes);
+ nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_BYTES, bytes);
if (nftnl_jansson_parse_val(root, "packets", NFTNL_TYPE_U64, &packets,
err) == 0)
- nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_ATTR_PACKETS, packets);
+ nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_PACKETS, packets);
if (nftnl_jansson_parse_family(root, &family, err) == 0)
- nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_ATTR_FAMILY, family);
+ nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_FAMILY, family);
table = nftnl_jansson_parse_str(root, "table", err);
if (table != NULL)
- nftnl_chain_attr_set_str(c, NFTNL_CHAIN_ATTR_TABLE, table);
+ nftnl_chain_attr_set_str(c, NFTNL_CHAIN_TABLE, table);
if (nftnl_jansson_parse_val(root, "use", NFTNL_TYPE_U32, &use, err) == 0)
- nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_ATTR_USE, use);
+ nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_USE, use);
if (nftnl_jansson_node_exist(root, "hooknum")) {
type = nftnl_jansson_parse_str(root, "type", err);
if (type != NULL)
- nftnl_chain_attr_set_str(c, NFTNL_CHAIN_ATTR_TYPE, type);
+ nftnl_chain_attr_set_str(c, NFTNL_CHAIN_TYPE, type);
if (nftnl_jansson_parse_val(root, "prio", NFTNL_TYPE_S32,
&prio, err) == 0)
- nftnl_chain_attr_set_s32(c, NFTNL_CHAIN_ATTR_PRIO, prio);
+ nftnl_chain_attr_set_s32(c, NFTNL_CHAIN_PRIO, prio);
hooknum_str = nftnl_jansson_parse_str(root, "hooknum", err);
if (hooknum_str != NULL) {
hooknum = nftnl_str2hooknum(c->family, hooknum_str);
if (hooknum == -1)
return -1;
- nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_ATTR_HOOKNUM,
+ nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_HOOKNUM,
hooknum);
}
@@ -653,13 +653,13 @@ int nftnl_jansson_parse_chain(struct nftnl_chain *c, json_t *tree,
err->error = NFTNL_PARSE_EBADTYPE;
return -1;
}
- nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_ATTR_POLICY,
+ nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_POLICY,
policy_num);
}
dev = nftnl_jansson_parse_str(root, "device", err);
if (dev != NULL)
- nftnl_chain_attr_set_str(c, NFTNL_CHAIN_ATTR_DEV, dev);
+ nftnl_chain_attr_set_str(c, NFTNL_CHAIN_DEV, dev);
}
return 0;
@@ -701,35 +701,35 @@ int nftnl_mxml_chain_parse(mxml_node_t *tree, struct nftnl_chain *c,
name = nftnl_mxml_str_parse(tree, "name", MXML_DESCEND_FIRST,
NFTNL_XML_MAND, err);
if (name != NULL)
- nftnl_chain_attr_set_str(c, NFTNL_CHAIN_ATTR_NAME, name);
+ nftnl_chain_attr_set_str(c, NFTNL_CHAIN_NAME, name);
if (nftnl_mxml_num_parse(tree, "handle", MXML_DESCEND_FIRST, BASE_DEC,
&handle, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) == 0)
- nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_ATTR_HANDLE, handle);
+ nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_HANDLE, handle);
if (nftnl_mxml_num_parse(tree, "bytes", MXML_DESCEND_FIRST, BASE_DEC,
&bytes, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) == 0)
- nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_ATTR_BYTES, bytes);
+ nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_BYTES, bytes);
if (nftnl_mxml_num_parse(tree, "packets", MXML_DESCEND_FIRST, BASE_DEC,
&packets, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) == 0)
- nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_ATTR_PACKETS, packets);
+ nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_PACKETS, packets);
table = nftnl_mxml_str_parse(tree, "table", MXML_DESCEND_FIRST,
NFTNL_XML_MAND, err);
if (table != NULL)
- nftnl_chain_attr_set_str(c, NFTNL_CHAIN_ATTR_TABLE, table);
+ nftnl_chain_attr_set_str(c, NFTNL_CHAIN_TABLE, table);
if (nftnl_mxml_num_parse(tree, "use", MXML_DESCEND_FIRST, BASE_DEC,
&use, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) == 0)
- nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_ATTR_PACKETS, use);
+ nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_PACKETS, use);
family = nftnl_mxml_family_parse(tree, "family", MXML_DESCEND_FIRST,
NFTNL_XML_MAND, err);
if (family >= 0)
- nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_ATTR_FAMILY, family);
+ nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_FAMILY, family);
hooknum_str = nftnl_mxml_str_parse(tree, "hooknum", MXML_DESCEND_FIRST,
NFTNL_XML_OPT, err);
@@ -737,18 +737,18 @@ int nftnl_mxml_chain_parse(mxml_node_t *tree, struct nftnl_chain *c,
hooknum = nftnl_str2hooknum(c->family, hooknum_str);
if (hooknum < 0)
return -1;
- nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_ATTR_HOOKNUM, hooknum);
+ nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_HOOKNUM, hooknum);
type = nftnl_mxml_str_parse(tree, "type", MXML_DESCEND_FIRST,
NFTNL_XML_MAND, err);
if (type != NULL)
- nftnl_chain_attr_set_str(c, NFTNL_CHAIN_ATTR_TYPE, type);
+ nftnl_chain_attr_set_str(c, NFTNL_CHAIN_TYPE, type);
if (nftnl_mxml_num_parse(tree, "prio", MXML_DESCEND, BASE_DEC,
&prio, NFTNL_TYPE_S32, NFTNL_XML_MAND,
err) == 0)
- nftnl_chain_attr_set_s32(c, NFTNL_CHAIN_ATTR_PRIO, prio);
+ nftnl_chain_attr_set_s32(c, NFTNL_CHAIN_PRIO, prio);
policy_str = nftnl_mxml_str_parse(tree, "policy",
MXML_DESCEND_FIRST,
@@ -760,14 +760,14 @@ int nftnl_mxml_chain_parse(mxml_node_t *tree, struct nftnl_chain *c,
err->error = NFTNL_PARSE_EBADTYPE;
return -1;
}
- nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_ATTR_POLICY,
+ nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_POLICY,
policy);
}
dev = nftnl_mxml_str_parse(tree, "device", MXML_DESCEND_FIRST,
NFTNL_XML_MAND, err);
if (table != NULL)
- nftnl_chain_attr_set_str(c, NFTNL_CHAIN_ATTR_DEV, dev);
+ nftnl_chain_attr_set_str(c, NFTNL_CHAIN_DEV, dev);
}
return 0;
@@ -839,31 +839,31 @@ static int nftnl_chain_export(char *buf, size_t size, struct nftnl_chain *c,
NFTNL_BUF_INIT(b, buf, size);
nftnl_buf_open(&b, type, CHAIN);
- if (c->flags & (1 << NFTNL_CHAIN_ATTR_NAME))
+ if (c->flags & (1 << NFTNL_CHAIN_NAME))
nftnl_buf_str(&b, type, c->name, NAME);
- if (c->flags & (1 << NFTNL_CHAIN_ATTR_HANDLE))
+ if (c->flags & (1 << NFTNL_CHAIN_HANDLE))
nftnl_buf_u64(&b, type, c->handle, HANDLE);
- if (c->flags & (1 << NFTNL_CHAIN_ATTR_BYTES))
+ if (c->flags & (1 << NFTNL_CHAIN_BYTES))
nftnl_buf_u64(&b, type, c->bytes, BYTES);
- if (c->flags & (1 << NFTNL_CHAIN_ATTR_PACKETS))
+ if (c->flags & (1 << NFTNL_CHAIN_PACKETS))
nftnl_buf_u64(&b, type, c->packets, PACKETS);
- if (c->flags & (1 << NFTNL_CHAIN_ATTR_TABLE))
+ if (c->flags & (1 << NFTNL_CHAIN_TABLE))
nftnl_buf_str(&b, type, c->table, TABLE);
- if (c->flags & (1 << NFTNL_CHAIN_ATTR_FAMILY))
+ if (c->flags & (1 << NFTNL_CHAIN_FAMILY))
nftnl_buf_str(&b, type, nftnl_family2str(c->family), FAMILY);
- if (c->flags & (1 << NFTNL_CHAIN_ATTR_USE))
+ if (c->flags & (1 << NFTNL_CHAIN_USE))
nftnl_buf_u32(&b, type, c->use, USE);
- if (c->flags & (1 << NFTNL_CHAIN_ATTR_HOOKNUM)) {
- if (c->flags & (1 << NFTNL_CHAIN_ATTR_TYPE))
+ if (c->flags & (1 << NFTNL_CHAIN_HOOKNUM)) {
+ if (c->flags & (1 << NFTNL_CHAIN_TYPE))
nftnl_buf_str(&b, type, c->type, TYPE);
- if (c->flags & (1 << NFTNL_CHAIN_ATTR_HOOKNUM))
+ if (c->flags & (1 << NFTNL_CHAIN_HOOKNUM))
nftnl_buf_str(&b, type, nftnl_hooknum2str(c->family,
c->hooknum), HOOKNUM);
- if (c->flags & (1 << NFTNL_CHAIN_ATTR_PRIO))
+ if (c->flags & (1 << NFTNL_CHAIN_PRIO))
nftnl_buf_s32(&b, type, c->prio, PRIO);
- if (c->flags & (1 << NFTNL_CHAIN_ATTR_POLICY))
+ if (c->flags & (1 << NFTNL_CHAIN_POLICY))
nftnl_buf_str(&b, type, nftnl_verdict2str(c->policy), POLICY);
- if (c->flags & (1 << NFTNL_CHAIN_ATTR_DEV))
+ if (c->flags & (1 << NFTNL_CHAIN_DEV))
nftnl_buf_str(&b, type, c->dev, DEVICE);
}
@@ -881,7 +881,7 @@ static int nftnl_chain_snprintf_default(char *buf, size_t size,
nftnl_family2str(c->family), c->table, c->name, c->use);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
- if (c->flags & (1 << NFTNL_CHAIN_ATTR_HOOKNUM)) {
+ if (c->flags & (1 << NFTNL_CHAIN_HOOKNUM)) {
ret = snprintf(buf+offset, len,
" type %s hook %s prio %d policy %s "
"packets %"PRIu64" bytes %"PRIu64"",
@@ -890,7 +890,7 @@ static int nftnl_chain_snprintf_default(char *buf, size_t size,
c->packets, c->bytes);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
- if (c->flags & (1 << NFTNL_CHAIN_ATTR_DEV)) {
+ if (c->flags & (1 << NFTNL_CHAIN_DEV)) {
ret = snprintf(buf+offset, len, " dev %s ", c->dev);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
diff --git a/src/jansson.c b/src/jansson.c
index 5c89ec7..38a6b97 100644
--- a/src/jansson.c
+++ b/src/jansson.c
@@ -251,22 +251,22 @@ int nftnl_jansson_set_elem_parse(struct nftnl_set_elem *e, json_t *root,
uint32_t flags;
if (nftnl_jansson_parse_val(root, "flags", NFTNL_TYPE_U32, &flags, err) == 0)
- nftnl_set_elem_attr_set_u32(e, NFTNL_SET_ELEM_ATTR_FLAGS, flags);
+ nftnl_set_elem_attr_set_u32(e, NFTNL_SET_ELEM_FLAGS, flags);
if (nftnl_jansson_data_reg_parse(root, "key", &e->key, err) == DATA_VALUE)
- e->flags |= (1 << NFTNL_SET_ELEM_ATTR_KEY);
+ e->flags |= (1 << NFTNL_SET_ELEM_KEY);
if (nftnl_jansson_node_exist(root, "data")) {
set_elem_data = nftnl_jansson_data_reg_parse(root, "data",
&e->data, err);
switch (set_elem_data) {
case DATA_VALUE:
- e->flags |= (1 << NFTNL_SET_ELEM_ATTR_DATA);
+ e->flags |= (1 << NFTNL_SET_ELEM_DATA);
break;
case DATA_VERDICT:
- e->flags |= (1 << NFTNL_SET_ELEM_ATTR_VERDICT);
+ e->flags |= (1 << NFTNL_SET_ELEM_VERDICT);
if (e->data.chain != NULL)
- e->flags |= (1 << NFTNL_SET_ELEM_ATTR_CHAIN);
+ e->flags |= (1 << NFTNL_SET_ELEM_CHAIN);
break;
case DATA_NONE:
default:
diff --git a/src/rule.c b/src/rule.c
index 1682c66..c0b1f89 100644
--- a/src/rule.c
+++ b/src/rule.c
@@ -92,24 +92,24 @@ void nftnl_rule_attr_unset(struct nftnl_rule *r, uint16_t attr)
return;
switch (attr) {
- case NFTNL_RULE_ATTR_TABLE:
+ case NFTNL_RULE_TABLE:
if (r->table) {
xfree(r->table);
r->table = NULL;
}
break;
- case NFTNL_RULE_ATTR_CHAIN:
+ case NFTNL_RULE_CHAIN:
if (r->chain) {
xfree(r->chain);
r->chain = NULL;
}
break;
- case NFTNL_RULE_ATTR_HANDLE:
- case NFTNL_RULE_ATTR_COMPAT_PROTO:
- case NFTNL_RULE_ATTR_COMPAT_FLAGS:
- case NFTNL_RULE_ATTR_POSITION:
- case NFTNL_RULE_ATTR_FAMILY:
- case NFTNL_RULE_ATTR_USERDATA:
+ case NFTNL_RULE_HANDLE:
+ case NFTNL_RULE_COMPAT_PROTO:
+ case NFTNL_RULE_COMPAT_FLAGS:
+ case NFTNL_RULE_POSITION:
+ case NFTNL_RULE_FAMILY:
+ case NFTNL_RULE_USERDATA:
break;
}
@@ -117,51 +117,51 @@ void nftnl_rule_attr_unset(struct nftnl_rule *r, uint16_t attr)
}
EXPORT_SYMBOL(nftnl_rule_attr_unset, nft_rule_attr_unset);
-static uint32_t nftnl_rule_attr_validate[NFTNL_RULE_ATTR_MAX + 1] = {
- [NFTNL_RULE_ATTR_HANDLE] = sizeof(uint64_t),
- [NFTNL_RULE_ATTR_COMPAT_PROTO] = sizeof(uint32_t),
- [NFTNL_RULE_ATTR_COMPAT_FLAGS] = sizeof(uint32_t),
- [NFTNL_RULE_ATTR_FAMILY] = sizeof(uint32_t),
- [NFTNL_RULE_ATTR_POSITION] = sizeof(uint64_t),
+static uint32_t nftnl_rule_attr_validate[NFTNL_RULE_MAX + 1] = {
+ [NFTNL_RULE_HANDLE] = sizeof(uint64_t),
+ [NFTNL_RULE_COMPAT_PROTO] = sizeof(uint32_t),
+ [NFTNL_RULE_COMPAT_FLAGS] = sizeof(uint32_t),
+ [NFTNL_RULE_FAMILY] = sizeof(uint32_t),
+ [NFTNL_RULE_POSITION] = sizeof(uint64_t),
};
void nftnl_rule_attr_set_data(struct nftnl_rule *r, uint16_t attr,
const void *data, uint32_t data_len)
{
- if (attr > NFTNL_RULE_ATTR_MAX)
+ if (attr > NFTNL_RULE_MAX)
return;
nftnl_assert_validate(data, nftnl_rule_attr_validate, attr, data_len);
switch(attr) {
- case NFTNL_RULE_ATTR_TABLE:
+ case NFTNL_RULE_TABLE:
if (r->table)
xfree(r->table);
r->table = strdup(data);
break;
- case NFTNL_RULE_ATTR_CHAIN:
+ case NFTNL_RULE_CHAIN:
if (r->chain)
xfree(r->chain);
r->chain = strdup(data);
break;
- case NFTNL_RULE_ATTR_HANDLE:
+ case NFTNL_RULE_HANDLE:
r->handle = *((uint64_t *)data);
break;
- case NFTNL_RULE_ATTR_COMPAT_PROTO:
+ case NFTNL_RULE_COMPAT_PROTO:
r->compat.proto = *((uint32_t *)data);
break;
- case NFTNL_RULE_ATTR_COMPAT_FLAGS:
+ case NFTNL_RULE_COMPAT_FLAGS:
r->compat.flags = *((uint32_t *)data);
break;
- case NFTNL_RULE_ATTR_FAMILY:
+ case NFTNL_RULE_FAMILY:
r->family = *((uint32_t *)data);
break;
- case NFTNL_RULE_ATTR_POSITION:
+ case NFTNL_RULE_POSITION:
r->position = *((uint64_t *)data);
break;
- case NFTNL_RULE_ATTR_USERDATA:
+ case NFTNL_RULE_USERDATA:
r->user.data = (void *)data;
r->user.len = data_len;
break;
@@ -201,26 +201,26 @@ const void *nftnl_rule_attr_get_data(const struct nftnl_rule *r, uint16_t attr,
return NULL;
switch(attr) {
- case NFTNL_RULE_ATTR_FAMILY:
+ case NFTNL_RULE_FAMILY:
*data_len = sizeof(uint32_t);
return &r->family;
- case NFTNL_RULE_ATTR_TABLE:
+ case NFTNL_RULE_TABLE:
return r->table;
- case NFTNL_RULE_ATTR_CHAIN:
+ case NFTNL_RULE_CHAIN:
return r->chain;
- case NFTNL_RULE_ATTR_HANDLE:
+ case NFTNL_RULE_HANDLE:
*data_len = sizeof(uint64_t);
return &r->handle;
- case NFTNL_RULE_ATTR_COMPAT_PROTO:
+ case NFTNL_RULE_COMPAT_PROTO:
*data_len = sizeof(uint32_t);
return &r->compat.proto;
- case NFTNL_RULE_ATTR_COMPAT_FLAGS:
+ case NFTNL_RULE_COMPAT_FLAGS:
*data_len = sizeof(uint32_t);
return &r->compat.flags;
- case NFTNL_RULE_ATTR_POSITION:
+ case NFTNL_RULE_POSITION:
*data_len = sizeof(uint64_t);
return &r->position;
- case NFTNL_RULE_ATTR_USERDATA:
+ case NFTNL_RULE_USERDATA:
*data_len = r->user.len;
return r->user.data;
}
@@ -279,15 +279,15 @@ void nftnl_rule_nlmsg_build_payload(struct nlmsghdr *nlh, struct nftnl_rule *r)
struct nftnl_expr *expr;
struct nlattr *nest, *nest2;
- if (r->flags & (1 << NFTNL_RULE_ATTR_TABLE))
+ if (r->flags & (1 << NFTNL_RULE_TABLE))
mnl_attr_put_strz(nlh, NFTA_RULE_TABLE, r->table);
- if (r->flags & (1 << NFTNL_RULE_ATTR_CHAIN))
+ if (r->flags & (1 << NFTNL_RULE_CHAIN))
mnl_attr_put_strz(nlh, NFTA_RULE_CHAIN, r->chain);
- if (r->flags & (1 << NFTNL_RULE_ATTR_HANDLE))
+ if (r->flags & (1 << NFTNL_RULE_HANDLE))
mnl_attr_put_u64(nlh, NFTA_RULE_HANDLE, htobe64(r->handle));
- if (r->flags & (1 << NFTNL_RULE_ATTR_POSITION))
+ if (r->flags & (1 << NFTNL_RULE_POSITION))
mnl_attr_put_u64(nlh, NFTA_RULE_POSITION, htobe64(r->position));
- if (r->flags & (1 << NFTNL_RULE_ATTR_USERDATA)) {
+ if (r->flags & (1 << NFTNL_RULE_USERDATA)) {
mnl_attr_put(nlh, NFTA_RULE_USERDATA, r->user.len,
r->user.data);
}
@@ -302,8 +302,8 @@ void nftnl_rule_nlmsg_build_payload(struct nlmsghdr *nlh, struct nftnl_rule *r)
mnl_attr_nest_end(nlh, nest);
}
- if (r->flags & (1 << NFTNL_RULE_ATTR_COMPAT_PROTO) &&
- r->flags & (1 << NFTNL_RULE_ATTR_COMPAT_FLAGS)) {
+ if (r->flags & (1 << NFTNL_RULE_COMPAT_PROTO) &&
+ r->flags & (1 << NFTNL_RULE_COMPAT_FLAGS)) {
nest = mnl_attr_nest_start(nlh, NFTA_RULE_COMPAT);
mnl_attr_put_u32(nlh, NFTA_RULE_COMPAT_PROTO,
@@ -405,12 +405,12 @@ static int nftnl_rule_parse_compat(struct nlattr *nest, struct nftnl_rule *r)
if (tb[NFTA_RULE_COMPAT_PROTO]) {
r->compat.proto =
ntohl(mnl_attr_get_u32(tb[NFTA_RULE_COMPAT_PROTO]));
- r->flags |= (1 << NFTNL_RULE_ATTR_COMPAT_PROTO);
+ r->flags |= (1 << NFTNL_RULE_COMPAT_PROTO);
}
if (tb[NFTA_RULE_COMPAT_FLAGS]) {
r->compat.flags =
ntohl(mnl_attr_get_u32(tb[NFTA_RULE_COMPAT_FLAGS]));
- r->flags |= (1 << NFTNL_RULE_ATTR_COMPAT_FLAGS);
+ r->flags |= (1 << NFTNL_RULE_COMPAT_FLAGS);
}
return 0;
}
@@ -427,16 +427,16 @@ int nftnl_rule_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_rule *r)
if (tb[NFTA_RULE_TABLE]) {
xfree(r->table);
r->table = strdup(mnl_attr_get_str(tb[NFTA_RULE_TABLE]));
- r->flags |= (1 << NFTNL_RULE_ATTR_TABLE);
+ r->flags |= (1 << NFTNL_RULE_TABLE);
}
if (tb[NFTA_RULE_CHAIN]) {
xfree(r->chain);
r->chain = strdup(mnl_attr_get_str(tb[NFTA_RULE_CHAIN]));
- r->flags |= (1 << NFTNL_RULE_ATTR_CHAIN);
+ r->flags |= (1 << NFTNL_RULE_CHAIN);
}
if (tb[NFTA_RULE_HANDLE]) {
r->handle = be64toh(mnl_attr_get_u64(tb[NFTA_RULE_HANDLE]));
- r->flags |= (1 << NFTNL_RULE_ATTR_HANDLE);
+ r->flags |= (1 << NFTNL_RULE_HANDLE);
}
if (tb[NFTA_RULE_EXPRESSIONS])
ret = nftnl_rule_parse_expr(tb[NFTA_RULE_EXPRESSIONS], r);
@@ -444,7 +444,7 @@ int nftnl_rule_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_rule *r)
ret = nftnl_rule_parse_compat(tb[NFTA_RULE_COMPAT], r);
if (tb[NFTA_RULE_POSITION]) {
r->position = be64toh(mnl_attr_get_u64(tb[NFTA_RULE_POSITION]));
- r->flags |= (1 << NFTNL_RULE_ATTR_POSITION);
+ r->flags |= (1 << NFTNL_RULE_POSITION);
}
if (tb[NFTA_RULE_USERDATA]) {
const void *udata =
@@ -460,11 +460,11 @@ int nftnl_rule_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_rule *r)
return -1;
memcpy(r->user.data, udata, r->user.len);
- r->flags |= (1 << NFTNL_RULE_ATTR_USERDATA);
+ r->flags |= (1 << NFTNL_RULE_USERDATA);
}
r->family = nfg->nfgen_family;
- r->flags |= (1 << NFTNL_RULE_ATTR_FAMILY);
+ r->flags |= (1 << NFTNL_RULE_FAMILY);
return ret;
}
@@ -490,7 +490,7 @@ int nftnl_jansson_parse_rule(struct nftnl_rule *r, json_t *tree,
if (nftnl_jansson_parse_family(root, &family, err) != 0)
goto err;
- nftnl_rule_attr_set_u32(r, NFTNL_RULE_ATTR_FAMILY, family);
+ nftnl_rule_attr_set_u32(r, NFTNL_RULE_FAMILY, family);
}
if (nftnl_jansson_node_exist(root, "table")) {
@@ -498,7 +498,7 @@ int nftnl_jansson_parse_rule(struct nftnl_rule *r, json_t *tree,
if (str == NULL)
goto err;
- nftnl_rule_attr_set_str(r, NFTNL_RULE_ATTR_TABLE, str);
+ nftnl_rule_attr_set_str(r, NFTNL_RULE_TABLE, str);
}
if (nftnl_jansson_node_exist(root, "chain")) {
@@ -506,7 +506,7 @@ int nftnl_jansson_parse_rule(struct nftnl_rule *r, json_t *tree,
if (str == NULL)
goto err;
- nftnl_rule_attr_set_str(r, NFTNL_RULE_ATTR_CHAIN, str);
+ nftnl_rule_attr_set_str(r, NFTNL_RULE_CHAIN, str);
}
if (nftnl_jansson_node_exist(root, "handle")) {
@@ -514,7 +514,7 @@ int nftnl_jansson_parse_rule(struct nftnl_rule *r, json_t *tree,
err) < 0)
goto err;
- nftnl_rule_attr_set_u64(r, NFTNL_RULE_ATTR_HANDLE, uval64);
+ nftnl_rule_attr_set_u64(r, NFTNL_RULE_HANDLE, uval64);
}
if (nftnl_jansson_node_exist(root, "compat_proto") ||
@@ -523,13 +523,13 @@ int nftnl_jansson_parse_rule(struct nftnl_rule *r, json_t *tree,
&uval32, err) < 0)
goto err;
- nftnl_rule_attr_set_u32(r, NFTNL_RULE_ATTR_COMPAT_PROTO, uval32);
+ nftnl_rule_attr_set_u32(r, NFTNL_RULE_COMPAT_PROTO, uval32);
if (nftnl_jansson_parse_val(root, "compat_flags", NFTNL_TYPE_U32,
&uval32, err) < 0)
goto err;
- nftnl_rule_attr_set_u32(r, NFTNL_RULE_ATTR_COMPAT_FLAGS, uval32);
+ nftnl_rule_attr_set_u32(r, NFTNL_RULE_COMPAT_FLAGS, uval32);
}
if (nftnl_jansson_node_exist(root, "position")) {
@@ -537,7 +537,7 @@ int nftnl_jansson_parse_rule(struct nftnl_rule *r, json_t *tree,
&uval64, err) < 0)
goto err;
- nftnl_rule_attr_set_u64(r, NFTNL_RULE_ATTR_POSITION, uval64);
+ nftnl_rule_attr_set_u64(r, NFTNL_RULE_POSITION, uval64);
}
array = json_object_get(root, "expr");
@@ -600,41 +600,41 @@ int nftnl_mxml_rule_parse(mxml_node_t *tree, struct nftnl_rule *r,
family = nftnl_mxml_family_parse(tree, "family", MXML_DESCEND_FIRST,
NFTNL_XML_MAND, err);
if (family >= 0)
- nftnl_rule_attr_set_u32(r, NFTNL_RULE_ATTR_FAMILY, family);
+ nftnl_rule_attr_set_u32(r, NFTNL_RULE_FAMILY, family);
table = nftnl_mxml_str_parse(tree, "table", MXML_DESCEND_FIRST,
NFTNL_XML_MAND, err);
if (table != NULL)
- nftnl_rule_attr_set_str(r, NFTNL_RULE_ATTR_TABLE, table);
+ nftnl_rule_attr_set_str(r, NFTNL_RULE_TABLE, table);
chain = nftnl_mxml_str_parse(tree, "chain", MXML_DESCEND_FIRST,
NFTNL_XML_MAND, err);
if (chain != NULL)
- nftnl_rule_attr_set_str(r, NFTNL_RULE_ATTR_CHAIN, chain);
+ nftnl_rule_attr_set_str(r, NFTNL_RULE_CHAIN, chain);
if (nftnl_mxml_num_parse(tree, "handle", MXML_DESCEND_FIRST, BASE_DEC,
&r->handle, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) >= 0)
- r->flags |= (1 << NFTNL_RULE_ATTR_HANDLE);
+ r->flags |= (1 << NFTNL_RULE_HANDLE);
if (nftnl_mxml_num_parse(tree, "compat_proto", MXML_DESCEND_FIRST,
BASE_DEC, &r->compat.proto, NFTNL_TYPE_U32,
NFTNL_XML_OPT, err) >= 0)
- r->flags |= (1 << NFTNL_RULE_ATTR_COMPAT_PROTO);
+ r->flags |= (1 << NFTNL_RULE_COMPAT_PROTO);
if (nftnl_mxml_num_parse(tree, "compat_flags", MXML_DESCEND_FIRST,
BASE_DEC, &r->compat.flags, NFTNL_TYPE_U32,
NFTNL_XML_OPT, err) >= 0)
- r->flags |= (1 << NFTNL_RULE_ATTR_COMPAT_FLAGS);
+ r->flags |= (1 << NFTNL_RULE_COMPAT_FLAGS);
- if (nftnl_rule_attr_is_set(r, NFTNL_RULE_ATTR_COMPAT_PROTO) !=
- nftnl_rule_attr_is_set(r, NFTNL_RULE_ATTR_COMPAT_FLAGS)) {
+ if (nftnl_rule_attr_is_set(r, NFTNL_RULE_COMPAT_PROTO) !=
+ nftnl_rule_attr_is_set(r, NFTNL_RULE_COMPAT_FLAGS)) {
errno = EINVAL;
}
if (nftnl_mxml_num_parse(tree, "position", MXML_DESCEND_FIRST,
BASE_DEC, &r->position, NFTNL_TYPE_U64,
NFTNL_XML_OPT, err) >= 0)
- r->flags |= (1 << NFTNL_RULE_ATTR_POSITION);
+ r->flags |= (1 << NFTNL_RULE_POSITION);
/* Iterating over <expr> */
for (node = mxmlFindElement(tree, tree, "expr", "type",
@@ -720,38 +720,38 @@ static int nftnl_rule_snprintf_json(char *buf, size_t size, struct nftnl_rule *r
ret = snprintf(buf, len, "{\"rule\":{");
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
- if (r->flags & (1 << NFTNL_RULE_ATTR_FAMILY)) {
+ if (r->flags & (1 << NFTNL_RULE_FAMILY)) {
ret = snprintf(buf+offset, len, "\"family\":\"%s\",",
nftnl_family2str(r->family));
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (r->flags & (1 << NFTNL_RULE_ATTR_TABLE)) {
+ if (r->flags & (1 << NFTNL_RULE_TABLE)) {
ret = snprintf(buf+offset, len, "\"table\":\"%s\",",
r->table);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (r->flags & (1 << NFTNL_RULE_ATTR_CHAIN)) {
+ if (r->flags & (1 << NFTNL_RULE_CHAIN)) {
ret = snprintf(buf+offset, len, "\"chain\":\"%s\",",
r->chain);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (r->flags & (1 << NFTNL_RULE_ATTR_HANDLE)) {
+ if (r->flags & (1 << NFTNL_RULE_HANDLE)) {
ret = snprintf(buf+offset, len, "\"handle\":%llu,",
(unsigned long long)r->handle);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (r->flags & (1 << NFTNL_RULE_ATTR_COMPAT_PROTO) ||
- r->flags & (1 << NFTNL_RULE_ATTR_COMPAT_FLAGS)) {
+ if (r->flags & (1 << NFTNL_RULE_COMPAT_PROTO) ||
+ r->flags & (1 << NFTNL_RULE_COMPAT_FLAGS)) {
ret = snprintf(buf+offset, len, "\"compat_flags\":%u,"
"\"compat_proto\":%u,",
r->compat.flags, r->compat.proto);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (r->flags & (1 << NFTNL_RULE_ATTR_POSITION)) {
+ if (r->flags & (1 << NFTNL_RULE_POSITION)) {
ret = snprintf(buf+offset, len, "\"position\":%"PRIu64",",
r->position);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
@@ -798,24 +798,24 @@ static int nftnl_rule_snprintf_xml(char *buf, size_t size, struct nftnl_rule *r,
ret = snprintf(buf, len, "<rule>");
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
- if (r->flags & (1 << NFTNL_RULE_ATTR_FAMILY)) {
+ if (r->flags & (1 << NFTNL_RULE_FAMILY)) {
ret = snprintf(buf+offset, len, "<family>%s</family>",
nftnl_family2str(r->family));
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (r->flags & (1 << NFTNL_RULE_ATTR_TABLE)) {
+ if (r->flags & (1 << NFTNL_RULE_TABLE)) {
ret = snprintf(buf+offset, len, "<table>%s</table>",
r->table);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (r->flags & (1 << NFTNL_RULE_ATTR_CHAIN)) {
+ if (r->flags & (1 << NFTNL_RULE_CHAIN)) {
ret = snprintf(buf+offset, len, "<chain>%s</chain>",
r->chain);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (r->flags & (1 << NFTNL_RULE_ATTR_HANDLE)) {
+ if (r->flags & (1 << NFTNL_RULE_HANDLE)) {
ret = snprintf(buf+offset, len, "<handle>%llu</handle>",
(unsigned long long)r->handle);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
@@ -829,7 +829,7 @@ static int nftnl_rule_snprintf_xml(char *buf, size_t size, struct nftnl_rule *r,
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (r->flags & (1 << NFTNL_RULE_ATTR_POSITION)) {
+ if (r->flags & (1 << NFTNL_RULE_POSITION)) {
ret = snprintf(buf+offset, len,
"<position>%"PRIu64"</position>",
r->position);
@@ -861,30 +861,30 @@ static int nftnl_rule_snprintf_default(char *buf, size_t size, struct nftnl_rule
struct nftnl_expr *expr;
int ret, len = size, offset = 0, i;
- if (r->flags & (1 << NFTNL_RULE_ATTR_FAMILY)) {
+ if (r->flags & (1 << NFTNL_RULE_FAMILY)) {
ret = snprintf(buf+offset, len, "%s ",
nftnl_family2str(r->family));
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (r->flags & (1 << NFTNL_RULE_ATTR_TABLE)) {
+ if (r->flags & (1 << NFTNL_RULE_TABLE)) {
ret = snprintf(buf+offset, len, "%s ",
r->table);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (r->flags & (1 << NFTNL_RULE_ATTR_CHAIN)) {
+ if (r->flags & (1 << NFTNL_RULE_CHAIN)) {
ret = snprintf(buf+offset, len, "%s ",
r->chain);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (r->flags & (1 << NFTNL_RULE_ATTR_HANDLE)) {
+ if (r->flags & (1 << NFTNL_RULE_HANDLE)) {
ret = snprintf(buf+offset, len, "%llu ",
(unsigned long long)r->handle);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (r->flags & (1 << NFTNL_RULE_ATTR_POSITION)) {
+ if (r->flags & (1 << NFTNL_RULE_POSITION)) {
ret = snprintf(buf+offset, len, "%llu ",
(unsigned long long)r->position);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
diff --git a/src/ruleset.c b/src/ruleset.c
index 969b862..fde24ad 100644
--- a/src/ruleset.c
+++ b/src/ruleset.c
@@ -66,13 +66,13 @@ EXPORT_SYMBOL(nftnl_ruleset_alloc, nft_ruleset_alloc);
void nftnl_ruleset_free(struct nftnl_ruleset *r)
{
- if (r->flags & (1 << NFTNL_RULESET_ATTR_TABLELIST))
+ if (r->flags & (1 << NFTNL_RULESET_TABLELIST))
nftnl_table_list_free(r->table_list);
- if (r->flags & (1 << NFTNL_RULESET_ATTR_CHAINLIST))
+ if (r->flags & (1 << NFTNL_RULESET_CHAINLIST))
nftnl_chain_list_free(r->chain_list);
- if (r->flags & (1 << NFTNL_RULESET_ATTR_SETLIST))
+ if (r->flags & (1 << NFTNL_RULESET_SETLIST))
nftnl_set_list_free(r->set_list);
- if (r->flags & (1 << NFTNL_RULESET_ATTR_RULELIST))
+ if (r->flags & (1 << NFTNL_RULESET_RULELIST))
nftnl_rule_list_free(r->rule_list);
xfree(r);
}
@@ -90,19 +90,19 @@ void nftnl_ruleset_attr_unset(struct nftnl_ruleset *r, uint16_t attr)
return;
switch (attr) {
- case NFTNL_RULESET_ATTR_TABLELIST:
+ case NFTNL_RULESET_TABLELIST:
nftnl_table_list_free(r->table_list);
r->table_list = NULL;
break;
- case NFTNL_RULESET_ATTR_CHAINLIST:
+ case NFTNL_RULESET_CHAINLIST:
nftnl_chain_list_free(r->chain_list);
r->chain_list = NULL;
break;
- case NFTNL_RULESET_ATTR_SETLIST:
+ case NFTNL_RULESET_SETLIST:
nftnl_set_list_free(r->set_list);
r->set_list = NULL;
break;
- case NFTNL_RULESET_ATTR_RULELIST:
+ case NFTNL_RULESET_RULELIST:
nftnl_rule_list_free(r->rule_list);
r->rule_list = NULL;
break;
@@ -114,20 +114,20 @@ EXPORT_SYMBOL(nftnl_ruleset_attr_unset, nft_ruleset_attr_unset);
void nftnl_ruleset_attr_set(struct nftnl_ruleset *r, uint16_t attr, void *data)
{
switch (attr) {
- case NFTNL_RULESET_ATTR_TABLELIST:
- nftnl_ruleset_attr_unset(r, NFTNL_RULESET_ATTR_TABLELIST);
+ case NFTNL_RULESET_TABLELIST:
+ nftnl_ruleset_attr_unset(r, NFTNL_RULESET_TABLELIST);
r->table_list = data;
break;
- case NFTNL_RULESET_ATTR_CHAINLIST:
- nftnl_ruleset_attr_unset(r, NFTNL_RULESET_ATTR_CHAINLIST);
+ case NFTNL_RULESET_CHAINLIST:
+ nftnl_ruleset_attr_unset(r, NFTNL_RULESET_CHAINLIST);
r->chain_list = data;
break;
- case NFTNL_RULESET_ATTR_SETLIST:
- nftnl_ruleset_attr_unset(r, NFTNL_RULESET_ATTR_SETLIST);
+ case NFTNL_RULESET_SETLIST:
+ nftnl_ruleset_attr_unset(r, NFTNL_RULESET_SETLIST);
r->set_list = data;
break;
- case NFTNL_RULESET_ATTR_RULELIST:
- nftnl_ruleset_attr_unset(r, NFTNL_RULESET_ATTR_RULELIST);
+ case NFTNL_RULESET_RULELIST:
+ nftnl_ruleset_attr_unset(r, NFTNL_RULESET_RULELIST);
r->rule_list = data;
break;
default:
@@ -143,13 +143,13 @@ void *nftnl_ruleset_attr_get(const struct nftnl_ruleset *r, uint16_t attr)
return NULL;
switch (attr) {
- case NFTNL_RULESET_ATTR_TABLELIST:
+ case NFTNL_RULESET_TABLELIST:
return r->table_list;
- case NFTNL_RULESET_ATTR_CHAINLIST:
+ case NFTNL_RULESET_CHAINLIST:
return r->chain_list;
- case NFTNL_RULESET_ATTR_SETLIST:
+ case NFTNL_RULESET_SETLIST:
return r->set_list;
- case NFTNL_RULESET_ATTR_RULELIST:
+ case NFTNL_RULESET_RULELIST:
return r->rule_list;
default:
return NULL;
@@ -337,7 +337,7 @@ static int nftnl_ruleset_parse_set(struct nftnl_parse_ctx *ctx,
{
struct nftnl_set *newset;
- nftnl_set_attr_set_u32(set, NFTNL_SET_ATTR_ID, ctx->set_id++);
+ nftnl_set_attr_set_u32(set, NFTNL_SET_ID, ctx->set_id++);
newset = nftnl_set_clone(set);
if (newset == NULL)
@@ -776,7 +776,7 @@ static int nftnl_ruleset_cb(const struct nftnl_parse_ctx *ctx)
if (r->table_list == NULL)
return -1;
- nftnl_ruleset_attr_set(r, NFTNL_RULESET_ATTR_TABLELIST,
+ nftnl_ruleset_attr_set(r, NFTNL_RULESET_TABLELIST,
r->table_list);
}
nftnl_table_list_add_tail(ctx->table, r->table_list);
@@ -787,7 +787,7 @@ static int nftnl_ruleset_cb(const struct nftnl_parse_ctx *ctx)
if (r->chain_list == NULL)
return -1;
- nftnl_ruleset_attr_set(r, NFTNL_RULESET_ATTR_CHAINLIST,
+ nftnl_ruleset_attr_set(r, NFTNL_RULESET_CHAINLIST,
r->chain_list);
}
nftnl_chain_list_add_tail(ctx->chain, r->chain_list);
@@ -798,7 +798,7 @@ static int nftnl_ruleset_cb(const struct nftnl_parse_ctx *ctx)
if (r->set_list == NULL)
return -1;
- nftnl_ruleset_attr_set(r, NFTNL_RULESET_ATTR_SETLIST,
+ nftnl_ruleset_attr_set(r, NFTNL_RULESET_SETLIST,
r->set_list);
}
nftnl_set_list_add_tail(ctx->set, r->set_list);
@@ -809,7 +809,7 @@ static int nftnl_ruleset_cb(const struct nftnl_parse_ctx *ctx)
if (r->rule_list == NULL)
return -1;
- nftnl_ruleset_attr_set(r, NFTNL_RULESET_ATTR_RULELIST,
+ nftnl_ruleset_attr_set(r, NFTNL_RULESET_RULELIST,
r->rule_list);
}
nftnl_rule_list_add_tail(ctx->rule, r->rule_list);
@@ -1009,7 +1009,7 @@ nftnl_ruleset_do_snprintf(char *buf, size_t size, const struct nftnl_ruleset *rs
ret = nftnl_cmd_header_snprintf(buf + offset, len, cmd, type, flags);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
- if (nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_ATTR_TABLELIST) &&
+ if (nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_TABLELIST) &&
(!nftnl_table_list_is_empty(rs->table_list))) {
ret = nftnl_ruleset_snprintf_table(buf+offset, len, rs,
type, inner_flags);
@@ -1019,7 +1019,7 @@ nftnl_ruleset_do_snprintf(char *buf, size_t size, const struct nftnl_ruleset *rs
prev = rs->table_list;
}
- if (nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_ATTR_CHAINLIST) &&
+ if (nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_CHAINLIST) &&
(!nftnl_chain_list_is_empty(rs->chain_list))) {
ret = snprintf(buf+offset, len, "%s",
nftnl_ruleset_o_separator(prev, type));
@@ -1033,7 +1033,7 @@ nftnl_ruleset_do_snprintf(char *buf, size_t size, const struct nftnl_ruleset *rs
prev = rs->chain_list;
}
- if (nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_ATTR_SETLIST) &&
+ if (nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_SETLIST) &&
(!nftnl_set_list_is_empty(rs->set_list))) {
ret = snprintf(buf+offset, len, "%s",
nftnl_ruleset_o_separator(prev, type));
@@ -1047,7 +1047,7 @@ nftnl_ruleset_do_snprintf(char *buf, size_t size, const struct nftnl_ruleset *rs
prev = rs->set_list;
}
- if (nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_ATTR_RULELIST) &&
+ if (nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_RULELIST) &&
(!nftnl_rule_list_is_empty(rs->rule_list))) {
ret = snprintf(buf+offset, len, "%s",
nftnl_ruleset_o_separator(prev, type));
@@ -1260,7 +1260,7 @@ static int nftnl_ruleset_cmd_fprintf(FILE *fp, const struct nftnl_ruleset *rs,
ret = nftnl_cmd_header_fprintf(fp, cmd, type, flags);
NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
- if ((nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_ATTR_TABLELIST)) &&
+ if ((nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_TABLELIST)) &&
(!nftnl_table_list_is_empty(rs->table_list))) {
ret = nftnl_ruleset_fprintf_tables(fp, rs, type, inner_flags);
NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
@@ -1269,7 +1269,7 @@ static int nftnl_ruleset_cmd_fprintf(FILE *fp, const struct nftnl_ruleset *rs,
prev = rs->table_list;
}
- if ((nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_ATTR_CHAINLIST)) &&
+ if ((nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_CHAINLIST)) &&
(!nftnl_chain_list_is_empty(rs->chain_list))) {
ret = fprintf(fp, "%s", nftnl_ruleset_o_separator(prev, type));
NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
@@ -1281,7 +1281,7 @@ static int nftnl_ruleset_cmd_fprintf(FILE *fp, const struct nftnl_ruleset *rs,
prev = rs->chain_list;
}
- if ((nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_ATTR_SETLIST)) &&
+ if ((nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_SETLIST)) &&
(!nftnl_set_list_is_empty(rs->set_list))) {
ret = fprintf(fp, "%s", nftnl_ruleset_o_separator(prev, type));
NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
@@ -1293,7 +1293,7 @@ static int nftnl_ruleset_cmd_fprintf(FILE *fp, const struct nftnl_ruleset *rs,
prev = rs->set_list;
}
- if ((nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_ATTR_RULELIST)) &&
+ if ((nftnl_ruleset_attr_is_set(rs, NFTNL_RULESET_RULELIST)) &&
(!nftnl_rule_list_is_empty(rs->rule_list))) {
ret = fprintf(fp, "%s", nftnl_ruleset_o_separator(prev, type));
NFTNL_FPRINTF_RETURN_OR_FIXLEN(ret, len);
diff --git a/src/set.c b/src/set.c
index befa6d1..983a8f4 100644
--- a/src/set.c
+++ b/src/set.c
@@ -66,31 +66,31 @@ EXPORT_SYMBOL(nftnl_set_attr_is_set, nft_set_attr_is_set);
void nftnl_set_attr_unset(struct nftnl_set *s, uint16_t attr)
{
switch (attr) {
- case NFTNL_SET_ATTR_TABLE:
- if (s->flags & (1 << NFTNL_SET_ATTR_TABLE))
+ case NFTNL_SET_TABLE:
+ if (s->flags & (1 << NFTNL_SET_TABLE))
if (s->table) {
xfree(s->table);
s->table = NULL;
}
break;
- case NFTNL_SET_ATTR_NAME:
- if (s->flags & (1 << NFTNL_SET_ATTR_NAME))
+ case NFTNL_SET_NAME:
+ if (s->flags & (1 << NFTNL_SET_NAME))
if (s->name) {
xfree(s->name);
s->name = NULL;
}
break;
- case NFTNL_SET_ATTR_FLAGS:
- case NFTNL_SET_ATTR_KEY_TYPE:
- case NFTNL_SET_ATTR_KEY_LEN:
- case NFTNL_SET_ATTR_DATA_TYPE:
- case NFTNL_SET_ATTR_DATA_LEN:
- case NFTNL_SET_ATTR_FAMILY:
- case NFTNL_SET_ATTR_ID:
- case NFTNL_SET_ATTR_POLICY:
- case NFTNL_SET_ATTR_DESC_SIZE:
- case NFTNL_SET_ATTR_TIMEOUT:
- case NFTNL_SET_ATTR_GC_INTERVAL:
+ case NFTNL_SET_FLAGS:
+ case NFTNL_SET_KEY_TYPE:
+ case NFTNL_SET_KEY_LEN:
+ case NFTNL_SET_DATA_TYPE:
+ case NFTNL_SET_DATA_LEN:
+ case NFTNL_SET_FAMILY:
+ case NFTNL_SET_ID:
+ case NFTNL_SET_POLICY:
+ case NFTNL_SET_DESC_SIZE:
+ case NFTNL_SET_TIMEOUT:
+ case NFTNL_SET_GC_INTERVAL:
break;
default:
return;
@@ -100,71 +100,71 @@ void nftnl_set_attr_unset(struct nftnl_set *s, uint16_t attr)
}
EXPORT_SYMBOL(nftnl_set_attr_unset, nft_set_attr_unset);
-static uint32_t nftnl_set_attr_validate[NFTNL_SET_ATTR_MAX + 1] = {
- [NFTNL_SET_ATTR_FLAGS] = sizeof(uint32_t),
- [NFTNL_SET_ATTR_KEY_TYPE] = sizeof(uint32_t),
- [NFTNL_SET_ATTR_KEY_LEN] = sizeof(uint32_t),
- [NFTNL_SET_ATTR_DATA_TYPE] = sizeof(uint32_t),
- [NFTNL_SET_ATTR_DATA_LEN] = sizeof(uint32_t),
- [NFTNL_SET_ATTR_FAMILY] = sizeof(uint32_t),
- [NFTNL_SET_ATTR_POLICY] = sizeof(uint32_t),
- [NFTNL_SET_ATTR_DESC_SIZE] = sizeof(uint32_t),
- [NFTNL_SET_ATTR_TIMEOUT] = sizeof(uint64_t),
- [NFTNL_SET_ATTR_GC_INTERVAL] = sizeof(uint32_t),
+static uint32_t nftnl_set_attr_validate[NFTNL_SET_MAX + 1] = {
+ [NFTNL_SET_FLAGS] = sizeof(uint32_t),
+ [NFTNL_SET_KEY_TYPE] = sizeof(uint32_t),
+ [NFTNL_SET_KEY_LEN] = sizeof(uint32_t),
+ [NFTNL_SET_DATA_TYPE] = sizeof(uint32_t),
+ [NFTNL_SET_DATA_LEN] = sizeof(uint32_t),
+ [NFTNL_SET_FAMILY] = sizeof(uint32_t),
+ [NFTNL_SET_POLICY] = sizeof(uint32_t),
+ [NFTNL_SET_DESC_SIZE] = sizeof(uint32_t),
+ [NFTNL_SET_TIMEOUT] = sizeof(uint64_t),
+ [NFTNL_SET_GC_INTERVAL] = sizeof(uint32_t),
};
void nftnl_set_attr_set_data(struct nftnl_set *s, uint16_t attr, const void *data,
uint32_t data_len)
{
- if (attr > NFTNL_SET_ATTR_MAX)
+ if (attr > NFTNL_SET_MAX)
return;
nftnl_assert_validate(data, nftnl_set_attr_validate, attr, data_len);
switch(attr) {
- case NFTNL_SET_ATTR_TABLE:
+ case NFTNL_SET_TABLE:
if (s->table)
xfree(s->table);
s->table = strdup(data);
break;
- case NFTNL_SET_ATTR_NAME:
+ case NFTNL_SET_NAME:
if (s->name)
xfree(s->name);
s->name = strdup(data);
break;
- case NFTNL_SET_ATTR_FLAGS:
+ case NFTNL_SET_FLAGS:
s->set_flags = *((uint32_t *)data);
break;
- case NFTNL_SET_ATTR_KEY_TYPE:
+ case NFTNL_SET_KEY_TYPE:
s->key_type = *((uint32_t *)data);
break;
- case NFTNL_SET_ATTR_KEY_LEN:
+ case NFTNL_SET_KEY_LEN:
s->key_len = *((uint32_t *)data);
break;
- case NFTNL_SET_ATTR_DATA_TYPE:
+ case NFTNL_SET_DATA_TYPE:
s->data_type = *((uint32_t *)data);
break;
- case NFTNL_SET_ATTR_DATA_LEN:
+ case NFTNL_SET_DATA_LEN:
s->data_len = *((uint32_t *)data);
break;
- case NFTNL_SET_ATTR_FAMILY:
+ case NFTNL_SET_FAMILY:
s->family = *((uint32_t *)data);
break;
- case NFTNL_SET_ATTR_ID:
+ case NFTNL_SET_ID:
s->id = *((uint32_t *)data);
break;
- case NFTNL_SET_ATTR_POLICY:
+ case NFTNL_SET_POLICY:
s->policy = *((uint32_t *)data);
break;
- case NFTNL_SET_ATTR_DESC_SIZE:
+ case NFTNL_SET_DESC_SIZE:
s->desc.size = *((uint32_t *)data);
break;
- case NFTNL_SET_ATTR_TIMEOUT:
+ case NFTNL_SET_TIMEOUT:
s->timeout = *((uint64_t *)data);
break;
- case NFTNL_SET_ATTR_GC_INTERVAL:
+ case NFTNL_SET_GC_INTERVAL:
s->gc_interval = *((uint32_t *)data);
break;
}
@@ -203,41 +203,41 @@ const void *nftnl_set_attr_get_data(struct nftnl_set *s, uint16_t attr,
return NULL;
switch(attr) {
- case NFTNL_SET_ATTR_TABLE:
+ case NFTNL_SET_TABLE:
return s->table;
- case NFTNL_SET_ATTR_NAME:
+ case NFTNL_SET_NAME:
return s->name;
- case NFTNL_SET_ATTR_FLAGS:
+ case NFTNL_SET_FLAGS:
*data_len = sizeof(uint32_t);
return &s->set_flags;
- case NFTNL_SET_ATTR_KEY_TYPE:
+ case NFTNL_SET_KEY_TYPE:
*data_len = sizeof(uint32_t);
return &s->key_type;
- case NFTNL_SET_ATTR_KEY_LEN:
+ case NFTNL_SET_KEY_LEN:
*data_len = sizeof(uint32_t);
return &s->key_len;
- case NFTNL_SET_ATTR_DATA_TYPE:
+ case NFTNL_SET_DATA_TYPE:
*data_len = sizeof(uint32_t);
return &s->data_type;
- case NFTNL_SET_ATTR_DATA_LEN:
+ case NFTNL_SET_DATA_LEN:
*data_len = sizeof(uint32_t);
return &s->data_len;
- case NFTNL_SET_ATTR_FAMILY:
+ case NFTNL_SET_FAMILY:
*data_len = sizeof(uint32_t);
return &s->family;
- case NFTNL_SET_ATTR_ID:
+ case NFTNL_SET_ID:
*data_len = sizeof(uint32_t);
return &s->id;
- case NFTNL_SET_ATTR_POLICY:
+ case NFTNL_SET_POLICY:
*data_len = sizeof(uint32_t);
return &s->policy;
- case NFTNL_SET_ATTR_DESC_SIZE:
+ case NFTNL_SET_DESC_SIZE:
*data_len = sizeof(uint32_t);
return &s->desc.size;
- case NFTNL_SET_ATTR_TIMEOUT:
+ case NFTNL_SET_TIMEOUT:
*data_len = sizeof(uint64_t);
return &s->timeout;
- case NFTNL_SET_ATTR_GC_INTERVAL:
+ case NFTNL_SET_GC_INTERVAL:
*data_len = sizeof(uint32_t);
return &s->gc_interval;
}
@@ -291,9 +291,9 @@ struct nftnl_set *nftnl_set_clone(const struct nftnl_set *set)
memcpy(newset, set, sizeof(*set));
- if (set->flags & (1 << NFTNL_SET_ATTR_TABLE))
+ if (set->flags & (1 << NFTNL_SET_TABLE))
newset->table = strdup(set->table);
- if (set->flags & (1 << NFTNL_SET_ATTR_NAME))
+ if (set->flags & (1 << NFTNL_SET_NAME))
newset->name = strdup(set->name);
INIT_LIST_HEAD(&newset->element_list);
@@ -323,30 +323,30 @@ nftnl_set_nlmsg_build_desc_payload(struct nlmsghdr *nlh, struct nftnl_set *s)
void nftnl_set_nlmsg_build_payload(struct nlmsghdr *nlh, struct nftnl_set *s)
{
- if (s->flags & (1 << NFTNL_SET_ATTR_TABLE))
+ if (s->flags & (1 << NFTNL_SET_TABLE))
mnl_attr_put_strz(nlh, NFTA_SET_TABLE, s->table);
- if (s->flags & (1 << NFTNL_SET_ATTR_NAME))
+ if (s->flags & (1 << NFTNL_SET_NAME))
mnl_attr_put_strz(nlh, NFTA_SET_NAME, s->name);
- if (s->flags & (1 << NFTNL_SET_ATTR_FLAGS))
+ if (s->flags & (1 << NFTNL_SET_FLAGS))
mnl_attr_put_u32(nlh, NFTA_SET_FLAGS, htonl(s->set_flags));
- if (s->flags & (1 << NFTNL_SET_ATTR_KEY_TYPE))
+ if (s->flags & (1 << NFTNL_SET_KEY_TYPE))
mnl_attr_put_u32(nlh, NFTA_SET_KEY_TYPE, htonl(s->key_type));
- if (s->flags & (1 << NFTNL_SET_ATTR_KEY_LEN))
+ if (s->flags & (1 << NFTNL_SET_KEY_LEN))
mnl_attr_put_u32(nlh, NFTA_SET_KEY_LEN, htonl(s->key_len));
/* These are only used to map matching -> action (1:1) */
- if (s->flags & (1 << NFTNL_SET_ATTR_DATA_TYPE))
+ if (s->flags & (1 << NFTNL_SET_DATA_TYPE))
mnl_attr_put_u32(nlh, NFTA_SET_DATA_TYPE, htonl(s->data_type));
- if (s->flags & (1 << NFTNL_SET_ATTR_DATA_LEN))
+ if (s->flags & (1 << NFTNL_SET_DATA_LEN))
mnl_attr_put_u32(nlh, NFTA_SET_DATA_LEN, htonl(s->data_len));
- if (s->flags & (1 << NFTNL_SET_ATTR_ID))
+ if (s->flags & (1 << NFTNL_SET_ID))
mnl_attr_put_u32(nlh, NFTA_SET_ID, htonl(s->id));
- if (s->flags & (1 << NFTNL_SET_ATTR_POLICY))
+ if (s->flags & (1 << NFTNL_SET_POLICY))
mnl_attr_put_u32(nlh, NFTA_SET_POLICY, htonl(s->policy));
- if (s->flags & (1 << NFTNL_SET_ATTR_DESC_SIZE))
+ if (s->flags & (1 << NFTNL_SET_DESC_SIZE))
nftnl_set_nlmsg_build_desc_payload(nlh, s);
- if (s->flags & (1 << NFTNL_SET_ATTR_TIMEOUT))
+ if (s->flags & (1 << NFTNL_SET_TIMEOUT))
mnl_attr_put_u64(nlh, NFTA_SET_TIMEOUT, htobe64(s->timeout));
- if (s->flags & (1 << NFTNL_SET_ATTR_GC_INTERVAL))
+ if (s->flags & (1 << NFTNL_SET_GC_INTERVAL))
mnl_attr_put_u32(nlh, NFTA_SET_GC_INTERVAL, htonl(s->gc_interval));
}
EXPORT_SYMBOL(nftnl_set_nlmsg_build_payload, nft_set_nlmsg_build_payload);
@@ -419,7 +419,7 @@ static int nftnl_set_desc_parse(struct nftnl_set *s,
if (tb[NFTA_SET_DESC_SIZE]) {
s->desc.size = ntohl(mnl_attr_get_u32(tb[NFTA_SET_DESC_SIZE]));
- s->flags |= (1 << NFTNL_SET_ATTR_DESC_SIZE);
+ s->flags |= (1 << NFTNL_SET_DESC_SIZE);
}
return 0;
@@ -437,54 +437,54 @@ int nftnl_set_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_set *s)
if (tb[NFTA_SET_TABLE]) {
xfree(s->table);
s->table = strdup(mnl_attr_get_str(tb[NFTA_SET_TABLE]));
- s->flags |= (1 << NFTNL_SET_ATTR_TABLE);
+ s->flags |= (1 << NFTNL_SET_TABLE);
}
if (tb[NFTA_SET_NAME]) {
xfree(s->name);
s->name = strdup(mnl_attr_get_str(tb[NFTA_SET_NAME]));
- s->flags |= (1 << NFTNL_SET_ATTR_NAME);
+ s->flags |= (1 << NFTNL_SET_NAME);
}
if (tb[NFTA_SET_FLAGS]) {
s->set_flags = ntohl(mnl_attr_get_u32(tb[NFTA_SET_FLAGS]));
- s->flags |= (1 << NFTNL_SET_ATTR_FLAGS);
+ s->flags |= (1 << NFTNL_SET_FLAGS);
}
if (tb[NFTA_SET_KEY_TYPE]) {
s->key_type = ntohl(mnl_attr_get_u32(tb[NFTA_SET_KEY_TYPE]));
- s->flags |= (1 << NFTNL_SET_ATTR_KEY_TYPE);
+ s->flags |= (1 << NFTNL_SET_KEY_TYPE);
}
if (tb[NFTA_SET_KEY_LEN]) {
s->key_len = ntohl(mnl_attr_get_u32(tb[NFTA_SET_KEY_LEN]));
- s->flags |= (1 << NFTNL_SET_ATTR_KEY_LEN);
+ s->flags |= (1 << NFTNL_SET_KEY_LEN);
}
if (tb[NFTA_SET_DATA_TYPE]) {
s->data_type = ntohl(mnl_attr_get_u32(tb[NFTA_SET_DATA_TYPE]));
- s->flags |= (1 << NFTNL_SET_ATTR_DATA_TYPE);
+ s->flags |= (1 << NFTNL_SET_DATA_TYPE);
}
if (tb[NFTA_SET_DATA_LEN]) {
s->data_len = ntohl(mnl_attr_get_u32(tb[NFTA_SET_DATA_LEN]));
- s->flags |= (1 << NFTNL_SET_ATTR_DATA_LEN);
+ s->flags |= (1 << NFTNL_SET_DATA_LEN);
}
if (tb[NFTA_SET_ID]) {
s->id = ntohl(mnl_attr_get_u32(tb[NFTA_SET_ID]));
- s->flags |= (1 << NFTNL_SET_ATTR_ID);
+ s->flags |= (1 << NFTNL_SET_ID);
}
if (tb[NFTA_SET_POLICY]) {
s->policy = ntohl(mnl_attr_get_u32(tb[NFTA_SET_POLICY]));
- s->flags |= (1 << NFTNL_SET_ATTR_POLICY);
+ s->flags |= (1 << NFTNL_SET_POLICY);
}
if (tb[NFTA_SET_TIMEOUT]) {
s->timeout = be64toh(mnl_attr_get_u64(tb[NFTA_SET_TIMEOUT]));
- s->flags |= (1 << NFTNL_SET_ATTR_TIMEOUT);
+ s->flags |= (1 << NFTNL_SET_TIMEOUT);
}
if (tb[NFTA_SET_GC_INTERVAL]) {
s->gc_interval = ntohl(mnl_attr_get_u32(tb[NFTA_SET_GC_INTERVAL]));
- s->flags |= (1 << NFTNL_SET_ATTR_GC_INTERVAL);
+ s->flags |= (1 << NFTNL_SET_GC_INTERVAL);
}
if (tb[NFTA_SET_DESC])
ret = nftnl_set_desc_parse(s, tb[NFTA_SET_DESC]);
s->family = nfg->nfgen_family;
- s->flags |= (1 << NFTNL_SET_ATTR_FAMILY);
+ s->flags |= (1 << NFTNL_SET_FAMILY);
return ret;
}
@@ -504,34 +504,34 @@ static int nftnl_jansson_parse_set_info(struct nftnl_set *s, json_t *tree,
if (name == NULL)
return -1;
- nftnl_set_attr_set_str(s, NFTNL_SET_ATTR_NAME, name);
+ nftnl_set_attr_set_str(s, NFTNL_SET_NAME, name);
table = nftnl_jansson_parse_str(root, "table", err);
if (table == NULL)
return -1;
- nftnl_set_attr_set_str(s, NFTNL_SET_ATTR_TABLE, table);
+ nftnl_set_attr_set_str(s, NFTNL_SET_TABLE, table);
if (nftnl_jansson_parse_family(root, &family, err) == 0)
- nftnl_set_attr_set_u32(s, NFTNL_SET_ATTR_FAMILY, family);
+ nftnl_set_attr_set_u32(s, NFTNL_SET_FAMILY, family);
if (nftnl_jansson_parse_val(root, "flags", NFTNL_TYPE_U32, &flags, err) == 0)
- nftnl_set_attr_set_u32(s, NFTNL_SET_ATTR_FLAGS, flags);
+ nftnl_set_attr_set_u32(s, NFTNL_SET_FLAGS, flags);
if (nftnl_jansson_parse_val(root, "key_type", NFTNL_TYPE_U32, &key_type,
err) == 0)
- nftnl_set_attr_set_u32(s, NFTNL_SET_ATTR_KEY_TYPE, key_type);
+ nftnl_set_attr_set_u32(s, NFTNL_SET_KEY_TYPE, key_type);
if (nftnl_jansson_parse_val(root, "key_len", NFTNL_TYPE_U32, &key_len,
err) == 0)
- nftnl_set_attr_set_u32(s, NFTNL_SET_ATTR_KEY_LEN, key_len);
+ nftnl_set_attr_set_u32(s, NFTNL_SET_KEY_LEN, key_len);
if (nftnl_jansson_node_exist(root, "data_type")) {
if (nftnl_jansson_parse_val(root, "data_type", NFTNL_TYPE_U32,
&data_type, err) < 0)
return -1;
- nftnl_set_attr_set_u32(s, NFTNL_SET_ATTR_DATA_TYPE, data_type);
+ nftnl_set_attr_set_u32(s, NFTNL_SET_DATA_TYPE, data_type);
}
if (nftnl_jansson_node_exist(root, "data_len")) {
@@ -539,7 +539,7 @@ static int nftnl_jansson_parse_set_info(struct nftnl_set *s, json_t *tree,
&data_len, err) < 0)
return -1;
- nftnl_set_attr_set_u32(s, NFTNL_SET_ATTR_DATA_LEN, data_len);
+ nftnl_set_attr_set_u32(s, NFTNL_SET_DATA_LEN, data_len);
}
if (nftnl_jansson_node_exist(root, "policy")) {
@@ -547,7 +547,7 @@ static int nftnl_jansson_parse_set_info(struct nftnl_set *s, json_t *tree,
&policy, err) < 0)
return -1;
- nftnl_set_attr_set_u32(s, NFTNL_SET_ATTR_POLICY, policy);
+ nftnl_set_attr_set_u32(s, NFTNL_SET_POLICY, policy);
}
if (nftnl_jansson_node_exist(root, "desc_size")) {
@@ -555,7 +555,7 @@ static int nftnl_jansson_parse_set_info(struct nftnl_set *s, json_t *tree,
&size, err) < 0)
return -1;
- nftnl_set_attr_set_u32(s, NFTNL_SET_ATTR_DESC_SIZE, size);
+ nftnl_set_attr_set_u32(s, NFTNL_SET_DESC_SIZE, size);
}
if (nftnl_jansson_node_exist(root, "set_elem")) {
@@ -644,54 +644,54 @@ int nftnl_mxml_set_parse(mxml_node_t *tree, struct nftnl_set *s,
NFTNL_XML_MAND, err);
if (name == NULL)
return -1;
- nftnl_set_attr_set_str(s, NFTNL_SET_ATTR_NAME, name);
+ nftnl_set_attr_set_str(s, NFTNL_SET_NAME, name);
table = nftnl_mxml_str_parse(tree, "table", MXML_DESCEND_FIRST,
NFTNL_XML_MAND, err);
if (table == NULL)
return -1;
- nftnl_set_attr_set_str(s, NFTNL_SET_ATTR_TABLE, table);
+ nftnl_set_attr_set_str(s, NFTNL_SET_TABLE, table);
family = nftnl_mxml_family_parse(tree, "family", MXML_DESCEND_FIRST,
NFTNL_XML_MAND, err);
if (family >= 0)
- nftnl_set_attr_set_u32(s, NFTNL_SET_ATTR_FAMILY, family);
+ nftnl_set_attr_set_u32(s, NFTNL_SET_FAMILY, family);
if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND_FIRST, BASE_DEC,
&set_flags, NFTNL_TYPE_U32, NFTNL_XML_MAND,
err) == 0)
- nftnl_set_attr_set_u32(s, NFTNL_SET_ATTR_FLAGS, set_flags);
+ nftnl_set_attr_set_u32(s, NFTNL_SET_FLAGS, set_flags);
if (nftnl_mxml_num_parse(tree, "key_type", MXML_DESCEND_FIRST, BASE_DEC,
&key_type, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0)
- nftnl_set_attr_set_u32(s, NFTNL_SET_ATTR_KEY_TYPE, key_type);
+ nftnl_set_attr_set_u32(s, NFTNL_SET_KEY_TYPE, key_type);
if (nftnl_mxml_num_parse(tree, "key_len", MXML_DESCEND_FIRST, BASE_DEC,
&key_len, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) < 0)
return -1;
- nftnl_set_attr_set_u32(s, NFTNL_SET_ATTR_KEY_LEN, key_len);
+ nftnl_set_attr_set_u32(s, NFTNL_SET_KEY_LEN, key_len);
if (nftnl_mxml_num_parse(tree, "data_type", MXML_DESCEND_FIRST, BASE_DEC,
&data_type, NFTNL_TYPE_U32,
NFTNL_XML_OPT, err) == 0) {
- nftnl_set_attr_set_u32(s, NFTNL_SET_ATTR_DATA_TYPE, data_type);
+ nftnl_set_attr_set_u32(s, NFTNL_SET_DATA_TYPE, data_type);
if (nftnl_mxml_num_parse(tree, "data_len", MXML_DESCEND_FIRST,
BASE_DEC, &data_len, NFTNL_TYPE_U32,
NFTNL_XML_MAND, err) == 0)
- nftnl_set_attr_set_u32(s, NFTNL_SET_ATTR_DATA_LEN, data_len);
+ nftnl_set_attr_set_u32(s, NFTNL_SET_DATA_LEN, data_len);
}
if (nftnl_mxml_num_parse(tree, "policy", MXML_DESCEND_FIRST,
BASE_DEC, &policy, NFTNL_TYPE_U32,
NFTNL_XML_OPT, err) == 0)
- nftnl_set_attr_set_u32(s, NFTNL_SET_ATTR_POLICY, policy);
+ nftnl_set_attr_set_u32(s, NFTNL_SET_POLICY, policy);
if (nftnl_mxml_num_parse(tree, "desc_size", MXML_DESCEND_FIRST,
BASE_DEC, &size, NFTNL_TYPE_U32,
NFTNL_XML_OPT, err) == 0)
- nftnl_set_attr_set_u32(s, NFTNL_SET_ATTR_DESC_SIZE, policy);
+ nftnl_set_attr_set_u32(s, NFTNL_SET_DESC_SIZE, policy);
for (node = mxmlFindElement(tree, tree, "set_elem", NULL,
NULL, MXML_DESCEND);
@@ -780,53 +780,53 @@ static int nftnl_set_snprintf_json(char *buf, size_t size, struct nftnl_set *s,
ret = snprintf(buf, len, "{\"set\":{");
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
- if (s->flags & (1 << NFTNL_SET_ATTR_NAME)) {
+ if (s->flags & (1 << NFTNL_SET_NAME)) {
ret = snprintf(buf + offset, len, "\"name\":\"%s\"",
s->name);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (s->flags & (1 << NFTNL_SET_ATTR_TABLE)) {
+ if (s->flags & (1 << NFTNL_SET_TABLE)) {
ret = snprintf(buf + offset, len, ",\"table\":\"%s\"",
s->table);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (s->flags & (1 << NFTNL_SET_ATTR_FLAGS)) {
+ if (s->flags & (1 << NFTNL_SET_FLAGS)) {
ret = snprintf(buf + offset, len, ",\"flags\":%u",
s->set_flags);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (s->flags & (1 << NFTNL_SET_ATTR_FAMILY)) {
+ if (s->flags & (1 << NFTNL_SET_FAMILY)) {
ret = snprintf(buf + offset, len, ",\"family\":\"%s\"",
nftnl_family2str(s->family));
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (s->flags & (1 << NFTNL_SET_ATTR_KEY_TYPE)) {
+ if (s->flags & (1 << NFTNL_SET_KEY_TYPE)) {
ret = snprintf(buf + offset, len, ",\"key_type\":%u",
s->key_type);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (s->flags & (1 << NFTNL_SET_ATTR_KEY_LEN)) {
+ if (s->flags & (1 << NFTNL_SET_KEY_LEN)) {
ret = snprintf(buf + offset, len, ",\"key_len\":%u",
s->key_len);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if(s->flags & (1 << NFTNL_SET_ATTR_DATA_TYPE)) {
+ if(s->flags & (1 << NFTNL_SET_DATA_TYPE)) {
ret = snprintf(buf + offset, len,
",\"data_type\":%u", s->data_type);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if(s->flags & (1 << NFTNL_SET_ATTR_DATA_LEN)) {
+ if(s->flags & (1 << NFTNL_SET_DATA_LEN)) {
ret = snprintf(buf + offset, len, ",\"data_len\":%u", s->data_len);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (s->flags & (1 << NFTNL_SET_ATTR_POLICY)) {
+ if (s->flags & (1 << NFTNL_SET_POLICY)) {
ret = snprintf(buf + offset, len, ",\"policy\":%u",
s->policy);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (s->flags & (1 << NFTNL_SET_ATTR_DESC_SIZE)) {
+ if (s->flags & (1 << NFTNL_SET_DESC_SIZE)) {
ret = snprintf(buf + offset, len, ",\"desc_size\":%u",
s->desc.size);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
@@ -873,24 +873,24 @@ static int nftnl_set_snprintf_default(char *buf, size_t size, struct nftnl_set *
s->name, s->table, s->set_flags);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
- if (s->flags & (1 << NFTNL_SET_ATTR_TIMEOUT)) {
+ if (s->flags & (1 << NFTNL_SET_TIMEOUT)) {
ret = snprintf(buf + offset, len, " timeout %"PRIu64"ms",
s->timeout);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (s->flags & (1 << NFTNL_SET_ATTR_GC_INTERVAL)) {
+ if (s->flags & (1 << NFTNL_SET_GC_INTERVAL)) {
ret = snprintf(buf + offset, len, " gc_interval %ums",
s->gc_interval);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (s->flags & (1 << NFTNL_SET_ATTR_POLICY)) {
+ if (s->flags & (1 << NFTNL_SET_POLICY)) {
ret = snprintf(buf + offset, len, " policy %u", s->policy);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (s->flags & (1 << NFTNL_SET_ATTR_DESC_SIZE)) {
+ if (s->flags & (1 << NFTNL_SET_DESC_SIZE)) {
ret = snprintf(buf + offset, len, " size %u", s->desc.size);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
@@ -923,58 +923,58 @@ static int nftnl_set_snprintf_xml(char *buf, size_t size, struct nftnl_set *s,
ret = snprintf(buf, len, "<set>");
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
- if (s->flags & (1 << NFTNL_SET_ATTR_FAMILY)) {
+ if (s->flags & (1 << NFTNL_SET_FAMILY)) {
ret = snprintf(buf + offset, len, "<family>%s</family>",
nftnl_family2str(s->family));
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (s->flags & (1 << NFTNL_SET_ATTR_TABLE)) {
+ if (s->flags & (1 << NFTNL_SET_TABLE)) {
ret = snprintf(buf + offset, len, "<table>%s</table>",
s->table);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (s->flags & (1 << NFTNL_SET_ATTR_NAME)) {
+ if (s->flags & (1 << NFTNL_SET_NAME)) {
ret = snprintf(buf + offset, len, "<name>%s</name>",
s->name);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (s->flags & (1 << NFTNL_SET_ATTR_FLAGS)) {
+ if (s->flags & (1 << NFTNL_SET_FLAGS)) {
ret = snprintf(buf + offset, len, "<flags>%u</flags>",
s->set_flags);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (s->flags & (1 << NFTNL_SET_ATTR_KEY_TYPE)) {
+ if (s->flags & (1 << NFTNL_SET_KEY_TYPE)) {
ret = snprintf(buf + offset, len, "<key_type>%u</key_type>",
s->key_type);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (s->flags & (1 << NFTNL_SET_ATTR_KEY_LEN)) {
+ if (s->flags & (1 << NFTNL_SET_KEY_LEN)) {
ret = snprintf(buf + offset, len, "<key_len>%u</key_len>",
s->key_len);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (s->flags & (1 << NFTNL_SET_ATTR_DATA_TYPE)) {
+ if (s->flags & (1 << NFTNL_SET_DATA_TYPE)) {
ret = snprintf(buf + offset, len, "<data_type>%u</data_type>",
s->data_type);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (s->flags & (1 << NFTNL_SET_ATTR_DATA_LEN)) {
+ if (s->flags & (1 << NFTNL_SET_DATA_LEN)) {
ret = snprintf(buf + offset, len, "<data_len>%u</data_len>",
s->data_len);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (s->flags & (1 << NFTNL_SET_ATTR_POLICY)) {
+ if (s->flags & (1 << NFTNL_SET_POLICY)) {
ret = snprintf(buf + offset, len, "<policy>%u</policy>",
s->policy);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (s->flags & (1 << NFTNL_SET_ATTR_DESC_SIZE)) {
+ if (s->flags & (1 << NFTNL_SET_DESC_SIZE)) {
ret = snprintf(buf + offset, len, "<desc_size>%u</desc_size>",
s->desc.size);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
@@ -1192,7 +1192,7 @@ static struct nftnl_set *nftnl_set_lookup(const char *this_set_name,
s = nftnl_set_list_iter_cur(iter);
while (s != NULL) {
- set_name = nftnl_set_attr_get_str(s, NFTNL_SET_ATTR_NAME);
+ set_name = nftnl_set_attr_get_str(s, NFTNL_SET_NAME);
if (strcmp(this_set_name, set_name) == 0)
break;
@@ -1217,6 +1217,6 @@ int nftnl_set_lookup_id(struct nftnl_expr *e,
if (s == NULL)
return 0;
- *set_id = nftnl_set_attr_get_u32(s, NFTNL_SET_ATTR_ID);
+ *set_id = nftnl_set_attr_get_u32(s, NFTNL_SET_ID);
return 1;
}
diff --git a/src/set_elem.c b/src/set_elem.c
index b66af58..3dd1658 100644
--- a/src/set_elem.c
+++ b/src/set_elem.c
@@ -41,14 +41,14 @@ EXPORT_SYMBOL(nftnl_set_elem_alloc, nft_set_elem_alloc);
void nftnl_set_elem_free(struct nftnl_set_elem *s)
{
- if (s->flags & (1 << NFTNL_SET_ELEM_ATTR_CHAIN)) {
+ if (s->flags & (1 << NFTNL_SET_ELEM_CHAIN)) {
if (s->data.chain) {
xfree(s->data.chain);
s->data.chain = NULL;
}
}
- if (s->flags & (1 << NFTNL_SET_ELEM_ATTR_EXPR))
+ if (s->flags & (1 << NFTNL_SET_ELEM_EXPR))
nftnl_expr_free(s->expr);
xfree(s);
@@ -64,24 +64,24 @@ EXPORT_SYMBOL(nftnl_set_elem_attr_is_set, nft_set_elem_attr_is_set);
void nftnl_set_elem_attr_unset(struct nftnl_set_elem *s, uint16_t attr)
{
switch (attr) {
- case NFTNL_SET_ELEM_ATTR_CHAIN:
- if (s->flags & (1 << NFTNL_SET_ELEM_ATTR_CHAIN)) {
+ case NFTNL_SET_ELEM_CHAIN:
+ if (s->flags & (1 << NFTNL_SET_ELEM_CHAIN)) {
if (s->data.chain) {
xfree(s->data.chain);
s->data.chain = NULL;
}
}
break;
- case NFTNL_SET_ELEM_ATTR_FLAGS:
- case NFTNL_SET_ELEM_ATTR_KEY: /* NFTA_SET_ELEM_KEY */
- case NFTNL_SET_ELEM_ATTR_VERDICT: /* NFTA_SET_ELEM_DATA */
- case NFTNL_SET_ELEM_ATTR_DATA: /* NFTA_SET_ELEM_DATA */
- case NFTNL_SET_ELEM_ATTR_TIMEOUT: /* NFTA_SET_ELEM_TIMEOUT */
- case NFTNL_SET_ELEM_ATTR_EXPIRATION: /* NFTA_SET_ELEM_EXPIRATION */
- case NFTNL_SET_ELEM_ATTR_USERDATA: /* NFTA_SET_ELEM_USERDATA */
+ case NFTNL_SET_ELEM_FLAGS:
+ case NFTNL_SET_ELEM_KEY: /* NFTA_SET_ELEM_KEY */
+ case NFTNL_SET_ELEM_VERDICT: /* NFTA_SET_ELEM_DATA */
+ case NFTNL_SET_ELEM_DATA: /* NFTA_SET_ELEM_DATA */
+ case NFTNL_SET_ELEM_TIMEOUT: /* NFTA_SET_ELEM_TIMEOUT */
+ case NFTNL_SET_ELEM_EXPIRATION: /* NFTA_SET_ELEM_EXPIRATION */
+ case NFTNL_SET_ELEM_USERDATA: /* NFTA_SET_ELEM_USERDATA */
break;
- case NFTNL_SET_ELEM_ATTR_EXPR:
- if (s->flags & (1 << NFTNL_SET_ELEM_ATTR_EXPR)) {
+ case NFTNL_SET_ELEM_EXPR:
+ if (s->flags & (1 << NFTNL_SET_ELEM_EXPR)) {
nftnl_expr_free(s->expr);
s->expr = NULL;
}
@@ -98,30 +98,30 @@ void nftnl_set_elem_attr_set(struct nftnl_set_elem *s, uint16_t attr,
const void *data, uint32_t data_len)
{
switch(attr) {
- case NFTNL_SET_ELEM_ATTR_FLAGS:
+ case NFTNL_SET_ELEM_FLAGS:
s->set_elem_flags = *((uint32_t *)data);
break;
- case NFTNL_SET_ELEM_ATTR_KEY: /* NFTA_SET_ELEM_KEY */
+ case NFTNL_SET_ELEM_KEY: /* NFTA_SET_ELEM_KEY */
memcpy(&s->key.val, data, data_len);
s->key.len = data_len;
break;
- case NFTNL_SET_ELEM_ATTR_VERDICT: /* NFTA_SET_ELEM_DATA */
+ case NFTNL_SET_ELEM_VERDICT: /* NFTA_SET_ELEM_DATA */
s->data.verdict = *((uint32_t *)data);
break;
- case NFTNL_SET_ELEM_ATTR_CHAIN: /* NFTA_SET_ELEM_DATA */
+ case NFTNL_SET_ELEM_CHAIN: /* NFTA_SET_ELEM_DATA */
if (s->data.chain)
xfree(s->data.chain);
s->data.chain = strdup(data);
break;
- case NFTNL_SET_ELEM_ATTR_DATA: /* NFTA_SET_ELEM_DATA */
+ case NFTNL_SET_ELEM_DATA: /* NFTA_SET_ELEM_DATA */
memcpy(s->data.val, data, data_len);
s->data.len = data_len;
break;
- case NFTNL_SET_ELEM_ATTR_TIMEOUT: /* NFTA_SET_ELEM_TIMEOUT */
+ case NFTNL_SET_ELEM_TIMEOUT: /* NFTA_SET_ELEM_TIMEOUT */
s->timeout = *((uint64_t *)data);
break;
- case NFTNL_SET_ELEM_ATTR_USERDATA: /* NFTA_SET_ELEM_USERDATA */
+ case NFTNL_SET_ELEM_USERDATA: /* NFTA_SET_ELEM_USERDATA */
s->user.data = (void *)data;
s->user.len = data_len;
break;
@@ -156,26 +156,26 @@ const void *nftnl_set_elem_attr_get(struct nftnl_set_elem *s, uint16_t attr, uin
return NULL;
switch(attr) {
- case NFTNL_SET_ELEM_ATTR_FLAGS:
+ case NFTNL_SET_ELEM_FLAGS:
return &s->set_elem_flags;
- case NFTNL_SET_ELEM_ATTR_KEY: /* NFTA_SET_ELEM_KEY */
+ case NFTNL_SET_ELEM_KEY: /* NFTA_SET_ELEM_KEY */
*data_len = s->key.len;
return &s->key.val;
- case NFTNL_SET_ELEM_ATTR_VERDICT: /* NFTA_SET_ELEM_DATA */
+ case NFTNL_SET_ELEM_VERDICT: /* NFTA_SET_ELEM_DATA */
return &s->data.verdict;
- case NFTNL_SET_ELEM_ATTR_CHAIN: /* NFTA_SET_ELEM_DATA */
+ case NFTNL_SET_ELEM_CHAIN: /* NFTA_SET_ELEM_DATA */
return s->data.chain;
- case NFTNL_SET_ELEM_ATTR_DATA: /* NFTA_SET_ELEM_DATA */
+ case NFTNL_SET_ELEM_DATA: /* NFTA_SET_ELEM_DATA */
*data_len = s->data.len;
return &s->data.val;
- case NFTNL_SET_ELEM_ATTR_TIMEOUT: /* NFTA_SET_ELEM_TIMEOUT */
+ case NFTNL_SET_ELEM_TIMEOUT: /* NFTA_SET_ELEM_TIMEOUT */
return &s->timeout;
- case NFTNL_SET_ELEM_ATTR_EXPIRATION: /* NFTA_SET_ELEM_EXPIRATION */
+ case NFTNL_SET_ELEM_EXPIRATION: /* NFTA_SET_ELEM_EXPIRATION */
return &s->expiration;
- case NFTNL_SET_ELEM_ATTR_USERDATA:
+ case NFTNL_SET_ELEM_USERDATA:
*data_len = s->user.len;
return s->user.data;
- case NFTNL_SET_ELEM_ATTR_EXPR:
+ case NFTNL_SET_ELEM_EXPR:
return s->expr;
}
return NULL;
@@ -216,7 +216,7 @@ struct nftnl_set_elem *nftnl_set_elem_clone(struct nftnl_set_elem *elem)
memcpy(newelem, elem, sizeof(*elem));
- if (elem->flags & (1 << NFTNL_SET_ELEM_ATTR_CHAIN))
+ if (elem->flags & (1 << NFTNL_SET_ELEM_CHAIN))
newelem->data.chain = strdup(elem->data.chain);
return newelem;
@@ -225,48 +225,48 @@ struct nftnl_set_elem *nftnl_set_elem_clone(struct nftnl_set_elem *elem)
void nftnl_set_elem_nlmsg_build_payload(struct nlmsghdr *nlh,
struct nftnl_set_elem *e)
{
- if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_FLAGS))
+ if (e->flags & (1 << NFTNL_SET_ELEM_FLAGS))
mnl_attr_put_u32(nlh, NFTA_SET_ELEM_FLAGS, htonl(e->set_elem_flags));
- if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_TIMEOUT))
+ if (e->flags & (1 << NFTNL_SET_ELEM_TIMEOUT))
mnl_attr_put_u64(nlh, NFTA_SET_ELEM_TIMEOUT, htobe64(e->timeout));
- if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_KEY)) {
+ if (e->flags & (1 << NFTNL_SET_ELEM_KEY)) {
struct nlattr *nest1;
nest1 = mnl_attr_nest_start(nlh, NFTA_SET_ELEM_KEY);
mnl_attr_put(nlh, NFTA_DATA_VALUE, e->key.len, e->key.val);
mnl_attr_nest_end(nlh, nest1);
}
- if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_VERDICT)) {
+ if (e->flags & (1 << NFTNL_SET_ELEM_VERDICT)) {
struct nlattr *nest1, *nest2;
nest1 = mnl_attr_nest_start(nlh, NFTA_SET_ELEM_DATA);
nest2 = mnl_attr_nest_start(nlh, NFTA_DATA_VERDICT);
mnl_attr_put_u32(nlh, NFTA_VERDICT_CODE, htonl(e->data.verdict));
- if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_CHAIN))
+ if (e->flags & (1 << NFTNL_SET_ELEM_CHAIN))
mnl_attr_put_strz(nlh, NFTA_VERDICT_CHAIN, e->data.chain);
mnl_attr_nest_end(nlh, nest1);
mnl_attr_nest_end(nlh, nest2);
}
- if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_DATA)) {
+ if (e->flags & (1 << NFTNL_SET_ELEM_DATA)) {
struct nlattr *nest1;
nest1 = mnl_attr_nest_start(nlh, NFTA_SET_ELEM_DATA);
mnl_attr_put(nlh, NFTA_DATA_VALUE, e->data.len, e->data.val);
mnl_attr_nest_end(nlh, nest1);
}
- if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_USERDATA))
+ if (e->flags & (1 << NFTNL_SET_ELEM_USERDATA))
mnl_attr_put(nlh, NFTA_SET_ELEM_USERDATA, e->user.len, e->user.data);
}
static void nftnl_set_elem_nlmsg_build_def(struct nlmsghdr *nlh,
struct nftnl_set *s)
{
- if (s->flags & (1 << NFTNL_SET_ATTR_NAME))
+ if (s->flags & (1 << NFTNL_SET_NAME))
mnl_attr_put_strz(nlh, NFTA_SET_ELEM_LIST_SET, s->name);
- if (s->flags & (1 << NFTNL_SET_ATTR_ID))
+ if (s->flags & (1 << NFTNL_SET_ID))
mnl_attr_put_u32(nlh, NFTA_SET_ELEM_LIST_SET_ID, htonl(s->id));
- if (s->flags & (1 << NFTNL_SET_ATTR_TABLE))
+ if (s->flags & (1 << NFTNL_SET_TABLE))
mnl_attr_put_strz(nlh, NFTA_SET_ELEM_LIST_TABLE, s->table);
}
@@ -350,32 +350,32 @@ static int nftnl_set_elems_parse2(struct nftnl_set *s, const struct nlattr *nest
if (tb[NFTA_SET_ELEM_FLAGS]) {
e->set_elem_flags =
ntohl(mnl_attr_get_u32(tb[NFTA_SET_ELEM_FLAGS]));
- e->flags |= (1 << NFTNL_SET_ELEM_ATTR_FLAGS);
+ e->flags |= (1 << NFTNL_SET_ELEM_FLAGS);
}
if (tb[NFTA_SET_ELEM_TIMEOUT]) {
e->timeout = be64toh(mnl_attr_get_u64(tb[NFTA_SET_ELEM_TIMEOUT]));
- e->flags |= (1 << NFTNL_SET_ELEM_ATTR_TIMEOUT);
+ e->flags |= (1 << NFTNL_SET_ELEM_TIMEOUT);
}
if (tb[NFTA_SET_ELEM_EXPIRATION]) {
e->expiration = be64toh(mnl_attr_get_u64(tb[NFTA_SET_ELEM_EXPIRATION]));
- e->flags |= (1 << NFTNL_SET_ELEM_ATTR_EXPIRATION);
+ e->flags |= (1 << NFTNL_SET_ELEM_EXPIRATION);
}
if (tb[NFTA_SET_ELEM_KEY]) {
ret = nftnl_parse_data(&e->key, tb[NFTA_SET_ELEM_KEY], &type);
- e->flags |= (1 << NFTNL_SET_ELEM_ATTR_KEY);
+ e->flags |= (1 << NFTNL_SET_ELEM_KEY);
}
if (tb[NFTA_SET_ELEM_DATA]) {
ret = nftnl_parse_data(&e->data, tb[NFTA_SET_ELEM_DATA], &type);
switch(type) {
case DATA_VERDICT:
- e->flags |= (1 << NFTNL_SET_ELEM_ATTR_VERDICT);
+ e->flags |= (1 << NFTNL_SET_ELEM_VERDICT);
break;
case DATA_CHAIN:
- e->flags |= (1 << NFTNL_SET_ELEM_ATTR_VERDICT) |
- (1 << NFTNL_SET_ELEM_ATTR_CHAIN);
+ e->flags |= (1 << NFTNL_SET_ELEM_VERDICT) |
+ (1 << NFTNL_SET_ELEM_CHAIN);
break;
case DATA_VALUE:
- e->flags |= (1 << NFTNL_SET_ELEM_ATTR_DATA);
+ e->flags |= (1 << NFTNL_SET_ELEM_DATA);
break;
}
}
@@ -383,7 +383,7 @@ static int nftnl_set_elems_parse2(struct nftnl_set *s, const struct nlattr *nest
e->expr = nftnl_expr_parse(tb[NFTA_SET_ELEM_EXPR]);
if (e->expr == NULL)
goto err;
- e->flags |= (1 << NFTNL_SET_ELEM_ATTR_EXPR);
+ e->flags |= (1 << NFTNL_SET_ELEM_EXPR);
}
if (tb[NFTA_SET_ELEM_USERDATA]) {
const void *udata =
@@ -397,7 +397,7 @@ static int nftnl_set_elems_parse2(struct nftnl_set *s, const struct nlattr *nest
if (e->user.data == NULL)
goto err;
memcpy(e->user.data, udata, e->user.len);
- e->flags |= (1 << NFTNL_RULE_ATTR_USERDATA);
+ e->flags |= (1 << NFTNL_RULE_USERDATA);
}
if (ret < 0) {
@@ -465,23 +465,23 @@ int nftnl_set_elems_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_set *s)
xfree(s->table);
s->table =
strdup(mnl_attr_get_str(tb[NFTA_SET_ELEM_LIST_TABLE]));
- s->flags |= (1 << NFTNL_SET_ATTR_TABLE);
+ s->flags |= (1 << NFTNL_SET_TABLE);
}
if (tb[NFTA_SET_ELEM_LIST_SET]) {
xfree(s->name);
s->name =
strdup(mnl_attr_get_str(tb[NFTA_SET_ELEM_LIST_SET]));
- s->flags |= (1 << NFTNL_SET_ATTR_NAME);
+ s->flags |= (1 << NFTNL_SET_NAME);
}
if (tb[NFTA_SET_ELEM_LIST_SET_ID]) {
s->id = ntohl(mnl_attr_get_u32(tb[NFTA_SET_ELEM_LIST_SET_ID]));
- s->flags |= (1 << NFTNL_SET_ATTR_ID);
+ s->flags |= (1 << NFTNL_SET_ID);
}
if (tb[NFTA_SET_ELEM_LIST_ELEMENTS])
ret = nftnl_set_elems_parse(s, tb[NFTA_SET_ELEM_LIST_ELEMENTS]);
s->family = nfg->nfgen_family;
- s->flags |= (1 << NFTNL_SET_ATTR_FAMILY);
+ s->flags |= (1 << NFTNL_SET_FAMILY);
return ret;
}
@@ -497,23 +497,23 @@ int nftnl_mxml_set_elem_parse(mxml_node_t *tree, struct nftnl_set_elem *e,
if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND_FIRST, BASE_DEC,
&set_elem_flags, NFTNL_TYPE_U32, NFTNL_XML_MAND,
err) == 0)
- nftnl_set_elem_attr_set_u32(e, NFTNL_SET_ELEM_ATTR_FLAGS, set_elem_flags);
+ nftnl_set_elem_attr_set_u32(e, NFTNL_SET_ELEM_FLAGS, set_elem_flags);
if (nftnl_mxml_data_reg_parse(tree, "key", &e->key,
NFTNL_XML_MAND, err) == DATA_VALUE)
- e->flags |= (1 << NFTNL_SET_ELEM_ATTR_KEY);
+ e->flags |= (1 << NFTNL_SET_ELEM_KEY);
/* <set_elem_data> is not mandatory */
set_elem_data = nftnl_mxml_data_reg_parse(tree, "data",
&e->data, NFTNL_XML_OPT, err);
switch (set_elem_data) {
case DATA_VALUE:
- e->flags |= (1 << NFTNL_SET_ELEM_ATTR_DATA);
+ e->flags |= (1 << NFTNL_SET_ELEM_DATA);
break;
case DATA_VERDICT:
- e->flags |= (1 << NFTNL_SET_ELEM_ATTR_VERDICT);
+ e->flags |= (1 << NFTNL_SET_ELEM_VERDICT);
if (e->data.chain != NULL)
- e->flags |= (1 << NFTNL_SET_ELEM_ATTR_CHAIN);
+ e->flags |= (1 << NFTNL_SET_ELEM_CHAIN);
break;
}
@@ -603,7 +603,7 @@ static int nftnl_set_elem_snprintf_json(char *buf, size_t size,
{
int ret, len = size, offset = 0, type = -1;
- if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_FLAGS)) {
+ if (e->flags & (1 << NFTNL_SET_ELEM_FLAGS)) {
ret = snprintf(buf, len, "\"flags\":%u,", e->set_elem_flags);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
@@ -618,11 +618,11 @@ static int nftnl_set_elem_snprintf_json(char *buf, size_t size,
ret = snprintf(buf + offset, len, "}");
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
- if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_DATA))
+ if (e->flags & (1 << NFTNL_SET_ELEM_DATA))
type = DATA_VALUE;
- else if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_CHAIN))
+ else if (e->flags & (1 << NFTNL_SET_ELEM_CHAIN))
type = DATA_CHAIN;
- else if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_VERDICT))
+ else if (e->flags & (1 << NFTNL_SET_ELEM_VERDICT))
type = DATA_VERDICT;
if (type != -1) {
@@ -691,13 +691,13 @@ static int nftnl_set_elem_snprintf_xml(char *buf, size_t size,
ret = snprintf(buf, size, "<set_elem>");
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
- if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_FLAGS)) {
+ if (e->flags & (1 << NFTNL_SET_ELEM_FLAGS)) {
ret = snprintf(buf + offset, size, "<flags>%u</flags>",
e->set_elem_flags);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_KEY)) {
+ if (e->flags & (1 << NFTNL_SET_ELEM_KEY)) {
ret = snprintf(buf + offset, len, "<key>");
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
@@ -709,11 +709,11 @@ static int nftnl_set_elem_snprintf_xml(char *buf, size_t size,
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_DATA))
+ if (e->flags & (1 << NFTNL_SET_ELEM_DATA))
type = DATA_VALUE;
- else if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_CHAIN))
+ else if (e->flags & (1 << NFTNL_SET_ELEM_CHAIN))
type = DATA_CHAIN;
- else if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_VERDICT))
+ else if (e->flags & (1 << NFTNL_SET_ELEM_VERDICT))
type = DATA_VERDICT;
if (type != DATA_NONE) {
diff --git a/src/table.c b/src/table.c
index 4adfba8..1d119ef 100644
--- a/src/table.c
+++ b/src/table.c
@@ -44,7 +44,7 @@ EXPORT_SYMBOL(nftnl_table_alloc, nft_table_alloc);
void nftnl_table_free(struct nftnl_table *t)
{
- if (t->flags & (1 << NFTNL_TABLE_ATTR_NAME))
+ if (t->flags & (1 << NFTNL_TABLE_NAME))
xfree(t->name);
xfree(t);
@@ -63,49 +63,49 @@ void nftnl_table_attr_unset(struct nftnl_table *t, uint16_t attr)
return;
switch (attr) {
- case NFTNL_TABLE_ATTR_NAME:
+ case NFTNL_TABLE_NAME:
if (t->name) {
xfree(t->name);
t->name = NULL;
}
break;
- case NFTNL_TABLE_ATTR_FLAGS:
- case NFTNL_TABLE_ATTR_FAMILY:
+ case NFTNL_TABLE_FLAGS:
+ case NFTNL_TABLE_FAMILY:
break;
- case NFTNL_TABLE_ATTR_USE:
+ case NFTNL_TABLE_USE:
break;
}
t->flags &= ~(1 << attr);
}
EXPORT_SYMBOL(nftnl_table_attr_unset, nft_table_attr_unset);
-static uint32_t nftnl_table_attr_validate[NFTNL_TABLE_ATTR_MAX + 1] = {
- [NFTNL_TABLE_ATTR_FLAGS] = sizeof(uint32_t),
- [NFTNL_TABLE_ATTR_FAMILY] = sizeof(uint32_t),
+static uint32_t nftnl_table_attr_validate[NFTNL_TABLE_MAX + 1] = {
+ [NFTNL_TABLE_FLAGS] = sizeof(uint32_t),
+ [NFTNL_TABLE_FAMILY] = sizeof(uint32_t),
};
void nftnl_table_attr_set_data(struct nftnl_table *t, uint16_t attr,
const void *data, uint32_t data_len)
{
- if (attr > NFTNL_TABLE_ATTR_MAX)
+ if (attr > NFTNL_TABLE_MAX)
return;
nftnl_assert_validate(data, nftnl_table_attr_validate, attr, data_len);
switch (attr) {
- case NFTNL_TABLE_ATTR_NAME:
+ case NFTNL_TABLE_NAME:
if (t->name)
xfree(t->name);
t->name = strdup(data);
break;
- case NFTNL_TABLE_ATTR_FLAGS:
+ case NFTNL_TABLE_FLAGS:
t->table_flags = *((uint32_t *)data);
break;
- case NFTNL_TABLE_ATTR_FAMILY:
+ case NFTNL_TABLE_FAMILY:
t->family = *((uint32_t *)data);
break;
- case NFTNL_TABLE_ATTR_USE:
+ case NFTNL_TABLE_USE:
t->use = *((uint32_t *)data);
break;
}
@@ -144,15 +144,15 @@ const void *nftnl_table_attr_get_data(struct nftnl_table *t, uint16_t attr,
return NULL;
switch(attr) {
- case NFTNL_TABLE_ATTR_NAME:
+ case NFTNL_TABLE_NAME:
return t->name;
- case NFTNL_TABLE_ATTR_FLAGS:
+ case NFTNL_TABLE_FLAGS:
*data_len = sizeof(uint32_t);
return &t->table_flags;
- case NFTNL_TABLE_ATTR_FAMILY:
+ case NFTNL_TABLE_FAMILY:
*data_len = sizeof(uint32_t);
return &t->family;
- case NFTNL_TABLE_ATTR_USE:
+ case NFTNL_TABLE_USE:
*data_len = sizeof(uint32_t);
return &t->use;
}
@@ -189,9 +189,9 @@ EXPORT_SYMBOL(nftnl_table_attr_get_str, nft_table_attr_get_str);
void nftnl_table_nlmsg_build_payload(struct nlmsghdr *nlh, const struct nftnl_table *t)
{
- if (t->flags & (1 << NFTNL_TABLE_ATTR_NAME))
+ if (t->flags & (1 << NFTNL_TABLE_NAME))
mnl_attr_put_strz(nlh, NFTA_TABLE_NAME, t->name);
- if (t->flags & (1 << NFTNL_TABLE_ATTR_FLAGS))
+ if (t->flags & (1 << NFTNL_TABLE_FLAGS))
mnl_attr_put_u32(nlh, NFTA_TABLE_FLAGS, htonl(t->table_flags));
}
EXPORT_SYMBOL(nftnl_table_nlmsg_build_payload, nft_table_nlmsg_build_payload);
@@ -231,19 +231,19 @@ int nftnl_table_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_table *t)
if (tb[NFTA_TABLE_NAME]) {
xfree(t->name);
t->name = strdup(mnl_attr_get_str(tb[NFTA_TABLE_NAME]));
- t->flags |= (1 << NFTNL_TABLE_ATTR_NAME);
+ t->flags |= (1 << NFTNL_TABLE_NAME);
}
if (tb[NFTA_TABLE_FLAGS]) {
t->table_flags = ntohl(mnl_attr_get_u32(tb[NFTA_TABLE_FLAGS]));
- t->flags |= (1 << NFTNL_TABLE_ATTR_FLAGS);
+ t->flags |= (1 << NFTNL_TABLE_FLAGS);
}
if (tb[NFTA_TABLE_USE]) {
t->use = ntohl(mnl_attr_get_u32(tb[NFTA_TABLE_USE]));
- t->flags |= (1 << NFTNL_TABLE_ATTR_USE);
+ t->flags |= (1 << NFTNL_TABLE_USE);
}
t->family = nfg->nfgen_family;
- t->flags |= (1 << NFTNL_TABLE_ATTR_FAMILY);
+ t->flags |= (1 << NFTNL_TABLE_FAMILY);
return 0;
}
@@ -260,20 +260,20 @@ int nftnl_mxml_table_parse(mxml_node_t *tree, struct nftnl_table *t,
name = nftnl_mxml_str_parse(tree, "name", MXML_DESCEND_FIRST,
NFTNL_XML_MAND, err);
if (name != NULL)
- nftnl_table_attr_set_str(t, NFTNL_TABLE_ATTR_NAME, name);
+ nftnl_table_attr_set_str(t, NFTNL_TABLE_NAME, name);
family = nftnl_mxml_family_parse(tree, "family", MXML_DESCEND_FIRST,
NFTNL_XML_MAND, err);
if (family >= 0)
- nftnl_table_attr_set_u32(t, NFTNL_TABLE_ATTR_FAMILY, family);
+ nftnl_table_attr_set_u32(t, NFTNL_TABLE_FAMILY, family);
if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND, BASE_DEC,
&flags, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0)
- nftnl_table_attr_set_u32(t, NFTNL_TABLE_ATTR_FLAGS, flags);
+ nftnl_table_attr_set_u32(t, NFTNL_TABLE_FLAGS, flags);
if (nftnl_mxml_num_parse(tree, "use", MXML_DESCEND, BASE_DEC,
&use, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0)
- nftnl_table_attr_set_u32(t, NFTNL_TABLE_ATTR_USE, use);
+ nftnl_table_attr_set_u32(t, NFTNL_TABLE_USE, use);
return 0;
}
@@ -313,17 +313,17 @@ int nftnl_jansson_parse_table(struct nftnl_table *t, json_t *tree,
str = nftnl_jansson_parse_str(root, "name", err);
if (str != NULL)
- nftnl_table_attr_set_str(t, NFTNL_TABLE_ATTR_NAME, str);
+ nftnl_table_attr_set_str(t, NFTNL_TABLE_NAME, str);
if (nftnl_jansson_parse_family(root, &family, err) == 0)
- nftnl_table_attr_set_u32(t, NFTNL_TABLE_ATTR_FAMILY, family);
+ nftnl_table_attr_set_u32(t, NFTNL_TABLE_FAMILY, family);
if (nftnl_jansson_parse_val(root, "flags", NFTNL_TYPE_U32, &flags,
err) == 0)
- nftnl_table_attr_set_u32(t, NFTNL_TABLE_ATTR_FLAGS, flags);
+ nftnl_table_attr_set_u32(t, NFTNL_TABLE_FLAGS, flags);
if (nftnl_jansson_parse_val(root, "use", NFTNL_TYPE_U32, &use, err) == 0)
- nftnl_table_attr_set_u32(t, NFTNL_TABLE_ATTR_USE, use);
+ nftnl_table_attr_set_u32(t, NFTNL_TABLE_USE, use);
return 0;
}
@@ -399,13 +399,13 @@ static int nftnl_table_export(char *buf, size_t size, struct nftnl_table *t,
NFTNL_BUF_INIT(b, buf, size);
nftnl_buf_open(&b, type, TABLE);
- if (t->flags & (1 << NFTNL_TABLE_ATTR_NAME))
+ if (t->flags & (1 << NFTNL_TABLE_NAME))
nftnl_buf_str(&b, type, t->name, NAME);
- if (t->flags & (1 << NFTNL_TABLE_ATTR_FAMILY))
+ if (t->flags & (1 << NFTNL_TABLE_FAMILY))
nftnl_buf_str(&b, type, nftnl_family2str(t->family), FAMILY);
- if (t->flags & (1 << NFTNL_TABLE_ATTR_FLAGS))
+ if (t->flags & (1 << NFTNL_TABLE_FLAGS))
nftnl_buf_u32(&b, type, t->table_flags, FLAGS);
- if (t->flags & (1 << NFTNL_TABLE_ATTR_USE))
+ if (t->flags & (1 << NFTNL_TABLE_USE))
nftnl_buf_u32(&b, type, t->use, USE);
nftnl_buf_close(&b, type, TABLE);