summaryrefslogtreecommitdiffstats
path: root/src/chain.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/chain.c')
-rw-r--r--src/chain.c593
1 files changed, 297 insertions, 296 deletions
diff --git a/src/chain.c b/src/chain.c
index bb9fe90..63cb91a 100644
--- a/src/chain.c
+++ b/src/chain.c
@@ -29,7 +29,7 @@
#include <libnftnl/chain.h>
#include <buffer.h>
-struct nft_chain {
+struct nftnl_chain {
struct list_head head;
char name[NFT_CHAIN_MAXNAMELEN];
@@ -47,7 +47,7 @@ struct nft_chain {
uint32_t flags;
};
-static const char *nft_hooknum2str(int family, int hooknum)
+static const char *nftnl_hooknum2str(int family, int hooknum)
{
switch (family) {
case NFPROTO_IPV4:
@@ -87,13 +87,13 @@ static const char *nft_hooknum2str(int family, int hooknum)
return "unknown";
}
-struct nft_chain *nft_chain_alloc(void)
+struct nftnl_chain *nftnl_chain_alloc(void)
{
- return calloc(1, sizeof(struct nft_chain));
+ return calloc(1, sizeof(struct nftnl_chain));
}
EXPORT_SYMBOL(nftnl_chain_alloc, nft_chain_alloc);
-void nft_chain_free(struct nft_chain *c)
+void nftnl_chain_free(struct nftnl_chain *c)
{
if (c->table != NULL)
xfree(c->table);
@@ -106,42 +106,42 @@ void nft_chain_free(struct nft_chain *c)
}
EXPORT_SYMBOL(nftnl_chain_free, nft_chain_free);
-bool nft_chain_attr_is_set(const struct nft_chain *c, uint16_t attr)
+bool nftnl_chain_attr_is_set(const struct nftnl_chain *c, uint16_t attr)
{
return c->flags & (1 << attr);
}
EXPORT_SYMBOL(nftnl_chain_attr_is_set, nft_chain_attr_is_set);
-void nft_chain_attr_unset(struct nft_chain *c, uint16_t attr)
+void nftnl_chain_attr_unset(struct nftnl_chain *c, uint16_t attr)
{
if (!(c->flags & (1 << attr)))
return;
switch (attr) {
- case NFT_CHAIN_ATTR_TABLE:
+ case NFTNL_CHAIN_ATTR_TABLE:
if (c->table) {
xfree(c->table);
c->table = NULL;
}
break;
- case NFT_CHAIN_ATTR_USE:
+ case NFTNL_CHAIN_ATTR_USE:
break;
- case NFT_CHAIN_ATTR_TYPE:
+ case NFTNL_CHAIN_ATTR_TYPE:
if (c->type) {
xfree(c->type);
c->type = NULL;
}
break;
- case NFT_CHAIN_ATTR_NAME:
- case NFT_CHAIN_ATTR_HOOKNUM:
- case NFT_CHAIN_ATTR_PRIO:
- case NFT_CHAIN_ATTR_POLICY:
- case NFT_CHAIN_ATTR_BYTES:
- case NFT_CHAIN_ATTR_PACKETS:
- case NFT_CHAIN_ATTR_HANDLE:
- case NFT_CHAIN_ATTR_FAMILY:
+ 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:
break;
- case NFT_CHAIN_ATTR_DEV:
+ case NFTNL_CHAIN_ATTR_DEV:
if (c->dev) {
xfree(c->dev);
c->dev = NULL;
@@ -155,65 +155,65 @@ void nft_chain_attr_unset(struct nft_chain *c, uint16_t attr)
}
EXPORT_SYMBOL(nftnl_chain_attr_unset, nft_chain_attr_unset);
-static uint32_t nft_chain_attr_validate[NFT_CHAIN_ATTR_MAX + 1] = {
- [NFT_CHAIN_ATTR_HOOKNUM] = sizeof(uint32_t),
- [NFT_CHAIN_ATTR_PRIO] = sizeof(int32_t),
- [NFT_CHAIN_ATTR_POLICY] = sizeof(uint32_t),
- [NFT_CHAIN_ATTR_BYTES] = sizeof(uint64_t),
- [NFT_CHAIN_ATTR_PACKETS] = sizeof(uint64_t),
- [NFT_CHAIN_ATTR_HANDLE] = sizeof(uint64_t),
- [NFT_CHAIN_ATTR_FAMILY] = sizeof(uint32_t),
+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),
};
-void nft_chain_attr_set_data(struct nft_chain *c, uint16_t attr,
+void nftnl_chain_attr_set_data(struct nftnl_chain *c, uint16_t attr,
const void *data, uint32_t data_len)
{
- if (attr > NFT_CHAIN_ATTR_MAX)
+ if (attr > NFTNL_CHAIN_ATTR_MAX)
return;
- nft_assert_validate(data, nft_chain_attr_validate, attr, data_len);
+ nftnl_assert_validate(data, nftnl_chain_attr_validate, attr, data_len);
switch(attr) {
- case NFT_CHAIN_ATTR_NAME:
+ case NFTNL_CHAIN_ATTR_NAME:
strncpy(c->name, data, NFT_CHAIN_MAXNAMELEN);
break;
- case NFT_CHAIN_ATTR_TABLE:
+ case NFTNL_CHAIN_ATTR_TABLE:
if (c->table)
xfree(c->table);
c->table = strdup(data);
break;
- case NFT_CHAIN_ATTR_HOOKNUM:
+ case NFTNL_CHAIN_ATTR_HOOKNUM:
memcpy(&c->hooknum, data, sizeof(c->hooknum));
break;
- case NFT_CHAIN_ATTR_PRIO:
+ case NFTNL_CHAIN_ATTR_PRIO:
memcpy(&c->prio, data, sizeof(c->prio));
break;
- case NFT_CHAIN_ATTR_POLICY:
+ case NFTNL_CHAIN_ATTR_POLICY:
c->policy = *((uint32_t *)data);
break;
- case NFT_CHAIN_ATTR_USE:
+ case NFTNL_CHAIN_ATTR_USE:
c->use = *((uint32_t *)data);
break;
- case NFT_CHAIN_ATTR_BYTES:
+ case NFTNL_CHAIN_ATTR_BYTES:
c->bytes = *((uint64_t *)data);
break;
- case NFT_CHAIN_ATTR_PACKETS:
+ case NFTNL_CHAIN_ATTR_PACKETS:
c->packets = *((uint64_t *)data);
break;
- case NFT_CHAIN_ATTR_HANDLE:
+ case NFTNL_CHAIN_ATTR_HANDLE:
c->handle = *((uint64_t *)data);
break;
- case NFT_CHAIN_ATTR_FAMILY:
+ case NFTNL_CHAIN_ATTR_FAMILY:
c->family = *((uint32_t *)data);
break;
- case NFT_CHAIN_ATTR_TYPE:
+ case NFTNL_CHAIN_ATTR_TYPE:
if (c->type)
xfree(c->type);
c->type = strdup(data);
break;
- case NFT_CHAIN_ATTR_DEV:
+ case NFTNL_CHAIN_ATTR_DEV:
if (c->dev)
xfree(c->dev);
@@ -224,167 +224,167 @@ void nft_chain_attr_set_data(struct nft_chain *c, uint16_t attr,
}
EXPORT_SYMBOL(nftnl_chain_attr_set_data, nft_chain_attr_set_data);
-void nft_chain_attr_set(struct nft_chain *c, uint16_t attr, const void *data)
+void nftnl_chain_attr_set(struct nftnl_chain *c, uint16_t attr, const void *data)
{
- nft_chain_attr_set_data(c, attr, data, nft_chain_attr_validate[attr]);
+ nftnl_chain_attr_set_data(c, attr, data, nftnl_chain_attr_validate[attr]);
}
EXPORT_SYMBOL(nftnl_chain_attr_set, nft_chain_attr_set);
-void nft_chain_attr_set_u32(struct nft_chain *c, uint16_t attr, uint32_t data)
+void nftnl_chain_attr_set_u32(struct nftnl_chain *c, uint16_t attr, uint32_t data)
{
- nft_chain_attr_set_data(c, attr, &data, sizeof(uint32_t));
+ nftnl_chain_attr_set_data(c, attr, &data, sizeof(uint32_t));
}
EXPORT_SYMBOL(nftnl_chain_attr_set_u32, nft_chain_attr_set_u32);
-void nft_chain_attr_set_s32(struct nft_chain *c, uint16_t attr, int32_t data)
+void nftnl_chain_attr_set_s32(struct nftnl_chain *c, uint16_t attr, int32_t data)
{
- nft_chain_attr_set_data(c, attr, &data, sizeof(int32_t));
+ nftnl_chain_attr_set_data(c, attr, &data, sizeof(int32_t));
}
EXPORT_SYMBOL(nftnl_chain_attr_set_s32, nft_chain_attr_set_s32);
-void nft_chain_attr_set_u64(struct nft_chain *c, uint16_t attr, uint64_t data)
+void nftnl_chain_attr_set_u64(struct nftnl_chain *c, uint16_t attr, uint64_t data)
{
- nft_chain_attr_set_data(c, attr, &data, sizeof(uint64_t));
+ nftnl_chain_attr_set_data(c, attr, &data, sizeof(uint64_t));
}
EXPORT_SYMBOL(nftnl_chain_attr_set_u64, nft_chain_attr_set_u64);
-void nft_chain_attr_set_u8(struct nft_chain *c, uint16_t attr, uint8_t data)
+void nftnl_chain_attr_set_u8(struct nftnl_chain *c, uint16_t attr, uint8_t data)
{
- nft_chain_attr_set_data(c, attr, &data, sizeof(uint8_t));
+ nftnl_chain_attr_set_data(c, attr, &data, sizeof(uint8_t));
}
EXPORT_SYMBOL(nftnl_chain_attr_set_u8, nft_chain_attr_set_u8);
-void nft_chain_attr_set_str(struct nft_chain *c, uint16_t attr, const char *str)
+void nftnl_chain_attr_set_str(struct nftnl_chain *c, uint16_t attr, const char *str)
{
- nft_chain_attr_set_data(c, attr, str, strlen(str));
+ nftnl_chain_attr_set_data(c, attr, str, strlen(str));
}
EXPORT_SYMBOL(nftnl_chain_attr_set_str, nft_chain_attr_set_str);
-const void *nft_chain_attr_get_data(struct nft_chain *c, uint16_t attr,
+const void *nftnl_chain_attr_get_data(struct nftnl_chain *c, uint16_t attr,
uint32_t *data_len)
{
if (!(c->flags & (1 << attr)))
return NULL;
switch(attr) {
- case NFT_CHAIN_ATTR_NAME:
+ case NFTNL_CHAIN_ATTR_NAME:
return c->name;
- case NFT_CHAIN_ATTR_TABLE:
+ case NFTNL_CHAIN_ATTR_TABLE:
return c->table;
- case NFT_CHAIN_ATTR_HOOKNUM:
+ case NFTNL_CHAIN_ATTR_HOOKNUM:
*data_len = sizeof(uint32_t);
return &c->hooknum;
- case NFT_CHAIN_ATTR_PRIO:
+ case NFTNL_CHAIN_ATTR_PRIO:
*data_len = sizeof(int32_t);
return &c->prio;
- case NFT_CHAIN_ATTR_POLICY:
+ case NFTNL_CHAIN_ATTR_POLICY:
*data_len = sizeof(uint32_t);
return &c->policy;
- case NFT_CHAIN_ATTR_USE:
+ case NFTNL_CHAIN_ATTR_USE:
*data_len = sizeof(uint32_t);
return &c->use;
- case NFT_CHAIN_ATTR_BYTES:
+ case NFTNL_CHAIN_ATTR_BYTES:
*data_len = sizeof(uint64_t);
return &c->bytes;
- case NFT_CHAIN_ATTR_PACKETS:
+ case NFTNL_CHAIN_ATTR_PACKETS:
*data_len = sizeof(uint64_t);
return &c->packets;
- case NFT_CHAIN_ATTR_HANDLE:
+ case NFTNL_CHAIN_ATTR_HANDLE:
*data_len = sizeof(uint64_t);
return &c->handle;
- case NFT_CHAIN_ATTR_FAMILY:
+ case NFTNL_CHAIN_ATTR_FAMILY:
*data_len = sizeof(uint32_t);
return &c->family;
- case NFT_CHAIN_ATTR_TYPE:
+ case NFTNL_CHAIN_ATTR_TYPE:
*data_len = sizeof(uint32_t);
return c->type;
- case NFT_CHAIN_ATTR_DEV:
+ case NFTNL_CHAIN_ATTR_DEV:
return c->dev;
}
return NULL;
}
EXPORT_SYMBOL(nftnl_chain_attr_get_data, nft_chain_attr_get_data);
-const void *nft_chain_attr_get(struct nft_chain *c, uint16_t attr)
+const void *nftnl_chain_attr_get(struct nftnl_chain *c, uint16_t attr)
{
uint32_t data_len;
- return nft_chain_attr_get_data(c, attr, &data_len);
+ return nftnl_chain_attr_get_data(c, attr, &data_len);
}
EXPORT_SYMBOL(nftnl_chain_attr_get, nft_chain_attr_get);
-const char *nft_chain_attr_get_str(struct nft_chain *c, uint16_t attr)
+const char *nftnl_chain_attr_get_str(struct nftnl_chain *c, uint16_t attr)
{
- return nft_chain_attr_get(c, attr);
+ return nftnl_chain_attr_get(c, attr);
}
EXPORT_SYMBOL(nftnl_chain_attr_get_str, nft_chain_attr_get_str);
-uint32_t nft_chain_attr_get_u32(struct nft_chain *c, uint16_t attr)
+uint32_t nftnl_chain_attr_get_u32(struct nftnl_chain *c, uint16_t attr)
{
uint32_t data_len;
- const uint32_t *val = nft_chain_attr_get_data(c, attr, &data_len);
+ const uint32_t *val = nftnl_chain_attr_get_data(c, attr, &data_len);
- nft_assert(val, attr, data_len == sizeof(uint32_t));
+ nftnl_assert(val, attr, data_len == sizeof(uint32_t));
return val ? *val : 0;
}
EXPORT_SYMBOL(nftnl_chain_attr_get_u32, nft_chain_attr_get_u32);
-int32_t nft_chain_attr_get_s32(struct nft_chain *c, uint16_t attr)
+int32_t nftnl_chain_attr_get_s32(struct nftnl_chain *c, uint16_t attr)
{
uint32_t data_len;
- const int32_t *val = nft_chain_attr_get_data(c, attr, &data_len);
+ const int32_t *val = nftnl_chain_attr_get_data(c, attr, &data_len);
- nft_assert(val, attr, data_len == sizeof(int32_t));
+ nftnl_assert(val, attr, data_len == sizeof(int32_t));
return val ? *val : 0;
}
EXPORT_SYMBOL(nftnl_chain_attr_get_s32, nft_chain_attr_get_s32);
-uint64_t nft_chain_attr_get_u64(struct nft_chain *c, uint16_t attr)
+uint64_t nftnl_chain_attr_get_u64(struct nftnl_chain *c, uint16_t attr)
{
uint32_t data_len;
- const uint64_t *val = nft_chain_attr_get_data(c, attr, &data_len);
+ const uint64_t *val = nftnl_chain_attr_get_data(c, attr, &data_len);
- nft_assert(val, attr, data_len == sizeof(int64_t));
+ nftnl_assert(val, attr, data_len == sizeof(int64_t));
return val ? *val : 0;
}
EXPORT_SYMBOL(nftnl_chain_attr_get_u64, nft_chain_attr_get_u64);
-uint8_t nft_chain_attr_get_u8(struct nft_chain *c, uint16_t attr)
+uint8_t nftnl_chain_attr_get_u8(struct nftnl_chain *c, uint16_t attr)
{
uint32_t data_len;
- const uint8_t *val = nft_chain_attr_get_data(c, attr, &data_len);
+ const uint8_t *val = nftnl_chain_attr_get_data(c, attr, &data_len);
- nft_assert(val, attr, data_len == sizeof(int8_t));
+ nftnl_assert(val, attr, data_len == sizeof(int8_t));
return val ? *val : 0;
}
EXPORT_SYMBOL(nftnl_chain_attr_get_u8, nft_chain_attr_get_u8);
-void nft_chain_nlmsg_build_payload(struct nlmsghdr *nlh, const struct nft_chain *c)
+void nftnl_chain_nlmsg_build_payload(struct nlmsghdr *nlh, const struct nftnl_chain *c)
{
- if (c->flags & (1 << NFT_CHAIN_ATTR_TABLE))
+ if (c->flags & (1 << NFTNL_CHAIN_ATTR_TABLE))
mnl_attr_put_strz(nlh, NFTA_CHAIN_TABLE, c->table);
- if (c->flags & (1 << NFT_CHAIN_ATTR_NAME))
+ if (c->flags & (1 << NFTNL_CHAIN_ATTR_NAME))
mnl_attr_put_strz(nlh, NFTA_CHAIN_NAME, c->name);
- if ((c->flags & (1 << NFT_CHAIN_ATTR_HOOKNUM)) &&
- (c->flags & (1 << NFT_CHAIN_ATTR_PRIO))) {
+ if ((c->flags & (1 << NFTNL_CHAIN_ATTR_HOOKNUM)) &&
+ (c->flags & (1 << NFTNL_CHAIN_ATTR_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 << NFT_CHAIN_ATTR_DEV))
+ if (c->flags & (1 << NFTNL_CHAIN_ATTR_DEV))
mnl_attr_put_strz(nlh, NFTA_HOOK_DEV, c->dev);
mnl_attr_nest_end(nlh, nest);
}
- if (c->flags & (1 << NFT_CHAIN_ATTR_POLICY))
+ if (c->flags & (1 << NFTNL_CHAIN_ATTR_POLICY))
mnl_attr_put_u32(nlh, NFTA_CHAIN_POLICY, htonl(c->policy));
- if (c->flags & (1 << NFT_CHAIN_ATTR_USE))
+ if (c->flags & (1 << NFTNL_CHAIN_ATTR_USE))
mnl_attr_put_u32(nlh, NFTA_CHAIN_USE, htonl(c->use));
- if ((c->flags & (1 << NFT_CHAIN_ATTR_PACKETS)) &&
- (c->flags & (1 << NFT_CHAIN_ATTR_BYTES))) {
+ if ((c->flags & (1 << NFTNL_CHAIN_ATTR_PACKETS)) &&
+ (c->flags & (1 << NFTNL_CHAIN_ATTR_BYTES))) {
struct nlattr *nest;
nest = mnl_attr_nest_start(nlh, NFTA_CHAIN_COUNTERS);
@@ -392,14 +392,14 @@ void nft_chain_nlmsg_build_payload(struct nlmsghdr *nlh, const struct nft_chain
mnl_attr_put_u64(nlh, NFTA_COUNTER_BYTES, be64toh(c->bytes));
mnl_attr_nest_end(nlh, nest);
}
- if (c->flags & (1 << NFT_CHAIN_ATTR_HANDLE))
+ if (c->flags & (1 << NFTNL_CHAIN_ATTR_HANDLE))
mnl_attr_put_u64(nlh, NFTA_CHAIN_HANDLE, be64toh(c->handle));
- if (c->flags & (1 << NFT_CHAIN_ATTR_TYPE))
+ if (c->flags & (1 << NFTNL_CHAIN_ATTR_TYPE))
mnl_attr_put_strz(nlh, NFTA_CHAIN_TYPE, c->type);
}
EXPORT_SYMBOL(nftnl_chain_nlmsg_build_payload, nft_chain_nlmsg_build_payload);
-static int nft_chain_parse_attr_cb(const struct nlattr *attr, void *data)
+static int nftnl_chain_parse_attr_cb(const struct nlattr *attr, void *data)
{
const struct nlattr **tb = data;
int type = mnl_attr_get_type(attr);
@@ -434,7 +434,7 @@ static int nft_chain_parse_attr_cb(const struct nlattr *attr, void *data)
return MNL_CB_OK;
}
-static int nft_chain_parse_counters_cb(const struct nlattr *attr, void *data)
+static int nftnl_chain_parse_counters_cb(const struct nlattr *attr, void *data)
{
const struct nlattr **tb = data;
int type = mnl_attr_get_type(attr);
@@ -454,25 +454,26 @@ static int nft_chain_parse_counters_cb(const struct nlattr *attr, void *data)
return MNL_CB_OK;
}
-static int nft_chain_parse_counters(struct nlattr *attr, struct nft_chain *c)
+static int nftnl_chain_parse_counters(struct nlattr *attr, struct nftnl_chain *c)
{
struct nlattr *tb[NFTA_COUNTER_MAX+1] = {};
- if (mnl_attr_parse_nested(attr, nft_chain_parse_counters_cb, tb) < 0)
+ if (mnl_attr_parse_nested(attr, nftnl_chain_parse_counters_cb, tb) < 0)
return -1;
if (tb[NFTA_COUNTER_PACKETS]) {
c->packets = be64toh(mnl_attr_get_u64(tb[NFTA_COUNTER_PACKETS]));
- c->flags |= (1 << NFT_CHAIN_ATTR_PACKETS);
+ c->flags |= (1 << NFTNL_CHAIN_ATTR_PACKETS);
}
if (tb[NFTA_COUNTER_BYTES]) {
c->bytes = be64toh(mnl_attr_get_u64(tb[NFTA_COUNTER_BYTES]));
- c->flags |= (1 << NFT_CHAIN_ATTR_BYTES);
+ c->flags |= (1 << NFTNL_CHAIN_ATTR_BYTES);
}
return 0;
}
-static int nft_chain_parse_hook_cb(const struct nlattr *attr, void *data)
+
+static int nftnl_chain_parse_hook_cb(const struct nlattr *attr, void *data)
{
const struct nlattr **tb = data;
int type = mnl_attr_get_type(attr);
@@ -496,97 +497,97 @@ static int nft_chain_parse_hook_cb(const struct nlattr *attr, void *data)
return MNL_CB_OK;
}
-static int nft_chain_parse_hook(struct nlattr *attr, struct nft_chain *c)
+static int nftnl_chain_parse_hook(struct nlattr *attr, struct nftnl_chain *c)
{
struct nlattr *tb[NFTA_HOOK_MAX+1] = {};
- if (mnl_attr_parse_nested(attr, nft_chain_parse_hook_cb, tb) < 0)
+ if (mnl_attr_parse_nested(attr, nftnl_chain_parse_hook_cb, tb) < 0)
return -1;
if (tb[NFTA_HOOK_HOOKNUM]) {
c->hooknum = ntohl(mnl_attr_get_u32(tb[NFTA_HOOK_HOOKNUM]));
- c->flags |= (1 << NFT_CHAIN_ATTR_HOOKNUM);
+ c->flags |= (1 << NFTNL_CHAIN_ATTR_HOOKNUM);
}
if (tb[NFTA_HOOK_PRIORITY]) {
c->prio = ntohl(mnl_attr_get_u32(tb[NFTA_HOOK_PRIORITY]));
- c->flags |= (1 << NFT_CHAIN_ATTR_PRIO);
+ c->flags |= (1 << NFTNL_CHAIN_ATTR_PRIO);
}
if (tb[NFTA_HOOK_DEV]) {
c->dev = strdup(mnl_attr_get_str(tb[NFTA_HOOK_DEV]));
- c->flags |= (1 << NFT_CHAIN_ATTR_DEV);
+ c->flags |= (1 << NFTNL_CHAIN_ATTR_DEV);
}
return 0;
}
-int nft_chain_nlmsg_parse(const struct nlmsghdr *nlh, struct nft_chain *c)
+int nftnl_chain_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_chain *c)
{
struct nlattr *tb[NFTA_CHAIN_MAX+1] = {};
struct nfgenmsg *nfg = mnl_nlmsg_get_payload(nlh);
int ret = 0;
- if (mnl_attr_parse(nlh, sizeof(*nfg), nft_chain_parse_attr_cb, tb) < 0)
+ if (mnl_attr_parse(nlh, sizeof(*nfg), nftnl_chain_parse_attr_cb, tb) < 0)
return -1;
if (tb[NFTA_CHAIN_NAME]) {
strncpy(c->name, mnl_attr_get_str(tb[NFTA_CHAIN_NAME]),
NFT_CHAIN_MAXNAMELEN);
- c->flags |= (1 << NFT_CHAIN_ATTR_NAME);
+ c->flags |= (1 << NFTNL_CHAIN_ATTR_NAME);
}
if (tb[NFTA_CHAIN_TABLE]) {
xfree(c->table);
c->table = strdup(mnl_attr_get_str(tb[NFTA_CHAIN_TABLE]));
- c->flags |= (1 << NFT_CHAIN_ATTR_TABLE);
+ c->flags |= (1 << NFTNL_CHAIN_ATTR_TABLE);
}
if (tb[NFTA_CHAIN_HOOK]) {
- ret = nft_chain_parse_hook(tb[NFTA_CHAIN_HOOK], c);
+ ret = nftnl_chain_parse_hook(tb[NFTA_CHAIN_HOOK], c);
if (ret < 0)
return ret;
}
if (tb[NFTA_CHAIN_POLICY]) {
c->policy = ntohl(mnl_attr_get_u32(tb[NFTA_CHAIN_POLICY]));
- c->flags |= (1 << NFT_CHAIN_ATTR_POLICY);
+ c->flags |= (1 << NFTNL_CHAIN_ATTR_POLICY);
}
if (tb[NFTA_CHAIN_USE]) {
c->use = ntohl(mnl_attr_get_u32(tb[NFTA_CHAIN_USE]));
- c->flags |= (1 << NFT_CHAIN_ATTR_USE);
+ c->flags |= (1 << NFTNL_CHAIN_ATTR_USE);
}
if (tb[NFTA_CHAIN_COUNTERS]) {
- ret = nft_chain_parse_counters(tb[NFTA_CHAIN_COUNTERS], c);
+ ret = nftnl_chain_parse_counters(tb[NFTA_CHAIN_COUNTERS], c);
if (ret < 0)
return ret;
}
if (tb[NFTA_CHAIN_HANDLE]) {
c->handle = be64toh(mnl_attr_get_u64(tb[NFTA_CHAIN_HANDLE]));
- c->flags |= (1 << NFT_CHAIN_ATTR_HANDLE);
+ c->flags |= (1 << NFTNL_CHAIN_ATTR_HANDLE);
}
if (tb[NFTA_CHAIN_TYPE]) {
xfree(c->type);
c->type = strdup(mnl_attr_get_str(tb[NFTA_CHAIN_TYPE]));
- c->flags |= (1 << NFT_CHAIN_ATTR_TYPE);
+ c->flags |= (1 << NFTNL_CHAIN_ATTR_TYPE);
}
c->family = nfg->nfgen_family;
- c->flags |= (1 << NFT_CHAIN_ATTR_FAMILY);
+ c->flags |= (1 << NFTNL_CHAIN_ATTR_FAMILY);
return ret;
}
EXPORT_SYMBOL(nftnl_chain_nlmsg_parse, nft_chain_nlmsg_parse);
-static inline int nft_str2hooknum(int family, const char *hook)
+static inline int nftnl_str2hooknum(int family, const char *hook)
{
int hooknum;
for (hooknum = 0; hooknum < NF_INET_NUMHOOKS; hooknum++) {
- if (strcmp(hook, nft_hooknum2str(family, hooknum)) == 0)
+ if (strcmp(hook, nftnl_hooknum2str(family, hooknum)) == 0)
return hooknum;
}
return -1;
}
#ifdef JSON_PARSING
-int nft_jansson_parse_chain(struct nft_chain *c, json_t *tree,
- struct nft_parse_err *err)
+int nftnl_jansson_parse_chain(struct nftnl_chain *c, json_t *tree,
+ struct nftnl_parse_err *err)
{
json_t *root;
uint64_t handle, bytes, packets;
@@ -594,93 +595,93 @@ int nft_jansson_parse_chain(struct nft_chain *c, json_t *tree,
int32_t family, prio, hooknum, use;
const char *name, *table, *type, *hooknum_str, *policy, *dev;
- root = nft_jansson_get_node(tree, "chain", err);
+ root = nftnl_jansson_get_node(tree, "chain", err);
if (root == NULL)
return -1;
- name = nft_jansson_parse_str(root, "name", err);
+ name = nftnl_jansson_parse_str(root, "name", err);
if (name != NULL)
- nft_chain_attr_set_str(c, NFT_CHAIN_ATTR_NAME, name);
+ nftnl_chain_attr_set_str(c, NFTNL_CHAIN_ATTR_NAME, name);
- if (nft_jansson_parse_val(root, "handle", NFT_TYPE_U64, &handle,
+ if (nftnl_jansson_parse_val(root, "handle", NFTNL_TYPE_U64, &handle,
err) == 0)
- nft_chain_attr_set_u64(c,NFT_CHAIN_ATTR_HANDLE, handle);
+ nftnl_chain_attr_set_u64(c,NFTNL_CHAIN_ATTR_HANDLE, handle);
- if (nft_jansson_parse_val(root, "bytes", NFT_TYPE_U64, &bytes,
+ if (nftnl_jansson_parse_val(root, "bytes", NFTNL_TYPE_U64, &bytes,
err) == 0)
- nft_chain_attr_set_u64(c, NFT_CHAIN_ATTR_BYTES, bytes);
+ nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_ATTR_BYTES, bytes);
- if (nft_jansson_parse_val(root, "packets", NFT_TYPE_U64, &packets,
+ if (nftnl_jansson_parse_val(root, "packets", NFTNL_TYPE_U64, &packets,
err) == 0)
- nft_chain_attr_set_u64(c, NFT_CHAIN_ATTR_PACKETS, packets);
+ nftnl_chain_attr_set_u64(c, NFTNL_CHAIN_ATTR_PACKETS, packets);
- if (nft_jansson_parse_family(root, &family, err) == 0)
- nft_chain_attr_set_u32(c, NFT_CHAIN_ATTR_FAMILY, family);
+ if (nftnl_jansson_parse_family(root, &family, err) == 0)
+ nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_ATTR_FAMILY, family);
- table = nft_jansson_parse_str(root, "table", err);
+ table = nftnl_jansson_parse_str(root, "table", err);
if (table != NULL)
- nft_chain_attr_set_str(c, NFT_CHAIN_ATTR_TABLE, table);
+ nftnl_chain_attr_set_str(c, NFTNL_CHAIN_ATTR_TABLE, table);
- if (nft_jansson_parse_val(root, "use", NFT_TYPE_U32, &use, err) == 0)
- nft_chain_attr_set_u32(c, NFT_CHAIN_ATTR_USE, use);
+ if (nftnl_jansson_parse_val(root, "use", NFTNL_TYPE_U32, &use, err) == 0)
+ nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_ATTR_USE, use);
- if (nft_jansson_node_exist(root, "hooknum")) {
- type = nft_jansson_parse_str(root, "type", err);
+ if (nftnl_jansson_node_exist(root, "hooknum")) {
+ type = nftnl_jansson_parse_str(root, "type", err);
if (type != NULL)
- nft_chain_attr_set_str(c, NFT_CHAIN_ATTR_TYPE, type);
+ nftnl_chain_attr_set_str(c, NFTNL_CHAIN_ATTR_TYPE, type);
- if (nft_jansson_parse_val(root, "prio", NFT_TYPE_S32,
+ if (nftnl_jansson_parse_val(root, "prio", NFTNL_TYPE_S32,
&prio, err) == 0)
- nft_chain_attr_set_s32(c, NFT_CHAIN_ATTR_PRIO, prio);
+ nftnl_chain_attr_set_s32(c, NFTNL_CHAIN_ATTR_PRIO, prio);
- hooknum_str = nft_jansson_parse_str(root, "hooknum", err);
+ hooknum_str = nftnl_jansson_parse_str(root, "hooknum", err);
if (hooknum_str != NULL) {
- hooknum = nft_str2hooknum(c->family, hooknum_str);
+ hooknum = nftnl_str2hooknum(c->family, hooknum_str);
if (hooknum == -1)
return -1;
- nft_chain_attr_set_u32(c, NFT_CHAIN_ATTR_HOOKNUM,
+ nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_ATTR_HOOKNUM,
hooknum);
}
- policy = nft_jansson_parse_str(root, "policy", err);
+ policy = nftnl_jansson_parse_str(root, "policy", err);
if (policy != NULL) {
- if (nft_str2verdict(policy, &policy_num) != 0) {
+ if (nftnl_str2verdict(policy, &policy_num) != 0) {
errno = EINVAL;
err->node_name = "policy";
- err->error = NFT_PARSE_EBADTYPE;
+ err->error = NFTNL_PARSE_EBADTYPE;
return -1;
}
- nft_chain_attr_set_u32(c, NFT_CHAIN_ATTR_POLICY,
+ nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_ATTR_POLICY,
policy_num);
}
- dev = nft_jansson_parse_str(root, "device", err);
+ dev = nftnl_jansson_parse_str(root, "device", err);
if (dev != NULL)
- nft_chain_attr_set_str(c, NFT_CHAIN_ATTR_DEV, dev);
+ nftnl_chain_attr_set_str(c, NFTNL_CHAIN_ATTR_DEV, dev);
}
return 0;
}
#endif
-static int nft_chain_json_parse(struct nft_chain *c, const void *json,
- struct nft_parse_err *err,
- enum nft_parse_input input)
+static int nftnl_chain_json_parse(struct nftnl_chain *c, const void *json,
+ struct nftnl_parse_err *err,
+ enum nftnl_parse_input input)
{
#ifdef JSON_PARSING
json_t *tree;
json_error_t error;
int ret;
- tree = nft_jansson_create_root(json, &error, err, input);
+ tree = nftnl_jansson_create_root(json, &error, err, input);
if (tree == NULL)
return -1;
- ret = nft_jansson_parse_chain(c, tree, err);
+ ret = nftnl_jansson_parse_chain(c, tree, err);
- nft_jansson_free_root(tree);
+ nftnl_jansson_free_root(tree);
return ret;
#else
@@ -690,100 +691,100 @@ static int nft_chain_json_parse(struct nft_chain *c, const void *json,
}
#ifdef XML_PARSING
-int nft_mxml_chain_parse(mxml_node_t *tree, struct nft_chain *c,
- struct nft_parse_err *err)
+int nftnl_mxml_chain_parse(mxml_node_t *tree, struct nftnl_chain *c,
+ struct nftnl_parse_err *err)
{
const char *table, *name, *hooknum_str, *policy_str, *type, *dev;
int family, hooknum, policy;
uint64_t handle, bytes, packets, prio, use;
- 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_chain_attr_set_str(c, NFT_CHAIN_ATTR_NAME, name);
+ nftnl_chain_attr_set_str(c, NFTNL_CHAIN_ATTR_NAME, name);
- if (nft_mxml_num_parse(tree, "handle", MXML_DESCEND_FIRST, BASE_DEC,
- &handle, NFT_TYPE_U64, NFT_XML_MAND, err) == 0)
- nft_chain_attr_set_u64(c, NFT_CHAIN_ATTR_HANDLE, handle);
+ 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);
- if (nft_mxml_num_parse(tree, "bytes", MXML_DESCEND_FIRST, BASE_DEC,
- &bytes, NFT_TYPE_U64, NFT_XML_MAND, err) == 0)
- nft_chain_attr_set_u64(c, NFT_CHAIN_ATTR_BYTES, bytes);
+ 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);
- if (nft_mxml_num_parse(tree, "packets", MXML_DESCEND_FIRST, BASE_DEC,
- &packets, NFT_TYPE_U64, NFT_XML_MAND, err) == 0)
- nft_chain_attr_set_u64(c, NFT_CHAIN_ATTR_PACKETS, packets);
+ 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);
- table = nft_mxml_str_parse(tree, "table", MXML_DESCEND_FIRST,
- NFT_XML_MAND, err);
+ table = nftnl_mxml_str_parse(tree, "table", MXML_DESCEND_FIRST,
+ NFTNL_XML_MAND, err);
if (table != NULL)
- nft_chain_attr_set_str(c, NFT_CHAIN_ATTR_TABLE, table);
+ nftnl_chain_attr_set_str(c, NFTNL_CHAIN_ATTR_TABLE, table);
- if (nft_mxml_num_parse(tree, "use", MXML_DESCEND_FIRST, BASE_DEC,
- &use, NFT_TYPE_U64, NFT_XML_MAND, err) == 0)
- nft_chain_attr_set_u64(c, NFT_CHAIN_ATTR_PACKETS, use);
+ 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);
- 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)
- nft_chain_attr_set_u32(c, NFT_CHAIN_ATTR_FAMILY, family);
+ nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_ATTR_FAMILY, family);
- hooknum_str = nft_mxml_str_parse(tree, "hooknum", MXML_DESCEND_FIRST,
- NFT_XML_OPT, err);
+ hooknum_str = nftnl_mxml_str_parse(tree, "hooknum", MXML_DESCEND_FIRST,
+ NFTNL_XML_OPT, err);
if (hooknum_str != NULL) {
- hooknum = nft_str2hooknum(c->family, hooknum_str);
+ hooknum = nftnl_str2hooknum(c->family, hooknum_str);
if (hooknum < 0)
return -1;
- nft_chain_attr_set_u32(c, NFT_CHAIN_ATTR_HOOKNUM, hooknum);
+ nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_ATTR_HOOKNUM, hooknum);
- type = nft_mxml_str_parse(tree, "type", MXML_DESCEND_FIRST,
- NFT_XML_MAND, err);
+ type = nftnl_mxml_str_parse(tree, "type", MXML_DESCEND_FIRST,
+ NFTNL_XML_MAND, err);
if (type != NULL)
- nft_chain_attr_set_str(c, NFT_CHAIN_ATTR_TYPE, type);
+ nftnl_chain_attr_set_str(c, NFTNL_CHAIN_ATTR_TYPE, type);
- if (nft_mxml_num_parse(tree, "prio", MXML_DESCEND, BASE_DEC,
- &prio, NFT_TYPE_S32, NFT_XML_MAND,
+ if (nftnl_mxml_num_parse(tree, "prio", MXML_DESCEND, BASE_DEC,
+ &prio, NFTNL_TYPE_S32, NFTNL_XML_MAND,
err) == 0)
- nft_chain_attr_set_s32(c, NFT_CHAIN_ATTR_PRIO, prio);
+ nftnl_chain_attr_set_s32(c, NFTNL_CHAIN_ATTR_PRIO, prio);
- policy_str = nft_mxml_str_parse(tree, "policy",
+ policy_str = nftnl_mxml_str_parse(tree, "policy",
MXML_DESCEND_FIRST,
- NFT_XML_MAND, err);
+ NFTNL_XML_MAND, err);
if (policy_str != NULL) {
- if (nft_str2verdict(policy_str, &policy) != 0) {
+ if (nftnl_str2verdict(policy_str, &policy) != 0) {
errno = EINVAL;
err->node_name = "policy";
- err->error = NFT_PARSE_EBADTYPE;
+ err->error = NFTNL_PARSE_EBADTYPE;
return -1;
}
- nft_chain_attr_set_u32(c, NFT_CHAIN_ATTR_POLICY,
+ nftnl_chain_attr_set_u32(c, NFTNL_CHAIN_ATTR_POLICY,
policy);
}
- dev = nft_mxml_str_parse(tree, "device", MXML_DESCEND_FIRST,
- NFT_XML_MAND, err);
+ dev = nftnl_mxml_str_parse(tree, "device", MXML_DESCEND_FIRST,
+ NFTNL_XML_MAND, err);
if (table != NULL)
- nft_chain_attr_set_str(c, NFT_CHAIN_ATTR_DEV, dev);
+ nftnl_chain_attr_set_str(c, NFTNL_CHAIN_ATTR_DEV, dev);
}
return 0;
}
#endif
-static int nft_chain_xml_parse(struct nft_chain *c, const void *xml,
- struct nft_parse_err *err,
- enum nft_parse_input input)
+static int nftnl_chain_xml_parse(struct nftnl_chain *c, const void *xml,
+ struct nftnl_parse_err *err,
+ enum nftnl_parse_input input)
{
#ifdef XML_PARSING
int ret;
- mxml_node_t *tree = nft_mxml_build_tree(xml, "chain", err, input);
+ mxml_node_t *tree = nftnl_mxml_build_tree(xml, "chain", err, input);
if (tree == NULL)
return -1;
- ret = nft_mxml_chain_parse(tree, c, err);
+ ret = nftnl_mxml_chain_parse(tree, c, err);
mxmlDelete(tree);
return ret;
#else
@@ -792,19 +793,19 @@ static int nft_chain_xml_parse(struct nft_chain *c, const void *xml,
#endif
}
-static int nft_chain_do_parse(struct nft_chain *c, enum nft_parse_type type,
- const void *data, struct nft_parse_err *err,
- enum nft_parse_input input)
+static int nftnl_chain_do_parse(struct nftnl_chain *c, enum nftnl_parse_type type,
+ const void *data, struct nftnl_parse_err *err,
+ enum nftnl_parse_input input)
{
int ret;
- struct nft_parse_err perr;
+ struct nftnl_parse_err perr;
switch (type) {
- case NFT_PARSE_XML:
- ret = nft_chain_xml_parse(c, data, &perr, input);
+ case NFTNL_PARSE_XML:
+ ret = nftnl_chain_xml_parse(c, data, &perr, input);
break;
- case NFT_PARSE_JSON:
- ret = nft_chain_json_parse(c, data, &perr, input);
+ case NFTNL_PARSE_JSON:
+ ret = nftnl_chain_json_parse(c, data, &perr, input);
break;
default:
ret = -1;
@@ -818,78 +819,78 @@ static int nft_chain_do_parse(struct nft_chain *c, enum nft_parse_type type,
return ret;
}
-int nft_chain_parse(struct nft_chain *c, enum nft_parse_type type,
- const char *data, struct nft_parse_err *err)
+int nftnl_chain_parse(struct nftnl_chain *c, enum nftnl_parse_type type,
+ const char *data, struct nftnl_parse_err *err)
{
- return nft_chain_do_parse(c, type, data, err, NFT_PARSE_BUFFER);
+ return nftnl_chain_do_parse(c, type, data, err, NFTNL_PARSE_BUFFER);
}
EXPORT_SYMBOL(nftnl_chain_parse, nft_chain_parse);
-int nft_chain_parse_file(struct nft_chain *c, enum nft_parse_type type,
- FILE *fp, struct nft_parse_err *err)
+int nftnl_chain_parse_file(struct nftnl_chain *c, enum nftnl_parse_type type,
+ FILE *fp, struct nftnl_parse_err *err)
{
- return nft_chain_do_parse(c, type, fp, err, NFT_PARSE_FILE);
+ return nftnl_chain_do_parse(c, type, fp, err, NFTNL_PARSE_FILE);
}
EXPORT_SYMBOL(nftnl_chain_parse_file, nft_chain_parse_file);
-static int nft_chain_export(char *buf, size_t size, struct nft_chain *c,
+static int nftnl_chain_export(char *buf, size_t size, struct nftnl_chain *c,
int type)
{
- NFT_BUF_INIT(b, buf, size);
-
- nft_buf_open(&b, type, CHAIN);
- if (c->flags & (1 << NFT_CHAIN_ATTR_NAME))
- nft_buf_str(&b, type, c->name, NAME);
- if (c->flags & (1 << NFT_CHAIN_ATTR_HANDLE))
- nft_buf_u64(&b, type, c->handle, HANDLE);
- if (c->flags & (1 << NFT_CHAIN_ATTR_BYTES))
- nft_buf_u64(&b, type, c->bytes, BYTES);
- if (c->flags & (1 << NFT_CHAIN_ATTR_PACKETS))
- nft_buf_u64(&b, type, c->packets, PACKETS);
- if (c->flags & (1 << NFT_CHAIN_ATTR_TABLE))
- nft_buf_str(&b, type, c->table, TABLE);
- if (c->flags & (1 << NFT_CHAIN_ATTR_FAMILY))
- nft_buf_str(&b, type, nft_family2str(c->family), FAMILY);
- if (c->flags & (1 << NFT_CHAIN_ATTR_USE))
- nft_buf_u32(&b, type, c->use, USE);
- if (c->flags & (1 << NFT_CHAIN_ATTR_HOOKNUM)) {
- if (c->flags & (1 << NFT_CHAIN_ATTR_TYPE))
- nft_buf_str(&b, type, c->type, TYPE);
- if (c->flags & (1 << NFT_CHAIN_ATTR_HOOKNUM))
- nft_buf_str(&b, type, nft_hooknum2str(c->family,
+ NFTNL_BUF_INIT(b, buf, size);
+
+ nftnl_buf_open(&b, type, CHAIN);
+ if (c->flags & (1 << NFTNL_CHAIN_ATTR_NAME))
+ nftnl_buf_str(&b, type, c->name, NAME);
+ if (c->flags & (1 << NFTNL_CHAIN_ATTR_HANDLE))
+ nftnl_buf_u64(&b, type, c->handle, HANDLE);
+ if (c->flags & (1 << NFTNL_CHAIN_ATTR_BYTES))
+ nftnl_buf_u64(&b, type, c->bytes, BYTES);
+ if (c->flags & (1 << NFTNL_CHAIN_ATTR_PACKETS))
+ nftnl_buf_u64(&b, type, c->packets, PACKETS);
+ if (c->flags & (1 << NFTNL_CHAIN_ATTR_TABLE))
+ nftnl_buf_str(&b, type, c->table, TABLE);
+ if (c->flags & (1 << NFTNL_CHAIN_ATTR_FAMILY))
+ nftnl_buf_str(&b, type, nftnl_family2str(c->family), FAMILY);
+ if (c->flags & (1 << NFTNL_CHAIN_ATTR_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))
+ nftnl_buf_str(&b, type, c->type, TYPE);
+ if (c->flags & (1 << NFTNL_CHAIN_ATTR_HOOKNUM))
+ nftnl_buf_str(&b, type, nftnl_hooknum2str(c->family,
c->hooknum), HOOKNUM);
- if (c->flags & (1 << NFT_CHAIN_ATTR_PRIO))
- nft_buf_s32(&b, type, c->prio, PRIO);
- if (c->flags & (1 << NFT_CHAIN_ATTR_POLICY))
- nft_buf_str(&b, type, nft_verdict2str(c->policy), POLICY);
- if (c->flags & (1 << NFT_CHAIN_ATTR_DEV))
- nft_buf_str(&b, type, c->dev, DEVICE);
+ if (c->flags & (1 << NFTNL_CHAIN_ATTR_PRIO))
+ nftnl_buf_s32(&b, type, c->prio, PRIO);
+ if (c->flags & (1 << NFTNL_CHAIN_ATTR_POLICY))
+ nftnl_buf_str(&b, type, nftnl_verdict2str(c->policy), POLICY);
+ if (c->flags & (1 << NFTNL_CHAIN_ATTR_DEV))
+ nftnl_buf_str(&b, type, c->dev, DEVICE);
}
- nft_buf_close(&b, type, CHAIN);
+ nftnl_buf_close(&b, type, CHAIN);
- return nft_buf_done(&b);
+ return nftnl_buf_done(&b);
}
-static int nft_chain_snprintf_default(char *buf, size_t size,
- struct nft_chain *c)
+static int nftnl_chain_snprintf_default(char *buf, size_t size,
+ struct nftnl_chain *c)
{
int ret, len = size, offset = 0;
ret = snprintf(buf, len, "%s %s %s use %u",
- nft_family2str(c->family), c->table, c->name, c->use);
+ nftnl_family2str(c->family), c->table, c->name, c->use);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
- if (c->flags & (1 << NFT_CHAIN_ATTR_HOOKNUM)) {
+ if (c->flags & (1 << NFTNL_CHAIN_ATTR_HOOKNUM)) {
ret = snprintf(buf+offset, len,
" type %s hook %s prio %d policy %s "
"packets %"PRIu64" bytes %"PRIu64"",
- c->type, nft_hooknum2str(c->family, c->hooknum),
- c->prio, nft_verdict2str(c->policy),
+ c->type, nftnl_hooknum2str(c->family, c->hooknum),
+ c->prio, nftnl_verdict2str(c->policy),
c->packets, c->bytes);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
- if (c->flags & (1 << NFT_CHAIN_ATTR_DEV)) {
+ if (c->flags & (1 << NFTNL_CHAIN_ATTR_DEV)) {
ret = snprintf(buf+offset, len, " dev %s ", c->dev);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
@@ -898,21 +899,21 @@ static int nft_chain_snprintf_default(char *buf, size_t size,
return offset;
}
-static int nft_chain_cmd_snprintf(char *buf, size_t size, struct nft_chain *c,
+static int nftnl_chain_cmd_snprintf(char *buf, size_t size, struct nftnl_chain *c,
uint32_t cmd, uint32_t type, uint32_t flags)
{
int ret, len = size, offset = 0;
- ret = nft_cmd_header_snprintf(buf + offset, len, cmd, type, flags);
+ ret = nftnl_cmd_header_snprintf(buf + offset, len, cmd, type, flags);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
switch (type) {
- case NFT_OUTPUT_DEFAULT:
- ret = nft_chain_snprintf_default(buf+offset, len, c);
+ case NFTNL_OUTPUT_DEFAULT:
+ ret = nftnl_chain_snprintf_default(buf+offset, len, c);
break;
- case NFT_OUTPUT_XML:
- case NFT_OUTPUT_JSON:
- ret = nft_chain_export(buf+offset, len, c, type);
+ case NFTNL_OUTPUT_XML:
+ case NFTNL_OUTPUT_JSON:
+ ret = nftnl_chain_export(buf+offset, len, c, type);
break;
default:
return -1;
@@ -920,44 +921,44 @@ static int nft_chain_cmd_snprintf(char *buf, size_t size, struct nft_chain *c,
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
- ret = nft_cmd_footer_snprintf(buf + offset, len, cmd, type, flags);
+ ret = nftnl_cmd_footer_snprintf(buf + offset, len, cmd, type, flags);
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
return offset;
}
-int nft_chain_snprintf(char *buf, size_t size, struct nft_chain *c,
+int nftnl_chain_snprintf(char *buf, size_t size, struct nftnl_chain *c,
uint32_t type, uint32_t flags)
{
- return nft_chain_cmd_snprintf(buf, size, c, nft_flag2cmd(flags), type,
+ return nftnl_chain_cmd_snprintf(buf, size, c, nftnl_flag2cmd(flags), type,
flags);
}
EXPORT_SYMBOL(nftnl_chain_snprintf, nft_chain_snprintf);
-static inline int nft_chain_do_snprintf(char *buf, size_t size, void *c,
+static inline int nftnl_chain_do_snprintf(char *buf, size_t size, void *c,
uint32_t cmd, uint32_t type,
uint32_t flags)
{
- return nft_chain_snprintf(buf, size, c, type, flags);
+ return nftnl_chain_snprintf(buf, size, c, type, flags);
}
-int nft_chain_fprintf(FILE *fp, struct nft_chain *c, uint32_t type,
+int nftnl_chain_fprintf(FILE *fp, struct nftnl_chain *c, uint32_t type,
uint32_t flags)
{
- return nft_fprintf(fp, c, NFT_CMD_UNSPEC, type, flags,
- nft_chain_do_snprintf);
+ return nftnl_fprintf(fp, c, NFTNL_CMD_UNSPEC, type, flags,
+ nftnl_chain_do_snprintf);
}
EXPORT_SYMBOL(nftnl_chain_fprintf, nft_chain_fprintf);
-struct nft_chain_list {
+struct nftnl_chain_list {
struct list_head list;
};
-struct nft_chain_list *nft_chain_list_alloc(void)
+struct nftnl_chain_list *nftnl_chain_list_alloc(void)
{
- struct nft_chain_list *list;
+ struct nftnl_chain_list *list;
- list = calloc(1, sizeof(struct nft_chain_list));
+ list = calloc(1, sizeof(struct nftnl_chain_list));
if (list == NULL)
return NULL;
@@ -967,47 +968,47 @@ struct nft_chain_list *nft_chain_list_alloc(void)
}
EXPORT_SYMBOL(nftnl_chain_list_alloc, nft_chain_list_alloc);
-void nft_chain_list_free(struct nft_chain_list *list)
+void nftnl_chain_list_free(struct nftnl_chain_list *list)
{
- struct nft_chain *r, *tmp;
+ struct nftnl_chain *r, *tmp;
list_for_each_entry_safe(r, tmp, &list->list, head) {
list_del(&r->head);
- nft_chain_free(r);
+ nftnl_chain_free(r);
}
xfree(list);
}
EXPORT_SYMBOL(nftnl_chain_list_free, nft_chain_list_free);
-int nft_chain_list_is_empty(struct nft_chain_list *list)
+int nftnl_chain_list_is_empty(struct nftnl_chain_list *list)
{
return list_empty(&list->list);
}
EXPORT_SYMBOL(nftnl_chain_list_is_empty, nft_chain_list_is_empty);
-void nft_chain_list_add(struct nft_chain *r, struct nft_chain_list *list)
+void nftnl_chain_list_add(struct nftnl_chain *r, struct nftnl_chain_list *list)
{
list_add(&r->head, &list->list);
}
EXPORT_SYMBOL(nftnl_chain_list_add, nft_chain_list_add);
-void nft_chain_list_add_tail(struct nft_chain *r, struct nft_chain_list *list)
+void nftnl_chain_list_add_tail(struct nftnl_chain *r, struct nftnl_chain_list *list)
{
list_add_tail(&r->head, &list->list);
}
EXPORT_SYMBOL(nftnl_chain_list_add_tail, nft_chain_list_add_tail);
-void nft_chain_list_del(struct nft_chain *r)
+void nftnl_chain_list_del(struct nftnl_chain *r)
{
list_del(&r->head);
}
EXPORT_SYMBOL(nftnl_chain_list_del, nft_chain_list_del);
-int nft_chain_list_foreach(struct nft_chain_list *chain_list,
- int (*cb)(struct nft_chain *r, void *data),
+int nftnl_chain_list_foreach(struct nftnl_chain_list *chain_list,
+ int (*cb)(struct nftnl_chain *r, void *data),
void *data)
{
- struct nft_chain *cur, *tmp;
+ struct nftnl_chain *cur, *tmp;
int ret;
list_for_each_entry_safe(cur, tmp, &chain_list->list, head) {
@@ -1019,38 +1020,38 @@ int nft_chain_list_foreach(struct nft_chain_list *chain_list,
}
EXPORT_SYMBOL(nftnl_chain_list_foreach, nft_chain_list_foreach);
-struct nft_chain_list_iter {
- struct nft_chain_list *list;
- struct nft_chain *cur;
+struct nftnl_chain_list_iter {
+ struct nftnl_chain_list *list;
+ struct nftnl_chain *cur;
};
-struct nft_chain_list_iter *nft_chain_list_iter_create(struct nft_chain_list *l)
+struct nftnl_chain_list_iter *nftnl_chain_list_iter_create(struct nftnl_chain_list *l)
{
- struct nft_chain_list_iter *iter;
+ struct nftnl_chain_list_iter *iter;
- iter = calloc(1, sizeof(struct nft_chain_list_iter));
+ iter = calloc(1, sizeof(struct nftnl_chain_list_iter));
if (iter == NULL)
return NULL;
iter->list = l;
- if (nft_chain_list_is_empty(l))
+ if (nftnl_chain_list_is_empty(l))
iter->cur = NULL;
else
- iter->cur = list_entry(l->list.next, struct nft_chain, head);
+ iter->cur = list_entry(l->list.next, struct nftnl_chain, head);
return iter;
}
EXPORT_SYMBOL(nftnl_chain_list_iter_create, nft_chain_list_iter_create);
-struct nft_chain *nft_chain_list_iter_next(struct nft_chain_list_iter *iter)
+struct nftnl_chain *nftnl_chain_list_iter_next(struct nftnl_chain_list_iter *iter)
{
- struct nft_chain *r = iter->cur;
+ struct nftnl_chain *r = iter->cur;
if (r == NULL)
return NULL;
/* get next chain, if any */
- iter->cur = list_entry(iter->cur->head.next, struct nft_chain, head);
+ iter->cur = list_entry(iter->cur->head.next, struct nftnl_chain, head);
if (&iter->cur->head == iter->list->list.next)
return NULL;
@@ -1058,7 +1059,7 @@ struct nft_chain *nft_chain_list_iter_next(struct nft_chain_list_iter *iter)
}
EXPORT_SYMBOL(nftnl_chain_list_iter_next, nft_chain_list_iter_next);
-void nft_chain_list_iter_destroy(struct nft_chain_list_iter *iter)
+void nftnl_chain_list_iter_destroy(struct nftnl_chain_list_iter *iter)
{
xfree(iter);
}