# Checks for libraries.
PKG_CHECK_MODULES([LIBMNL], [libmnl >= 1.0.3])
-PKG_CHECK_MODULES([LIBNFTNL], [libnftnl >= 1.0.2])
+PKG_CHECK_MODULES([LIBNFTNL], [libnftnl >= 1.0.5])
AC_ARG_WITH([mini-gmp], [AS_HELP_STRING([--with-mini-gmp],
[Use builtin mini-gmp (for embedded builds)])], [],
uint32_t mnl_batch_begin(void);
void mnl_batch_end(void);
int mnl_batch_talk(struct mnl_socket *nl, struct list_head *err_list);
-int mnl_nft_rule_batch_add(struct nft_rule *nlr, unsigned int flags,
+int mnl_nft_rule_batch_add(struct nftnl_rule *nlr, unsigned int flags,
uint32_t seqnum);
-int mnl_nft_rule_batch_del(struct nft_rule *nlr, unsigned int flags,
+int mnl_nft_rule_batch_del(struct nftnl_rule *nlr, unsigned int flags,
uint32_t seqnum);
-int mnl_nft_rule_add(struct mnl_socket *nf_sock, struct nft_rule *r,
+int mnl_nft_rule_add(struct mnl_socket *nf_sock, struct nftnl_rule *r,
unsigned int flags);
-int mnl_nft_rule_delete(struct mnl_socket *nf_sock, struct nft_rule *r,
+int mnl_nft_rule_delete(struct mnl_socket *nf_sock, struct nftnl_rule *r,
unsigned int flags);
-struct nft_rule_list *mnl_nft_rule_dump(struct mnl_socket *nf_sock,
+struct nftnl_rule_list *mnl_nft_rule_dump(struct mnl_socket *nf_sock,
int family);
-int mnl_nft_chain_add(struct mnl_socket *nf_sock, struct nft_chain *nlc,
+int mnl_nft_chain_add(struct mnl_socket *nf_sock, struct nftnl_chain *nlc,
unsigned int flags);
-int mnl_nft_chain_batch_add(struct nft_chain *nlc,
+int mnl_nft_chain_batch_add(struct nftnl_chain *nlc,
unsigned int flags, uint32_t seq);
-int mnl_nft_chain_delete(struct mnl_socket *nf_sock, struct nft_chain *nlc,
+int mnl_nft_chain_delete(struct mnl_socket *nf_sock, struct nftnl_chain *nlc,
unsigned int flags);
-int mnl_nft_chain_batch_del(struct nft_chain *nlc,
+int mnl_nft_chain_batch_del(struct nftnl_chain *nlc,
unsigned int flags, uint32_t seq);
-struct nft_chain_list *mnl_nft_chain_dump(struct mnl_socket *nf_sock,
+struct nftnl_chain_list *mnl_nft_chain_dump(struct mnl_socket *nf_sock,
int family);
-int mnl_nft_chain_get(struct mnl_socket *nf_sock, struct nft_chain *nlc,
+int mnl_nft_chain_get(struct mnl_socket *nf_sock, struct nftnl_chain *nlc,
unsigned int flags);
-int mnl_nft_table_add(struct mnl_socket *nf_sock, struct nft_table *nlt,
+int mnl_nft_table_add(struct mnl_socket *nf_sock, struct nftnl_table *nlt,
unsigned int flags);
-int mnl_nft_table_batch_add(struct nft_table *nlt,
+int mnl_nft_table_batch_add(struct nftnl_table *nlt,
unsigned int flags, uint32_t seq);
-int mnl_nft_table_delete(struct mnl_socket *nf_sock, struct nft_table *nlt,
+int mnl_nft_table_delete(struct mnl_socket *nf_sock, struct nftnl_table *nlt,
unsigned int flags);
-int mnl_nft_table_batch_del(struct nft_table *nlt,
+int mnl_nft_table_batch_del(struct nftnl_table *nlt,
unsigned int flags, uint32_t seq);
-struct nft_table_list *mnl_nft_table_dump(struct mnl_socket *nf_sock,
+struct nftnl_table_list *mnl_nft_table_dump(struct mnl_socket *nf_sock,
int family);
-int mnl_nft_table_get(struct mnl_socket *nf_sock, struct nft_table *nlt,
+int mnl_nft_table_get(struct mnl_socket *nf_sock, struct nftnl_table *nlt,
unsigned int flags);
-int mnl_nft_set_add(struct mnl_socket *nf_sock, struct nft_set *nls,
+int mnl_nft_set_add(struct mnl_socket *nf_sock, struct nftnl_set *nls,
unsigned int flags);
-int mnl_nft_set_batch_add(struct nft_set *nls,
+int mnl_nft_set_batch_add(struct nftnl_set *nls,
unsigned int flags, uint32_t seq);
-int mnl_nft_set_delete(struct mnl_socket *nf_sock, struct nft_set *nls,
+int mnl_nft_set_delete(struct mnl_socket *nf_sock, struct nftnl_set *nls,
unsigned int flags);
-int mnl_nft_set_batch_del(struct nft_set *nls,
+int mnl_nft_set_batch_del(struct nftnl_set *nls,
unsigned int flags, uint32_t seq);
-struct nft_set_list *mnl_nft_set_dump(struct mnl_socket *nf_sock, int family,
+struct nftnl_set_list *mnl_nft_set_dump(struct mnl_socket *nf_sock, int family,
const char *table);
-int mnl_nft_set_get(struct mnl_socket *nf_sock, struct nft_set *nls);
+int mnl_nft_set_get(struct mnl_socket *nf_sock, struct nftnl_set *nls);
-int mnl_nft_setelem_add(struct mnl_socket *nf_sock, struct nft_set *nls,
+int mnl_nft_setelem_add(struct mnl_socket *nf_sock, struct nftnl_set *nls,
unsigned int flags);
-int mnl_nft_setelem_batch_add(struct nft_set *nls,
+int mnl_nft_setelem_batch_add(struct nftnl_set *nls,
unsigned int flags, uint32_t seq);
-int mnl_nft_setelem_delete(struct mnl_socket *nf_sock, struct nft_set *nls,
+int mnl_nft_setelem_delete(struct mnl_socket *nf_sock, struct nftnl_set *nls,
unsigned int flags);
-int mnl_nft_setelem_batch_del(struct nft_set *nls,
+int mnl_nft_setelem_batch_del(struct nftnl_set *nls,
unsigned int flags, uint32_t seq);
-int mnl_nft_setelem_get(struct mnl_socket *nf_sock, struct nft_set *nls);
+int mnl_nft_setelem_get(struct mnl_socket *nf_sock, struct nftnl_set *nls);
-struct nft_ruleset *mnl_nft_ruleset_dump(struct mnl_socket *nf_sock,
+struct nftnl_ruleset *mnl_nft_ruleset_dump(struct mnl_socket *nf_sock,
uint32_t family);
int mnl_nft_event_listener(struct mnl_socket *nf_sock,
int (*cb)(const struct nlmsghdr *nlh, void *data),
bool batch_supported;
};
-extern struct nft_table *alloc_nft_table(const struct handle *h);
-extern struct nft_chain *alloc_nft_chain(const struct handle *h);
-extern struct nft_rule *alloc_nft_rule(const struct handle *h);
-extern struct nft_rule_expr *alloc_nft_expr(const char *name);
-extern struct nft_set *alloc_nft_set(const struct handle *h);
+extern struct nftnl_table *alloc_nftnl_table(const struct handle *h);
+extern struct nftnl_chain *alloc_nftnl_chain(const struct handle *h);
+extern struct nftnl_rule *alloc_nftnl_rule(const struct handle *h);
+extern struct nftnl_expr *alloc_nft_expr(const char *name);
+extern struct nftnl_set *alloc_nftnl_set(const struct handle *h);
struct nft_data_linearize {
uint32_t len;
enum nft_registers dreg);
extern void netlink_linearize_rule(struct netlink_ctx *ctx,
- struct nft_rule *nlr,
+ struct nftnl_rule *nlr,
const struct rule *rule);
extern struct rule *netlink_delinearize_rule(struct netlink_ctx *ctx,
- const struct nft_rule *r);
+ const struct nftnl_rule *r);
extern int netlink_add_rule(struct netlink_ctx *ctx, const struct handle *h,
const struct rule *rule, uint32_t flags);
extern int netlink_get_setelems(struct netlink_ctx *ctx, const struct handle *h,
const struct location *loc, struct set *set);
-extern void netlink_dump_table(struct nft_table *nlt);
-extern void netlink_dump_chain(struct nft_chain *nlc);
-extern void netlink_dump_rule(struct nft_rule *nlr);
-extern void netlink_dump_expr(struct nft_rule_expr *nle);
-extern void netlink_dump_set(struct nft_set *nls);
+extern void netlink_dump_table(struct nftnl_table *nlt);
+extern void netlink_dump_chain(struct nftnl_chain *nlc);
+extern void netlink_dump_rule(struct nftnl_rule *nlr);
+extern void netlink_dump_expr(struct nftnl_expr *nle);
+extern void netlink_dump_set(struct nftnl_set *nls);
extern int netlink_batch_send(struct list_head *err_list);
const struct handle *h,
const struct location *loc);
-extern struct nft_ruleset *netlink_dump_ruleset(struct netlink_ctx *ctx,
+extern struct nftnl_ruleset *netlink_dump_ruleset(struct netlink_ctx *ctx,
const struct handle *h,
const struct location *loc);
struct netlink_mon_handler {
char buf[MNL_SOCKET_BUFFER_SIZE];
struct nlmsghdr *nlh;
- nlh = nft_nlmsg_build_hdr(buf, NFT_MSG_GETGEN, AF_UNSPEC, 0, seq);
+ nlh = nftnl_nlmsg_build_hdr(buf, NFT_MSG_GETGEN, AF_UNSPEC, 0, seq);
/* Skip error checking, old kernels sets res_id field to zero. */
nft_mnl_talk(nf_sock, nlh, nlh->nlmsg_len, genid_cb, NULL);
}
*/
#define BATCH_PAGE_SIZE getpagesize() * 32
-static struct nft_batch *batch;
+static struct nftnl_batch *batch;
void mnl_batch_init(void)
{
- batch = nft_batch_alloc(BATCH_PAGE_SIZE, NFT_NLMSG_MAXSIZE);
+ batch = nftnl_batch_alloc(BATCH_PAGE_SIZE, NFT_NLMSG_MAXSIZE);
if (batch == NULL)
memory_allocation_error();
}
-static void nft_batch_continue(void)
+static void mnl_nft_batch_continue(void)
{
- if (nft_batch_update(batch) < 0)
+ if (nftnl_batch_update(batch) < 0)
memory_allocation_error();
}
{
uint32_t seq = mnl_seqnum_alloc();
- nft_batch_begin(nft_batch_buffer(batch), seq);
- nft_batch_continue();
+ nftnl_batch_begin(nftnl_batch_buffer(batch), seq);
+ mnl_nft_batch_continue();
return seq;
}
void mnl_batch_end(void)
{
- nft_batch_end(nft_batch_buffer(batch), mnl_seqnum_alloc());
- nft_batch_continue();
+ nftnl_batch_end(nftnl_batch_buffer(batch), mnl_seqnum_alloc());
+ mnl_nft_batch_continue();
}
bool mnl_batch_ready(void)
/* Check if the batch only contains the initial and trailing batch
* messages. In that case, the batch is empty.
*/
- return nft_batch_buffer_len(batch) !=
+ return nftnl_batch_buffer_len(batch) !=
(NLMSG_HDRLEN + sizeof(struct nfgenmsg)) * 2;
}
void mnl_batch_reset(void)
{
- nft_batch_free(batch);
+ nftnl_batch_free(batch);
}
static void mnl_err_list_node_add(struct list_head *err_list, int error,
{
int newbuffsiz;
- if (nft_batch_iovec_len(batch) * BATCH_PAGE_SIZE <= nlbuffsiz)
+ if (nftnl_batch_iovec_len(batch) * BATCH_PAGE_SIZE <= nlbuffsiz)
return;
- newbuffsiz = nft_batch_iovec_len(batch) * BATCH_PAGE_SIZE;
+ newbuffsiz = nftnl_batch_iovec_len(batch) * BATCH_PAGE_SIZE;
/* Rise sender buffer length to avoid hitting -EMSGSIZE */
if (setsockopt(mnl_socket_get_fd(nl), SOL_SOCKET, SO_SNDBUFFORCE,
static const struct sockaddr_nl snl = {
.nl_family = AF_NETLINK
};
- uint32_t iov_len = nft_batch_iovec_len(batch);
+ uint32_t iov_len = nftnl_batch_iovec_len(batch);
struct iovec iov[iov_len];
struct msghdr msg = {
.msg_name = (struct sockaddr *) &snl,
#endif
mnl_set_sndbuffer(nl);
- nft_batch_iovec(batch, iov, iov_len);
+ nftnl_batch_iovec(batch, iov, iov_len);
#ifdef DEBUG
for (i = 0; i < iov_len; i++) {
return ret;
}
-int mnl_nft_rule_batch_add(struct nft_rule *nlr, unsigned int flags,
+int mnl_nft_rule_batch_add(struct nftnl_rule *nlr, unsigned int flags,
uint32_t seqnum)
{
struct nlmsghdr *nlh;
- nlh = nft_rule_nlmsg_build_hdr(nft_batch_buffer(batch),
+ nlh = nftnl_rule_nlmsg_build_hdr(nftnl_batch_buffer(batch),
NFT_MSG_NEWRULE,
- nft_rule_attr_get_u32(nlr, NFT_RULE_ATTR_FAMILY),
+ nftnl_rule_get_u32(nlr, NFTNL_RULE_FAMILY),
NLM_F_CREATE | flags, seqnum);
- nft_rule_nlmsg_build_payload(nlh, nlr);
- nft_batch_continue();
+ nftnl_rule_nlmsg_build_payload(nlh, nlr);
+ mnl_nft_batch_continue();
return 0;
}
-int mnl_nft_rule_batch_del(struct nft_rule *nlr, unsigned int flags,
+int mnl_nft_rule_batch_del(struct nftnl_rule *nlr, unsigned int flags,
uint32_t seqnum)
{
struct nlmsghdr *nlh;
- nlh = nft_rule_nlmsg_build_hdr(nft_batch_buffer(batch),
+ nlh = nftnl_rule_nlmsg_build_hdr(nftnl_batch_buffer(batch),
NFT_MSG_DELRULE,
- nft_rule_attr_get_u32(nlr, NFT_RULE_ATTR_FAMILY),
+ nftnl_rule_get_u32(nlr, NFTNL_RULE_FAMILY),
0, seqnum);
- nft_rule_nlmsg_build_payload(nlh, nlr);
- nft_batch_continue();
+ nftnl_rule_nlmsg_build_payload(nlh, nlr);
+ mnl_nft_batch_continue();
return 0;
}
/*
* Rule
*/
-int mnl_nft_rule_add(struct mnl_socket *nf_sock, struct nft_rule *nlr,
+int mnl_nft_rule_add(struct mnl_socket *nf_sock, struct nftnl_rule *nlr,
unsigned int flags)
{
char buf[MNL_SOCKET_BUFFER_SIZE];
struct nlmsghdr *nlh;
- nlh = nft_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE,
- nft_rule_attr_get_u32(nlr, NFT_RULE_ATTR_FAMILY),
+ nlh = nftnl_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE,
+ nftnl_rule_get_u32(nlr, NFTNL_RULE_FAMILY),
NLM_F_ACK | NLM_F_CREATE | flags, seq);
- nft_rule_nlmsg_build_payload(nlh, nlr);
+ nftnl_rule_nlmsg_build_payload(nlh, nlr);
return nft_mnl_talk(nf_sock, nlh, nlh->nlmsg_len, NULL, NULL);
}
-int mnl_nft_rule_delete(struct mnl_socket *nf_sock, struct nft_rule *nlr,
+int mnl_nft_rule_delete(struct mnl_socket *nf_sock, struct nftnl_rule *nlr,
unsigned int flags)
{
char buf[MNL_SOCKET_BUFFER_SIZE];
struct nlmsghdr *nlh;
- nlh = nft_rule_nlmsg_build_hdr(buf, NFT_MSG_DELRULE,
- nft_rule_attr_get_u32(nlr, NFT_RULE_ATTR_FAMILY),
+ nlh = nftnl_rule_nlmsg_build_hdr(buf, NFT_MSG_DELRULE,
+ nftnl_rule_get_u32(nlr, NFTNL_RULE_FAMILY),
NLM_F_ACK, seq);
- nft_rule_nlmsg_build_payload(nlh, nlr);
+ nftnl_rule_nlmsg_build_payload(nlh, nlr);
return nft_mnl_talk(nf_sock, nlh, nlh->nlmsg_len, NULL, NULL);
}
static int rule_cb(const struct nlmsghdr *nlh, void *data)
{
- struct nft_rule_list *nlr_list = data;
- struct nft_rule *r;
+ struct nftnl_rule_list *nlr_list = data;
+ struct nftnl_rule *r;
if (check_genid(nlh) < 0)
return MNL_CB_ERROR;
- r = nft_rule_alloc();
+ r = nftnl_rule_alloc();
if (r == NULL)
memory_allocation_error();
- if (nft_rule_nlmsg_parse(nlh, r) < 0)
+ if (nftnl_rule_nlmsg_parse(nlh, r) < 0)
goto err_free;
- nft_rule_list_add_tail(r, nlr_list);
+ nftnl_rule_list_add_tail(r, nlr_list);
return MNL_CB_OK;
err_free:
- nft_rule_free(r);
+ nftnl_rule_free(r);
return MNL_CB_OK;
}
-struct nft_rule_list *mnl_nft_rule_dump(struct mnl_socket *nf_sock, int family)
+struct nftnl_rule_list *mnl_nft_rule_dump(struct mnl_socket *nf_sock, int family)
{
char buf[MNL_SOCKET_BUFFER_SIZE];
struct nlmsghdr *nlh;
- struct nft_rule_list *nlr_list;
+ struct nftnl_rule_list *nlr_list;
int ret;
- nlr_list = nft_rule_list_alloc();
+ nlr_list = nftnl_rule_list_alloc();
if (nlr_list == NULL)
memory_allocation_error();
- nlh = nft_rule_nlmsg_build_hdr(buf, NFT_MSG_GETRULE, family,
+ nlh = nftnl_rule_nlmsg_build_hdr(buf, NFT_MSG_GETRULE, family,
NLM_F_DUMP, seq);
ret = nft_mnl_talk(nf_sock, nlh, nlh->nlmsg_len, rule_cb, nlr_list);
return nlr_list;
err:
- nft_rule_list_free(nlr_list);
+ nftnl_rule_list_free(nlr_list);
return NULL;
}
/*
* Chain
*/
-int mnl_nft_chain_add(struct mnl_socket *nf_sock, struct nft_chain *nlc,
+int mnl_nft_chain_add(struct mnl_socket *nf_sock, struct nftnl_chain *nlc,
unsigned int flags)
{
char buf[MNL_SOCKET_BUFFER_SIZE];
struct nlmsghdr *nlh;
- nlh = nft_chain_nlmsg_build_hdr(buf, NFT_MSG_NEWCHAIN,
- nft_chain_attr_get_u32(nlc, NFT_CHAIN_ATTR_FAMILY),
+ nlh = nftnl_chain_nlmsg_build_hdr(buf, NFT_MSG_NEWCHAIN,
+ nftnl_chain_get_u32(nlc, NFTNL_CHAIN_FAMILY),
NLM_F_CREATE | NLM_F_ACK | flags, seq);
- nft_chain_nlmsg_build_payload(nlh, nlc);
+ nftnl_chain_nlmsg_build_payload(nlh, nlc);
return nft_mnl_talk(nf_sock, nlh, nlh->nlmsg_len, NULL, NULL);
}
-int mnl_nft_chain_batch_add(struct nft_chain *nlc, unsigned int flags,
+int mnl_nft_chain_batch_add(struct nftnl_chain *nlc, unsigned int flags,
uint32_t seqnum)
{
struct nlmsghdr *nlh;
- nlh = nft_chain_nlmsg_build_hdr(nft_batch_buffer(batch),
+ nlh = nftnl_chain_nlmsg_build_hdr(nftnl_batch_buffer(batch),
NFT_MSG_NEWCHAIN,
- nft_chain_attr_get_u32(nlc, NFT_CHAIN_ATTR_FAMILY),
+ nftnl_chain_get_u32(nlc, NFTNL_CHAIN_FAMILY),
NLM_F_CREATE | flags, seqnum);
- nft_chain_nlmsg_build_payload(nlh, nlc);
- nft_batch_continue();
+ nftnl_chain_nlmsg_build_payload(nlh, nlc);
+ mnl_nft_batch_continue();
return 0;
}
-int mnl_nft_chain_delete(struct mnl_socket *nf_sock, struct nft_chain *nlc,
+int mnl_nft_chain_delete(struct mnl_socket *nf_sock, struct nftnl_chain *nlc,
unsigned int flags)
{
char buf[MNL_SOCKET_BUFFER_SIZE];
struct nlmsghdr *nlh;
- nlh = nft_chain_nlmsg_build_hdr(buf, NFT_MSG_DELCHAIN,
- nft_chain_attr_get_u32(nlc, NFT_CHAIN_ATTR_FAMILY),
+ nlh = nftnl_chain_nlmsg_build_hdr(buf, NFT_MSG_DELCHAIN,
+ nftnl_chain_get_u32(nlc, NFTNL_CHAIN_FAMILY),
NLM_F_ACK, seq);
- nft_chain_nlmsg_build_payload(nlh, nlc);
+ nftnl_chain_nlmsg_build_payload(nlh, nlc);
return nft_mnl_talk(nf_sock, nlh, nlh->nlmsg_len, NULL, NULL);
}
-int mnl_nft_chain_batch_del(struct nft_chain *nlc, unsigned int flags,
+int mnl_nft_chain_batch_del(struct nftnl_chain *nlc, unsigned int flags,
uint32_t seqnum)
{
struct nlmsghdr *nlh;
- nlh = nft_chain_nlmsg_build_hdr(nft_batch_buffer(batch),
+ nlh = nftnl_chain_nlmsg_build_hdr(nftnl_batch_buffer(batch),
NFT_MSG_DELCHAIN,
- nft_chain_attr_get_u32(nlc, NFT_CHAIN_ATTR_FAMILY),
+ nftnl_chain_get_u32(nlc, NFTNL_CHAIN_FAMILY),
NLM_F_ACK, seqnum);
- nft_chain_nlmsg_build_payload(nlh, nlc);
- nft_batch_continue();
+ nftnl_chain_nlmsg_build_payload(nlh, nlc);
+ mnl_nft_batch_continue();
return 0;
}
static int chain_cb(const struct nlmsghdr *nlh, void *data)
{
- struct nft_chain_list *nlc_list = data;
- struct nft_chain *c;
+ struct nftnl_chain_list *nlc_list = data;
+ struct nftnl_chain *c;
if (check_genid(nlh) < 0)
return MNL_CB_ERROR;
- c = nft_chain_alloc();
+ c = nftnl_chain_alloc();
if (c == NULL)
memory_allocation_error();
- if (nft_chain_nlmsg_parse(nlh, c) < 0)
+ if (nftnl_chain_nlmsg_parse(nlh, c) < 0)
goto err_free;
- nft_chain_list_add_tail(c, nlc_list);
+ nftnl_chain_list_add_tail(c, nlc_list);
return MNL_CB_OK;
err_free:
- nft_chain_free(c);
+ nftnl_chain_free(c);
return MNL_CB_OK;
}
-struct nft_chain_list *mnl_nft_chain_dump(struct mnl_socket *nf_sock, int family)
+struct nftnl_chain_list *mnl_nft_chain_dump(struct mnl_socket *nf_sock, int family)
{
char buf[MNL_SOCKET_BUFFER_SIZE];
struct nlmsghdr *nlh;
- struct nft_chain_list *nlc_list;
+ struct nftnl_chain_list *nlc_list;
int ret;
- nlc_list = nft_chain_list_alloc();
+ nlc_list = nftnl_chain_list_alloc();
if (nlc_list == NULL)
memory_allocation_error();
- nlh = nft_chain_nlmsg_build_hdr(buf, NFT_MSG_GETCHAIN, family,
+ nlh = nftnl_chain_nlmsg_build_hdr(buf, NFT_MSG_GETCHAIN, family,
NLM_F_DUMP, seq);
ret = nft_mnl_talk(nf_sock, nlh, nlh->nlmsg_len, chain_cb, nlc_list);
return nlc_list;
err:
- nft_chain_list_free(nlc_list);
+ nftnl_chain_list_free(nlc_list);
return NULL;
}
static int chain_get_cb(const struct nlmsghdr *nlh, void *data)
{
- nft_chain_nlmsg_parse(nlh, data);
+ nftnl_chain_nlmsg_parse(nlh, data);
return MNL_CB_OK;
}
-int mnl_nft_chain_get(struct mnl_socket *nf_sock, struct nft_chain *nlc,
+int mnl_nft_chain_get(struct mnl_socket *nf_sock, struct nftnl_chain *nlc,
unsigned int flags)
{
char buf[MNL_SOCKET_BUFFER_SIZE];
struct nlmsghdr *nlh;
- nlh = nft_chain_nlmsg_build_hdr(buf, NFT_MSG_GETCHAIN,
- nft_chain_attr_get_u32(nlc, NFT_CHAIN_ATTR_FAMILY),
+ nlh = nftnl_chain_nlmsg_build_hdr(buf, NFT_MSG_GETCHAIN,
+ nftnl_chain_get_u32(nlc, NFTNL_CHAIN_FAMILY),
NLM_F_ACK | flags, seq);
- nft_chain_nlmsg_build_payload(nlh, nlc);
+ nftnl_chain_nlmsg_build_payload(nlh, nlc);
return nft_mnl_talk(nf_sock, nlh, nlh->nlmsg_len, chain_get_cb, nlc);
}
/*
* Table
*/
-int mnl_nft_table_add(struct mnl_socket *nf_sock, struct nft_table *nlt,
+int mnl_nft_table_add(struct mnl_socket *nf_sock, struct nftnl_table *nlt,
unsigned int flags)
{
char buf[MNL_SOCKET_BUFFER_SIZE];
struct nlmsghdr *nlh;
- nlh = nft_table_nlmsg_build_hdr(buf, NFT_MSG_NEWTABLE,
- nft_table_attr_get_u32(nlt, NFT_TABLE_ATTR_FAMILY),
+ nlh = nftnl_table_nlmsg_build_hdr(buf, NFT_MSG_NEWTABLE,
+ nftnl_table_get_u32(nlt, NFTNL_TABLE_FAMILY),
NLM_F_ACK | flags, seq);
- nft_table_nlmsg_build_payload(nlh, nlt);
+ nftnl_table_nlmsg_build_payload(nlh, nlt);
return nft_mnl_talk(nf_sock, nlh, nlh->nlmsg_len, NULL, NULL);
}
-int mnl_nft_table_batch_add(struct nft_table *nlt, unsigned int flags,
+int mnl_nft_table_batch_add(struct nftnl_table *nlt, unsigned int flags,
uint32_t seqnum)
{
struct nlmsghdr *nlh;
- nlh = nft_table_nlmsg_build_hdr(nft_batch_buffer(batch),
+ nlh = nftnl_table_nlmsg_build_hdr(nftnl_batch_buffer(batch),
NFT_MSG_NEWTABLE,
- nft_table_attr_get_u32(nlt, NFT_TABLE_ATTR_FAMILY),
+ nftnl_table_get_u32(nlt, NFTNL_TABLE_FAMILY),
flags, seqnum);
- nft_table_nlmsg_build_payload(nlh, nlt);
- nft_batch_continue();
+ nftnl_table_nlmsg_build_payload(nlh, nlt);
+ mnl_nft_batch_continue();
return 0;
}
-int mnl_nft_table_delete(struct mnl_socket *nf_sock, struct nft_table *nlt,
+int mnl_nft_table_delete(struct mnl_socket *nf_sock, struct nftnl_table *nlt,
unsigned int flags)
{
char buf[MNL_SOCKET_BUFFER_SIZE];
struct nlmsghdr *nlh;
- nlh = nft_table_nlmsg_build_hdr(buf, NFT_MSG_DELTABLE,
- nft_table_attr_get_u32(nlt, NFT_TABLE_ATTR_FAMILY),
+ nlh = nftnl_table_nlmsg_build_hdr(buf, NFT_MSG_DELTABLE,
+ nftnl_table_get_u32(nlt, NFTNL_TABLE_FAMILY),
NLM_F_ACK, seq);
- nft_table_nlmsg_build_payload(nlh, nlt);
+ nftnl_table_nlmsg_build_payload(nlh, nlt);
return nft_mnl_talk(nf_sock, nlh, nlh->nlmsg_len, NULL, NULL);
}
-int mnl_nft_table_batch_del(struct nft_table *nlt, unsigned int flags,
+int mnl_nft_table_batch_del(struct nftnl_table *nlt, unsigned int flags,
uint32_t seqnum)
{
struct nlmsghdr *nlh;
- nlh = nft_table_nlmsg_build_hdr(nft_batch_buffer(batch),
+ nlh = nftnl_table_nlmsg_build_hdr(nftnl_batch_buffer(batch),
NFT_MSG_DELTABLE,
- nft_table_attr_get_u32(nlt, NFT_TABLE_ATTR_FAMILY),
+ nftnl_table_get_u32(nlt, NFTNL_TABLE_FAMILY),
NLM_F_ACK, seqnum);
- nft_table_nlmsg_build_payload(nlh, nlt);
- nft_batch_continue();
+ nftnl_table_nlmsg_build_payload(nlh, nlt);
+ mnl_nft_batch_continue();
return 0;
}
static int table_cb(const struct nlmsghdr *nlh, void *data)
{
- struct nft_table_list *nlt_list = data;
- struct nft_table *t;
+ struct nftnl_table_list *nlt_list = data;
+ struct nftnl_table *t;
if (check_genid(nlh) < 0)
return MNL_CB_ERROR;
- t = nft_table_alloc();
+ t = nftnl_table_alloc();
if (t == NULL)
memory_allocation_error();
- if (nft_table_nlmsg_parse(nlh, t) < 0)
+ if (nftnl_table_nlmsg_parse(nlh, t) < 0)
goto err_free;
- nft_table_list_add_tail(t, nlt_list);
+ nftnl_table_list_add_tail(t, nlt_list);
return MNL_CB_OK;
err_free:
- nft_table_free(t);
+ nftnl_table_free(t);
return MNL_CB_OK;
}
-struct nft_table_list *mnl_nft_table_dump(struct mnl_socket *nf_sock, int family)
+struct nftnl_table_list *mnl_nft_table_dump(struct mnl_socket *nf_sock, int family)
{
char buf[MNL_SOCKET_BUFFER_SIZE];
struct nlmsghdr *nlh;
- struct nft_table_list *nlt_list;
+ struct nftnl_table_list *nlt_list;
int ret;
- nlt_list = nft_table_list_alloc();
+ nlt_list = nftnl_table_list_alloc();
if (nlt_list == NULL)
memory_allocation_error();
- nlh = nft_table_nlmsg_build_hdr(buf, NFT_MSG_GETTABLE, family,
+ nlh = nftnl_table_nlmsg_build_hdr(buf, NFT_MSG_GETTABLE, family,
NLM_F_DUMP, seq);
ret = nft_mnl_talk(nf_sock, nlh, nlh->nlmsg_len, table_cb, nlt_list);
return nlt_list;
err:
- nft_table_list_free(nlt_list);
+ nftnl_table_list_free(nlt_list);
return NULL;
}
static int table_get_cb(const struct nlmsghdr *nlh, void *data)
{
- struct nft_table *t = data;
+ struct nftnl_table *t = data;
- nft_table_nlmsg_parse(nlh, t);
+ nftnl_table_nlmsg_parse(nlh, t);
return MNL_CB_OK;
}
-int mnl_nft_table_get(struct mnl_socket *nf_sock, struct nft_table *nlt,
+int mnl_nft_table_get(struct mnl_socket *nf_sock, struct nftnl_table *nlt,
unsigned int flags)
{
char buf[MNL_SOCKET_BUFFER_SIZE];
struct nlmsghdr *nlh;
- nlh = nft_table_nlmsg_build_hdr(buf, NFT_MSG_GETTABLE,
- nft_table_attr_get_u32(nlt, NFT_TABLE_ATTR_FAMILY),
+ nlh = nftnl_table_nlmsg_build_hdr(buf, NFT_MSG_GETTABLE,
+ nftnl_table_get_u32(nlt, NFTNL_TABLE_FAMILY),
NLM_F_ACK, seq);
- nft_table_nlmsg_build_payload(nlh, nlt);
+ nftnl_table_nlmsg_build_payload(nlh, nlt);
return nft_mnl_talk(nf_sock, nlh, nlh->nlmsg_len, table_get_cb, nlt);
}
*/
static int set_add_cb(const struct nlmsghdr *nlh, void *data)
{
- nft_set_nlmsg_parse(nlh, data);
+ nftnl_set_nlmsg_parse(nlh, data);
return MNL_CB_OK;
}
-int mnl_nft_set_add(struct mnl_socket *nf_sock, struct nft_set *nls,
+int mnl_nft_set_add(struct mnl_socket *nf_sock, struct nftnl_set *nls,
unsigned int flags)
{
char buf[MNL_SOCKET_BUFFER_SIZE];
struct nlmsghdr *nlh;
- nlh = nft_set_nlmsg_build_hdr(buf, NFT_MSG_NEWSET,
- nft_set_attr_get_u32(nls, NFT_SET_ATTR_FAMILY),
+ nlh = nftnl_set_nlmsg_build_hdr(buf, NFT_MSG_NEWSET,
+ nftnl_set_get_u32(nls, NFTNL_SET_FAMILY),
NLM_F_CREATE | NLM_F_ACK | flags, seq);
- nft_set_nlmsg_build_payload(nlh, nls);
+ nftnl_set_nlmsg_build_payload(nlh, nls);
return nft_mnl_talk(nf_sock, nlh, nlh->nlmsg_len, set_add_cb, nls);
}
-int mnl_nft_set_delete(struct mnl_socket *nf_sock, struct nft_set *nls,
+int mnl_nft_set_delete(struct mnl_socket *nf_sock, struct nftnl_set *nls,
unsigned int flags)
{
char buf[MNL_SOCKET_BUFFER_SIZE];
struct nlmsghdr *nlh;
- nlh = nft_set_nlmsg_build_hdr(buf, NFT_MSG_DELSET,
- nft_set_attr_get_u32(nls, NFT_SET_ATTR_FAMILY),
+ nlh = nftnl_set_nlmsg_build_hdr(buf, NFT_MSG_DELSET,
+ nftnl_set_get_u32(nls, NFTNL_SET_FAMILY),
flags|NLM_F_ACK, seq);
- nft_set_nlmsg_build_payload(nlh, nls);
+ nftnl_set_nlmsg_build_payload(nlh, nls);
return nft_mnl_talk(nf_sock, nlh, nlh->nlmsg_len, NULL, NULL);
}
-int mnl_nft_set_batch_add(struct nft_set *nls, unsigned int flags,
+int mnl_nft_set_batch_add(struct nftnl_set *nls, unsigned int flags,
uint32_t seqnum)
{
struct nlmsghdr *nlh;
- nlh = nft_set_nlmsg_build_hdr(nft_batch_buffer(batch),
+ nlh = nftnl_set_nlmsg_build_hdr(nftnl_batch_buffer(batch),
NFT_MSG_NEWSET,
- nft_set_attr_get_u32(nls, NFT_SET_ATTR_FAMILY),
+ nftnl_set_get_u32(nls, NFTNL_SET_FAMILY),
NLM_F_CREATE | flags, seqnum);
- nft_set_nlmsg_build_payload(nlh, nls);
- nft_batch_continue();
+ nftnl_set_nlmsg_build_payload(nlh, nls);
+ mnl_nft_batch_continue();
return 0;
}
-int mnl_nft_set_batch_del(struct nft_set *nls, unsigned int flags,
+int mnl_nft_set_batch_del(struct nftnl_set *nls, unsigned int flags,
uint32_t seqnum)
{
struct nlmsghdr *nlh;
- nlh = nft_set_nlmsg_build_hdr(nft_batch_buffer(batch),
+ nlh = nftnl_set_nlmsg_build_hdr(nftnl_batch_buffer(batch),
NFT_MSG_DELSET,
- nft_set_attr_get_u32(nls, NFT_SET_ATTR_FAMILY),
+ nftnl_set_get_u32(nls, NFTNL_SET_FAMILY),
flags, seqnum);
- nft_set_nlmsg_build_payload(nlh, nls);
- nft_batch_continue();
+ nftnl_set_nlmsg_build_payload(nlh, nls);
+ mnl_nft_batch_continue();
return 0;
}
static int set_cb(const struct nlmsghdr *nlh, void *data)
{
- struct nft_set_list *nls_list = data;
- struct nft_set *s;
+ struct nftnl_set_list *nls_list = data;
+ struct nftnl_set *s;
if (check_genid(nlh) < 0)
return MNL_CB_ERROR;
- s = nft_set_alloc();
+ s = nftnl_set_alloc();
if (s == NULL)
memory_allocation_error();
- if (nft_set_nlmsg_parse(nlh, s) < 0)
+ if (nftnl_set_nlmsg_parse(nlh, s) < 0)
goto err_free;
- nft_set_list_add_tail(s, nls_list);
+ nftnl_set_list_add_tail(s, nls_list);
return MNL_CB_OK;
err_free:
- nft_set_free(s);
+ nftnl_set_free(s);
return MNL_CB_OK;
}
-struct nft_set_list *
+struct nftnl_set_list *
mnl_nft_set_dump(struct mnl_socket *nf_sock, int family, const char *table)
{
char buf[MNL_SOCKET_BUFFER_SIZE];
struct nlmsghdr *nlh;
- struct nft_set *s;
- struct nft_set_list *nls_list;
+ struct nftnl_set *s;
+ struct nftnl_set_list *nls_list;
int ret;
- s = nft_set_alloc();
+ s = nftnl_set_alloc();
if (s == NULL)
memory_allocation_error();
- nlh = nft_set_nlmsg_build_hdr(buf, NFT_MSG_GETSET, family,
+ nlh = nftnl_set_nlmsg_build_hdr(buf, NFT_MSG_GETSET, family,
NLM_F_DUMP|NLM_F_ACK, seq);
if (table != NULL)
- nft_set_attr_set(s, NFT_SET_ATTR_TABLE, table);
- nft_set_nlmsg_build_payload(nlh, s);
- nft_set_free(s);
+ nftnl_set_set(s, NFTNL_SET_TABLE, table);
+ nftnl_set_nlmsg_build_payload(nlh, s);
+ nftnl_set_free(s);
- nls_list = nft_set_list_alloc();
+ nls_list = nftnl_set_list_alloc();
if (nls_list == NULL)
memory_allocation_error();
return nls_list;
err:
- nft_set_list_free(nls_list);
+ nftnl_set_list_free(nls_list);
return NULL;
}
static int set_get_cb(const struct nlmsghdr *nlh, void *data)
{
- struct nft_set *s = data;
+ struct nftnl_set *s = data;
- nft_set_nlmsg_parse(nlh, s);
+ nftnl_set_nlmsg_parse(nlh, s);
return MNL_CB_OK;
}
-int mnl_nft_set_get(struct mnl_socket *nf_sock, struct nft_set *nls)
+int mnl_nft_set_get(struct mnl_socket *nf_sock, struct nftnl_set *nls)
{
char buf[MNL_SOCKET_BUFFER_SIZE];
struct nlmsghdr *nlh;
- nlh = nft_set_nlmsg_build_hdr(buf, NFT_MSG_GETSET,
- nft_set_attr_get_u32(nls, NFT_SET_ATTR_FAMILY),
+ nlh = nftnl_set_nlmsg_build_hdr(buf, NFT_MSG_GETSET,
+ nftnl_set_get_u32(nls, NFTNL_SET_FAMILY),
NLM_F_ACK, seq);
- nft_set_nlmsg_build_payload(nlh, nls);
+ nftnl_set_nlmsg_build_payload(nlh, nls);
return nft_mnl_talk(nf_sock, nlh, nlh->nlmsg_len, set_get_cb, nls);
}
/*
* Set elements
*/
-int mnl_nft_setelem_add(struct mnl_socket *nf_sock, struct nft_set *nls,
+int mnl_nft_setelem_add(struct mnl_socket *nf_sock, struct nftnl_set *nls,
unsigned int flags)
{
char buf[NFT_NLMSG_MAXSIZE];
struct nlmsghdr *nlh;
- struct nft_set_elems_iter *iter;
+ struct nftnl_set_elems_iter *iter;
int ret, err;
- iter = nft_set_elems_iter_create(nls);
+ iter = nftnl_set_elems_iter_create(nls);
if (iter == NULL)
memory_allocation_error();
do {
- nlh = nft_set_elem_nlmsg_build_hdr(buf, NFT_MSG_NEWSETELEM,
- nft_set_attr_get_u32(nls, NFT_SET_ATTR_FAMILY),
+ nlh = nftnl_set_elem_nlmsg_build_hdr(buf, NFT_MSG_NEWSETELEM,
+ nftnl_set_get_u32(nls, NFTNL_SET_FAMILY),
NLM_F_CREATE | NLM_F_ACK | flags, seq);
- ret = nft_set_elems_nlmsg_build_payload_iter(nlh, iter);
+ ret = nftnl_set_elems_nlmsg_build_payload_iter(nlh, iter);
err = nft_mnl_talk(nf_sock, nlh, nlh->nlmsg_len, NULL, NULL);
} while (ret > 0 && err >= 0);
- nft_set_elems_iter_destroy(iter);
+ nftnl_set_elems_iter_destroy(iter);
return err;
}
-int mnl_nft_setelem_delete(struct mnl_socket *nf_sock, struct nft_set *nls,
+int mnl_nft_setelem_delete(struct mnl_socket *nf_sock, struct nftnl_set *nls,
unsigned int flags)
{
char buf[NFT_NLMSG_MAXSIZE];
struct nlmsghdr *nlh;
- nlh = nft_set_elem_nlmsg_build_hdr(buf, NFT_MSG_DELSETELEM,
- nft_set_attr_get_u32(nls, NFT_SET_ATTR_FAMILY),
+ nlh = nftnl_set_elem_nlmsg_build_hdr(buf, NFT_MSG_DELSETELEM,
+ nftnl_set_get_u32(nls, NFTNL_SET_FAMILY),
NLM_F_ACK, seq);
- nft_set_elems_nlmsg_build_payload(nlh, nls);
+ nftnl_set_elems_nlmsg_build_payload(nlh, nls);
return nft_mnl_talk(nf_sock, nlh, nlh->nlmsg_len, NULL, NULL);
}
if (check_genid(nlh) < 0)
return MNL_CB_ERROR;
- nft_set_elems_nlmsg_parse(nlh, data);
+ nftnl_set_elems_nlmsg_parse(nlh, data);
return MNL_CB_OK;
}
-int mnl_nft_setelem_batch_add(struct nft_set *nls, unsigned int flags,
+int mnl_nft_setelem_batch_add(struct nftnl_set *nls, unsigned int flags,
uint32_t seqnum)
{
struct nlmsghdr *nlh;
- struct nft_set_elems_iter *iter;
+ struct nftnl_set_elems_iter *iter;
int ret;
- iter = nft_set_elems_iter_create(nls);
+ iter = nftnl_set_elems_iter_create(nls);
if (iter == NULL)
memory_allocation_error();
do {
- nlh = nft_set_elem_nlmsg_build_hdr(nft_batch_buffer(batch),
+ nlh = nftnl_set_elem_nlmsg_build_hdr(nftnl_batch_buffer(batch),
NFT_MSG_NEWSETELEM,
- nft_set_attr_get_u32(nls, NFT_SET_ATTR_FAMILY),
+ nftnl_set_get_u32(nls, NFTNL_SET_FAMILY),
NLM_F_CREATE | flags, seqnum);
- ret = nft_set_elems_nlmsg_build_payload_iter(nlh, iter);
- nft_batch_continue();
+ ret = nftnl_set_elems_nlmsg_build_payload_iter(nlh, iter);
+ mnl_nft_batch_continue();
} while (ret > 0);
- nft_set_elems_iter_destroy(iter);
+ nftnl_set_elems_iter_destroy(iter);
return 0;
}
-int mnl_nft_setelem_batch_del(struct nft_set *nls, unsigned int flags,
+int mnl_nft_setelem_batch_del(struct nftnl_set *nls, unsigned int flags,
uint32_t seqnum)
{
struct nlmsghdr *nlh;
- nlh = nft_set_elem_nlmsg_build_hdr(nft_batch_buffer(batch),
+ nlh = nftnl_set_elem_nlmsg_build_hdr(nftnl_batch_buffer(batch),
NFT_MSG_DELSETELEM,
- nft_set_attr_get_u32(nls, NFT_SET_ATTR_FAMILY),
+ nftnl_set_get_u32(nls, NFTNL_SET_FAMILY),
0, seqnum);
- nft_set_elems_nlmsg_build_payload(nlh, nls);
- nft_batch_continue();
+ nftnl_set_elems_nlmsg_build_payload(nlh, nls);
+ mnl_nft_batch_continue();
return 0;
}
-int mnl_nft_setelem_get(struct mnl_socket *nf_sock, struct nft_set *nls)
+int mnl_nft_setelem_get(struct mnl_socket *nf_sock, struct nftnl_set *nls)
{
char buf[MNL_SOCKET_BUFFER_SIZE];
struct nlmsghdr *nlh;
- nlh = nft_set_elem_nlmsg_build_hdr(buf, NFT_MSG_GETSETELEM,
- nft_set_attr_get_u32(nls, NFT_SET_ATTR_FAMILY),
+ nlh = nftnl_set_elem_nlmsg_build_hdr(buf, NFT_MSG_GETSETELEM,
+ nftnl_set_get_u32(nls, NFTNL_SET_FAMILY),
NLM_F_DUMP|NLM_F_ACK, seq);
- nft_set_nlmsg_build_payload(nlh, nls);
+ nftnl_set_nlmsg_build_payload(nlh, nls);
return nft_mnl_talk(nf_sock, nlh, nlh->nlmsg_len, set_elem_cb, nls);
}
/*
* ruleset
*/
-struct nft_ruleset *mnl_nft_ruleset_dump(struct mnl_socket *nf_sock,
+struct nftnl_ruleset *mnl_nft_ruleset_dump(struct mnl_socket *nf_sock,
uint32_t family)
{
- struct nft_ruleset *rs;
- struct nft_table_list *t;
- struct nft_chain_list *c;
- struct nft_set_list *sl;
- struct nft_set_list_iter *i;
- struct nft_set *s;
- struct nft_rule_list *r;
+ struct nftnl_ruleset *rs;
+ struct nftnl_table_list *t;
+ struct nftnl_chain_list *c;
+ struct nftnl_set_list *sl;
+ struct nftnl_set_list_iter *i;
+ struct nftnl_set *s;
+ struct nftnl_rule_list *r;
int ret = 0;
- rs = nft_ruleset_alloc();
+ rs = nftnl_ruleset_alloc();
if (rs == NULL)
memory_allocation_error();
if (t == NULL)
goto err;
- nft_ruleset_attr_set(rs, NFT_RULESET_ATTR_TABLELIST, t);
+ nftnl_ruleset_set(rs, NFTNL_RULESET_TABLELIST, t);
c = mnl_nft_chain_dump(nf_sock, family);
if (c == NULL)
goto err;
- nft_ruleset_attr_set(rs, NFT_RULESET_ATTR_CHAINLIST, c);
+ nftnl_ruleset_set(rs, NFTNL_RULESET_CHAINLIST, c);
sl = mnl_nft_set_dump(nf_sock, family, NULL);
if (sl == NULL)
goto err;
- i = nft_set_list_iter_create(sl);
- s = nft_set_list_iter_next(i);
+ i = nftnl_set_list_iter_create(sl);
+ s = nftnl_set_list_iter_next(i);
while (s != NULL) {
ret = mnl_nft_setelem_get(nf_sock, s);
if (ret < 0)
goto err;
- s = nft_set_list_iter_next(i);
+ s = nftnl_set_list_iter_next(i);
}
- nft_set_list_iter_destroy(i);
+ nftnl_set_list_iter_destroy(i);
- nft_ruleset_attr_set(rs, NFT_RULESET_ATTR_SETLIST, sl);
+ nftnl_ruleset_set(rs, NFTNL_RULESET_SETLIST, sl);
r = mnl_nft_rule_dump(nf_sock, family);
if (r == NULL)
goto err;
- nft_ruleset_attr_set(rs, NFT_RULESET_ATTR_RULELIST, r);
+ nftnl_ruleset_set(rs, NFTNL_RULESET_RULELIST, r);
return rs;
err:
- nft_ruleset_free(rs);
+ nftnl_ruleset_free(rs);
return NULL;
}
seq++);
mnl_nlmsg_batch_next(b);
- nft_set_nlmsg_build_hdr(mnl_nlmsg_batch_current(b),
+ nftnl_set_nlmsg_build_hdr(mnl_nlmsg_batch_current(b),
NFT_MSG_NEWSET, AF_INET,
NLM_F_ACK, seq++);
mnl_nlmsg_batch_next(b);
exit(NFT_EXIT_NONL);
}
-struct nft_table *alloc_nft_table(const struct handle *h)
+struct nftnl_table *alloc_nftnl_table(const struct handle *h)
{
- struct nft_table *nlt;
+ struct nftnl_table *nlt;
- nlt = nft_table_alloc();
+ nlt = nftnl_table_alloc();
if (nlt == NULL)
memory_allocation_error();
- nft_table_attr_set_u32(nlt, NFT_TABLE_ATTR_FAMILY, h->family);
+ nftnl_table_set_u32(nlt, NFTNL_TABLE_FAMILY, h->family);
if (h->table != NULL)
- nft_table_attr_set(nlt, NFT_TABLE_ATTR_NAME, h->table);
+ nftnl_table_set(nlt, NFTNL_TABLE_NAME, h->table);
return nlt;
}
-struct nft_chain *alloc_nft_chain(const struct handle *h)
+struct nftnl_chain *alloc_nftnl_chain(const struct handle *h)
{
- struct nft_chain *nlc;
+ struct nftnl_chain *nlc;
- nlc = nft_chain_alloc();
+ nlc = nftnl_chain_alloc();
if (nlc == NULL)
memory_allocation_error();
- nft_chain_attr_set_u32(nlc, NFT_CHAIN_ATTR_FAMILY, h->family);
- nft_chain_attr_set_str(nlc, NFT_CHAIN_ATTR_TABLE, h->table);
+ nftnl_chain_set_u32(nlc, NFTNL_CHAIN_FAMILY, h->family);
+ nftnl_chain_set_str(nlc, NFTNL_CHAIN_TABLE, h->table);
if (h->handle != 0)
- nft_chain_attr_set_u64(nlc, NFT_CHAIN_ATTR_HANDLE, h->handle);
+ nftnl_chain_set_u64(nlc, NFTNL_CHAIN_HANDLE, h->handle);
if (h->chain != NULL)
- nft_chain_attr_set_str(nlc, NFT_CHAIN_ATTR_NAME, h->chain);
+ nftnl_chain_set_str(nlc, NFTNL_CHAIN_NAME, h->chain);
return nlc;
}
-struct nft_rule *alloc_nft_rule(const struct handle *h)
+struct nftnl_rule *alloc_nftnl_rule(const struct handle *h)
{
- struct nft_rule *nlr;
+ struct nftnl_rule *nlr;
- nlr = nft_rule_alloc();
+ nlr = nftnl_rule_alloc();
if (nlr == NULL)
memory_allocation_error();
- nft_rule_attr_set_u32(nlr, NFT_RULE_ATTR_FAMILY, h->family);
- nft_rule_attr_set_str(nlr, NFT_RULE_ATTR_TABLE, h->table);
+ nftnl_rule_set_u32(nlr, NFTNL_RULE_FAMILY, h->family);
+ nftnl_rule_set_str(nlr, NFTNL_RULE_TABLE, h->table);
if (h->chain != NULL)
- nft_rule_attr_set_str(nlr, NFT_RULE_ATTR_CHAIN, h->chain);
+ nftnl_rule_set_str(nlr, NFTNL_RULE_CHAIN, h->chain);
if (h->handle)
- nft_rule_attr_set_u64(nlr, NFT_RULE_ATTR_HANDLE, h->handle);
+ nftnl_rule_set_u64(nlr, NFTNL_RULE_HANDLE, h->handle);
if (h->position)
- nft_rule_attr_set_u64(nlr, NFT_RULE_ATTR_POSITION, h->position);
+ nftnl_rule_set_u64(nlr, NFTNL_RULE_POSITION, h->position);
if (h->comment)
- nft_rule_attr_set_data(nlr, NFT_RULE_ATTR_USERDATA,
+ nftnl_rule_set_data(nlr, NFTNL_RULE_USERDATA,
h->comment, strlen(h->comment) + 1);
return nlr;
}
-struct nft_rule_expr *alloc_nft_expr(const char *name)
+struct nftnl_expr *alloc_nft_expr(const char *name)
{
- struct nft_rule_expr *nle;
+ struct nftnl_expr *nle;
- nle = nft_rule_expr_alloc(name);
+ nle = nftnl_expr_alloc(name);
if (nle == NULL)
memory_allocation_error();
return nle;
}
-struct nft_set *alloc_nft_set(const struct handle *h)
+struct nftnl_set *alloc_nftnl_set(const struct handle *h)
{
- struct nft_set *nls;
+ struct nftnl_set *nls;
- nls = nft_set_alloc();
+ nls = nftnl_set_alloc();
if (nls == NULL)
memory_allocation_error();
- nft_set_attr_set_u32(nls, NFT_SET_ATTR_FAMILY, h->family);
- nft_set_attr_set_str(nls, NFT_SET_ATTR_TABLE, h->table);
+ nftnl_set_set_u32(nls, NFTNL_SET_FAMILY, h->family);
+ nftnl_set_set_str(nls, NFTNL_SET_TABLE, h->table);
if (h->set != NULL)
- nft_set_attr_set_str(nls, NFT_SET_ATTR_NAME, h->set);
+ nftnl_set_set_str(nls, NFTNL_SET_NAME, h->set);
if (h->set_id)
- nft_set_attr_set_u32(nls, NFT_SET_ATTR_ID, h->set_id);
+ nftnl_set_set_u32(nls, NFTNL_SET_ID, h->set_id);
return nls;
}
-static struct nft_set_elem *alloc_nft_setelem(const struct expr *expr)
+static struct nftnl_set_elem *alloc_nftnl_setelem(const struct expr *expr)
{
const struct expr *elem, *key, *data;
- struct nft_set_elem *nlse;
+ struct nftnl_set_elem *nlse;
struct nft_data_linearize nld;
- nlse = nft_set_elem_alloc();
+ nlse = nftnl_set_elem_alloc();
if (nlse == NULL)
memory_allocation_error();
key = elem->key;
netlink_gen_data(key, &nld);
- nft_set_elem_attr_set(nlse, NFT_SET_ELEM_ATTR_KEY, &nld.value, nld.len);
+ nftnl_set_elem_set(nlse, NFTNL_SET_ELEM_KEY, &nld.value, nld.len);
if (elem->timeout)
- nft_set_elem_attr_set_u64(nlse, NFT_SET_ELEM_ATTR_TIMEOUT,
+ nftnl_set_elem_set_u64(nlse, NFTNL_SET_ELEM_TIMEOUT,
elem->timeout);
if (elem->comment)
- nft_set_elem_attr_set(nlse, NFT_SET_ELEM_ATTR_USERDATA,
+ nftnl_set_elem_set(nlse, NFTNL_SET_ELEM_USERDATA,
elem->comment, strlen(elem->comment) + 1);
if (data != NULL) {
netlink_gen_data(data, &nld);
switch (data->ops->type) {
case EXPR_VERDICT:
- nft_set_elem_attr_set_u32(nlse, NFT_SET_ELEM_ATTR_VERDICT,
+ nftnl_set_elem_set_u32(nlse, NFTNL_SET_ELEM_VERDICT,
data->verdict);
if (data->chain != NULL)
- nft_set_elem_attr_set(nlse, NFT_SET_ELEM_ATTR_CHAIN,
+ nftnl_set_elem_set(nlse, NFTNL_SET_ELEM_CHAIN,
nld.chain, strlen(nld.chain));
break;
case EXPR_VALUE:
- nft_set_elem_attr_set(nlse, NFT_SET_ELEM_ATTR_DATA,
+ nftnl_set_elem_set(nlse, NFTNL_SET_ELEM_DATA,
nld.value, nld.len);
break;
default:
}
if (expr->flags & EXPR_F_INTERVAL_END)
- nft_set_elem_attr_set_u32(nlse, NFT_SET_ELEM_ATTR_FLAGS,
+ nftnl_set_elem_set_u32(nlse, NFTNL_SET_ELEM_FLAGS,
NFT_SET_ELEM_INTERVAL_END);
return nlse;
const struct handle *h,
const struct rule *rule, uint32_t flags)
{
- struct nft_rule *nlr;
+ struct nftnl_rule *nlr;
int err;
- nlr = alloc_nft_rule(&rule->handle);
+ nlr = alloc_nftnl_rule(&rule->handle);
netlink_linearize_rule(ctx, nlr, rule);
err = mnl_nft_rule_batch_add(nlr, flags | NLM_F_EXCL, ctx->seqnum);
- nft_rule_free(nlr);
+ nftnl_rule_free(nlr);
if (err < 0)
netlink_io_error(ctx, &rule->location,
"Could not add rule to batch: %s",
int netlink_del_rule_batch(struct netlink_ctx *ctx, const struct handle *h,
const struct location *loc)
{
- struct nft_rule *nlr;
+ struct nftnl_rule *nlr;
int err;
- nlr = alloc_nft_rule(h);
+ nlr = alloc_nftnl_rule(h);
err = mnl_nft_rule_batch_del(nlr, 0, ctx->seqnum);
- nft_rule_free(nlr);
+ nftnl_rule_free(nlr);
if (err < 0)
netlink_io_error(ctx, loc, "Could not delete rule to batch: %s",
return err;
}
-void netlink_dump_rule(struct nft_rule *nlr)
+void netlink_dump_rule(struct nftnl_rule *nlr)
{
#ifdef DEBUG
char buf[4096];
if (!(debug_level & DEBUG_NETLINK))
return;
- nft_rule_snprintf(buf, sizeof(buf), nlr, 0, 0);
+ nftnl_rule_snprintf(buf, sizeof(buf), nlr, 0, 0);
fprintf(stdout, "%s\n", buf);
#endif
}
-void netlink_dump_expr(struct nft_rule_expr *nle)
+void netlink_dump_expr(struct nftnl_expr *nle)
{
#ifdef DEBUG
char buf[4096];
if (!(debug_level & DEBUG_NETLINK))
return;
- nft_rule_expr_snprintf(buf, sizeof(buf), nle, 0, 0);
+ nftnl_expr_snprintf(buf, sizeof(buf), nle, 0, 0);
fprintf(stdout, "%s\n", buf);
#endif
}
-static int list_rule_cb(struct nft_rule *nlr, void *arg)
+static int list_rule_cb(struct nftnl_rule *nlr, void *arg)
{
struct netlink_ctx *ctx = arg;
const struct handle *h = ctx->data;
const char *table, *chain;
uint32_t family;
- family = nft_rule_attr_get_u32(nlr, NFT_RULE_ATTR_FAMILY);
- table = nft_rule_attr_get_str(nlr, NFT_RULE_ATTR_TABLE);
- chain = nft_rule_attr_get_str(nlr, NFT_RULE_ATTR_CHAIN);
+ family = nftnl_rule_get_u32(nlr, NFTNL_RULE_FAMILY);
+ table = nftnl_rule_get_str(nlr, NFTNL_RULE_TABLE);
+ chain = nftnl_rule_get_str(nlr, NFTNL_RULE_CHAIN);
if (h->family != family ||
strcmp(table, h->table) != 0 ||
static int netlink_list_rules(struct netlink_ctx *ctx, const struct handle *h,
const struct location *loc)
{
- struct nft_rule_list *rule_cache;
+ struct nftnl_rule_list *rule_cache;
rule_cache = mnl_nft_rule_dump(nf_sock, h->family);
if (rule_cache == NULL) {
}
ctx->data = h;
- nft_rule_list_foreach(rule_cache, list_rule_cb, ctx);
- nft_rule_list_free(rule_cache);
+ nftnl_rule_list_foreach(rule_cache, list_rule_cb, ctx);
+ nftnl_rule_list_free(rule_cache);
return 0;
}
return netlink_del_rule_batch(ctx, h, loc);
}
-void netlink_dump_chain(struct nft_chain *nlc)
+void netlink_dump_chain(struct nftnl_chain *nlc)
{
#ifdef DEBUG
char buf[4096];
if (!(debug_level & DEBUG_NETLINK))
return;
- nft_chain_snprintf(buf, sizeof(buf), nlc, 0, 0);
+ nftnl_chain_snprintf(buf, sizeof(buf), nlc, 0, 0);
fprintf(stdout, "%s\n", buf);
#endif
}
const struct location *loc,
const struct chain *chain, bool excl)
{
- struct nft_chain *nlc;
+ struct nftnl_chain *nlc;
int err;
- nlc = alloc_nft_chain(h);
+ nlc = alloc_nftnl_chain(h);
if (chain != NULL) {
if (chain->flags & CHAIN_F_BASECHAIN) {
- nft_chain_attr_set_u32(nlc, NFT_CHAIN_ATTR_HOOKNUM,
+ nftnl_chain_set_u32(nlc, NFTNL_CHAIN_HOOKNUM,
chain->hooknum);
- nft_chain_attr_set_s32(nlc, NFT_CHAIN_ATTR_PRIO,
+ nftnl_chain_set_s32(nlc, NFTNL_CHAIN_PRIO,
chain->priority);
- nft_chain_attr_set_str(nlc, NFT_CHAIN_ATTR_TYPE,
+ nftnl_chain_set_str(nlc, NFTNL_CHAIN_TYPE,
chain->type);
}
if (chain->policy != -1)
- nft_chain_attr_set_u32(nlc, NFT_CHAIN_ATTR_POLICY,
+ nftnl_chain_set_u32(nlc, NFTNL_CHAIN_POLICY,
chain->policy);
}
netlink_dump_chain(nlc);
err = mnl_nft_chain_add(nf_sock, nlc, excl ? NLM_F_EXCL : 0);
- nft_chain_free(nlc);
+ nftnl_chain_free(nlc);
if (err < 0)
netlink_io_error(ctx, loc, "Could not add chain: %s",
const struct location *loc,
const struct chain *chain, bool excl)
{
- struct nft_chain *nlc;
+ struct nftnl_chain *nlc;
int err;
- nlc = alloc_nft_chain(h);
+ nlc = alloc_nftnl_chain(h);
if (chain != NULL) {
if (chain->flags & CHAIN_F_BASECHAIN) {
- nft_chain_attr_set_u32(nlc, NFT_CHAIN_ATTR_HOOKNUM,
+ nftnl_chain_set_u32(nlc, NFTNL_CHAIN_HOOKNUM,
chain->hooknum);
- nft_chain_attr_set_s32(nlc, NFT_CHAIN_ATTR_PRIO,
+ nftnl_chain_set_s32(nlc, NFTNL_CHAIN_PRIO,
chain->priority);
- nft_chain_attr_set_str(nlc, NFT_CHAIN_ATTR_TYPE,
+ nftnl_chain_set_str(nlc, NFTNL_CHAIN_TYPE,
chain->type);
}
if (chain->policy != -1)
- nft_chain_attr_set_u32(nlc, NFT_CHAIN_ATTR_POLICY,
+ nftnl_chain_set_u32(nlc, NFTNL_CHAIN_POLICY,
chain->policy);
if (chain->dev != NULL)
- nft_chain_attr_set_str(nlc, NFT_CHAIN_ATTR_DEV,
+ nftnl_chain_set_str(nlc, NFTNL_CHAIN_DEV,
chain->dev);
}
netlink_dump_chain(nlc);
err = mnl_nft_chain_batch_add(nlc, excl ? NLM_F_EXCL : 0,
ctx->seqnum);
- nft_chain_free(nlc);
+ nftnl_chain_free(nlc);
if (err < 0)
netlink_io_error(ctx, loc, "Could not add chain: %s",
const struct location *loc,
const char *name)
{
- struct nft_chain *nlc;
+ struct nftnl_chain *nlc;
int err;
- nlc = alloc_nft_chain(h);
- nft_chain_attr_set_str(nlc, NFT_CHAIN_ATTR_NAME, name);
+ nlc = alloc_nftnl_chain(h);
+ nftnl_chain_set_str(nlc, NFTNL_CHAIN_NAME, name);
netlink_dump_chain(nlc);
err = mnl_nft_chain_add(nf_sock, nlc, 0);
- nft_chain_free(nlc);
+ nftnl_chain_free(nlc);
if (err < 0)
netlink_io_error(ctx, loc, "Could not rename chain: %s",
const struct location *loc,
const char *name)
{
- struct nft_chain *nlc;
+ struct nftnl_chain *nlc;
int err;
- nlc = alloc_nft_chain(h);
- nft_chain_attr_set_str(nlc, NFT_CHAIN_ATTR_NAME, name);
+ nlc = alloc_nftnl_chain(h);
+ nftnl_chain_set_str(nlc, NFTNL_CHAIN_NAME, name);
netlink_dump_chain(nlc);
err = mnl_nft_chain_batch_add(nlc, 0, ctx->seqnum);
- nft_chain_free(nlc);
+ nftnl_chain_free(nlc);
if (err < 0)
netlink_io_error(ctx, loc, "Could not rename chain: %s",
const struct handle *h,
const struct location *loc)
{
- struct nft_chain *nlc;
+ struct nftnl_chain *nlc;
int err;
- nlc = alloc_nft_chain(h);
+ nlc = alloc_nftnl_chain(h);
netlink_dump_chain(nlc);
err = mnl_nft_chain_delete(nf_sock, nlc, 0);
- nft_chain_free(nlc);
+ nftnl_chain_free(nlc);
if (err < 0)
netlink_io_error(ctx, loc, "Could not delete chain: %s",
const struct handle *h,
const struct location *loc)
{
- struct nft_chain *nlc;
+ struct nftnl_chain *nlc;
int err;
- nlc = alloc_nft_chain(h);
+ nlc = alloc_nftnl_chain(h);
netlink_dump_chain(nlc);
err = mnl_nft_chain_batch_del(nlc, 0, ctx->seqnum);
- nft_chain_free(nlc);
+ nftnl_chain_free(nlc);
if (err < 0)
netlink_io_error(ctx, loc, "Could not delete chain: %s",
}
static struct chain *netlink_delinearize_chain(struct netlink_ctx *ctx,
- struct nft_chain *nlc)
+ struct nftnl_chain *nlc)
{
struct chain *chain;
- chain = chain_alloc(nft_chain_attr_get_str(nlc, NFT_CHAIN_ATTR_NAME));
+ chain = chain_alloc(nftnl_chain_get_str(nlc, NFTNL_CHAIN_NAME));
chain->handle.family =
- nft_chain_attr_get_u32(nlc, NFT_CHAIN_ATTR_FAMILY);
+ nftnl_chain_get_u32(nlc, NFTNL_CHAIN_FAMILY);
chain->handle.table =
- xstrdup(nft_chain_attr_get_str(nlc, NFT_CHAIN_ATTR_TABLE));
+ xstrdup(nftnl_chain_get_str(nlc, NFTNL_CHAIN_TABLE));
chain->handle.handle =
- nft_chain_attr_get_u64(nlc, NFT_CHAIN_ATTR_HANDLE);
+ nftnl_chain_get_u64(nlc, NFTNL_CHAIN_HANDLE);
- if (nft_chain_attr_is_set(nlc, NFT_CHAIN_ATTR_HOOKNUM) &&
- nft_chain_attr_is_set(nlc, NFT_CHAIN_ATTR_PRIO) &&
- nft_chain_attr_is_set(nlc, NFT_CHAIN_ATTR_TYPE) &&
- nft_chain_attr_is_set(nlc, NFT_CHAIN_ATTR_POLICY)) {
+ if (nftnl_chain_is_set(nlc, NFTNL_CHAIN_HOOKNUM) &&
+ nftnl_chain_is_set(nlc, NFTNL_CHAIN_PRIO) &&
+ nftnl_chain_is_set(nlc, NFTNL_CHAIN_TYPE) &&
+ nftnl_chain_is_set(nlc, NFTNL_CHAIN_POLICY)) {
chain->hooknum =
- nft_chain_attr_get_u32(nlc, NFT_CHAIN_ATTR_HOOKNUM);
+ nftnl_chain_get_u32(nlc, NFTNL_CHAIN_HOOKNUM);
chain->hookstr =
hooknum2str(chain->handle.family, chain->hooknum);
chain->priority =
- nft_chain_attr_get_s32(nlc, NFT_CHAIN_ATTR_PRIO);
+ nftnl_chain_get_s32(nlc, NFTNL_CHAIN_PRIO);
chain->type =
- xstrdup(nft_chain_attr_get_str(nlc, NFT_CHAIN_ATTR_TYPE));
+ xstrdup(nftnl_chain_get_str(nlc, NFTNL_CHAIN_TYPE));
chain->policy =
- nft_chain_attr_get_u32(nlc, NFT_CHAIN_ATTR_POLICY);
- if (nft_chain_attr_is_set(nlc, NFT_CHAIN_ATTR_DEV)) {
+ nftnl_chain_get_u32(nlc, NFTNL_CHAIN_POLICY);
+ if (nftnl_chain_is_set(nlc, NFTNL_CHAIN_DEV)) {
chain->dev =
- xstrdup(nft_chain_attr_get_str(nlc, NFT_CHAIN_ATTR_DEV));
+ xstrdup(nftnl_chain_get_str(nlc, NFTNL_CHAIN_DEV));
}
chain->flags |= CHAIN_F_BASECHAIN;
}
return chain;
}
-static int list_chain_cb(struct nft_chain *nlc, void *arg)
+static int list_chain_cb(struct nftnl_chain *nlc, void *arg)
{
struct netlink_ctx *ctx = arg;
const struct handle *h = ctx->data;
struct chain *chain;
uint32_t family;
- table = nft_chain_attr_get_str(nlc, NFT_CHAIN_ATTR_TABLE);
- name = nft_chain_attr_get_str(nlc, NFT_CHAIN_ATTR_NAME);
- family = nft_chain_attr_get_u32(nlc, NFT_CHAIN_ATTR_FAMILY);
+ table = nftnl_chain_get_str(nlc, NFTNL_CHAIN_TABLE);
+ name = nftnl_chain_get_str(nlc, NFTNL_CHAIN_NAME);
+ family = nftnl_chain_get_u32(nlc, NFTNL_CHAIN_FAMILY);
if (h->family != family || strcmp(table, h->table) != 0)
return 0;
int netlink_list_chains(struct netlink_ctx *ctx, const struct handle *h,
const struct location *loc)
{
- struct nft_chain_list *chain_cache;
+ struct nftnl_chain_list *chain_cache;
struct chain *chain;
chain_cache = mnl_nft_chain_dump(nf_sock, h->family);
}
ctx->data = h;
- nft_chain_list_foreach(chain_cache, list_chain_cb, ctx);
- nft_chain_list_free(chain_cache);
+ nftnl_chain_list_foreach(chain_cache, list_chain_cb, ctx);
+ nftnl_chain_list_free(chain_cache);
/* Caller wants all existing chains */
if (h->chain == NULL)
int netlink_get_chain(struct netlink_ctx *ctx, const struct handle *h,
const struct location *loc)
{
- struct nft_chain *nlc;
+ struct nftnl_chain *nlc;
struct chain *chain;
int err;
- nlc = alloc_nft_chain(h);
+ nlc = alloc_nftnl_chain(h);
err = mnl_nft_chain_get(nf_sock, nlc, 0);
if (err < 0) {
netlink_io_error(ctx, loc,
chain = netlink_delinearize_chain(ctx, nlc);
list_add_tail(&chain->list, &ctx->list);
out:
- nft_chain_free(nlc);
+ nftnl_chain_free(nlc);
return err;
}
const struct location *loc,
const struct table *table, bool excl)
{
- struct nft_table *nlt;
+ struct nftnl_table *nlt;
int err;
- nlt = alloc_nft_table(h);
+ nlt = alloc_nftnl_table(h);
err = mnl_nft_table_add(nf_sock, nlt, excl ? NLM_F_EXCL : 0);
- nft_table_free(nlt);
+ nftnl_table_free(nlt);
if (err < 0)
netlink_io_error(ctx, loc, "Could not add table: %s",
const struct location *loc,
const struct table *table, bool excl)
{
- struct nft_table *nlt;
+ struct nftnl_table *nlt;
int err;
- nlt = alloc_nft_table(h);
+ nlt = alloc_nftnl_table(h);
if (table != NULL)
- nft_table_attr_set_u32(nlt, NFT_TABLE_ATTR_FLAGS, table->flags);
+ nftnl_table_set_u32(nlt, NFTNL_TABLE_FLAGS, table->flags);
else
- nft_table_attr_set_u32(nlt, NFT_TABLE_ATTR_FLAGS, 0);
+ nftnl_table_set_u32(nlt, NFTNL_TABLE_FLAGS, 0);
err = mnl_nft_table_batch_add(nlt, excl ? NLM_F_EXCL : 0,
ctx->seqnum);
- nft_table_free(nlt);
+ nftnl_table_free(nlt);
if (err < 0)
netlink_io_error(ctx, loc, "Could not add table: %s",
const struct handle *h,
const struct location *loc)
{
- struct nft_table *nlt;
+ struct nftnl_table *nlt;
int err;
- nlt = alloc_nft_table(h);
+ nlt = alloc_nftnl_table(h);
err = mnl_nft_table_delete(nf_sock, nlt, 0);
- nft_table_free(nlt);
+ nftnl_table_free(nlt);
if (err < 0)
netlink_io_error(ctx, loc, "Could not delete table: %s",
const struct handle *h,
const struct location *loc)
{
- struct nft_table *nlt;
+ struct nftnl_table *nlt;
int err;
- nlt = alloc_nft_table(h);
+ nlt = alloc_nftnl_table(h);
err = mnl_nft_table_batch_del(nlt, 0, ctx->seqnum);
- nft_table_free(nlt);
+ nftnl_table_free(nlt);
if (err < 0)
netlink_io_error(ctx, loc, "Could not delete table: %s",
return netlink_del_table_compat(ctx, h, loc);
}
-void netlink_dump_table(struct nft_table *nlt)
+void netlink_dump_table(struct nftnl_table *nlt)
{
#ifdef DEBUG
char buf[4096];
if (!(debug_level & DEBUG_NETLINK))
return;
- nft_table_snprintf(buf, sizeof(buf), nlt, 0, 0);
+ nftnl_table_snprintf(buf, sizeof(buf), nlt, 0, 0);
fprintf(stdout, "%s\n", buf);
#endif
}
static struct table *netlink_delinearize_table(struct netlink_ctx *ctx,
- struct nft_table *nlt)
+ struct nftnl_table *nlt)
{
struct table *table;
table = table_alloc();
table->handle.family =
- nft_table_attr_get_u32(nlt, NFT_TABLE_ATTR_FAMILY);
+ nftnl_table_get_u32(nlt, NFTNL_TABLE_FAMILY);
table->handle.table =
- xstrdup(nft_table_attr_get_str(nlt, NFT_TABLE_ATTR_NAME));
+ xstrdup(nftnl_table_get_str(nlt, NFTNL_TABLE_NAME));
table->flags =
- nft_table_attr_get_u32(nlt, NFT_TABLE_ATTR_FLAGS);
+ nftnl_table_get_u32(nlt, NFTNL_TABLE_FLAGS);
return table;
}
-static int list_table_cb(struct nft_table *nlt, void *arg)
+static int list_table_cb(struct nftnl_table *nlt, void *arg)
{
struct netlink_ctx *ctx = arg;
struct table *table;
int netlink_list_tables(struct netlink_ctx *ctx, const struct handle *h,
const struct location *loc)
{
- struct nft_table_list *table_cache;
+ struct nftnl_table_list *table_cache;
table_cache = mnl_nft_table_dump(nf_sock, h->family);
if (table_cache == NULL) {
strerror(errno));
}
- nft_table_list_foreach(table_cache, list_table_cb, ctx);
- nft_table_list_free(table_cache);
+ nftnl_table_list_foreach(table_cache, list_table_cb, ctx);
+ nftnl_table_list_free(table_cache);
return 0;
}
int netlink_get_table(struct netlink_ctx *ctx, const struct handle *h,
const struct location *loc, struct table *table)
{
- struct nft_table *nlt;
+ struct nftnl_table *nlt;
struct table *ntable;
int err;
- nlt = alloc_nft_table(h);
+ nlt = alloc_nftnl_table(h);
err = mnl_nft_table_get(nf_sock, nlt, 0);
if (err < 0) {
netlink_io_error(ctx, loc,
table->flags = ntable->flags;
table_free(ntable);
out:
- nft_table_free(nlt);
+ nftnl_table_free(nlt);
return err;
}
}
}
-void netlink_dump_set(struct nft_set *nls)
+void netlink_dump_set(struct nftnl_set *nls)
{
#ifdef DEBUG
char buf[4096];
if (!(debug_level & DEBUG_NETLINK))
return;
- nft_set_snprintf(buf, sizeof(buf), nls, 0, 0);
+ nftnl_set_snprintf(buf, sizeof(buf), nls, 0, 0);
fprintf(stdout, "%s\n", buf);
#endif
}
static struct set *netlink_delinearize_set(struct netlink_ctx *ctx,
- struct nft_set *nls)
+ struct nftnl_set *nls)
{
struct set *set;
const struct datatype *keytype, *datatype;
uint32_t flags, key, data, data_len;
- key = nft_set_attr_get_u32(nls, NFT_SET_ATTR_KEY_TYPE);
+ key = nftnl_set_get_u32(nls, NFTNL_SET_KEY_TYPE);
keytype = dtype_map_from_kernel(key);
if (keytype == NULL) {
netlink_io_error(ctx, NULL, "Unknown data type in set key %u",
return NULL;
}
- flags = nft_set_attr_get_u32(nls, NFT_SET_ATTR_FLAGS);
+ flags = nftnl_set_get_u32(nls, NFTNL_SET_FLAGS);
if (flags & NFT_SET_MAP) {
- data = nft_set_attr_get_u32(nls, NFT_SET_ATTR_DATA_TYPE);
+ data = nftnl_set_get_u32(nls, NFTNL_SET_DATA_TYPE);
datatype = dtype_map_from_kernel(data);
if (datatype == NULL) {
netlink_io_error(ctx, NULL,
datatype = NULL;
set = set_alloc(&netlink_location);
- set->handle.family = nft_set_attr_get_u32(nls, NFT_SET_ATTR_FAMILY);
+ set->handle.family = nftnl_set_get_u32(nls, NFTNL_SET_FAMILY);
set->handle.table =
- xstrdup(nft_set_attr_get_str(nls, NFT_SET_ATTR_TABLE));
+ xstrdup(nftnl_set_get_str(nls, NFTNL_SET_TABLE));
set->handle.set =
- xstrdup(nft_set_attr_get_str(nls, NFT_SET_ATTR_NAME));
+ xstrdup(nftnl_set_get_str(nls, NFTNL_SET_NAME));
set->keytype = keytype;
set->keylen =
- nft_set_attr_get_u32(nls, NFT_SET_ATTR_KEY_LEN) * BITS_PER_BYTE;
+ nftnl_set_get_u32(nls, NFTNL_SET_KEY_LEN) * BITS_PER_BYTE;
- set->flags = nft_set_attr_get_u32(nls, NFT_SET_ATTR_FLAGS);
+ set->flags = nftnl_set_get_u32(nls, NFTNL_SET_FLAGS);
set->datatype = datatype;
- if (nft_set_attr_is_set(nls, NFT_SET_ATTR_DATA_LEN)) {
- data_len = nft_set_attr_get_u32(nls, NFT_SET_ATTR_DATA_LEN);
+ if (nftnl_set_is_set(nls, NFTNL_SET_DATA_LEN)) {
+ data_len = nftnl_set_get_u32(nls, NFTNL_SET_DATA_LEN);
set->datalen = data_len * BITS_PER_BYTE;
}
- if (nft_set_attr_is_set(nls, NFT_SET_ATTR_TIMEOUT))
- set->timeout = nft_set_attr_get_u64(nls, NFT_SET_ATTR_TIMEOUT);
- if (nft_set_attr_is_set(nls, NFT_SET_ATTR_GC_INTERVAL))
- set->gc_int = nft_set_attr_get_u32(nls, NFT_SET_ATTR_GC_INTERVAL);
+ if (nftnl_set_is_set(nls, NFTNL_SET_TIMEOUT))
+ set->timeout = nftnl_set_get_u64(nls, NFTNL_SET_TIMEOUT);
+ if (nftnl_set_is_set(nls, NFTNL_SET_GC_INTERVAL))
+ set->gc_int = nftnl_set_get_u32(nls, NFTNL_SET_GC_INTERVAL);
- if (nft_set_attr_is_set(nls, NFT_SET_ATTR_POLICY))
- set->policy = nft_set_attr_get_u32(nls, NFT_SET_ATTR_POLICY);
+ if (nftnl_set_is_set(nls, NFTNL_SET_POLICY))
+ set->policy = nftnl_set_get_u32(nls, NFTNL_SET_POLICY);
- if (nft_set_attr_is_set(nls, NFT_SET_ATTR_DESC_SIZE))
- set->desc.size = nft_set_attr_get_u32(nls,
- NFT_SET_ATTR_DESC_SIZE);
+ if (nftnl_set_is_set(nls, NFTNL_SET_DESC_SIZE))
+ set->desc.size = nftnl_set_get_u32(nls,
+ NFTNL_SET_DESC_SIZE);
return set;
}
static int netlink_add_set_compat(struct netlink_ctx *ctx,
const struct handle *h, struct set *set)
{
- struct nft_set *nls;
+ struct nftnl_set *nls;
int err;
- nls = alloc_nft_set(h);
- nft_set_attr_set_u32(nls, NFT_SET_ATTR_FLAGS, set->flags);
- nft_set_attr_set_u32(nls, NFT_SET_ATTR_KEY_TYPE,
+ nls = alloc_nftnl_set(h);
+ nftnl_set_set_u32(nls, NFTNL_SET_FLAGS, set->flags);
+ nftnl_set_set_u32(nls, NFTNL_SET_KEY_TYPE,
dtype_map_to_kernel(set->keytype));
- nft_set_attr_set_u32(nls, NFT_SET_ATTR_KEY_LEN,
+ nftnl_set_set_u32(nls, NFTNL_SET_KEY_LEN,
set->keylen / BITS_PER_BYTE);
if (set->flags & NFT_SET_MAP) {
- nft_set_attr_set_u32(nls, NFT_SET_ATTR_DATA_TYPE,
+ nftnl_set_set_u32(nls, NFTNL_SET_DATA_TYPE,
dtype_map_to_kernel(set->datatype));
- nft_set_attr_set_u32(nls, NFT_SET_ATTR_DATA_LEN,
+ nftnl_set_set_u32(nls, NFTNL_SET_DATA_LEN,
set->datalen / BITS_PER_BYTE);
}
netlink_dump_set(nls);
strerror(errno));
set->handle.set =
- xstrdup(nft_set_attr_get_str(nls, NFT_SET_ATTR_NAME));
- nft_set_free(nls);
+ xstrdup(nftnl_set_get_str(nls, NFTNL_SET_NAME));
+ nftnl_set_free(nls);
return err;
}
static int netlink_add_set_batch(struct netlink_ctx *ctx,
const struct handle *h, struct set *set)
{
- struct nft_set *nls;
+ struct nftnl_set *nls;
int err;
- nls = alloc_nft_set(h);
- nft_set_attr_set_u32(nls, NFT_SET_ATTR_FLAGS, set->flags);
- nft_set_attr_set_u32(nls, NFT_SET_ATTR_KEY_TYPE,
+ nls = alloc_nftnl_set(h);
+ nftnl_set_set_u32(nls, NFTNL_SET_FLAGS, set->flags);
+ nftnl_set_set_u32(nls, NFTNL_SET_KEY_TYPE,
dtype_map_to_kernel(set->keytype));
- nft_set_attr_set_u32(nls, NFT_SET_ATTR_KEY_LEN,
+ nftnl_set_set_u32(nls, NFTNL_SET_KEY_LEN,
set->keylen / BITS_PER_BYTE);
if (set->flags & NFT_SET_MAP) {
- nft_set_attr_set_u32(nls, NFT_SET_ATTR_DATA_TYPE,
+ nftnl_set_set_u32(nls, NFTNL_SET_DATA_TYPE,
dtype_map_to_kernel(set->datatype));
- nft_set_attr_set_u32(nls, NFT_SET_ATTR_DATA_LEN,
+ nftnl_set_set_u32(nls, NFTNL_SET_DATA_LEN,
set->datalen / BITS_PER_BYTE);
}
if (set->timeout)
- nft_set_attr_set_u64(nls, NFT_SET_ATTR_TIMEOUT, set->timeout);
+ nftnl_set_set_u64(nls, NFTNL_SET_TIMEOUT, set->timeout);
if (set->gc_int)
- nft_set_attr_set_u32(nls, NFT_SET_ATTR_GC_INTERVAL, set->gc_int);
+ nftnl_set_set_u32(nls, NFTNL_SET_GC_INTERVAL, set->gc_int);
- nft_set_attr_set_u32(nls, NFT_SET_ATTR_ID, set->handle.set_id);
+ nftnl_set_set_u32(nls, NFTNL_SET_ID, set->handle.set_id);
if (!(set->flags & (SET_F_CONSTANT))) {
if (set->policy != NFT_SET_POL_PERFORMANCE) {
- nft_set_attr_set_u32(nls, NFT_SET_ATTR_POLICY,
+ nftnl_set_set_u32(nls, NFTNL_SET_POLICY,
set->policy);
}
if (set->desc.size != 0) {
- nft_set_attr_set_u32(nls, NFT_SET_ATTR_DESC_SIZE,
+ nftnl_set_set_u32(nls, NFTNL_SET_DESC_SIZE,
set->desc.size);
}
}
if (err < 0)
netlink_io_error(ctx, &set->location, "Could not add set: %s",
strerror(errno));
- nft_set_free(nls);
+ nftnl_set_free(nls);
return err;
}
const struct handle *h,
const struct location *loc)
{
- struct nft_set *nls;
+ struct nftnl_set *nls;
int err;
- nls = alloc_nft_set(h);
+ nls = alloc_nftnl_set(h);
err = mnl_nft_set_delete(nf_sock, nls, 0);
- nft_set_free(nls);
+ nftnl_set_free(nls);
if (err < 0)
netlink_io_error(ctx, loc, "Could not delete set: %s",
const struct handle *h,
const struct location *loc)
{
- struct nft_set *nls;
+ struct nftnl_set *nls;
int err;
- nls = alloc_nft_set(h);
+ nls = alloc_nftnl_set(h);
err = mnl_nft_set_batch_del(nls, 0, ctx->seqnum);
- nft_set_free(nls);
+ nftnl_set_free(nls);
if (err < 0)
netlink_io_error(ctx, loc, "Could not delete set: %s",
return netlink_del_set_compat(ctx, h, loc);
}
-static int list_set_cb(struct nft_set *nls, void *arg)
+static int list_set_cb(struct nftnl_set *nls, void *arg)
{
struct netlink_ctx *ctx = arg;
struct set *set;
int netlink_list_sets(struct netlink_ctx *ctx, const struct handle *h,
const struct location *loc)
{
- struct nft_set_list *set_cache;
+ struct nftnl_set_list *set_cache;
int err;
set_cache = mnl_nft_set_dump(nf_sock, h->family, h->table);
strerror(errno));
}
- err = nft_set_list_foreach(set_cache, list_set_cb, ctx);
- nft_set_list_free(set_cache);
+ err = nftnl_set_list_foreach(set_cache, list_set_cb, ctx);
+ nftnl_set_list_free(set_cache);
return err;
}
int netlink_get_set(struct netlink_ctx *ctx, const struct handle *h,
const struct location *loc)
{
- struct nft_set *nls;
+ struct nftnl_set *nls;
struct set *set;
int err;
- nls = alloc_nft_set(h);
+ nls = alloc_nftnl_set(h);
err = mnl_nft_set_get(nf_sock, nls);
if (err < 0) {
- nft_set_free(nls);
+ nftnl_set_free(nls);
return netlink_io_error(ctx, loc,
"Could not receive set from kernel: %s",
strerror(errno));
}
set = netlink_delinearize_set(ctx, nls);
- nft_set_free(nls);
+ nftnl_set_free(nls);
if (set == NULL)
return -1;
list_add_tail(&set->list, &ctx->list);
return err;
}
-static void alloc_setelem_cache(const struct expr *set, struct nft_set *nls)
+static void alloc_setelem_cache(const struct expr *set, struct nftnl_set *nls)
{
- struct nft_set_elem *nlse;
+ struct nftnl_set_elem *nlse;
const struct expr *expr;
list_for_each_entry(expr, &set->expressions, list) {
- nlse = alloc_nft_setelem(expr);
- nft_set_elem_add(nls, nlse);
+ nlse = alloc_nftnl_setelem(expr);
+ nftnl_set_elem_add(nls, nlse);
}
}
const struct handle *h,
const struct expr *expr)
{
- struct nft_set *nls;
+ struct nftnl_set *nls;
int err;
- nls = alloc_nft_set(h);
+ nls = alloc_nftnl_set(h);
alloc_setelem_cache(expr, nls);
netlink_dump_set(nls);
err = mnl_nft_setelem_batch_add(nls, 0, ctx->seqnum);
- nft_set_free(nls);
+ nftnl_set_free(nls);
if (err < 0)
netlink_io_error(ctx, &expr->location,
"Could not add set elements: %s",
const struct handle *h,
const struct expr *expr)
{
- struct nft_set *nls;
+ struct nftnl_set *nls;
int err;
- nls = alloc_nft_set(h);
+ nls = alloc_nftnl_set(h);
alloc_setelem_cache(expr, nls);
netlink_dump_set(nls);
err = mnl_nft_setelem_add(nf_sock, nls, 0);
- nft_set_free(nls);
+ nftnl_set_free(nls);
if (err < 0)
netlink_io_error(ctx, &expr->location,
"Could not add set elements: %s",
const struct handle *h,
const struct expr *expr)
{
- struct nft_set *nls;
+ struct nftnl_set *nls;
int err;
- nls = alloc_nft_set(h);
+ nls = alloc_nftnl_set(h);
alloc_setelem_cache(expr, nls);
netlink_dump_set(nls);
err = mnl_nft_setelem_batch_del(nls, 0, ctx->seqnum);
- nft_set_free(nls);
+ nftnl_set_free(nls);
if (err < 0)
netlink_io_error(ctx, &expr->location,
"Could not delete set elements: %s",
const struct handle *h,
const struct expr *expr)
{
- struct nft_set *nls;
+ struct nftnl_set *nls;
int err;
- nls = alloc_nft_set(h);
+ nls = alloc_nftnl_set(h);
alloc_setelem_cache(expr, nls);
netlink_dump_set(nls);
err = mnl_nft_setelem_delete(nf_sock, nls, 0);
- nft_set_free(nls);
+ nftnl_set_free(nls);
if (err < 0)
netlink_io_error(ctx, &expr->location,
"Could not delete set elements: %s",
return concat;
}
-static int netlink_delinearize_setelem(struct nft_set_elem *nlse,
+static int netlink_delinearize_setelem(struct nftnl_set_elem *nlse,
struct set *set)
{
struct nft_data_delinearize nld;
uint32_t flags = 0;
nld.value =
- nft_set_elem_attr_get(nlse, NFT_SET_ELEM_ATTR_KEY, &nld.len);
- if (nft_set_elem_attr_is_set(nlse, NFT_SET_ELEM_ATTR_FLAGS))
- flags = nft_set_elem_attr_get_u32(nlse, NFT_SET_ELEM_ATTR_FLAGS);
+ nftnl_set_elem_get(nlse, NFTNL_SET_ELEM_KEY, &nld.len);
+ if (nftnl_set_elem_is_set(nlse, NFTNL_SET_ELEM_FLAGS))
+ flags = nftnl_set_elem_get_u32(nlse, NFTNL_SET_ELEM_FLAGS);
key = netlink_alloc_value(&netlink_location, &nld);
key->dtype = set->keytype;
key = bitmask_expr_to_binops(key);
expr = set_elem_expr_alloc(&netlink_location, key);
- if (nft_set_elem_attr_is_set(nlse, NFT_SET_ELEM_ATTR_TIMEOUT))
- expr->timeout = nft_set_elem_attr_get_u64(nlse, NFT_SET_ELEM_ATTR_TIMEOUT);
- if (nft_set_elem_attr_is_set(nlse, NFT_SET_ELEM_ATTR_EXPIRATION))
- expr->expiration = nft_set_elem_attr_get_u64(nlse, NFT_SET_ELEM_ATTR_EXPIRATION);
- if (nft_set_elem_attr_is_set(nlse, NFT_SET_ELEM_ATTR_USERDATA)) {
+ if (nftnl_set_elem_is_set(nlse, NFTNL_SET_ELEM_TIMEOUT))
+ expr->timeout = nftnl_set_elem_get_u64(nlse, NFTNL_SET_ELEM_TIMEOUT);
+ if (nftnl_set_elem_is_set(nlse, NFTNL_SET_ELEM_EXPIRATION))
+ expr->expiration = nftnl_set_elem_get_u64(nlse, NFTNL_SET_ELEM_EXPIRATION);
+ if (nftnl_set_elem_is_set(nlse, NFTNL_SET_ELEM_USERDATA)) {
const void *data;
uint32_t len;
- data = nft_set_elem_attr_get(nlse, NFT_SET_ELEM_ATTR_USERDATA, &len);
+ data = nftnl_set_elem_get(nlse, NFTNL_SET_ELEM_USERDATA, &len);
expr->comment = xmalloc(len);
memcpy((char *)expr->comment, data, len);
}
if (flags & NFT_SET_ELEM_INTERVAL_END) {
expr->flags |= EXPR_F_INTERVAL_END;
} else {
- if (nft_set_elem_attr_is_set(nlse, NFT_SET_ELEM_ATTR_DATA)) {
- nld.value = nft_set_elem_attr_get(nlse, NFT_SET_ELEM_ATTR_DATA,
+ if (nftnl_set_elem_is_set(nlse, NFTNL_SET_ELEM_DATA)) {
+ nld.value = nftnl_set_elem_get(nlse, NFTNL_SET_ELEM_DATA,
&nld.len);
- } else if (nft_set_elem_attr_is_set(nlse, NFT_SET_ELEM_ATTR_CHAIN)) {
- nld.chain = nft_set_elem_attr_get_str(nlse, NFT_SET_ELEM_ATTR_CHAIN);
- nld.verdict = nft_set_elem_attr_get_u32(nlse, NFT_SET_ELEM_ATTR_VERDICT);
- } else if (nft_set_elem_attr_is_set(nlse, NFT_SET_ELEM_ATTR_VERDICT)) {
- nld.verdict = nft_set_elem_attr_get_u32(nlse, NFT_SET_ELEM_ATTR_VERDICT);
+ } else if (nftnl_set_elem_is_set(nlse, NFTNL_SET_ELEM_CHAIN)) {
+ nld.chain = nftnl_set_elem_get_str(nlse, NFTNL_SET_ELEM_CHAIN);
+ nld.verdict = nftnl_set_elem_get_u32(nlse, NFTNL_SET_ELEM_VERDICT);
+ } else if (nftnl_set_elem_is_set(nlse, NFTNL_SET_ELEM_VERDICT)) {
+ nld.verdict = nftnl_set_elem_get_u32(nlse, NFTNL_SET_ELEM_VERDICT);
} else
goto out;
return netlink_del_setelems_compat(ctx, h, expr);
}
-static int list_setelem_cb(struct nft_set_elem *nlse, void *arg)
+static int list_setelem_cb(struct nftnl_set_elem *nlse, void *arg)
{
struct netlink_ctx *ctx = arg;
return netlink_delinearize_setelem(nlse, ctx->set);
int netlink_get_setelems(struct netlink_ctx *ctx, const struct handle *h,
const struct location *loc, struct set *set)
{
- struct nft_set *nls;
+ struct nftnl_set *nls;
int err;
- nls = alloc_nft_set(h);
+ nls = alloc_nftnl_set(h);
err = mnl_nft_setelem_get(nf_sock, nls);
if (err < 0) {
- nft_set_free(nls);
+ nftnl_set_free(nls);
if (errno == EINTR)
return -1;
ctx->set = set;
set->init = set_expr_alloc(loc);
- nft_set_elem_foreach(nls, list_setelem_cb, ctx);
- nft_set_free(nls);
+ nftnl_set_elem_foreach(nls, list_setelem_cb, ctx);
+ nftnl_set_free(nls);
ctx->set = NULL;
if (set->flags & NFT_SET_INTERVAL)
int netlink_flush_ruleset(struct netlink_ctx *ctx, const struct handle *h,
const struct location *loc)
{
- struct nft_table *nlt;
+ struct nftnl_table *nlt;
int err;
if (!ctx->batch_supported)
return netlink_io_error(ctx, loc, "Operation not supported");
- nlt = alloc_nft_table(h);
+ nlt = alloc_nftnl_table(h);
err = mnl_nft_table_batch_del(nlt, 0, ctx->seqnum);
- nft_table_free(nlt);
+ nftnl_table_free(nlt);
if (err < 0)
netlink_io_error(ctx, loc, "Could not flush the ruleset: %s",
return err;
}
-struct nft_ruleset *netlink_dump_ruleset(struct netlink_ctx *ctx,
+struct nftnl_ruleset *netlink_dump_ruleset(struct netlink_ctx *ctx,
const struct handle *h,
const struct location *loc)
{
- struct nft_ruleset *rs;
+ struct nftnl_ruleset *rs;
rs = mnl_nft_ruleset_dump(nf_sock, h->family);
if (rs == NULL) {
return rs;
}
-static struct nft_table *netlink_table_alloc(const struct nlmsghdr *nlh)
+static struct nftnl_table *netlink_table_alloc(const struct nlmsghdr *nlh)
{
- struct nft_table *nlt;
+ struct nftnl_table *nlt;
- nlt = nft_table_alloc();
+ nlt = nftnl_table_alloc();
if (nlt == NULL)
memory_allocation_error();
- if (nft_table_nlmsg_parse(nlh, nlt) < 0)
+ if (nftnl_table_nlmsg_parse(nlh, nlt) < 0)
netlink_abi_error();
return nlt;
}
-static struct nft_chain *netlink_chain_alloc(const struct nlmsghdr *nlh)
+static struct nftnl_chain *netlink_chain_alloc(const struct nlmsghdr *nlh)
{
- struct nft_chain *nlc;
+ struct nftnl_chain *nlc;
- nlc = nft_chain_alloc();
+ nlc = nftnl_chain_alloc();
if (nlc == NULL)
memory_allocation_error();
- if (nft_chain_nlmsg_parse(nlh, nlc) < 0)
+ if (nftnl_chain_nlmsg_parse(nlh, nlc) < 0)
netlink_abi_error();
return nlc;
}
-static struct nft_set *netlink_set_alloc(const struct nlmsghdr *nlh)
+static struct nftnl_set *netlink_set_alloc(const struct nlmsghdr *nlh)
{
- struct nft_set *nls;
+ struct nftnl_set *nls;
- nls = nft_set_alloc();
+ nls = nftnl_set_alloc();
if (nls == NULL)
memory_allocation_error();
- if (nft_set_nlmsg_parse(nlh, nls) < 0)
+ if (nftnl_set_nlmsg_parse(nlh, nls) < 0)
netlink_abi_error();
return nls;
}
-static struct nft_set *netlink_setelem_alloc(const struct nlmsghdr *nlh)
+static struct nftnl_set *netlink_setelem_alloc(const struct nlmsghdr *nlh)
{
- struct nft_set *nls;
+ struct nftnl_set *nls;
- nls = nft_set_alloc();
+ nls = nftnl_set_alloc();
if (nls == NULL)
memory_allocation_error();
- if (nft_set_elems_nlmsg_parse(nlh, nls) < 0)
+ if (nftnl_set_elems_nlmsg_parse(nlh, nls) < 0)
netlink_abi_error();
return nls;
}
-static struct nft_rule *netlink_rule_alloc(const struct nlmsghdr *nlh)
+static struct nftnl_rule *netlink_rule_alloc(const struct nlmsghdr *nlh)
{
- struct nft_rule *nlr;
+ struct nftnl_rule *nlr;
- nlr = nft_rule_alloc();
+ nlr = nftnl_rule_alloc();
if (nlr == NULL)
memory_allocation_error();
- if (nft_rule_nlmsg_parse(nlh, nlr) < 0)
+ if (nftnl_rule_nlmsg_parse(nlh, nlr) < 0)
netlink_abi_error();
return nlr;
case NFT_MSG_NEWSET:
case NFT_MSG_NEWSETELEM:
case NFT_MSG_NEWRULE:
- return NFT_OF_EVENT_NEW;
+ return NFTNL_OF_EVENT_NEW;
case NFT_MSG_DELTABLE:
case NFT_MSG_DELCHAIN:
case NFT_MSG_DELSET:
case NFT_MSG_DELSETELEM:
case NFT_MSG_DELRULE:
- return NFT_OF_EVENT_DEL;
+ return NFTNL_OF_EVENT_DEL;
}
return 0;
}
-static void nlr_for_each_set(struct nft_rule *nlr,
+static void nlr_for_each_set(struct nftnl_rule *nlr,
void (*cb)(struct set *s, void *data),
void *data)
{
- struct nft_rule_expr_iter *nlrei;
- struct nft_rule_expr *nlre;
+ struct nftnl_expr_iter *nlrei;
+ struct nftnl_expr *nlre;
const char *set_name, *table;
const char *name;
struct set *s;
uint32_t family;
- nlrei = nft_rule_expr_iter_create(nlr);
+ nlrei = nftnl_expr_iter_create(nlr);
if (nlrei == NULL)
memory_allocation_error();
- family = nft_rule_attr_get_u32(nlr, NFT_RULE_ATTR_FAMILY);
- table = nft_rule_attr_get_str(nlr, NFT_RULE_ATTR_TABLE);
+ family = nftnl_rule_get_u32(nlr, NFTNL_RULE_FAMILY);
+ table = nftnl_rule_get_str(nlr, NFTNL_RULE_TABLE);
- nlre = nft_rule_expr_iter_next(nlrei);
+ nlre = nftnl_expr_iter_next(nlrei);
while (nlre != NULL) {
- name = nft_rule_expr_get_str(nlre, NFT_RULE_EXPR_ATTR_NAME);
+ name = nftnl_expr_get_str(nlre, NFTNL_EXPR_NAME);
if (strcmp(name, "lookup") != 0)
goto next;
- set_name = nft_rule_expr_get_str(nlre, NFT_EXPR_LOOKUP_SET);
+ set_name = nftnl_expr_get_str(nlre, NFTNL_EXPR_LOOKUP_SET);
s = set_lookup_global(family, table, set_name);
if (s == NULL)
goto next;
cb(s, data);
next:
- nlre = nft_rule_expr_iter_next(nlrei);
+ nlre = nftnl_expr_iter_next(nlrei);
}
- nft_rule_expr_iter_destroy(nlrei);
+ nftnl_expr_iter_destroy(nlrei);
}
static int netlink_events_table_cb(const struct nlmsghdr *nlh, int type,
struct netlink_mon_handler *monh)
{
- struct nft_table *nlt;
+ struct nftnl_table *nlt;
uint32_t family;
nlt = netlink_table_alloc(nlh);
switch (monh->format) {
- case NFT_OUTPUT_DEFAULT:
+ case NFTNL_OUTPUT_DEFAULT:
if (type == NFT_MSG_NEWTABLE) {
if (nlh->nlmsg_flags & NLM_F_EXCL)
printf("update table ");
printf("delete table ");
}
- family = nft_table_attr_get_u32(nlt, NFT_TABLE_ATTR_FAMILY);
+ family = nftnl_table_get_u32(nlt, NFTNL_TABLE_FAMILY);
printf("%s %s\n", family2str(family),
- nft_table_attr_get_str(nlt, NFT_TABLE_ATTR_NAME));
+ nftnl_table_get_str(nlt, NFTNL_TABLE_NAME));
break;
- case NFT_OUTPUT_XML:
- case NFT_OUTPUT_JSON:
- nft_table_fprintf(stdout, nlt, monh->format,
+ case NFTNL_OUTPUT_XML:
+ case NFTNL_OUTPUT_JSON:
+ nftnl_table_fprintf(stdout, nlt, monh->format,
netlink_msg2nftnl_of(type));
fprintf(stdout, "\n");
break;
}
- nft_table_free(nlt);
+ nftnl_table_free(nlt);
return MNL_CB_OK;
}
static int netlink_events_chain_cb(const struct nlmsghdr *nlh, int type,
struct netlink_mon_handler *monh)
{
- struct nft_chain *nlc;
+ struct nftnl_chain *nlc;
struct chain *c;
uint32_t family;
nlc = netlink_chain_alloc(nlh);
switch (monh->format) {
- case NFT_OUTPUT_DEFAULT:
+ case NFTNL_OUTPUT_DEFAULT:
switch (type) {
case NFT_MSG_NEWCHAIN:
if (nlh->nlmsg_flags & NLM_F_EXCL)
chain_free(c);
break;
case NFT_MSG_DELCHAIN:
- family = nft_chain_attr_get_u32(nlc,
- NFT_CHAIN_ATTR_FAMILY);
+ family = nftnl_chain_get_u32(nlc,
+ NFTNL_CHAIN_FAMILY);
printf("delete chain %s %s %s\n", family2str(family),
- nft_chain_attr_get_str(nlc,
- NFT_CHAIN_ATTR_TABLE),
- nft_chain_attr_get_str(nlc,
- NFT_CHAIN_ATTR_NAME));
+ nftnl_chain_get_str(nlc,
+ NFTNL_CHAIN_TABLE),
+ nftnl_chain_get_str(nlc,
+ NFTNL_CHAIN_NAME));
break;
}
break;
- case NFT_OUTPUT_XML:
- case NFT_OUTPUT_JSON:
- nft_chain_fprintf(stdout, nlc, monh->format,
+ case NFTNL_OUTPUT_XML:
+ case NFTNL_OUTPUT_JSON:
+ nftnl_chain_fprintf(stdout, nlc, monh->format,
netlink_msg2nftnl_of(type));
fprintf(stdout, "\n");
break;
}
- nft_chain_free(nlc);
+ nftnl_chain_free(nlc);
return MNL_CB_OK;
}
static int netlink_events_set_cb(const struct nlmsghdr *nlh, int type,
struct netlink_mon_handler *monh)
{
- struct nft_set *nls;
+ struct nftnl_set *nls;
struct set *set;
uint32_t family, flags;
nls = netlink_set_alloc(nlh);
- flags = nft_set_attr_get_u32(nls, NFT_SET_ATTR_FLAGS);
+ flags = nftnl_set_get_u32(nls, NFTNL_SET_FLAGS);
if (flags & SET_F_ANONYMOUS)
goto out;
switch (monh->format) {
- case NFT_OUTPUT_DEFAULT:
+ case NFTNL_OUTPUT_DEFAULT:
switch (type) {
case NFT_MSG_NEWSET:
printf("add ");
set = netlink_delinearize_set(monh->ctx, nls);
if (set == NULL) {
- nft_set_free(nls);
+ nftnl_set_free(nls);
return MNL_CB_ERROR;
}
set_print_plain(set);
printf("\n");
break;
case NFT_MSG_DELSET:
- family = nft_set_attr_get_u32(nls,
- NFT_SET_ATTR_FAMILY);
+ family = nftnl_set_get_u32(nls,
+ NFTNL_SET_FAMILY);
printf("delete set %s %s %s\n",
family2str(family),
- nft_set_attr_get_str(nls, NFT_SET_ATTR_TABLE),
- nft_set_attr_get_str(nls, NFT_SET_ATTR_NAME));
+ nftnl_set_get_str(nls, NFTNL_SET_TABLE),
+ nftnl_set_get_str(nls, NFTNL_SET_NAME));
break;
}
break;
- case NFT_OUTPUT_XML:
- case NFT_OUTPUT_JSON:
- nft_set_fprintf(stdout, nls, monh->format,
+ case NFTNL_OUTPUT_XML:
+ case NFTNL_OUTPUT_JSON:
+ nftnl_set_fprintf(stdout, nls, monh->format,
netlink_msg2nftnl_of(type));
fprintf(stdout, "\n");
break;
}
out:
- nft_set_free(nls);
+ nftnl_set_free(nls);
return MNL_CB_OK;
}
static int netlink_events_setelem_cb(const struct nlmsghdr *nlh, int type,
struct netlink_mon_handler *monh)
{
- struct nft_set_elems_iter *nlsei;
- struct nft_set_elem *nlse;
- struct nft_set *nls;
+ struct nftnl_set_elems_iter *nlsei;
+ struct nftnl_set_elem *nlse;
+ struct nftnl_set *nls;
struct set *dummyset;
struct set *set;
const char *setname, *table;
uint32_t family;
nls = netlink_setelem_alloc(nlh);
- table = nft_set_attr_get_str(nls, NFT_SET_ATTR_TABLE);
- setname = nft_set_attr_get_str(nls, NFT_SET_ATTR_NAME);
- family = nft_set_attr_get_u32(nls, NFT_SET_ATTR_FAMILY);
+ table = nftnl_set_get_str(nls, NFTNL_SET_TABLE);
+ setname = nftnl_set_get_str(nls, NFTNL_SET_NAME);
+ family = nftnl_set_get_u32(nls, NFTNL_SET_FAMILY);
set = set_lookup_global(family, table, setname);
if (set == NULL) {
}
switch (monh->format) {
- case NFT_OUTPUT_DEFAULT:
+ case NFTNL_OUTPUT_DEFAULT:
if (set->flags & SET_F_ANONYMOUS)
goto out;
dummyset->datatype = set->datatype;
dummyset->init = set_expr_alloc(monh->loc);
- nlsei = nft_set_elems_iter_create(nls);
+ nlsei = nftnl_set_elems_iter_create(nls);
if (nlsei == NULL)
memory_allocation_error();
- nlse = nft_set_elems_iter_next(nlsei);
+ nlse = nftnl_set_elems_iter_next(nlsei);
while (nlse != NULL) {
if (netlink_delinearize_setelem(nlse, dummyset) < 0) {
set_free(dummyset);
- nft_set_elems_iter_destroy(nlsei);
+ nftnl_set_elems_iter_destroy(nlsei);
goto out;
}
- nlse = nft_set_elems_iter_next(nlsei);
+ nlse = nftnl_set_elems_iter_next(nlsei);
}
- nft_set_elems_iter_destroy(nlsei);
+ nftnl_set_elems_iter_destroy(nlsei);
switch (type) {
case NFT_MSG_NEWSETELEM:
set_free(dummyset);
break;
- case NFT_OUTPUT_XML:
- case NFT_OUTPUT_JSON:
- nft_set_fprintf(stdout, nls, monh->format,
+ case NFTNL_OUTPUT_XML:
+ case NFTNL_OUTPUT_JSON:
+ nftnl_set_fprintf(stdout, nls, monh->format,
netlink_msg2nftnl_of(type));
fprintf(stdout, "\n");
break;
}
out:
- nft_set_free(nls);
+ nftnl_set_free(nls);
return MNL_CB_OK;
}
static int netlink_events_rule_cb(const struct nlmsghdr *nlh, int type,
struct netlink_mon_handler *monh)
{
- struct nft_rule *nlr;
+ struct nftnl_rule *nlr;
const char *family;
const char *table;
const char *chain;
nlr = netlink_rule_alloc(nlh);
switch (monh->format) {
- case NFT_OUTPUT_DEFAULT:
- fam = nft_rule_attr_get_u32(nlr, NFT_RULE_ATTR_FAMILY);
+ case NFTNL_OUTPUT_DEFAULT:
+ fam = nftnl_rule_get_u32(nlr, NFTNL_RULE_FAMILY);
family = family2str(fam);
- table = nft_rule_attr_get_str(nlr, NFT_RULE_ATTR_TABLE);
- chain = nft_rule_attr_get_str(nlr, NFT_RULE_ATTR_CHAIN);
- handle = nft_rule_attr_get_u64(nlr, NFT_RULE_ATTR_HANDLE);
+ table = nftnl_rule_get_str(nlr, NFTNL_RULE_TABLE);
+ chain = nftnl_rule_get_str(nlr, NFTNL_RULE_CHAIN);
+ handle = nftnl_rule_get_u64(nlr, NFTNL_RULE_HANDLE);
switch (type) {
case NFT_MSG_NEWRULE:
break;
}
break;
- case NFT_OUTPUT_XML:
- case NFT_OUTPUT_JSON:
- nft_rule_fprintf(stdout, nlr, monh->format,
+ case NFTNL_OUTPUT_XML:
+ case NFTNL_OUTPUT_JSON:
+ nftnl_rule_fprintf(stdout, nlr, monh->format,
netlink_msg2nftnl_of(type));
fprintf(stdout, "\n");
break;
}
- nft_rule_free(nlr);
+ nftnl_rule_free(nlr);
return MNL_CB_OK;
}
static void netlink_events_cache_addtable(struct netlink_mon_handler *monh,
const struct nlmsghdr *nlh)
{
- struct nft_table *nlt;
+ struct nftnl_table *nlt;
struct table *t;
nlt = netlink_table_alloc(nlh);
t = netlink_delinearize_table(monh->ctx, nlt);
- nft_table_free(nlt);
+ nftnl_table_free(nlt);
table_add_hash(t);
}
static void netlink_events_cache_deltable(struct netlink_mon_handler *monh,
const struct nlmsghdr *nlh)
{
- struct nft_table *nlt;
+ struct nftnl_table *nlt;
struct table *t;
struct handle h;
nlt = netlink_table_alloc(nlh);
- h.family = nft_table_attr_get_u32(nlt, NFT_TABLE_ATTR_FAMILY);
- h.table = nft_table_attr_get_str(nlt, NFT_TABLE_ATTR_NAME);
+ h.family = nftnl_table_get_u32(nlt, NFTNL_TABLE_FAMILY);
+ h.table = nftnl_table_get_str(nlt, NFTNL_TABLE_NAME);
t = table_lookup(&h);
if (t == NULL)
list_del(&t->list);
table_free(t);
out:
- nft_table_free(nlt);
+ nftnl_table_free(nlt);
}
static void netlink_events_cache_addset(struct netlink_mon_handler *monh,
const struct nlmsghdr *nlh)
{
struct netlink_ctx set_tmpctx;
- struct nft_set *nls;
+ struct nftnl_set *nls;
struct table *t;
struct set *s;
LIST_HEAD(msgs);
set_add_hash(s, t);
out:
- nft_set_free(nls);
+ nftnl_set_free(nls);
}
static void netlink_events_cache_addsetelem(struct netlink_mon_handler *monh,
const struct nlmsghdr *nlh)
{
- struct nft_set_elems_iter *nlsei;
- struct nft_set_elem *nlse;
- struct nft_set *nls;
+ struct nftnl_set_elems_iter *nlsei;
+ struct nftnl_set_elem *nlse;
+ struct nftnl_set *nls;
struct set *set;
const char *table, *setname;
uint32_t family;
nls = netlink_setelem_alloc(nlh);
- family = nft_set_attr_get_u32(nls, NFT_SET_ATTR_FAMILY);
- table = nft_set_attr_get_str(nls, NFT_SET_ATTR_TABLE);
- setname = nft_set_attr_get_str(nls, NFT_SET_ATTR_NAME);
+ family = nftnl_set_get_u32(nls, NFTNL_SET_FAMILY);
+ table = nftnl_set_get_str(nls, NFTNL_SET_TABLE);
+ setname = nftnl_set_get_str(nls, NFTNL_SET_NAME);
set = set_lookup_global(family, table, setname);
if (set == NULL) {
goto out;
}
- nlsei = nft_set_elems_iter_create(nls);
+ nlsei = nftnl_set_elems_iter_create(nls);
if (nlsei == NULL)
memory_allocation_error();
- nlse = nft_set_elems_iter_next(nlsei);
+ nlse = nftnl_set_elems_iter_next(nlsei);
while (nlse != NULL) {
if (netlink_delinearize_setelem(nlse, set) < 0) {
fprintf(stderr,
"W: Unable to cache set_elem. "
"Delinearize failed.\n");
- nft_set_elems_iter_destroy(nlsei);
+ nftnl_set_elems_iter_destroy(nlsei);
goto out;
}
- nlse = nft_set_elems_iter_next(nlsei);
+ nlse = nftnl_set_elems_iter_next(nlsei);
}
- nft_set_elems_iter_destroy(nlsei);
+ nftnl_set_elems_iter_destroy(nlsei);
out:
- nft_set_free(nls);
+ nftnl_set_free(nls);
}
static void netlink_events_cache_delset_cb(struct set *s,
static void netlink_events_cache_delsets(struct netlink_mon_handler *monh,
const struct nlmsghdr *nlh)
{
- struct nft_rule *nlr = netlink_rule_alloc(nlh);
+ struct nftnl_rule *nlr = netlink_rule_alloc(nlh);
nlr_for_each_set(nlr, netlink_events_cache_delset_cb, NULL);
- nft_rule_free(nlr);
+ nftnl_rule_free(nlr);
}
static void netlink_events_cache_update(struct netlink_mon_handler *monh,
erec_queue(erec, ctx->msgs);
}
-static unsigned int netlink_parse_register(const struct nft_rule_expr *nle,
+static unsigned int netlink_parse_register(const struct nftnl_expr *nle,
unsigned int attr)
{
unsigned int reg;
- reg = nft_rule_expr_get_u32(nle, attr);
+ reg = nftnl_expr_get_u32(nle, attr);
/* Translate 128bit registers to corresponding 32bit registers */
if (reg >= NFT_REG_1 && reg <= NFT_REG_4)
reg = 1 + (reg - NFT_REG_1) * (NFT_REG_SIZE / NFT_REG32_SIZE);
static void netlink_parse_immediate(struct netlink_parse_ctx *ctx,
const struct location *loc,
- const struct nft_rule_expr *nle)
+ const struct nftnl_expr *nle)
{
struct nft_data_delinearize nld;
enum nft_registers dreg;
struct stmt *stmt;
struct expr *expr;
- if (nft_rule_expr_is_set(nle, NFT_EXPR_IMM_VERDICT)) {
- nld.verdict = nft_rule_expr_get_u32(nle, NFT_EXPR_IMM_VERDICT);
- if (nft_rule_expr_is_set(nle, NFT_EXPR_IMM_CHAIN)) {
- nld.chain = nft_rule_expr_get(nle, NFT_EXPR_IMM_CHAIN,
+ if (nftnl_expr_is_set(nle, NFTNL_EXPR_IMM_VERDICT)) {
+ nld.verdict = nftnl_expr_get_u32(nle, NFTNL_EXPR_IMM_VERDICT);
+ if (nftnl_expr_is_set(nle, NFTNL_EXPR_IMM_CHAIN)) {
+ nld.chain = nftnl_expr_get(nle, NFTNL_EXPR_IMM_CHAIN,
&nld.len);
}
- } else if (nft_rule_expr_is_set(nle, NFT_EXPR_IMM_DATA)) {
- nld.value = nft_rule_expr_get(nle, NFT_EXPR_IMM_DATA, &nld.len);
+ } else if (nftnl_expr_is_set(nle, NFTNL_EXPR_IMM_DATA)) {
+ nld.value = nftnl_expr_get(nle, NFTNL_EXPR_IMM_DATA, &nld.len);
}
- dreg = netlink_parse_register(nle, NFT_EXPR_IMM_DREG);
+ dreg = netlink_parse_register(nle, NFTNL_EXPR_IMM_DREG);
expr = netlink_alloc_data(loc, &nld, dreg);
if (dreg == NFT_REG_VERDICT) {
netlink_set_register(ctx, dreg, expr);
}
-static enum ops netlink_parse_cmp_op(const struct nft_rule_expr *nle)
+static enum ops netlink_parse_cmp_op(const struct nftnl_expr *nle)
{
- switch (nft_rule_expr_get_u32(nle, NFT_EXPR_CMP_OP)) {
+ switch (nftnl_expr_get_u32(nle, NFTNL_EXPR_CMP_OP)) {
case NFT_CMP_EQ:
return OP_EQ;
case NFT_CMP_NEQ:
static void netlink_parse_cmp(struct netlink_parse_ctx *ctx,
const struct location *loc,
- const struct nft_rule_expr *nle)
+ const struct nftnl_expr *nle)
{
struct nft_data_delinearize nld;
enum nft_registers sreg;
struct stmt *stmt;
enum ops op;
- sreg = netlink_parse_register(nle, NFT_EXPR_CMP_SREG);
+ sreg = netlink_parse_register(nle, NFTNL_EXPR_CMP_SREG);
left = netlink_get_register(ctx, loc, sreg);
if (left == NULL)
return netlink_error(ctx, loc,
op = netlink_parse_cmp_op(nle);
- nld.value = nft_rule_expr_get(nle, NFT_EXPR_CMP_DATA, &nld.len);
+ nld.value = nftnl_expr_get(nle, NFTNL_EXPR_CMP_DATA, &nld.len);
right = netlink_alloc_value(loc, &nld);
if (left->len != right->len) {
static void netlink_parse_lookup(struct netlink_parse_ctx *ctx,
const struct location *loc,
- const struct nft_rule_expr *nle)
+ const struct nftnl_expr *nle)
{
enum nft_registers sreg, dreg;
const char *name;
struct expr *expr, *left, *right;
struct set *set;
- name = nft_rule_expr_get_str(nle, NFT_EXPR_LOOKUP_SET);
+ name = nftnl_expr_get_str(nle, NFTNL_EXPR_LOOKUP_SET);
set = set_lookup(ctx->table, name);
if (set == NULL)
return netlink_error(ctx, loc,
"Unknown set '%s' in lookup expression",
name);
- sreg = netlink_parse_register(nle, NFT_EXPR_LOOKUP_SREG);
+ sreg = netlink_parse_register(nle, NFTNL_EXPR_LOOKUP_SREG);
left = netlink_get_register(ctx, loc, sreg);
if (left == NULL)
return netlink_error(ctx, loc,
right = set_ref_expr_alloc(loc, set);
- if (nft_rule_expr_is_set(nle, NFT_EXPR_LOOKUP_DREG)) {
- dreg = netlink_parse_register(nle, NFT_EXPR_LOOKUP_DREG);
+ if (nftnl_expr_is_set(nle, NFTNL_EXPR_LOOKUP_DREG)) {
+ dreg = netlink_parse_register(nle, NFTNL_EXPR_LOOKUP_DREG);
expr = map_expr_alloc(loc, left, right);
if (dreg != NFT_REG_VERDICT)
return netlink_set_register(ctx, dreg, expr);
static void netlink_parse_bitwise(struct netlink_parse_ctx *ctx,
const struct location *loc,
- const struct nft_rule_expr *nle)
+ const struct nftnl_expr *nle)
{
struct nft_data_delinearize nld;
enum nft_registers sreg, dreg;
struct expr *expr, *left, *mask, *xor, *or;
mpz_t m, x, o;
- sreg = netlink_parse_register(nle, NFT_EXPR_BITWISE_SREG);
+ sreg = netlink_parse_register(nle, NFTNL_EXPR_BITWISE_SREG);
left = netlink_get_register(ctx, loc, sreg);
if (left == NULL)
return netlink_error(ctx, loc,
expr = left;
- nld.value = nft_rule_expr_get(nle, NFT_EXPR_BITWISE_MASK, &nld.len);
+ nld.value = nftnl_expr_get(nle, NFTNL_EXPR_BITWISE_MASK, &nld.len);
mask = netlink_alloc_value(loc, &nld);
mpz_init_set(m, mask->value);
- nld.value = nft_rule_expr_get(nle, NFT_EXPR_BITWISE_XOR, &nld.len);
+ nld.value = nftnl_expr_get(nle, NFTNL_EXPR_BITWISE_XOR, &nld.len);
xor = netlink_alloc_value(loc, &nld);
mpz_init_set(x, xor->value);
expr_free(xor);
if (mpz_cmp_ui(o, 0)) {
- nld.value = nft_rule_expr_get(nle, NFT_EXPR_BITWISE_XOR,
+ nld.value = nftnl_expr_get(nle, NFTNL_EXPR_BITWISE_XOR,
&nld.len);
or = netlink_alloc_value(loc, &nld);
mpz_clear(x);
mpz_clear(o);
- dreg = netlink_parse_register(nle, NFT_EXPR_BITWISE_DREG);
+ dreg = netlink_parse_register(nle, NFTNL_EXPR_BITWISE_DREG);
netlink_set_register(ctx, dreg, expr);
}
static void netlink_parse_byteorder(struct netlink_parse_ctx *ctx,
const struct location *loc,
- const struct nft_rule_expr *nle)
+ const struct nftnl_expr *nle)
{
enum nft_registers sreg, dreg;
struct expr *expr, *arg;
enum ops op;
- sreg = netlink_parse_register(nle, NFT_EXPR_BYTEORDER_SREG);
+ sreg = netlink_parse_register(nle, NFTNL_EXPR_BYTEORDER_SREG);
arg = netlink_get_register(ctx, loc, sreg);
if (arg == NULL)
return netlink_error(ctx, loc,
"Byteorder expression has no left "
"hand side");
- switch (nft_rule_expr_get_u32(nle, NFT_EXPR_BYTEORDER_OP)) {
+ switch (nftnl_expr_get_u32(nle, NFTNL_EXPR_BYTEORDER_OP)) {
case NFT_BYTEORDER_NTOH:
op = OP_NTOH;
break;
break;
default:
BUG("invalid byteorder operation %u\n",
- nft_rule_expr_get_u32(nle, NFT_EXPR_BYTEORDER_OP));
+ nftnl_expr_get_u32(nle, NFTNL_EXPR_BYTEORDER_OP));
}
expr = unary_expr_alloc(loc, op, arg);
expr->len = arg->len;
- dreg = netlink_parse_register(nle, NFT_EXPR_BYTEORDER_DREG);
+ dreg = netlink_parse_register(nle, NFTNL_EXPR_BYTEORDER_DREG);
netlink_set_register(ctx, dreg, expr);
}
static void netlink_parse_payload(struct netlink_parse_ctx *ctx,
const struct location *loc,
- const struct nft_rule_expr *nle)
+ const struct nftnl_expr *nle)
{
enum nft_registers dreg;
uint32_t base, offset, len;
struct expr *expr;
- base = nft_rule_expr_get_u32(nle, NFT_EXPR_PAYLOAD_BASE) + 1;
- offset = nft_rule_expr_get_u32(nle, NFT_EXPR_PAYLOAD_OFFSET) * BITS_PER_BYTE;
- len = nft_rule_expr_get_u32(nle, NFT_EXPR_PAYLOAD_LEN) * BITS_PER_BYTE;
+ base = nftnl_expr_get_u32(nle, NFTNL_EXPR_PAYLOAD_BASE) + 1;
+ offset = nftnl_expr_get_u32(nle, NFTNL_EXPR_PAYLOAD_OFFSET) * BITS_PER_BYTE;
+ len = nftnl_expr_get_u32(nle, NFTNL_EXPR_PAYLOAD_LEN) * BITS_PER_BYTE;
expr = payload_expr_alloc(loc, NULL, 0);
payload_init_raw(expr, base, offset, len);
- dreg = netlink_parse_register(nle, NFT_EXPR_PAYLOAD_DREG);
+ dreg = netlink_parse_register(nle, NFTNL_EXPR_PAYLOAD_DREG);
netlink_set_register(ctx, dreg, expr);
}
static void netlink_parse_exthdr(struct netlink_parse_ctx *ctx,
const struct location *loc,
- const struct nft_rule_expr *nle)
+ const struct nftnl_expr *nle)
{
enum nft_registers dreg;
uint32_t offset, len;
uint8_t type;
struct expr *expr;
- type = nft_rule_expr_get_u8(nle, NFT_EXPR_EXTHDR_TYPE);
- offset = nft_rule_expr_get_u32(nle, NFT_EXPR_EXTHDR_OFFSET) * BITS_PER_BYTE;
- len = nft_rule_expr_get_u32(nle, NFT_EXPR_EXTHDR_LEN) * BITS_PER_BYTE;
+ type = nftnl_expr_get_u8(nle, NFTNL_EXPR_EXTHDR_TYPE);
+ offset = nftnl_expr_get_u32(nle, NFTNL_EXPR_EXTHDR_OFFSET) * BITS_PER_BYTE;
+ len = nftnl_expr_get_u32(nle, NFTNL_EXPR_EXTHDR_LEN) * BITS_PER_BYTE;
expr = exthdr_expr_alloc(loc, NULL, 0);
exthdr_init_raw(expr, type, offset, len);
- dreg = netlink_parse_register(nle, NFT_EXPR_EXTHDR_DREG);
+ dreg = netlink_parse_register(nle, NFTNL_EXPR_EXTHDR_DREG);
netlink_set_register(ctx, dreg, expr);
}
static void netlink_parse_meta_expr(struct netlink_parse_ctx *ctx,
const struct location *loc,
- const struct nft_rule_expr *nle)
+ const struct nftnl_expr *nle)
{
enum nft_registers dreg;
uint32_t key;
struct expr *expr;
- key = nft_rule_expr_get_u32(nle, NFT_EXPR_META_KEY);
+ key = nftnl_expr_get_u32(nle, NFTNL_EXPR_META_KEY);
expr = meta_expr_alloc(loc, key);
- dreg = netlink_parse_register(nle, NFT_EXPR_META_DREG);
+ dreg = netlink_parse_register(nle, NFTNL_EXPR_META_DREG);
netlink_set_register(ctx, dreg, expr);
}
static void netlink_parse_meta_stmt(struct netlink_parse_ctx *ctx,
const struct location *loc,
- const struct nft_rule_expr *nle)
+ const struct nftnl_expr *nle)
{
enum nft_registers sreg;
uint32_t key;
struct stmt *stmt;
struct expr *expr;
- sreg = netlink_parse_register(nle, NFT_EXPR_META_SREG);
+ sreg = netlink_parse_register(nle, NFTNL_EXPR_META_SREG);
expr = netlink_get_register(ctx, loc, sreg);
- key = nft_rule_expr_get_u32(nle, NFT_EXPR_META_KEY);
+ key = nftnl_expr_get_u32(nle, NFTNL_EXPR_META_KEY);
stmt = meta_stmt_alloc(loc, key, expr);
expr_set_type(expr, stmt->meta.tmpl->dtype, stmt->meta.tmpl->byteorder);
static void netlink_parse_meta(struct netlink_parse_ctx *ctx,
const struct location *loc,
- const struct nft_rule_expr *nle)
+ const struct nftnl_expr *nle)
{
- if (nft_rule_expr_is_set(nle, NFT_EXPR_META_DREG))
+ if (nftnl_expr_is_set(nle, NFTNL_EXPR_META_DREG))
netlink_parse_meta_expr(ctx, loc, nle);
else
netlink_parse_meta_stmt(ctx, loc, nle);
static void netlink_parse_ct_stmt(struct netlink_parse_ctx *ctx,
const struct location *loc,
- const struct nft_rule_expr *nle)
+ const struct nftnl_expr *nle)
{
enum nft_registers sreg;
uint32_t key;
struct stmt *stmt;
struct expr *expr;
- sreg = netlink_parse_register(nle, NFT_EXPR_CT_SREG);
+ sreg = netlink_parse_register(nle, NFTNL_EXPR_CT_SREG);
expr = netlink_get_register(ctx, loc, sreg);
- key = nft_rule_expr_get_u32(nle, NFT_EXPR_CT_KEY);
+ key = nftnl_expr_get_u32(nle, NFTNL_EXPR_CT_KEY);
stmt = ct_stmt_alloc(loc, key, expr);
expr_set_type(expr, stmt->ct.tmpl->dtype, stmt->ct.tmpl->byteorder);
static void netlink_parse_ct_expr(struct netlink_parse_ctx *ctx,
const struct location *loc,
- const struct nft_rule_expr *nle)
+ const struct nftnl_expr *nle)
{
enum nft_registers dreg;
uint32_t key;
struct expr *expr;
- key = nft_rule_expr_get_u32(nle, NFT_EXPR_CT_KEY);
+ key = nftnl_expr_get_u32(nle, NFTNL_EXPR_CT_KEY);
expr = ct_expr_alloc(loc, key);
- dreg = netlink_parse_register(nle, NFT_EXPR_CT_DREG);
+ dreg = netlink_parse_register(nle, NFTNL_EXPR_CT_DREG);
netlink_set_register(ctx, dreg, expr);
}
static void netlink_parse_ct(struct netlink_parse_ctx *ctx,
const struct location *loc,
- const struct nft_rule_expr *nle)
+ const struct nftnl_expr *nle)
{
- if (nft_rule_expr_is_set(nle, NFT_EXPR_CT_DREG))
+ if (nftnl_expr_is_set(nle, NFTNL_EXPR_CT_DREG))
netlink_parse_ct_expr(ctx, loc, nle);
else
netlink_parse_ct_stmt(ctx, loc, nle);
static void netlink_parse_counter(struct netlink_parse_ctx *ctx,
const struct location *loc,
- const struct nft_rule_expr *nle)
+ const struct nftnl_expr *nle)
{
struct stmt *stmt;
stmt = counter_stmt_alloc(loc);
stmt->counter.packets =
- nft_rule_expr_get_u64(nle, NFT_EXPR_CTR_PACKETS);
+ nftnl_expr_get_u64(nle, NFTNL_EXPR_CTR_PACKETS);
stmt->counter.bytes =
- nft_rule_expr_get_u64(nle, NFT_EXPR_CTR_BYTES);
+ nftnl_expr_get_u64(nle, NFTNL_EXPR_CTR_BYTES);
list_add_tail(&stmt->list, &ctx->rule->stmts);
}
static void netlink_parse_log(struct netlink_parse_ctx *ctx,
const struct location *loc,
- const struct nft_rule_expr *nle)
+ const struct nftnl_expr *nle)
{
struct stmt *stmt;
const char *prefix;
stmt = log_stmt_alloc(loc);
- prefix = nft_rule_expr_get_str(nle, NFT_EXPR_LOG_PREFIX);
- if (nft_rule_expr_is_set(nle, NFT_EXPR_LOG_PREFIX)) {
+ prefix = nftnl_expr_get_str(nle, NFTNL_EXPR_LOG_PREFIX);
+ if (nftnl_expr_is_set(nle, NFTNL_EXPR_LOG_PREFIX)) {
stmt->log.prefix = xstrdup(prefix);
stmt->log.flags |= STMT_LOG_PREFIX;
}
- if (nft_rule_expr_is_set(nle, NFT_EXPR_LOG_GROUP)) {
+ if (nftnl_expr_is_set(nle, NFTNL_EXPR_LOG_GROUP)) {
stmt->log.group =
- nft_rule_expr_get_u16(nle, NFT_EXPR_LOG_GROUP);
+ nftnl_expr_get_u16(nle, NFTNL_EXPR_LOG_GROUP);
stmt->log.flags |= STMT_LOG_GROUP;
}
- if (nft_rule_expr_is_set(nle, NFT_EXPR_LOG_SNAPLEN)) {
+ if (nftnl_expr_is_set(nle, NFTNL_EXPR_LOG_SNAPLEN)) {
stmt->log.snaplen =
- nft_rule_expr_get_u32(nle, NFT_EXPR_LOG_SNAPLEN);
+ nftnl_expr_get_u32(nle, NFTNL_EXPR_LOG_SNAPLEN);
stmt->log.flags |= STMT_LOG_SNAPLEN;
}
- if (nft_rule_expr_is_set(nle, NFT_EXPR_LOG_QTHRESHOLD)) {
+ if (nftnl_expr_is_set(nle, NFTNL_EXPR_LOG_QTHRESHOLD)) {
stmt->log.qthreshold =
- nft_rule_expr_get_u16(nle, NFT_EXPR_LOG_QTHRESHOLD);
+ nftnl_expr_get_u16(nle, NFTNL_EXPR_LOG_QTHRESHOLD);
stmt->log.flags |= STMT_LOG_QTHRESHOLD;
}
- if (nft_rule_expr_is_set(nle, NFT_EXPR_LOG_LEVEL)) {
+ if (nftnl_expr_is_set(nle, NFTNL_EXPR_LOG_LEVEL)) {
stmt->log.level =
- nft_rule_expr_get_u32(nle, NFT_EXPR_LOG_LEVEL);
+ nftnl_expr_get_u32(nle, NFTNL_EXPR_LOG_LEVEL);
stmt->log.flags |= STMT_LOG_LEVEL;
}
list_add_tail(&stmt->list, &ctx->rule->stmts);
static void netlink_parse_limit(struct netlink_parse_ctx *ctx,
const struct location *loc,
- const struct nft_rule_expr *nle)
+ const struct nftnl_expr *nle)
{
struct stmt *stmt;
stmt = limit_stmt_alloc(loc);
- stmt->limit.rate = nft_rule_expr_get_u64(nle, NFT_EXPR_LIMIT_RATE);
- stmt->limit.unit = nft_rule_expr_get_u64(nle, NFT_EXPR_LIMIT_UNIT);
+ stmt->limit.rate = nftnl_expr_get_u64(nle, NFTNL_EXPR_LIMIT_RATE);
+ stmt->limit.unit = nftnl_expr_get_u64(nle, NFTNL_EXPR_LIMIT_UNIT);
list_add_tail(&stmt->list, &ctx->rule->stmts);
}
static void netlink_parse_reject(struct netlink_parse_ctx *ctx,
const struct location *loc,
- const struct nft_rule_expr *expr)
+ const struct nftnl_expr *expr)
{
struct stmt *stmt;
uint8_t icmp_code;
stmt = reject_stmt_alloc(loc);
- stmt->reject.type = nft_rule_expr_get_u32(expr, NFT_EXPR_REJECT_TYPE);
- icmp_code = nft_rule_expr_get_u8(expr, NFT_EXPR_REJECT_CODE);
+ stmt->reject.type = nftnl_expr_get_u32(expr, NFTNL_EXPR_REJECT_TYPE);
+ icmp_code = nftnl_expr_get_u8(expr, NFTNL_EXPR_REJECT_CODE);
stmt->reject.icmp_code = icmp_code;
stmt->reject.expr = constant_expr_alloc(loc, &integer_type,
BYTEORDER_HOST_ENDIAN, 8,
static void netlink_parse_nat(struct netlink_parse_ctx *ctx,
const struct location *loc,
- const struct nft_rule_expr *nle)
+ const struct nftnl_expr *nle)
{
struct stmt *stmt;
struct expr *addr, *proto;
int family;
stmt = nat_stmt_alloc(loc);
- stmt->nat.type = nft_rule_expr_get_u32(nle, NFT_EXPR_NAT_TYPE);
+ stmt->nat.type = nftnl_expr_get_u32(nle, NFTNL_EXPR_NAT_TYPE);
- family = nft_rule_expr_get_u32(nle, NFT_EXPR_NAT_FAMILY);
+ family = nftnl_expr_get_u32(nle, NFTNL_EXPR_NAT_FAMILY);
- if (nft_rule_expr_is_set(nle, NFT_EXPR_NAT_FLAGS))
- stmt->nat.flags = nft_rule_expr_get_u32(nle,
- NFT_EXPR_NAT_FLAGS);
+ if (nftnl_expr_is_set(nle, NFTNL_EXPR_NAT_FLAGS))
+ stmt->nat.flags = nftnl_expr_get_u32(nle,
+ NFTNL_EXPR_NAT_FLAGS);
- reg1 = netlink_parse_register(nle, NFT_EXPR_NAT_REG_ADDR_MIN);
+ reg1 = netlink_parse_register(nle, NFTNL_EXPR_NAT_REG_ADDR_MIN);
if (reg1) {
addr = netlink_get_register(ctx, loc, reg1);
if (addr == NULL)
stmt->nat.addr = addr;
}
- reg2 = netlink_parse_register(nle, NFT_EXPR_NAT_REG_ADDR_MAX);
+ reg2 = netlink_parse_register(nle, NFTNL_EXPR_NAT_REG_ADDR_MAX);
if (reg2 && reg2 != reg1) {
addr = netlink_get_register(ctx, loc, reg2);
if (addr == NULL)
stmt->nat.addr = addr;
}
- reg1 = netlink_parse_register(nle, NFT_EXPR_NAT_REG_PROTO_MIN);
+ reg1 = netlink_parse_register(nle, NFTNL_EXPR_NAT_REG_PROTO_MIN);
if (reg1) {
proto = netlink_get_register(ctx, loc, reg1);
if (proto == NULL)
stmt->nat.proto = proto;
}
- reg2 = netlink_parse_register(nle, NFT_EXPR_NAT_REG_PROTO_MAX);
+ reg2 = netlink_parse_register(nle, NFTNL_EXPR_NAT_REG_PROTO_MAX);
if (reg2 && reg2 != reg1) {
proto = netlink_get_register(ctx, loc, reg2);
if (proto == NULL)
static void netlink_parse_masq(struct netlink_parse_ctx *ctx,
const struct location *loc,
- const struct nft_rule_expr *nle)
+ const struct nftnl_expr *nle)
{
struct stmt *stmt;
uint32_t flags;
flags = 0;
- if (nft_rule_expr_is_set(nle, NFT_EXPR_MASQ_FLAGS))
- flags = nft_rule_expr_get_u32(nle, NFT_EXPR_MASQ_FLAGS);
+ if (nftnl_expr_is_set(nle, NFTNL_EXPR_MASQ_FLAGS))
+ flags = nftnl_expr_get_u32(nle, NFTNL_EXPR_MASQ_FLAGS);
stmt = masq_stmt_alloc(loc);
stmt->masq.flags = flags;
static void netlink_parse_redir(struct netlink_parse_ctx *ctx,
const struct location *loc,
- const struct nft_rule_expr *nle)
+ const struct nftnl_expr *nle)
{
struct stmt *stmt;
struct expr *proto;
stmt = redir_stmt_alloc(loc);
- if (nft_rule_expr_is_set(nle, NFT_EXPR_REDIR_FLAGS)) {
- flags = nft_rule_expr_get_u32(nle, NFT_EXPR_REDIR_FLAGS);
+ if (nftnl_expr_is_set(nle, NFTNL_EXPR_REDIR_FLAGS)) {
+ flags = nftnl_expr_get_u32(nle, NFTNL_EXPR_REDIR_FLAGS);
stmt->redir.flags = flags;
}
- reg1 = netlink_parse_register(nle, NFT_EXPR_REDIR_REG_PROTO_MIN);
+ reg1 = netlink_parse_register(nle, NFTNL_EXPR_REDIR_REG_PROTO_MIN);
if (reg1) {
proto = netlink_get_register(ctx, loc, reg1);
if (proto == NULL)
stmt->redir.proto = proto;
}
- reg2 = netlink_parse_register(nle, NFT_EXPR_REDIR_REG_PROTO_MAX);
+ reg2 = netlink_parse_register(nle, NFTNL_EXPR_REDIR_REG_PROTO_MAX);
if (reg2 && reg2 != reg1) {
proto = netlink_get_register(ctx, loc, reg2);
if (proto == NULL)
static void netlink_parse_queue(struct netlink_parse_ctx *ctx,
const struct location *loc,
- const struct nft_rule_expr *nle)
+ const struct nftnl_expr *nle)
{
struct expr *expr, *high;
struct stmt *stmt;
uint16_t num, total;
- num = nft_rule_expr_get_u16(nle, NFT_EXPR_QUEUE_NUM);
- total = nft_rule_expr_get_u16(nle, NFT_EXPR_QUEUE_TOTAL);
+ num = nftnl_expr_get_u16(nle, NFTNL_EXPR_QUEUE_NUM);
+ total = nftnl_expr_get_u16(nle, NFTNL_EXPR_QUEUE_TOTAL);
expr = constant_expr_alloc(loc, &integer_type,
BYTEORDER_HOST_ENDIAN, 16, &num);
stmt = queue_stmt_alloc(loc);
stmt->queue.queue = expr;
- stmt->queue.flags = nft_rule_expr_get_u16(nle, NFT_EXPR_QUEUE_FLAGS);
+ stmt->queue.flags = nftnl_expr_get_u16(nle, NFTNL_EXPR_QUEUE_FLAGS);
list_add_tail(&stmt->list, &ctx->rule->stmts);
}
static void netlink_parse_dynset(struct netlink_parse_ctx *ctx,
const struct location *loc,
- const struct nft_rule_expr *nle)
+ const struct nftnl_expr *nle)
{
struct expr *expr;
struct stmt *stmt;
enum nft_registers sreg;
const char *name;
- name = nft_rule_expr_get_str(nle, NFT_EXPR_DYNSET_SET_NAME);
+ name = nftnl_expr_get_str(nle, NFTNL_EXPR_DYNSET_SET_NAME);
set = set_lookup(ctx->table, name);
if (set == NULL)
return netlink_error(ctx, loc,
"Unknown set '%s' in dynset statement",
name);
- sreg = netlink_parse_register(nle, NFT_EXPR_DYNSET_SREG_KEY);
+ sreg = netlink_parse_register(nle, NFTNL_EXPR_DYNSET_SREG_KEY);
expr = netlink_get_register(ctx, loc, sreg);
if (expr == NULL)
return netlink_error(ctx, loc,
}
expr = set_elem_expr_alloc(&expr->location, expr);
- expr->timeout = nft_rule_expr_get_u64(nle, NFT_EXPR_DYNSET_TIMEOUT);
+ expr->timeout = nftnl_expr_get_u64(nle, NFTNL_EXPR_DYNSET_TIMEOUT);
stmt = set_stmt_alloc(loc);
stmt->set.set = set_ref_expr_alloc(loc, set);
- stmt->set.op = nft_rule_expr_get_u32(nle, NFT_EXPR_DYNSET_OP);
+ stmt->set.op = nftnl_expr_get_u32(nle, NFTNL_EXPR_DYNSET_OP);
stmt->set.key = expr;
list_add_tail(&stmt->list, &ctx->rule->stmts);
const char *name;
void (*parse)(struct netlink_parse_ctx *ctx,
const struct location *loc,
- const struct nft_rule_expr *nle);
+ const struct nftnl_expr *nle);
} netlink_parsers[] = {
{ .name = "immediate", .parse = netlink_parse_immediate },
{ .name = "cmp", .parse = netlink_parse_cmp },
{ .name = "dynset", .parse = netlink_parse_dynset },
};
-static int netlink_parse_expr(struct nft_rule_expr *nle, void *arg)
+static int netlink_parse_expr(struct nftnl_expr *nle, void *arg)
{
- const char *type = nft_rule_expr_get_str(nle, NFT_RULE_EXPR_ATTR_NAME);
+ const char *type = nftnl_expr_get_str(nle, NFTNL_EXPR_NAME);
struct netlink_parse_ctx *ctx = arg;
struct location loc;
unsigned int i;
}
struct rule *netlink_delinearize_rule(struct netlink_ctx *ctx,
- const struct nft_rule *nlr)
+ const struct nftnl_rule *nlr)
{
struct netlink_parse_ctx _ctx, *pctx = &_ctx;
struct handle h;
_ctx.msgs = ctx->msgs;
memset(&h, 0, sizeof(h));
- h.family = nft_rule_attr_get_u32(nlr, NFT_RULE_ATTR_FAMILY);
- h.table = xstrdup(nft_rule_attr_get_str(nlr, NFT_RULE_ATTR_TABLE));
- h.chain = xstrdup(nft_rule_attr_get_str(nlr, NFT_RULE_ATTR_CHAIN));
- h.handle = nft_rule_attr_get_u64(nlr, NFT_RULE_ATTR_HANDLE);
+ h.family = nftnl_rule_get_u32(nlr, NFTNL_RULE_FAMILY);
+ h.table = xstrdup(nftnl_rule_get_str(nlr, NFTNL_RULE_TABLE));
+ h.chain = xstrdup(nftnl_rule_get_str(nlr, NFTNL_RULE_CHAIN));
+ h.handle = nftnl_rule_get_u64(nlr, NFTNL_RULE_HANDLE);
- if (nft_rule_attr_is_set(nlr, NFT_RULE_ATTR_POSITION))
- h.position = nft_rule_attr_get_u64(nlr, NFT_RULE_ATTR_POSITION);
+ if (nftnl_rule_is_set(nlr, NFTNL_RULE_POSITION))
+ h.position = nftnl_rule_get_u64(nlr, NFTNL_RULE_POSITION);
- if (nft_rule_attr_is_set(nlr, NFT_RULE_ATTR_USERDATA)) {
+ if (nftnl_rule_is_set(nlr, NFTNL_RULE_USERDATA)) {
uint32_t len;
const void *data;
- data = nft_rule_attr_get_data(nlr, NFT_RULE_ATTR_USERDATA,
+ data = nftnl_rule_get_data(nlr, NFTNL_RULE_USERDATA,
&len);
h.comment = xmalloc(len);
memcpy((char *)h.comment, data, len);
pctx->rule = rule_alloc(&netlink_location, &h);
pctx->table = table_lookup(&h);
assert(pctx->table != NULL);
- nft_rule_expr_foreach((struct nft_rule *)nlr, netlink_parse_expr, pctx);
+ nftnl_expr_foreach((struct nftnl_rule *)nlr, netlink_parse_expr, pctx);
rule_parse_postprocess(pctx, pctx->rule);
netlink_release_registers(pctx);
#include <utils.h>
struct netlink_linearize_ctx {
- struct nft_rule *nlr;
+ struct nftnl_rule *nlr;
unsigned int reg_low;
};
-static void netlink_put_register(struct nft_rule_expr *nle,
+static void netlink_put_register(struct nftnl_expr *nle,
uint32_t attr, uint32_t reg)
{
/* Convert to 128 bit register numbers if possible for compatibility */
reg += NFT_REG32_00;
}
- nft_rule_expr_set_u32(nle, attr, reg);
+ nftnl_expr_set_u32(nle, attr, reg);
}
static enum nft_registers __get_register(struct netlink_linearize_ctx *ctx,
const struct expr *expr,
enum nft_registers dreg)
{
- struct nft_rule_expr *nle;
+ struct nftnl_expr *nle;
nle = alloc_nft_expr("payload");
- netlink_put_register(nle, NFT_EXPR_PAYLOAD_DREG, dreg);
- nft_rule_expr_set_u32(nle, NFT_EXPR_PAYLOAD_BASE,
+ netlink_put_register(nle, NFTNL_EXPR_PAYLOAD_DREG, dreg);
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_PAYLOAD_BASE,
expr->payload.base - 1);
- nft_rule_expr_set_u32(nle, NFT_EXPR_PAYLOAD_OFFSET,
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_PAYLOAD_OFFSET,
expr->payload.offset / BITS_PER_BYTE);
- nft_rule_expr_set_u32(nle, NFT_EXPR_PAYLOAD_LEN,
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_PAYLOAD_LEN,
expr->len / BITS_PER_BYTE);
- nft_rule_add_expr(ctx->nlr, nle);
+ nftnl_rule_add_expr(ctx->nlr, nle);
}
static void netlink_gen_exthdr(struct netlink_linearize_ctx *ctx,
const struct expr *expr,
enum nft_registers dreg)
{
- struct nft_rule_expr *nle;
+ struct nftnl_expr *nle;
nle = alloc_nft_expr("exthdr");
- netlink_put_register(nle, NFT_EXPR_EXTHDR_DREG, dreg);
- nft_rule_expr_set_u8(nle, NFT_EXPR_EXTHDR_TYPE,
+ netlink_put_register(nle, NFTNL_EXPR_EXTHDR_DREG, dreg);
+ nftnl_expr_set_u8(nle, NFTNL_EXPR_EXTHDR_TYPE,
expr->exthdr.desc->type);
- nft_rule_expr_set_u32(nle, NFT_EXPR_EXTHDR_OFFSET,
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_EXTHDR_OFFSET,
expr->exthdr.tmpl->offset / BITS_PER_BYTE);
- nft_rule_expr_set_u32(nle, NFT_EXPR_EXTHDR_LEN,
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_EXTHDR_LEN,
expr->len / BITS_PER_BYTE);
- nft_rule_add_expr(ctx->nlr, nle);
+ nftnl_rule_add_expr(ctx->nlr, nle);
}
static void netlink_gen_meta(struct netlink_linearize_ctx *ctx,
const struct expr *expr,
enum nft_registers dreg)
{
- struct nft_rule_expr *nle;
+ struct nftnl_expr *nle;
nle = alloc_nft_expr("meta");
- netlink_put_register(nle, NFT_EXPR_META_DREG, dreg);
- nft_rule_expr_set_u32(nle, NFT_EXPR_META_KEY, expr->meta.key);
- nft_rule_add_expr(ctx->nlr, nle);
+ netlink_put_register(nle, NFTNL_EXPR_META_DREG, dreg);
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_META_KEY, expr->meta.key);
+ nftnl_rule_add_expr(ctx->nlr, nle);
}
static void netlink_gen_ct(struct netlink_linearize_ctx *ctx,
const struct expr *expr,
enum nft_registers dreg)
{
- struct nft_rule_expr *nle;
+ struct nftnl_expr *nle;
nle = alloc_nft_expr("ct");
- netlink_put_register(nle, NFT_EXPR_CT_DREG, dreg);
- nft_rule_expr_set_u32(nle, NFT_EXPR_CT_KEY, expr->ct.key);
- nft_rule_add_expr(ctx->nlr, nle);
+ netlink_put_register(nle, NFTNL_EXPR_CT_DREG, dreg);
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_CT_KEY, expr->ct.key);
+ nftnl_rule_add_expr(ctx->nlr, nle);
}
static void netlink_gen_map(struct netlink_linearize_ctx *ctx,
const struct expr *expr,
enum nft_registers dreg)
{
- struct nft_rule_expr *nle;
+ struct nftnl_expr *nle;
enum nft_registers sreg;
assert(expr->mappings->ops->type == EXPR_SET_REF);
netlink_gen_expr(ctx, expr->map, sreg);
nle = alloc_nft_expr("lookup");
- netlink_put_register(nle, NFT_EXPR_LOOKUP_SREG, sreg);
- netlink_put_register(nle, NFT_EXPR_LOOKUP_DREG, dreg);
- nft_rule_expr_set_str(nle, NFT_EXPR_LOOKUP_SET,
+ netlink_put_register(nle, NFTNL_EXPR_LOOKUP_SREG, sreg);
+ netlink_put_register(nle, NFTNL_EXPR_LOOKUP_DREG, dreg);
+ nftnl_expr_set_str(nle, NFTNL_EXPR_LOOKUP_SET,
expr->mappings->set->handle.set);
- nft_rule_expr_set_u32(nle, NFT_EXPR_LOOKUP_SET_ID,
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_LOOKUP_SET_ID,
expr->mappings->set->handle.set_id);
if (dreg == NFT_REG_VERDICT)
release_register(ctx, expr->map);
- nft_rule_add_expr(ctx->nlr, nle);
+ nftnl_rule_add_expr(ctx->nlr, nle);
}
static void netlink_gen_lookup(struct netlink_linearize_ctx *ctx,
const struct expr *expr,
enum nft_registers dreg)
{
- struct nft_rule_expr *nle;
+ struct nftnl_expr *nle;
enum nft_registers sreg;
assert(expr->right->ops->type == EXPR_SET_REF);
netlink_gen_expr(ctx, expr->left, sreg);
nle = alloc_nft_expr("lookup");
- netlink_put_register(nle, NFT_EXPR_LOOKUP_SREG, sreg);
- nft_rule_expr_set_str(nle, NFT_EXPR_LOOKUP_SET,
+ netlink_put_register(nle, NFTNL_EXPR_LOOKUP_SREG, sreg);
+ nftnl_expr_set_str(nle, NFTNL_EXPR_LOOKUP_SET,
expr->right->set->handle.set);
- nft_rule_expr_set_u32(nle, NFT_EXPR_LOOKUP_SET_ID,
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_LOOKUP_SET_ID,
expr->right->set->handle.set_id);
release_register(ctx, expr->left);
- nft_rule_add_expr(ctx->nlr, nle);
+ nftnl_rule_add_expr(ctx->nlr, nle);
}
static enum nft_cmp_ops netlink_gen_cmp_op(enum ops op)
const struct expr *expr,
enum nft_registers dreg)
{
- struct nft_rule_expr *nle;
+ struct nftnl_expr *nle;
enum nft_registers sreg;
struct nft_data_linearize nld, zero = {};
struct expr *right;
zero.len = nld.len;
nle = alloc_nft_expr("bitwise");
- netlink_put_register(nle, NFT_EXPR_BITWISE_SREG, sreg);
- netlink_put_register(nle, NFT_EXPR_BITWISE_DREG, sreg);
- nft_rule_expr_set_u32(nle, NFT_EXPR_BITWISE_LEN, nld.len);
- nft_rule_expr_set(nle, NFT_EXPR_BITWISE_MASK, &nld.value, nld.len);
- nft_rule_expr_set(nle, NFT_EXPR_BITWISE_XOR, &zero.value, zero.len);
- nft_rule_add_expr(ctx->nlr, nle);
+ netlink_put_register(nle, NFTNL_EXPR_BITWISE_SREG, sreg);
+ netlink_put_register(nle, NFTNL_EXPR_BITWISE_DREG, sreg);
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_BITWISE_LEN, nld.len);
+ nftnl_expr_set(nle, NFTNL_EXPR_BITWISE_MASK, &nld.value, nld.len);
+ nftnl_expr_set(nle, NFTNL_EXPR_BITWISE_XOR, &zero.value, zero.len);
+ nftnl_rule_add_expr(ctx->nlr, nle);
right = expr->right->prefix;
break;
}
nle = alloc_nft_expr("cmp");
- netlink_put_register(nle, NFT_EXPR_CMP_SREG, sreg);
- nft_rule_expr_set_u32(nle, NFT_EXPR_CMP_OP,
+ netlink_put_register(nle, NFTNL_EXPR_CMP_SREG, sreg);
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_CMP_OP,
netlink_gen_cmp_op(expr->op));
netlink_gen_data(right, &nld);
- nft_rule_expr_set(nle, NFT_EXPR_CMP_DATA, nld.value, nld.len);
+ nftnl_expr_set(nle, NFTNL_EXPR_CMP_DATA, nld.value, nld.len);
release_register(ctx, expr->left);
- nft_rule_add_expr(ctx->nlr, nle);
+ nftnl_rule_add_expr(ctx->nlr, nle);
}
static void netlink_gen_range(struct netlink_linearize_ctx *ctx,
enum nft_registers dreg)
{
struct expr *range = expr->right;
- struct nft_rule_expr *nle;
+ struct nftnl_expr *nle;
enum nft_registers sreg;
struct nft_data_linearize nld;
netlink_gen_expr(ctx, expr->left, sreg);
nle = alloc_nft_expr("cmp");
- netlink_put_register(nle, NFT_EXPR_CMP_SREG, sreg);
+ netlink_put_register(nle, NFTNL_EXPR_CMP_SREG, sreg);
switch (expr->op) {
case OP_NEQ:
- nft_rule_expr_set_u32(nle, NFT_EXPR_CMP_OP,
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_CMP_OP,
netlink_gen_cmp_op(OP_LT));
break;
case OP_RANGE:
case OP_EQ:
- nft_rule_expr_set_u32(nle, NFT_EXPR_CMP_OP,
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_CMP_OP,
netlink_gen_cmp_op(OP_GTE));
break;
default:
}
netlink_gen_data(range->left, &nld);
- nft_rule_expr_set(nle, NFT_EXPR_CMP_DATA, nld.value, nld.len);
- nft_rule_add_expr(ctx->nlr, nle);
+ nftnl_expr_set(nle, NFTNL_EXPR_CMP_DATA, nld.value, nld.len);
+ nftnl_rule_add_expr(ctx->nlr, nle);
nle = alloc_nft_expr("cmp");
- netlink_put_register(nle, NFT_EXPR_CMP_SREG, sreg);
+ netlink_put_register(nle, NFTNL_EXPR_CMP_SREG, sreg);
switch (expr->op) {
case OP_NEQ:
- nft_rule_expr_set_u32(nle, NFT_EXPR_CMP_OP,
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_CMP_OP,
netlink_gen_cmp_op(OP_GT));
break;
case OP_RANGE:
case OP_EQ:
- nft_rule_expr_set_u32(nle, NFT_EXPR_CMP_OP,
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_CMP_OP,
netlink_gen_cmp_op(OP_LTE));
break;
default:
}
netlink_gen_data(range->right, &nld);
- nft_rule_expr_set(nle, NFT_EXPR_CMP_DATA, nld.value, nld.len);
- nft_rule_add_expr(ctx->nlr, nle);
+ nftnl_expr_set(nle, NFTNL_EXPR_CMP_DATA, nld.value, nld.len);
+ nftnl_rule_add_expr(ctx->nlr, nle);
release_register(ctx, expr->left);
}
const struct expr *expr,
enum nft_registers dreg)
{
- struct nft_rule_expr *nle;
+ struct nftnl_expr *nle;
struct nft_data_linearize nld, nld2;
enum nft_registers sreg;
unsigned int len;
netlink_gen_data(expr->right, &nld2);
nle = alloc_nft_expr("bitwise");
- netlink_put_register(nle, NFT_EXPR_BITWISE_SREG, sreg);
- netlink_put_register(nle, NFT_EXPR_BITWISE_DREG, sreg);
- nft_rule_expr_set_u32(nle, NFT_EXPR_BITWISE_LEN, len);
- nft_rule_expr_set(nle, NFT_EXPR_BITWISE_MASK, &nld2.value, nld2.len);
- nft_rule_expr_set(nle, NFT_EXPR_BITWISE_XOR, &nld.value, nld.len);
- nft_rule_add_expr(ctx->nlr, nle);
+ netlink_put_register(nle, NFTNL_EXPR_BITWISE_SREG, sreg);
+ netlink_put_register(nle, NFTNL_EXPR_BITWISE_DREG, sreg);
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_BITWISE_LEN, len);
+ nftnl_expr_set(nle, NFTNL_EXPR_BITWISE_MASK, &nld2.value, nld2.len);
+ nftnl_expr_set(nle, NFTNL_EXPR_BITWISE_XOR, &nld.value, nld.len);
+ nftnl_rule_add_expr(ctx->nlr, nle);
nle = alloc_nft_expr("cmp");
- netlink_put_register(nle, NFT_EXPR_CMP_SREG, sreg);
- nft_rule_expr_set_u32(nle, NFT_EXPR_CMP_OP, NFT_CMP_NEQ);
- nft_rule_expr_set(nle, NFT_EXPR_CMP_DATA, nld.value, nld.len);
- nft_rule_add_expr(ctx->nlr, nle);
+ netlink_put_register(nle, NFTNL_EXPR_CMP_SREG, sreg);
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_CMP_OP, NFT_CMP_NEQ);
+ nftnl_expr_set(nle, NFTNL_EXPR_CMP_DATA, nld.value, nld.len);
+ nftnl_rule_add_expr(ctx->nlr, nle);
mpz_clear(zero);
release_register(ctx, expr->left);
const struct expr *expr,
enum nft_registers dreg)
{
- struct nft_rule_expr *nle;
+ struct nftnl_expr *nle;
struct nft_data_linearize nld;
struct expr *left, *i;
struct expr *binops[16];
len = div_round_up(expr->len, BITS_PER_BYTE);
nle = alloc_nft_expr("bitwise");
- netlink_put_register(nle, NFT_EXPR_BITWISE_SREG, dreg);
- netlink_put_register(nle, NFT_EXPR_BITWISE_DREG, dreg);
- nft_rule_expr_set_u32(nle, NFT_EXPR_BITWISE_LEN, len);
+ netlink_put_register(nle, NFTNL_EXPR_BITWISE_SREG, dreg);
+ netlink_put_register(nle, NFTNL_EXPR_BITWISE_DREG, dreg);
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_BITWISE_LEN, len);
netlink_gen_raw_data(mask, expr->byteorder, len, &nld);
- nft_rule_expr_set(nle, NFT_EXPR_BITWISE_MASK, nld.value, nld.len);
+ nftnl_expr_set(nle, NFTNL_EXPR_BITWISE_MASK, nld.value, nld.len);
netlink_gen_raw_data(xor, expr->byteorder, len, &nld);
- nft_rule_expr_set(nle, NFT_EXPR_BITWISE_XOR, nld.value, nld.len);
+ nftnl_expr_set(nle, NFTNL_EXPR_BITWISE_XOR, nld.value, nld.len);
mpz_clear(tmp);
mpz_clear(val);
mpz_clear(xor);
mpz_clear(mask);
- nft_rule_add_expr(ctx->nlr, nle);
+ nftnl_rule_add_expr(ctx->nlr, nle);
}
static enum nft_byteorder_ops netlink_gen_unary_op(enum ops op)
const struct expr *expr,
enum nft_registers dreg)
{
- struct nft_rule_expr *nle;
+ struct nftnl_expr *nle;
netlink_gen_expr(ctx, expr->arg, dreg);
nle = alloc_nft_expr("byteorder");
- netlink_put_register(nle, NFT_EXPR_BYTEORDER_SREG, dreg);
- netlink_put_register(nle, NFT_EXPR_BYTEORDER_DREG, dreg);
- nft_rule_expr_set_u32(nle, NFT_EXPR_BYTEORDER_LEN,
+ netlink_put_register(nle, NFTNL_EXPR_BYTEORDER_SREG, dreg);
+ netlink_put_register(nle, NFTNL_EXPR_BYTEORDER_DREG, dreg);
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_BYTEORDER_LEN,
expr->len / BITS_PER_BYTE);
- nft_rule_expr_set_u32(nle, NFT_EXPR_BYTEORDER_SIZE,
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_BYTEORDER_SIZE,
expr->arg->len % 32 ? 2 : 4);
- nft_rule_expr_set_u32(nle, NFT_EXPR_BYTEORDER_OP,
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_BYTEORDER_OP,
netlink_gen_unary_op(expr->op));
- nft_rule_add_expr(ctx->nlr, nle);
+ nftnl_rule_add_expr(ctx->nlr, nle);
}
static void netlink_gen_immediate(struct netlink_linearize_ctx *ctx,
const struct expr *expr,
enum nft_registers dreg)
{
- struct nft_rule_expr *nle;
+ struct nftnl_expr *nle;
struct nft_data_linearize nld;
nle = alloc_nft_expr("immediate");
- netlink_put_register(nle, NFT_EXPR_IMM_DREG, dreg);
+ netlink_put_register(nle, NFTNL_EXPR_IMM_DREG, dreg);
netlink_gen_data(expr, &nld);
switch (expr->ops->type) {
case EXPR_VALUE:
- nft_rule_expr_set(nle, NFT_EXPR_IMM_DATA, nld.value, nld.len);
+ nftnl_expr_set(nle, NFTNL_EXPR_IMM_DATA, nld.value, nld.len);
break;
case EXPR_VERDICT:
if ((expr->chain != NULL) &&
- !nft_rule_expr_is_set(nle, NFT_EXPR_IMM_CHAIN)) {
- nft_rule_expr_set_str(nle, NFT_EXPR_IMM_CHAIN,
+ !nftnl_expr_is_set(nle, NFTNL_EXPR_IMM_CHAIN)) {
+ nftnl_expr_set_str(nle, NFTNL_EXPR_IMM_CHAIN,
nld.chain);
}
- nft_rule_expr_set_u32(nle, NFT_EXPR_IMM_VERDICT, nld.verdict);
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_IMM_VERDICT, nld.verdict);
break;
default:
break;
}
- nft_rule_add_expr(ctx->nlr, nle);
+ nftnl_rule_add_expr(ctx->nlr, nle);
}
static void netlink_gen_expr(struct netlink_linearize_ctx *ctx,
static void netlink_gen_counter_stmt(struct netlink_linearize_ctx *ctx,
const struct stmt *stmt)
{
- struct nft_rule_expr *nle;
+ struct nftnl_expr *nle;
nle = alloc_nft_expr("counter");
if (stmt->counter.packets) {
- nft_rule_expr_set_u64(nle, NFT_EXPR_CTR_PACKETS,
+ nftnl_expr_set_u64(nle, NFTNL_EXPR_CTR_PACKETS,
stmt->counter.packets);
}
if (stmt->counter.bytes) {
- nft_rule_expr_set_u64(nle, NFT_EXPR_CTR_BYTES,
+ nftnl_expr_set_u64(nle, NFTNL_EXPR_CTR_BYTES,
stmt->counter.bytes);
}
- nft_rule_add_expr(ctx->nlr, nle);
+ nftnl_rule_add_expr(ctx->nlr, nle);
}
static void netlink_gen_meta_stmt(struct netlink_linearize_ctx *ctx,
const struct stmt *stmt)
{
- struct nft_rule_expr *nle;
+ struct nftnl_expr *nle;
enum nft_registers sreg;
sreg = get_register(ctx, stmt->meta.expr);
release_register(ctx, stmt->meta.expr);
nle = alloc_nft_expr("meta");
- netlink_put_register(nle, NFT_EXPR_META_SREG, sreg);
- nft_rule_expr_set_u32(nle, NFT_EXPR_META_KEY, stmt->meta.key);
- nft_rule_add_expr(ctx->nlr, nle);
+ netlink_put_register(nle, NFTNL_EXPR_META_SREG, sreg);
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_META_KEY, stmt->meta.key);
+ nftnl_rule_add_expr(ctx->nlr, nle);
}
static void netlink_gen_log_stmt(struct netlink_linearize_ctx *ctx,
const struct stmt *stmt)
{
- struct nft_rule_expr *nle;
+ struct nftnl_expr *nle;
nle = alloc_nft_expr("log");
if (stmt->log.prefix != NULL) {
- nft_rule_expr_set_str(nle, NFT_EXPR_LOG_PREFIX,
+ nftnl_expr_set_str(nle, NFTNL_EXPR_LOG_PREFIX,
stmt->log.prefix);
}
if (stmt->log.flags & STMT_LOG_GROUP) {
- nft_rule_expr_set_u16(nle, NFT_EXPR_LOG_GROUP,
+ nftnl_expr_set_u16(nle, NFTNL_EXPR_LOG_GROUP,
stmt->log.group);
if (stmt->log.flags & STMT_LOG_SNAPLEN)
- nft_rule_expr_set_u32(nle, NFT_EXPR_LOG_SNAPLEN,
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_LOG_SNAPLEN,
stmt->log.snaplen);
if (stmt->log.flags & STMT_LOG_QTHRESHOLD)
- nft_rule_expr_set_u16(nle, NFT_EXPR_LOG_QTHRESHOLD,
+ nftnl_expr_set_u16(nle, NFTNL_EXPR_LOG_QTHRESHOLD,
stmt->log.qthreshold);
} else {
if (stmt->log.flags & STMT_LOG_LEVEL) {
- nft_rule_expr_set_u32(nle, NFT_EXPR_LOG_LEVEL,
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_LOG_LEVEL,
stmt->log.level);
}
}
- nft_rule_add_expr(ctx->nlr, nle);
+ nftnl_rule_add_expr(ctx->nlr, nle);
}
static void netlink_gen_limit_stmt(struct netlink_linearize_ctx *ctx,
const struct stmt *stmt)
{
- struct nft_rule_expr *nle;
+ struct nftnl_expr *nle;
nle = alloc_nft_expr("limit");
- nft_rule_expr_set_u64(nle, NFT_EXPR_LIMIT_RATE, stmt->limit.rate);
- nft_rule_expr_set_u64(nle, NFT_EXPR_LIMIT_UNIT, stmt->limit.unit);
- nft_rule_add_expr(ctx->nlr, nle);
+ nftnl_expr_set_u64(nle, NFTNL_EXPR_LIMIT_RATE, stmt->limit.rate);
+ nftnl_expr_set_u64(nle, NFTNL_EXPR_LIMIT_UNIT, stmt->limit.unit);
+ nftnl_rule_add_expr(ctx->nlr, nle);
}
static void netlink_gen_reject_stmt(struct netlink_linearize_ctx *ctx,
const struct stmt *stmt)
{
- struct nft_rule_expr *nle;
+ struct nftnl_expr *nle;
nle = alloc_nft_expr("reject");
- nft_rule_expr_set_u32(nle, NFT_EXPR_REJECT_TYPE, stmt->reject.type);
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_REJECT_TYPE, stmt->reject.type);
if (stmt->reject.icmp_code != -1)
- nft_rule_expr_set_u8(nle, NFT_EXPR_REJECT_CODE,
+ nftnl_expr_set_u8(nle, NFTNL_EXPR_REJECT_CODE,
stmt->reject.icmp_code);
- nft_rule_add_expr(ctx->nlr, nle);
+ nftnl_rule_add_expr(ctx->nlr, nle);
}
static void netlink_gen_nat_stmt(struct netlink_linearize_ctx *ctx,
const struct stmt *stmt)
{
- struct nft_rule_expr *nle;
+ struct nftnl_expr *nle;
enum nft_registers amin_reg, amax_reg;
enum nft_registers pmin_reg, pmax_reg;
int registers = 0;
int family;
nle = alloc_nft_expr("nat");
- nft_rule_expr_set_u32(nle, NFT_EXPR_NAT_TYPE, stmt->nat.type);
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_NAT_TYPE, stmt->nat.type);
- family = nft_rule_attr_get_u32(ctx->nlr, NFT_RULE_ATTR_FAMILY);
- nft_rule_expr_set_u32(nle, NFT_EXPR_NAT_FAMILY, family);
+ family = nftnl_rule_get_u32(ctx->nlr, NFTNL_RULE_FAMILY);
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_NAT_FAMILY, family);
if (stmt->nat.flags != 0)
- nft_rule_expr_set_u32(nle, NFT_EXPR_NAT_FLAGS, stmt->nat.flags);
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_NAT_FLAGS, stmt->nat.flags);
if (stmt->nat.addr) {
amin_reg = get_register(ctx, NULL);
netlink_gen_expr(ctx, stmt->nat.addr->left, amin_reg);
netlink_gen_expr(ctx, stmt->nat.addr->right, amax_reg);
- netlink_put_register(nle, NFT_EXPR_NAT_REG_ADDR_MIN,
+ netlink_put_register(nle, NFTNL_EXPR_NAT_REG_ADDR_MIN,
amin_reg);
- netlink_put_register(nle, NFT_EXPR_NAT_REG_ADDR_MAX,
+ netlink_put_register(nle, NFTNL_EXPR_NAT_REG_ADDR_MAX,
amax_reg);
} else {
netlink_gen_expr(ctx, stmt->nat.addr, amin_reg);
- netlink_put_register(nle, NFT_EXPR_NAT_REG_ADDR_MIN,
+ netlink_put_register(nle, NFTNL_EXPR_NAT_REG_ADDR_MIN,
amin_reg);
}
netlink_gen_expr(ctx, stmt->nat.proto->left, pmin_reg);
netlink_gen_expr(ctx, stmt->nat.proto->right, pmax_reg);
- netlink_put_register(nle, NFT_EXPR_NAT_REG_PROTO_MIN,
+ netlink_put_register(nle, NFTNL_EXPR_NAT_REG_PROTO_MIN,
pmin_reg);
- netlink_put_register(nle, NFT_EXPR_NAT_REG_PROTO_MAX,
+ netlink_put_register(nle, NFTNL_EXPR_NAT_REG_PROTO_MAX,
pmax_reg);
} else {
netlink_gen_expr(ctx, stmt->nat.proto, pmin_reg);
- netlink_put_register(nle, NFT_EXPR_NAT_REG_PROTO_MIN,
+ netlink_put_register(nle, NFTNL_EXPR_NAT_REG_PROTO_MIN,
pmin_reg);
}
}
registers--;
}
- nft_rule_add_expr(ctx->nlr, nle);
+ nftnl_rule_add_expr(ctx->nlr, nle);
}
static void netlink_gen_masq_stmt(struct netlink_linearize_ctx *ctx,
const struct stmt *stmt)
{
- struct nft_rule_expr *nle;
+ struct nftnl_expr *nle;
nle = alloc_nft_expr("masq");
if (stmt->masq.flags != 0)
- nft_rule_expr_set_u32(nle, NFT_EXPR_MASQ_FLAGS,
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_MASQ_FLAGS,
stmt->masq.flags);
- nft_rule_add_expr(ctx->nlr, nle);
+ nftnl_rule_add_expr(ctx->nlr, nle);
}
static void netlink_gen_redir_stmt(struct netlink_linearize_ctx *ctx,
const struct stmt *stmt)
{
- struct nft_rule_expr *nle;
+ struct nftnl_expr *nle;
enum nft_registers pmin_reg, pmax_reg;
int registers = 0;
nle = alloc_nft_expr("redir");
if (stmt->redir.flags != 0)
- nft_rule_expr_set_u32(nle, NFT_EXPR_REDIR_FLAGS,
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_REDIR_FLAGS,
stmt->redir.flags);
if (stmt->redir.proto) {
pmin_reg);
netlink_gen_expr(ctx, stmt->redir.proto->right,
pmax_reg);
- nft_rule_expr_set_u32(nle,
- NFT_EXPR_REDIR_REG_PROTO_MIN,
+ nftnl_expr_set_u32(nle,
+ NFTNL_EXPR_REDIR_REG_PROTO_MIN,
pmin_reg);
- nft_rule_expr_set_u32(nle,
- NFT_EXPR_REDIR_REG_PROTO_MAX,
+ nftnl_expr_set_u32(nle,
+ NFTNL_EXPR_REDIR_REG_PROTO_MAX,
pmax_reg);
} else {
netlink_gen_expr(ctx, stmt->redir.proto, pmin_reg);
- nft_rule_expr_set_u32(nle,
- NFT_EXPR_REDIR_REG_PROTO_MIN,
+ nftnl_expr_set_u32(nle,
+ NFTNL_EXPR_REDIR_REG_PROTO_MIN,
pmin_reg);
}
}
registers--;
}
- nft_rule_add_expr(ctx->nlr, nle);
+ nftnl_rule_add_expr(ctx->nlr, nle);
}
static void netlink_gen_queue_stmt(struct netlink_linearize_ctx *ctx,
const struct stmt *stmt)
{
- struct nft_rule_expr *nle;
+ struct nftnl_expr *nle;
uint16_t total_queues;
mpz_t low, high;
total_queues = mpz_get_uint16(high) - mpz_get_uint16(low) + 1;
nle = alloc_nft_expr("queue");
- nft_rule_expr_set_u16(nle, NFT_EXPR_QUEUE_NUM, mpz_get_uint16(low));
- nft_rule_expr_set_u16(nle, NFT_EXPR_QUEUE_TOTAL, total_queues);
+ nftnl_expr_set_u16(nle, NFTNL_EXPR_QUEUE_NUM, mpz_get_uint16(low));
+ nftnl_expr_set_u16(nle, NFTNL_EXPR_QUEUE_TOTAL, total_queues);
if (stmt->queue.flags) {
- nft_rule_expr_set_u16(nle, NFT_EXPR_QUEUE_FLAGS,
+ nftnl_expr_set_u16(nle, NFTNL_EXPR_QUEUE_FLAGS,
stmt->queue.flags);
}
- nft_rule_add_expr(ctx->nlr, nle);
+ nftnl_rule_add_expr(ctx->nlr, nle);
mpz_clear(low);
mpz_clear(high);
static void netlink_gen_ct_stmt(struct netlink_linearize_ctx *ctx,
const struct stmt *stmt)
{
- struct nft_rule_expr *nle;
+ struct nftnl_expr *nle;
enum nft_registers sreg;
sreg = get_register(ctx, stmt->ct.expr);
release_register(ctx, stmt->ct.expr);
nle = alloc_nft_expr("ct");
- netlink_put_register(nle, NFT_EXPR_CT_SREG, sreg);
- nft_rule_expr_set_u32(nle, NFT_EXPR_CT_KEY, stmt->ct.key);
- nft_rule_add_expr(ctx->nlr, nle);
+ netlink_put_register(nle, NFTNL_EXPR_CT_SREG, sreg);
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_CT_KEY, stmt->ct.key);
+ nftnl_rule_add_expr(ctx->nlr, nle);
}
static void netlink_gen_set_stmt(struct netlink_linearize_ctx *ctx,
const struct stmt *stmt)
{
- struct nft_rule_expr *nle;
+ struct nftnl_expr *nle;
enum nft_registers sreg_key;
sreg_key = get_register(ctx, stmt->set.key);
release_register(ctx, stmt->set.key);
nle = alloc_nft_expr("dynset");
- netlink_put_register(nle, NFT_EXPR_DYNSET_SREG_KEY, sreg_key);
- nft_rule_expr_set_u64(nle, NFT_EXPR_DYNSET_TIMEOUT,
+ netlink_put_register(nle, NFTNL_EXPR_DYNSET_SREG_KEY, sreg_key);
+ nftnl_expr_set_u64(nle, NFTNL_EXPR_DYNSET_TIMEOUT,
stmt->set.key->timeout);
- nft_rule_expr_set_u32(nle, NFT_EXPR_DYNSET_OP, stmt->set.op);
- nft_rule_expr_set_str(nle, NFT_EXPR_DYNSET_SET_NAME,
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_DYNSET_OP, stmt->set.op);
+ nftnl_expr_set_str(nle, NFTNL_EXPR_DYNSET_SET_NAME,
stmt->set.set->set->handle.set);
- nft_rule_expr_set_u32(nle, NFT_EXPR_DYNSET_SET_ID,
+ nftnl_expr_set_u32(nle, NFTNL_EXPR_DYNSET_SET_ID,
stmt->set.set->set->handle.set_id);
- nft_rule_add_expr(ctx->nlr, nle);
+ nftnl_rule_add_expr(ctx->nlr, nle);
}
static void netlink_gen_stmt(struct netlink_linearize_ctx *ctx,
}
}
-void netlink_linearize_rule(struct netlink_ctx *ctx, struct nft_rule *nlr,
+void netlink_linearize_rule(struct netlink_ctx *ctx, struct nftnl_rule *nlr,
const struct rule *rule)
{
struct netlink_linearize_ctx lctx;
| ELEMENTS { $$ = CMD_MONITOR_OBJ_ELEMS; }
;
-monitor_format : /* empty */ { $$ = NFT_OUTPUT_DEFAULT; }
+monitor_format : /* empty */ { $$ = NFTNL_OUTPUT_DEFAULT; }
| export_format
;
-export_format : XML { $$ = NFT_OUTPUT_XML; }
- | JSON { $$ = NFT_OUTPUT_JSON; }
+export_format : XML { $$ = NFTNL_OUTPUT_XML; }
+ | JSON { $$ = NFTNL_OUTPUT_JSON; }
;
describe_cmd : primary_expr
static int do_command_export(struct netlink_ctx *ctx, struct cmd *cmd)
{
- struct nft_ruleset *rs;
+ struct nftnl_ruleset *rs;
do {
rs = netlink_dump_ruleset(ctx, &cmd->handle, &cmd->location);
return -1;
} while (rs == NULL);
- nft_ruleset_fprintf(stdout, rs, cmd->export->format, 0);
+ nftnl_ruleset_fprintf(stdout, rs, cmd->export->format, 0);
fprintf(stdout, "\n");
- nft_ruleset_free(rs);
+ nftnl_ruleset_free(rs);
return 0;
}
* - new elements
*/
if (((cmd->monitor->flags & (1 << NFT_MSG_NEWRULE)) &&
- (cmd->monitor->format == NFT_OUTPUT_DEFAULT)) ||
+ (cmd->monitor->format == NFTNL_OUTPUT_DEFAULT)) ||
(cmd->monitor->flags & (1 << NFT_MSG_NEWSETELEM)))
monhandler.cache_needed = true;
else
projects / thirdparty / nftables.git / commitdiff
