summaryrefslogtreecommitdiffstats
path: root/include
diff options
context:
space:
mode:
authorPablo Neira Ayuso <pablo@netfilter.org>2015-09-01 20:19:56 +0200
committerPablo Neira Ayuso <pablo@netfilter.org>2015-09-07 19:24:19 +0200
commit760768890e60617acfd144dce875a4a3be14513c (patch)
tree14a3a4f53e81fd9b44c8481e123f2c0ceb6f2bff /include
parentb7154e52fc417e927bef0bbfa5db6e7a71f28602 (diff)
src: rename existing functions to use the nftnl_ prefix
So we can use the nft_* prefix anytime soon for our upcoming higher level library. After this patch, the nft_* symbols become an alias of the nftnl_* symbols. Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
Diffstat (limited to 'include')
-rw-r--r--include/buffer.h34
-rw-r--r--include/common.h18
-rw-r--r--include/data_reg.h8
-rw-r--r--include/expr.h6
-rw-r--r--include/expr_ops.h26
-rw-r--r--include/json.h86
-rw-r--r--include/libnftnl/batch.h16
-rw-r--r--include/libnftnl/chain.h110
-rw-r--r--include/libnftnl/common.h66
-rw-r--r--include/libnftnl/expr.h192
-rw-r--r--include/libnftnl/gen.h38
-rw-r--r--include/libnftnl/rule.h112
-rw-r--r--include/libnftnl/ruleset.h86
-rw-r--r--include/libnftnl/set.h190
-rw-r--r--include/libnftnl/table.h84
-rw-r--r--include/set.h8
-rw-r--r--include/set_elem.h8
-rw-r--r--include/utils.h54
-rw-r--r--include/xml.h78
19 files changed, 610 insertions, 610 deletions
diff --git a/include/buffer.h b/include/buffer.h
index 38b6136..a5bd039 100644
--- a/include/buffer.h
+++ b/include/buffer.h
@@ -1,10 +1,10 @@
-#ifndef _NFT_BUFFER_H_
-#define _NFT_BUFFER_H_
+#ifndef _NFTNL_BUFFER_H_
+#define _NFTNL_BUFFER_H_
#include <stdint.h>
#include <stdbool.h>
-struct nft_buf {
+struct nftnl_buf {
char *buf;
size_t size;
size_t len;
@@ -12,28 +12,28 @@ struct nft_buf {
bool fail;
};
-#define NFT_BUF_INIT(__b, __buf, __len) \
- struct nft_buf __b = { \
+#define NFTNL_BUF_INIT(__b, __buf, __len) \
+ struct nftnl_buf __b = { \
.buf = __buf, \
.len = __len, \
};
-int nft_buf_update(struct nft_buf *b, int ret);
-int nft_buf_done(struct nft_buf *b);
+int nftnl_buf_update(struct nftnl_buf *b, int ret);
+int nftnl_buf_done(struct nftnl_buf *b);
-union nft_data_reg;
+union nftnl_data_reg;
-int nft_buf_open(struct nft_buf *b, int type, const char *tag);
-int nft_buf_close(struct nft_buf *b, int type, const char *tag);
+int nftnl_buf_open(struct nftnl_buf *b, int type, const char *tag);
+int nftnl_buf_close(struct nftnl_buf *b, int type, const char *tag);
-int nft_buf_open_array(struct nft_buf *b, int type, const char *tag);
-int nft_buf_close_array(struct nft_buf *b, int type, const char *tag);
+int nftnl_buf_open_array(struct nftnl_buf *b, int type, const char *tag);
+int nftnl_buf_close_array(struct nftnl_buf *b, int type, const char *tag);
-int nft_buf_u32(struct nft_buf *b, int type, uint32_t value, const char *tag);
-int nft_buf_s32(struct nft_buf *b, int type, uint32_t value, const char *tag);
-int nft_buf_u64(struct nft_buf *b, int type, uint64_t value, const char *tag);
-int nft_buf_str(struct nft_buf *b, int type, const char *str, const char *tag);
-int nft_buf_reg(struct nft_buf *b, int type, union nft_data_reg *reg,
+int nftnl_buf_u32(struct nftnl_buf *b, int type, uint32_t value, const char *tag);
+int nftnl_buf_s32(struct nftnl_buf *b, int type, uint32_t value, const char *tag);
+int nftnl_buf_u64(struct nftnl_buf *b, int type, uint64_t value, const char *tag);
+int nftnl_buf_str(struct nftnl_buf *b, int type, const char *str, const char *tag);
+int nftnl_buf_reg(struct nftnl_buf *b, int type, union nftnl_data_reg *reg,
int reg_type, const char *tag);
#define BASE "base"
diff --git a/include/common.h b/include/common.h
index 4b9e2c5..425bbf5 100644
--- a/include/common.h
+++ b/include/common.h
@@ -4,29 +4,29 @@
#define BASE_DEC 10
#define BASE_HEX 16
-#define NFT_SNPRINTF_BUFSIZ 4096
+#define NFTNL_SNPRINTF_BUFSIZ 4096
-struct nft_parse_err {
+struct nftnl_parse_err {
int line;
int column;
int error;
const char *node_name;
};
-enum nft_parse_input {
- NFT_PARSE_BUFFER,
- NFT_PARSE_FILE,
+enum nftnl_parse_input {
+ NFTNL_PARSE_BUFFER,
+ NFTNL_PARSE_FILE,
};
#include <stdio.h>
-int nft_cmd_header_snprintf(char *buf, size_t bufsize, uint32_t cmd,
+int nftnl_cmd_header_snprintf(char *buf, size_t bufsize, uint32_t cmd,
uint32_t format, uint32_t flags);
-int nft_cmd_header_fprintf(FILE *fp, uint32_t cmd, uint32_t format,
+int nftnl_cmd_header_fprintf(FILE *fp, uint32_t cmd, uint32_t format,
uint32_t flags);
-int nft_cmd_footer_snprintf(char *buf, size_t bufsize, uint32_t cmd,
+int nftnl_cmd_footer_snprintf(char *buf, size_t bufsize, uint32_t cmd,
uint32_t format, uint32_t flags);
-int nft_cmd_footer_fprintf(FILE *fp, uint32_t cmd, uint32_t format,
+int nftnl_cmd_footer_fprintf(FILE *fp, uint32_t cmd, uint32_t format,
uint32_t flags);
#endif
diff --git a/include/data_reg.h b/include/data_reg.h
index e0fdd10..0f2ae9a 100644
--- a/include/data_reg.h
+++ b/include/data_reg.h
@@ -12,7 +12,7 @@ enum {
DATA_CHAIN,
};
-union nft_data_reg {
+union nftnl_data_reg {
struct {
uint32_t val[NFT_DATA_VALUE_MAXLEN / sizeof(uint32_t)];
uint32_t len;
@@ -23,11 +23,11 @@ union nft_data_reg {
};
};
-int nft_data_reg_snprintf(char *buf, size_t size, union nft_data_reg *reg,
+int nftnl_data_reg_snprintf(char *buf, size_t size, union nftnl_data_reg *reg,
uint32_t output_format, uint32_t flags, int reg_type);
struct nlattr;
-int nft_parse_data(union nft_data_reg *data, struct nlattr *attr, int *type);
-void nft_free_verdict(union nft_data_reg *data);
+int nftnl_parse_data(union nftnl_data_reg *data, struct nlattr *attr, int *type);
+void nftnl_free_verdict(union nftnl_data_reg *data);
#endif
diff --git a/include/expr.h b/include/expr.h
index a4333c6..26b4a95 100644
--- a/include/expr.h
+++ b/include/expr.h
@@ -3,7 +3,7 @@
struct expr_ops;
-struct nft_rule_expr {
+struct nftnl_rule_expr {
struct list_head head;
uint32_t flags;
struct expr_ops *ops;
@@ -12,8 +12,8 @@ struct nft_rule_expr {
struct nlmsghdr;
-void nft_rule_expr_build_payload(struct nlmsghdr *nlh, struct nft_rule_expr *expr);
-struct nft_rule_expr *nft_rule_expr_parse(struct nlattr *attr);
+void nftnl_rule_expr_build_payload(struct nlmsghdr *nlh, struct nftnl_rule_expr *expr);
+struct nftnl_rule_expr *nftnl_rule_expr_parse(struct nlattr *attr);
#endif
diff --git a/include/expr_ops.h b/include/expr_ops.h
index 08cf57f..caf9218 100644
--- a/include/expr_ops.h
+++ b/include/expr_ops.h
@@ -6,26 +6,26 @@
struct nlattr;
struct nlmsghdr;
-struct nft_rule_expr;
+struct nftnl_rule_expr;
struct expr_ops {
const char *name;
uint32_t alloc_len;
int max_attr;
- void (*free)(struct nft_rule_expr *e);
- int (*set)(struct nft_rule_expr *e, uint16_t type, const void *data, uint32_t data_len);
- const void *(*get)(const struct nft_rule_expr *e, uint16_t type, uint32_t *data_len);
- int (*parse)(struct nft_rule_expr *e, struct nlattr *attr);
- void (*build)(struct nlmsghdr *nlh, struct nft_rule_expr *e);
- int (*snprintf)(char *buf, size_t len, uint32_t type, uint32_t flags, struct nft_rule_expr *e);
- int (*xml_parse)(struct nft_rule_expr *e, mxml_node_t *tree,
- struct nft_parse_err *err);
- int (*json_parse)(struct nft_rule_expr *e, json_t *data,
- struct nft_parse_err *err);
+ void (*free)(struct nftnl_rule_expr *e);
+ int (*set)(struct nftnl_rule_expr *e, uint16_t type, const void *data, uint32_t data_len);
+ const void *(*get)(const struct nftnl_rule_expr *e, uint16_t type, uint32_t *data_len);
+ int (*parse)(struct nftnl_rule_expr *e, struct nlattr *attr);
+ void (*build)(struct nlmsghdr *nlh, struct nftnl_rule_expr *e);
+ int (*snprintf)(char *buf, size_t len, uint32_t type, uint32_t flags, struct nftnl_rule_expr *e);
+ int (*xml_parse)(struct nftnl_rule_expr *e, mxml_node_t *tree,
+ struct nftnl_parse_err *err);
+ int (*json_parse)(struct nftnl_rule_expr *e, json_t *data,
+ struct nftnl_parse_err *err);
};
-struct expr_ops *nft_expr_ops_lookup(const char *name);
+struct expr_ops *nftnl_expr_ops_lookup(const char *name);
-#define nft_expr_data(ops) (void *)ops->data
+#define nftnl_expr_data(ops) (void *)ops->data
#endif
diff --git a/include/json.h b/include/json.h
index 821c15f..a15a65b 100644
--- a/include/json.h
+++ b/include/json.h
@@ -6,51 +6,51 @@
#include <stdbool.h>
#include "common.h"
-struct nft_table;
-struct nft_chain;
-struct nft_rule;
-struct nft_set;
-struct nft_set_elem;
-struct nft_set_list;
-union nft_data_reg;
+struct nftnl_table;
+struct nftnl_chain;
+struct nftnl_rule;
+struct nftnl_set;
+struct nftnl_set_elem;
+struct nftnl_set_list;
+union nftnl_data_reg;
-int nft_jansson_parse_val(json_t *root, const char *node_name, int type,
- void *out, struct nft_parse_err *err);
-const char *nft_jansson_parse_str(json_t *root, const char *node_name,
- struct nft_parse_err *err);
-bool nft_jansson_node_exist(json_t *root, const char *node_name);
-json_t *nft_jansson_create_root(const void *json, json_error_t *error,
- struct nft_parse_err *err, enum nft_parse_input input);
-json_t *nft_jansson_get_node(json_t *root, const char *node_name,
- struct nft_parse_err *err);
-void nft_jansson_free_root(json_t *root);
-int nft_jansson_parse_family(json_t *root, void *out, struct nft_parse_err *err);
-int nft_jansson_str2num(json_t *root, const char *node_name, int base, void *out,
- enum nft_type type, struct nft_parse_err *err);
-int nft_jansson_parse_reg(json_t *root, const char *node_name, int type,
- void *out, struct nft_parse_err *err);
-struct nft_rule_expr *nft_jansson_expr_parse(json_t *root,
- struct nft_parse_err *err,
- struct nft_set_list *set_list);
-int nft_jansson_data_reg_parse(json_t *root, const char *node_name,
- union nft_data_reg *data_reg,
- struct nft_parse_err *err);
-int nft_jansson_set_elem_parse(struct nft_set_elem *e, json_t *root,
- struct nft_parse_err *err);
-int nft_jansson_parse_table(struct nft_table *t, json_t *tree,
- struct nft_parse_err *err);
-int nft_jansson_parse_chain(struct nft_chain *c, json_t *tree,
- struct nft_parse_err *err);
-int nft_jansson_parse_rule(struct nft_rule *r, json_t *tree,
- struct nft_parse_err *err,
- struct nft_set_list *set_list);
-int nft_jansson_parse_set(struct nft_set *s, json_t *tree,
- struct nft_parse_err *err);
-int nft_jansson_parse_elem(struct nft_set *s, json_t *tree,
- struct nft_parse_err *err);
+int nftnl_jansson_parse_val(json_t *root, const char *node_name, int type,
+ void *out, struct nftnl_parse_err *err);
+const char *nftnl_jansson_parse_str(json_t *root, const char *node_name,
+ struct nftnl_parse_err *err);
+bool nftnl_jansson_node_exist(json_t *root, const char *node_name);
+json_t *nftnl_jansson_create_root(const void *json, json_error_t *error,
+ struct nftnl_parse_err *err, enum nftnl_parse_input input);
+json_t *nftnl_jansson_get_node(json_t *root, const char *node_name,
+ struct nftnl_parse_err *err);
+void nftnl_jansson_free_root(json_t *root);
+int nftnl_jansson_parse_family(json_t *root, void *out, struct nftnl_parse_err *err);
+int nftnl_jansson_str2num(json_t *root, const char *node_name, int base, void *out,
+ enum nftnl_type type, struct nftnl_parse_err *err);
+int nftnl_jansson_parse_reg(json_t *root, const char *node_name, int type,
+ void *out, struct nftnl_parse_err *err);
+struct nftnl_rule_expr *nftnl_jansson_expr_parse(json_t *root,
+ struct nftnl_parse_err *err,
+ struct nftnl_set_list *set_list);
+int nftnl_jansson_data_reg_parse(json_t *root, const char *node_name,
+ union nftnl_data_reg *data_reg,
+ struct nftnl_parse_err *err);
+int nftnl_jansson_set_elem_parse(struct nftnl_set_elem *e, json_t *root,
+ struct nftnl_parse_err *err);
+int nftnl_jansson_parse_table(struct nftnl_table *t, json_t *tree,
+ struct nftnl_parse_err *err);
+int nftnl_jansson_parse_chain(struct nftnl_chain *c, json_t *tree,
+ struct nftnl_parse_err *err);
+int nftnl_jansson_parse_rule(struct nftnl_rule *r, json_t *tree,
+ struct nftnl_parse_err *err,
+ struct nftnl_set_list *set_list);
+int nftnl_jansson_parse_set(struct nftnl_set *s, json_t *tree,
+ struct nftnl_parse_err *err);
+int nftnl_jansson_parse_elem(struct nftnl_set *s, json_t *tree,
+ struct nftnl_parse_err *err);
-int nft_data_reg_json_parse(union nft_data_reg *reg, json_t *data,
- struct nft_parse_err *err);
+int nftnl_data_reg_json_parse(union nftnl_data_reg *reg, json_t *data,
+ struct nftnl_parse_err *err);
#else
#define json_t void
#endif
diff --git a/include/libnftnl/batch.h b/include/libnftnl/batch.h
index 40416e6..ea1ea66 100644
--- a/include/libnftnl/batch.h
+++ b/include/libnftnl/batch.h
@@ -3,16 +3,16 @@
#include <stdint.h>
-struct nft_batch;
+struct nftnl_batch;
-struct nft_batch *nft_batch_alloc(uint32_t pg_size, uint32_t pg_overrun_size);
-int nft_batch_update(struct nft_batch *batch);
-void nft_batch_free(struct nft_batch *batch);
+struct nftnl_batch *nftnl_batch_alloc(uint32_t pg_size, uint32_t pg_overrun_size);
+int nftnl_batch_update(struct nftnl_batch *batch);
+void nftnl_batch_free(struct nftnl_batch *batch);
-void *nft_batch_buffer(struct nft_batch *batch);
-uint32_t nft_batch_buffer_len(struct nft_batch *batch);
+void *nftnl_batch_buffer(struct nftnl_batch *batch);
+uint32_t nftnl_batch_buffer_len(struct nftnl_batch *batch);
-int nft_batch_iovec_len(struct nft_batch *batch);
-void nft_batch_iovec(struct nft_batch *batch, struct iovec *iov, uint32_t iovlen);
+int nftnl_batch_iovec_len(struct nftnl_batch *batch);
+void nftnl_batch_iovec(struct nftnl_batch *batch, struct iovec *iov, uint32_t iovlen);
#endif
diff --git a/include/libnftnl/chain.h b/include/libnftnl/chain.h
index 3968e6b..1f426f7 100644
--- a/include/libnftnl/chain.h
+++ b/include/libnftnl/chain.h
@@ -12,78 +12,78 @@
extern "C" {
#endif
-struct nft_chain;
+struct nftnl_chain;
-struct nft_chain *nft_chain_alloc(void);
-void nft_chain_free(struct nft_chain *);
+struct nftnl_chain *nftnl_chain_alloc(void);
+void nftnl_chain_free(struct nftnl_chain *);
enum {
- NFT_CHAIN_ATTR_NAME = 0,
- NFT_CHAIN_ATTR_FAMILY,
- NFT_CHAIN_ATTR_TABLE,
- NFT_CHAIN_ATTR_HOOKNUM,
- NFT_CHAIN_ATTR_PRIO = 4,
- NFT_CHAIN_ATTR_POLICY,
- NFT_CHAIN_ATTR_USE,
- NFT_CHAIN_ATTR_BYTES,
- NFT_CHAIN_ATTR_PACKETS = 8,
- NFT_CHAIN_ATTR_HANDLE,
- NFT_CHAIN_ATTR_TYPE,
- NFT_CHAIN_ATTR_DEV,
- __NFT_CHAIN_ATTR_MAX
+ NFTNL_CHAIN_ATTR_NAME = 0,
+ NFTNL_CHAIN_ATTR_FAMILY,
+ NFTNL_CHAIN_ATTR_TABLE,
+ NFTNL_CHAIN_ATTR_HOOKNUM,
+ NFTNL_CHAIN_ATTR_PRIO = 4,
+ NFTNL_CHAIN_ATTR_POLICY,
+ NFTNL_CHAIN_ATTR_USE,
+ NFTNL_CHAIN_ATTR_BYTES,
+ NFTNL_CHAIN_ATTR_PACKETS = 8,
+ NFTNL_CHAIN_ATTR_HANDLE,
+ NFTNL_CHAIN_ATTR_TYPE,
+ NFTNL_CHAIN_ATTR_DEV,
+ __NFTNL_CHAIN_ATTR_MAX
};
-#define NFT_CHAIN_ATTR_MAX (__NFT_CHAIN_ATTR_MAX - 1)
+#define NFTNL_CHAIN_ATTR_MAX (__NFTNL_CHAIN_ATTR_MAX - 1)
-bool nft_chain_attr_is_set(const struct nft_chain *c, uint16_t attr);
-void nft_chain_attr_unset(struct nft_chain *c, uint16_t attr);
-void nft_chain_attr_set(struct nft_chain *t, uint16_t attr, const void *data);
-void nft_chain_attr_set_data(struct nft_chain *t, uint16_t attr,
+bool nftnl_chain_attr_is_set(const struct nftnl_chain *c, uint16_t attr);
+void nftnl_chain_attr_unset(struct nftnl_chain *c, uint16_t attr);
+void nftnl_chain_attr_set(struct nftnl_chain *t, uint16_t attr, const void *data);
+void nftnl_chain_attr_set_data(struct nftnl_chain *t, uint16_t attr,
const void *data, uint32_t data_len);
-void nft_chain_attr_set_u8(struct nft_chain *t, uint16_t attr, uint8_t data);
-void nft_chain_attr_set_u32(struct nft_chain *t, uint16_t attr, uint32_t data);
-void nft_chain_attr_set_s32(struct nft_chain *t, uint16_t attr, int32_t data);
-void nft_chain_attr_set_u64(struct nft_chain *t, uint16_t attr, uint64_t data);
-void nft_chain_attr_set_str(struct nft_chain *t, uint16_t attr, const char *str);
-
-const void *nft_chain_attr_get(struct nft_chain *c, uint16_t attr);
-const void *nft_chain_attr_get_data(struct nft_chain *c, uint16_t attr,
+void nftnl_chain_attr_set_u8(struct nftnl_chain *t, uint16_t attr, uint8_t data);
+void nftnl_chain_attr_set_u32(struct nftnl_chain *t, uint16_t attr, uint32_t data);
+void nftnl_chain_attr_set_s32(struct nftnl_chain *t, uint16_t attr, int32_t data);
+void nftnl_chain_attr_set_u64(struct nftnl_chain *t, uint16_t attr, uint64_t data);
+void nftnl_chain_attr_set_str(struct nftnl_chain *t, uint16_t attr, const char *str);
+
+const void *nftnl_chain_attr_get(struct nftnl_chain *c, uint16_t attr);
+const void *nftnl_chain_attr_get_data(struct nftnl_chain *c, uint16_t attr,
uint32_t *data_len);
-const char *nft_chain_attr_get_str(struct nft_chain *c, uint16_t attr);
-uint8_t nft_chain_attr_get_u8(struct nft_chain *c, uint16_t attr);
-uint32_t nft_chain_attr_get_u32(struct nft_chain *c, uint16_t attr);
-int32_t nft_chain_attr_get_s32(struct nft_chain *c, uint16_t attr);
-uint64_t nft_chain_attr_get_u64(struct nft_chain *c, uint16_t attr);
+const char *nftnl_chain_attr_get_str(struct nftnl_chain *c, uint16_t attr);
+uint8_t nftnl_chain_attr_get_u8(struct nftnl_chain *c, uint16_t attr);
+uint32_t nftnl_chain_attr_get_u32(struct nftnl_chain *c, uint16_t attr);
+int32_t nftnl_chain_attr_get_s32(struct nftnl_chain *c, uint16_t attr);
+uint64_t nftnl_chain_attr_get_u64(struct nftnl_chain *c, uint16_t attr);
struct nlmsghdr;
-void nft_chain_nlmsg_build_payload(struct nlmsghdr *nlh, const struct nft_chain *t);
+void nftnl_chain_nlmsg_build_payload(struct nlmsghdr *nlh, const struct nftnl_chain *t);
-int nft_chain_parse(struct nft_chain *c, enum nft_parse_type type,
- const char *data, struct nft_parse_err *err);
-int nft_chain_parse_file(struct nft_chain *c, enum nft_parse_type type,
- FILE *fp, struct nft_parse_err *err);
-int nft_chain_snprintf(char *buf, size_t size, struct nft_chain *t, uint32_t type, uint32_t flags);
-int nft_chain_fprintf(FILE *fp, struct nft_chain *c, uint32_t type, uint32_t flags);
+int nftnl_chain_parse(struct nftnl_chain *c, enum nftnl_parse_type type,
+ const char *data, struct nftnl_parse_err *err);
+int nftnl_chain_parse_file(struct nftnl_chain *c, enum nftnl_parse_type type,
+ FILE *fp, struct nftnl_parse_err *err);
+int nftnl_chain_snprintf(char *buf, size_t size, struct nftnl_chain *t, uint32_t type, uint32_t flags);
+int nftnl_chain_fprintf(FILE *fp, struct nftnl_chain *c, uint32_t type, uint32_t flags);
-#define nft_chain_nlmsg_build_hdr nft_nlmsg_build_hdr
-int nft_chain_nlmsg_parse(const struct nlmsghdr *nlh, struct nft_chain *t);
+#define nftnl_chain_nlmsg_build_hdr nftnl_nlmsg_build_hdr
+int nftnl_chain_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_chain *t);
-struct nft_chain_list;
+struct nftnl_chain_list;
-struct nft_chain_list *nft_chain_list_alloc(void);
-void nft_chain_list_free(struct nft_chain_list *list);
-int nft_chain_list_is_empty(struct nft_chain_list *list);
-int nft_chain_list_foreach(struct nft_chain_list *chain_list, int (*cb)(struct nft_chain *t, void *data), void *data);
+struct nftnl_chain_list *nftnl_chain_list_alloc(void);
+void nftnl_chain_list_free(struct nftnl_chain_list *list);
+int nftnl_chain_list_is_empty(struct nftnl_chain_list *list);
+int nftnl_chain_list_foreach(struct nftnl_chain_list *chain_list, int (*cb)(struct nftnl_chain *t, void *data), void *data);
-void nft_chain_list_add(struct nft_chain *r, struct nft_chain_list *list);
-void nft_chain_list_add_tail(struct nft_chain *r, struct nft_chain_list *list);
-void nft_chain_list_del(struct nft_chain *c);
+void nftnl_chain_list_add(struct nftnl_chain *r, struct nftnl_chain_list *list);
+void nftnl_chain_list_add_tail(struct nftnl_chain *r, struct nftnl_chain_list *list);
+void nftnl_chain_list_del(struct nftnl_chain *c);
-struct nft_chain_list_iter;
+struct nftnl_chain_list_iter;
-struct nft_chain_list_iter *nft_chain_list_iter_create(struct nft_chain_list *l);
-struct nft_chain *nft_chain_list_iter_next(struct nft_chain_list_iter *iter);
-void nft_chain_list_iter_destroy(struct nft_chain_list_iter *iter);
+struct nftnl_chain_list_iter *nftnl_chain_list_iter_create(struct nftnl_chain_list *l);
+struct nftnl_chain *nftnl_chain_list_iter_next(struct nftnl_chain_list_iter *iter);
+void nftnl_chain_list_iter_destroy(struct nftnl_chain_list_iter *iter);
#ifdef __cplusplus
} /* extern "C" */
diff --git a/include/libnftnl/common.h b/include/libnftnl/common.h
index 14db823..b9c6ff3 100644
--- a/include/libnftnl/common.h
+++ b/include/libnftnl/common.h
@@ -4,52 +4,52 @@
#include <stdint.h>
enum {
- NFT_PARSE_EBADINPUT = 0,
- NFT_PARSE_EMISSINGNODE,
- NFT_PARSE_EBADTYPE,
- NFT_PARSE_EOPNOTSUPP,
+ NFTNL_PARSE_EBADINPUT = 0,
+ NFTNL_PARSE_EMISSINGNODE,
+ NFTNL_PARSE_EBADTYPE,
+ NFTNL_PARSE_EOPNOTSUPP,
};
-enum nft_output_type {
- NFT_OUTPUT_DEFAULT = 0,
- NFT_OUTPUT_XML,
- NFT_OUTPUT_JSON,
+enum nftnl_output_type {
+ NFTNL_OUTPUT_DEFAULT = 0,
+ NFTNL_OUTPUT_XML,
+ NFTNL_OUTPUT_JSON,
};
-enum nft_output_flags {
- NFT_OF_EVENT_NEW = (1 << 0),
- NFT_OF_EVENT_DEL = (1 << 1),
- NFT_OF_EVENT_ANY = (NFT_OF_EVENT_NEW | NFT_OF_EVENT_DEL),
+enum nftnl_output_flags {
+ NFTNL_OF_EVENT_NEW = (1 << 0),
+ NFTNL_OF_EVENT_DEL = (1 << 1),
+ NFTNL_OF_EVENT_ANY = (NFTNL_OF_EVENT_NEW | NFTNL_OF_EVENT_DEL),
};
-enum nft_cmd_type {
- NFT_CMD_UNSPEC = 0,
- NFT_CMD_ADD,
- NFT_CMD_INSERT,
- NFT_CMD_DELETE,
- NFT_CMD_REPLACE,
- NFT_CMD_FLUSH,
- NFT_CMD_MAX,
+enum nftnl_cmd_type {
+ NFTNL_CMD_UNSPEC = 0,
+ NFTNL_CMD_ADD,
+ NFTNL_CMD_INSERT,
+ NFTNL_CMD_DELETE,
+ NFTNL_CMD_REPLACE,
+ NFTNL_CMD_FLUSH,
+ NFTNL_CMD_MAX,
};
-enum nft_parse_type {
- NFT_PARSE_NONE = 0,
- NFT_PARSE_XML,
- NFT_PARSE_JSON,
- NFT_PARSE_MAX,
+enum nftnl_parse_type {
+ NFTNL_PARSE_NONE = 0,
+ NFTNL_PARSE_XML,
+ NFTNL_PARSE_JSON,
+ NFTNL_PARSE_MAX,
};
-struct nft_parse_err;
+struct nftnl_parse_err;
-struct nlmsghdr *nft_nlmsg_build_hdr(char *buf, uint16_t cmd, uint16_t family,
+struct nlmsghdr *nftnl_nlmsg_build_hdr(char *buf, uint16_t cmd, uint16_t family,
uint16_t type, uint32_t seq);
-struct nft_parse_err *nft_parse_err_alloc(void);
-void nft_parse_err_free(struct nft_parse_err *);
-int nft_parse_perror(const char *str, struct nft_parse_err *err);
+struct nftnl_parse_err *nftnl_parse_err_alloc(void);
+void nftnl_parse_err_free(struct nftnl_parse_err *);
+int nftnl_parse_perror(const char *str, struct nftnl_parse_err *err);
-int nft_batch_is_supported(void);
-void nft_batch_begin(char *buf, uint32_t seq);
-void nft_batch_end(char *buf, uint32_t seq);
+int nftnl_batch_is_supported(void);
+void nftnl_batch_begin(char *buf, uint32_t seq);
+void nftnl_batch_end(char *buf, uint32_t seq);
#endif
diff --git a/include/libnftnl/expr.h b/include/libnftnl/expr.h
index 59ae2d7..1ca1d8b 100644
--- a/include/libnftnl/expr.h
+++ b/include/libnftnl/expr.h
@@ -9,168 +9,168 @@
extern "C" {
#endif
-struct nft_rule_expr;
+struct nftnl_rule_expr;
enum {
- NFT_RULE_EXPR_ATTR_NAME = 0,
- NFT_RULE_EXPR_ATTR_BASE,
+ NFTNL_RULE_EXPR_ATTR_NAME = 0,
+ NFTNL_RULE_EXPR_ATTR_BASE,
};
-struct nft_rule_expr *nft_rule_expr_alloc(const char *name);
-void nft_rule_expr_free(struct nft_rule_expr *expr);
+struct nftnl_rule_expr *nftnl_rule_expr_alloc(const char *name);
+void nftnl_rule_expr_free(struct nftnl_rule_expr *expr);
-bool nft_rule_expr_is_set(const struct nft_rule_expr *expr, uint16_t type);
-void nft_rule_expr_set(struct nft_rule_expr *expr, uint16_t type, const void *data, uint32_t data_len);
-#define nft_rule_expr_set_data nft_rule_expr_set
-void nft_rule_expr_set_u8(struct nft_rule_expr *expr, uint16_t type, uint8_t data);
-void nft_rule_expr_set_u16(struct nft_rule_expr *expr, uint16_t type, uint16_t data);
-void nft_rule_expr_set_u32(struct nft_rule_expr *expr, uint16_t type, uint32_t data);
-void nft_rule_expr_set_u64(struct nft_rule_expr *expr, uint16_t type, uint64_t data);
-void nft_rule_expr_set_str(struct nft_rule_expr *expr, uint16_t type, const char *str);
+bool nftnl_rule_expr_is_set(const struct nftnl_rule_expr *expr, uint16_t type);
+void nftnl_rule_expr_set(struct nftnl_rule_expr *expr, uint16_t type, const void *data, uint32_t data_len);
+#define nftnl_rule_expr_set_data nftnl_rule_expr_set
+void nftnl_rule_expr_set_u8(struct nftnl_rule_expr *expr, uint16_t type, uint8_t data);
+void nftnl_rule_expr_set_u16(struct nftnl_rule_expr *expr, uint16_t type, uint16_t data);
+void nftnl_rule_expr_set_u32(struct nftnl_rule_expr *expr, uint16_t type, uint32_t data);
+void nftnl_rule_expr_set_u64(struct nftnl_rule_expr *expr, uint16_t type, uint64_t data);
+void nftnl_rule_expr_set_str(struct nftnl_rule_expr *expr, uint16_t type, const char *str);
-const void *nft_rule_expr_get(const struct nft_rule_expr *expr, uint16_t type, uint32_t *data_len);
-#define nft_rule_expr_get_data nft_rule_expr_get
-uint8_t nft_rule_expr_get_u8(const struct nft_rule_expr *expr, uint16_t type);
-uint16_t nft_rule_expr_get_u16(const struct nft_rule_expr *expr, uint16_t type);
-uint32_t nft_rule_expr_get_u32(const struct nft_rule_expr *expr, uint16_t type);
-uint64_t nft_rule_expr_get_u64(const struct nft_rule_expr *expr, uint16_t type);
-const char *nft_rule_expr_get_str(const struct nft_rule_expr *expr, uint16_t type);
+const void *nftnl_rule_expr_get(const struct nftnl_rule_expr *expr, uint16_t type, uint32_t *data_len);
+#define nftnl_rule_expr_get_data nftnl_rule_expr_get
+uint8_t nftnl_rule_expr_get_u8(const struct nftnl_rule_expr *expr, uint16_t type);
+uint16_t nftnl_rule_expr_get_u16(const struct nftnl_rule_expr *expr, uint16_t type);
+uint32_t nftnl_rule_expr_get_u32(const struct nftnl_rule_expr *expr, uint16_t type);
+uint64_t nftnl_rule_expr_get_u64(const struct nftnl_rule_expr *expr, uint16_t type);
+const char *nftnl_rule_expr_get_str(const struct nftnl_rule_expr *expr, uint16_t type);
-int nft_rule_expr_snprintf(char *buf, size_t buflen, struct nft_rule_expr *expr, uint32_t type, uint32_t flags);
+int nftnl_rule_expr_snprintf(char *buf, size_t buflen, struct nftnl_rule_expr *expr, uint32_t type, uint32_t flags);
enum {
- NFT_EXPR_PAYLOAD_DREG = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_PAYLOAD_BASE,
- NFT_EXPR_PAYLOAD_OFFSET,
- NFT_EXPR_PAYLOAD_LEN,
+ NFTNL_EXPR_PAYLOAD_DREG = NFTNL_RULE_EXPR_ATTR_BASE,
+ NFTNL_EXPR_PAYLOAD_BASE,
+ NFTNL_EXPR_PAYLOAD_OFFSET,
+ NFTNL_EXPR_PAYLOAD_LEN,
};
enum {
- NFT_EXPR_META_KEY = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_META_DREG,
- NFT_EXPR_META_SREG,
+ NFTNL_EXPR_META_KEY = NFTNL_RULE_EXPR_ATTR_BASE,
+ NFTNL_EXPR_META_DREG,
+ NFTNL_EXPR_META_SREG,
};
enum {
- NFT_EXPR_CMP_SREG = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_CMP_OP,
- NFT_EXPR_CMP_DATA,
+ NFTNL_EXPR_CMP_SREG = NFTNL_RULE_EXPR_ATTR_BASE,
+ NFTNL_EXPR_CMP_OP,
+ NFTNL_EXPR_CMP_DATA,
};
enum {
- NFT_EXPR_IMM_DREG = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_IMM_DATA,
- NFT_EXPR_IMM_VERDICT,
- NFT_EXPR_IMM_CHAIN,
+ NFTNL_EXPR_IMM_DREG = NFTNL_RULE_EXPR_ATTR_BASE,
+ NFTNL_EXPR_IMM_DATA,
+ NFTNL_EXPR_IMM_VERDICT,
+ NFTNL_EXPR_IMM_CHAIN,
};
enum {
- NFT_EXPR_CTR_PACKETS = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_CTR_BYTES,
+ NFTNL_EXPR_CTR_PACKETS = NFTNL_RULE_EXPR_ATTR_BASE,
+ NFTNL_EXPR_CTR_BYTES,
};
enum {
- NFT_EXPR_BITWISE_SREG = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_BITWISE_DREG,
- NFT_EXPR_BITWISE_LEN,
- NFT_EXPR_BITWISE_MASK,
- NFT_EXPR_BITWISE_XOR,
+ NFTNL_EXPR_BITWISE_SREG = NFTNL_RULE_EXPR_ATTR_BASE,
+ NFTNL_EXPR_BITWISE_DREG,
+ NFTNL_EXPR_BITWISE_LEN,
+ NFTNL_EXPR_BITWISE_MASK,
+ NFTNL_EXPR_BITWISE_XOR,
};
enum {
- NFT_EXPR_TG_NAME = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_TG_REV,
- NFT_EXPR_TG_INFO,
+ NFTNL_EXPR_TG_NAME = NFTNL_RULE_EXPR_ATTR_BASE,
+ NFTNL_EXPR_TG_REV,
+ NFTNL_EXPR_TG_INFO,
};
enum {
- NFT_EXPR_MT_NAME = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_MT_REV,
- NFT_EXPR_MT_INFO,
+ NFTNL_EXPR_MT_NAME = NFTNL_RULE_EXPR_ATTR_BASE,
+ NFTNL_EXPR_MT_REV,
+ NFTNL_EXPR_MT_INFO,
};
enum {
- NFT_EXPR_NAT_TYPE = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_NAT_FAMILY,
- NFT_EXPR_NAT_REG_ADDR_MIN,
- NFT_EXPR_NAT_REG_ADDR_MAX,
- NFT_EXPR_NAT_REG_PROTO_MIN,
- NFT_EXPR_NAT_REG_PROTO_MAX,
- NFT_EXPR_NAT_FLAGS,
+ NFTNL_EXPR_NAT_TYPE = NFTNL_RULE_EXPR_ATTR_BASE,
+ NFTNL_EXPR_NAT_FAMILY,
+ NFTNL_EXPR_NAT_REG_ADDR_MIN,
+ NFTNL_EXPR_NAT_REG_ADDR_MAX,
+ NFTNL_EXPR_NAT_REG_PROTO_MIN,
+ NFTNL_EXPR_NAT_REG_PROTO_MAX,
+ NFTNL_EXPR_NAT_FLAGS,
};
enum {
- NFT_EXPR_LOOKUP_SREG = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_LOOKUP_DREG,
- NFT_EXPR_LOOKUP_SET,
- NFT_EXPR_LOOKUP_SET_ID,
+ NFTNL_EXPR_LOOKUP_SREG = NFTNL_RULE_EXPR_ATTR_BASE,
+ NFTNL_EXPR_LOOKUP_DREG,
+ NFTNL_EXPR_LOOKUP_SET,
+ NFTNL_EXPR_LOOKUP_SET_ID,
};
enum {
- NFT_EXPR_DYNSET_SREG_KEY = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_DYNSET_SREG_DATA,
- NFT_EXPR_DYNSET_OP,
- NFT_EXPR_DYNSET_TIMEOUT,
- NFT_EXPR_DYNSET_SET_NAME,
- NFT_EXPR_DYNSET_SET_ID,
- NFT_EXPR_DYNSET_EXPR,
+ NFTNL_EXPR_DYNSET_SREG_KEY = NFTNL_RULE_EXPR_ATTR_BASE,
+ NFTNL_EXPR_DYNSET_SREG_DATA,
+ NFTNL_EXPR_DYNSET_OP,
+ NFTNL_EXPR_DYNSET_TIMEOUT,
+ NFTNL_EXPR_DYNSET_SET_NAME,
+ NFTNL_EXPR_DYNSET_SET_ID,
+ NFTNL_EXPR_DYNSET_EXPR,
};
enum {
- NFT_EXPR_LOG_PREFIX = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_LOG_GROUP,
- NFT_EXPR_LOG_SNAPLEN,
- NFT_EXPR_LOG_QTHRESHOLD,
- NFT_EXPR_LOG_LEVEL,
- NFT_EXPR_LOG_FLAGS,
+ NFTNL_EXPR_LOG_PREFIX = NFTNL_RULE_EXPR_ATTR_BASE,
+ NFTNL_EXPR_LOG_GROUP,
+ NFTNL_EXPR_LOG_SNAPLEN,
+ NFTNL_EXPR_LOG_QTHRESHOLD,
+ NFTNL_EXPR_LOG_LEVEL,
+ NFTNL_EXPR_LOG_FLAGS,
};
enum {
- NFT_EXPR_EXTHDR_DREG = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_EXTHDR_TYPE,
- NFT_EXPR_EXTHDR_OFFSET,
- NFT_EXPR_EXTHDR_LEN,
+ NFTNL_EXPR_EXTHDR_DREG = NFTNL_RULE_EXPR_ATTR_BASE,
+ NFTNL_EXPR_EXTHDR_TYPE,
+ NFTNL_EXPR_EXTHDR_OFFSET,
+ NFTNL_EXPR_EXTHDR_LEN,
};
enum {
- NFT_EXPR_CT_DREG = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_CT_KEY,
- NFT_EXPR_CT_DIR,
- NFT_EXPR_CT_SREG,
+ NFTNL_EXPR_CT_DREG = NFTNL_RULE_EXPR_ATTR_BASE,
+ NFTNL_EXPR_CT_KEY,
+ NFTNL_EXPR_CT_DIR,
+ NFTNL_EXPR_CT_SREG,
};
enum {
- NFT_EXPR_BYTEORDER_DREG = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_BYTEORDER_SREG,
- NFT_EXPR_BYTEORDER_OP,
- NFT_EXPR_BYTEORDER_LEN,
- NFT_EXPR_BYTEORDER_SIZE,
+ NFTNL_EXPR_BYTEORDER_DREG = NFTNL_RULE_EXPR_ATTR_BASE,
+ NFTNL_EXPR_BYTEORDER_SREG,
+ NFTNL_EXPR_BYTEORDER_OP,
+ NFTNL_EXPR_BYTEORDER_LEN,
+ NFTNL_EXPR_BYTEORDER_SIZE,
};
enum {
- NFT_EXPR_LIMIT_RATE = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_LIMIT_UNIT,
+ NFTNL_EXPR_LIMIT_RATE = NFTNL_RULE_EXPR_ATTR_BASE,
+ NFTNL_EXPR_LIMIT_UNIT,
};
enum {
- NFT_EXPR_REJECT_TYPE = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_REJECT_CODE,
+ NFTNL_EXPR_REJECT_TYPE = NFTNL_RULE_EXPR_ATTR_BASE,
+ NFTNL_EXPR_REJECT_CODE,
};
enum {
- NFT_EXPR_QUEUE_NUM = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_QUEUE_TOTAL,
- NFT_EXPR_QUEUE_FLAGS,
+ NFTNL_EXPR_QUEUE_NUM = NFTNL_RULE_EXPR_ATTR_BASE,
+ NFTNL_EXPR_QUEUE_TOTAL,
+ NFTNL_EXPR_QUEUE_FLAGS,
};
enum {
- NFT_EXPR_MASQ_FLAGS = NFT_RULE_EXPR_ATTR_BASE,
+ NFTNL_EXPR_MASQ_FLAGS = NFTNL_RULE_EXPR_ATTR_BASE,
};
enum {
- NFT_EXPR_REDIR_REG_PROTO_MIN = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_REDIR_REG_PROTO_MAX,
- NFT_EXPR_REDIR_FLAGS,
+ NFTNL_EXPR_REDIR_REG_PROTO_MIN = NFTNL_RULE_EXPR_ATTR_BASE,
+ NFTNL_EXPR_REDIR_REG_PROTO_MAX,
+ NFTNL_EXPR_REDIR_FLAGS,
};
#ifdef __cplusplus
diff --git a/include/libnftnl/gen.h b/include/libnftnl/gen.h
index 00753b0..eb72d56 100644
--- a/include/libnftnl/gen.h
+++ b/include/libnftnl/gen.h
@@ -12,37 +12,37 @@
extern "C" {
#endif
-struct nft_gen;
+struct nftnl_gen;
-struct nft_gen *nft_gen_alloc(void);
-void nft_gen_free(struct nft_gen *);
+struct nftnl_gen *nftnl_gen_alloc(void);
+void nftnl_gen_free(struct nftnl_gen *);
enum {
- NFT_GEN_ID = 0,
- __NFT_GEN_MAX
+ NFTNL_GEN_ID = 0,
+ __NFTNL_GEN_MAX
};
-#define NFT_GEN_MAX (__NFT_GEN_MAX - 1)
+#define NFTNL_GEN_MAX (__NFTNL_GEN_MAX - 1)
-bool nft_gen_attr_is_set(const struct nft_gen *gen, uint16_t attr);
-void nft_gen_attr_unset(struct nft_gen *gen, uint16_t attr);
-void nft_gen_attr_set(struct nft_gen *gen, uint16_t attr, const void *data);
-void nft_gen_attr_set_data(struct nft_gen *gen, uint16_t attr,
+bool nftnl_gen_attr_is_set(const struct nftnl_gen *gen, uint16_t attr);
+void nftnl_gen_attr_unset(struct nftnl_gen *gen, uint16_t attr);
+void nftnl_gen_attr_set(struct nftnl_gen *gen, uint16_t attr, const void *data);
+void nftnl_gen_attr_set_data(struct nftnl_gen *gen, uint16_t attr,
const void *data, uint32_t data_len);
-const void *nft_gen_attr_get(struct nft_gen *gen, uint16_t attr);
-const void *nft_gen_attr_get_data(struct nft_gen *gen, uint16_t attr,
+const void *nftnl_gen_attr_get(struct nftnl_gen *gen, uint16_t attr);
+const void *nftnl_gen_attr_get_data(struct nftnl_gen *gen, uint16_t attr,
uint32_t *data_len);
-void nft_gen_attr_set_u32(struct nft_gen *gen, uint16_t attr, uint32_t data);
-uint32_t nft_gen_attr_get_u32(struct nft_gen *gen, uint16_t attr);
+void nftnl_gen_attr_set_u32(struct nftnl_gen *gen, uint16_t attr, uint32_t data);
+uint32_t nftnl_gen_attr_get_u32(struct nftnl_gen *gen, uint16_t attr);
struct nlmsghdr;
-int nft_gen_nlmsg_parse(const struct nlmsghdr *nlh, struct nft_gen *gen);
+int nftnl_gen_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_gen *gen);
-int nft_gen_snprintf(char *buf, size_t size, struct nft_gen *gen, uint32_t type, uint32_t flags);
-int nft_gen_fprintf(FILE *fp, struct nft_gen *gen, uint32_t type, uint32_t flags);
+int nftnl_gen_snprintf(char *buf, size_t size, struct nftnl_gen *gen, uint32_t type, uint32_t flags);
+int nftnl_gen_fprintf(FILE *fp, struct nftnl_gen *gen, uint32_t type, uint32_t flags);
-#define nft_gen_nlmsg_build_hdr nft_nlmsg_build_hdr
-int nft_gen_nlmsg_parse(const struct nlmsghdr *nlh, struct nft_gen *gen);
+#define nftnl_gen_nlmsg_build_hdr nftnl_nlmsg_build_hdr
+int nftnl_gen_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_gen *gen);
#ifdef __cplusplus
} /* extern "C" */
diff --git a/include/libnftnl/rule.h b/include/libnftnl/rule.h
index 62dba59..8aa47ea 100644
--- a/include/libnftnl/rule.h
+++ b/include/libnftnl/rule.h
@@ -12,84 +12,84 @@
extern "C" {
#endif
-struct nft_rule;
-struct nft_rule_expr;
+struct nftnl_rule;
+struct nftnl_rule_expr;
-struct nft_rule *nft_rule_alloc(void);
-void nft_rule_free(struct nft_rule *);
+struct nftnl_rule *nftnl_rule_alloc(void);
+void nftnl_rule_free(struct nftnl_rule *);
enum {
- NFT_RULE_ATTR_FAMILY = 0,
- NFT_RULE_ATTR_TABLE,
- NFT_RULE_ATTR_CHAIN,
- NFT_RULE_ATTR_HANDLE,
- NFT_RULE_ATTR_COMPAT_PROTO,
- NFT_RULE_ATTR_COMPAT_FLAGS,
- NFT_RULE_ATTR_POSITION,
- NFT_RULE_ATTR_USERDATA,
- __NFT_RULE_ATTR_MAX
+ NFTNL_RULE_ATTR_FAMILY = 0,
+ NFTNL_RULE_ATTR_TABLE,
+ NFTNL_RULE_ATTR_CHAIN,
+ NFTNL_RULE_ATTR_HANDLE,
+ NFTNL_RULE_ATTR_COMPAT_PROTO,
+ NFTNL_RULE_ATTR_COMPAT_FLAGS,
+ NFTNL_RULE_ATTR_POSITION,
+ NFTNL_RULE_ATTR_USERDATA,
+ __NFTNL_RULE_ATTR_MAX
};
-#define NFT_RULE_ATTR_MAX (__NFT_RULE_ATTR_MAX - 1)
+#define NFTNL_RULE_ATTR_MAX (__NFTNL_RULE_ATTR_MAX - 1)
-void nft_rule_attr_unset(struct nft_rule *r, uint16_t attr);
-bool nft_rule_attr_is_set(const struct nft_rule *r, uint16_t attr);
-void nft_rule_attr_set(struct nft_rule *r, uint16_t attr, const void *data);
-void nft_rule_attr_set_data(struct nft_rule *r, uint16_t attr,
+void nftnl_rule_attr_unset(struct nftnl_rule *r, uint16_t attr);
+bool nftnl_rule_attr_is_set(const struct nftnl_rule *r, uint16_t attr);
+void nftnl_rule_attr_set(struct nftnl_rule *r, uint16_t attr, const void *data);
+void nftnl_rule_attr_set_data(struct nftnl_rule *r, uint16_t attr,
const void *data, uint32_t data_len);
-void nft_rule_attr_set_u32(struct nft_rule *r, uint16_t attr, uint32_t val);
-void nft_rule_attr_set_u64(struct nft_rule *r, uint16_t attr, uint64_t val);
-void nft_rule_attr_set_str(struct nft_rule *r, uint16_t attr, const char *str);
+void nftnl_rule_attr_set_u32(struct nftnl_rule *r, uint16_t attr, uint32_t val);
+void nftnl_rule_attr_set_u64(struct nftnl_rule *r, uint16_t attr, uint64_t val);
+void nftnl_rule_attr_set_str(struct nftnl_rule *r, uint16_t attr, const char *str);
-const void *nft_rule_attr_get(const struct nft_rule *r, uint16_t attr);
-const void *nft_rule_attr_get_data(const struct nft_rule *r, uint16_t attr,
+const void *nftnl_rule_attr_get(const struct nftnl_rule *r, uint16_t attr);
+const void *nftnl_rule_attr_get_data(const struct nftnl_rule *r, uint16_t attr,
uint32_t *data_len);
-const char *nft_rule_attr_get_str(const struct nft_rule *r, uint16_t attr);
-uint8_t nft_rule_attr_get_u8(const struct nft_rule *r, uint16_t attr);
-uint32_t nft_rule_attr_get_u32(const struct nft_rule *r, uint16_t attr);
-uint64_t nft_rule_attr_get_u64(const struct nft_rule *r, uint16_t attr);
+const char *nftnl_rule_attr_get_str(const struct nftnl_rule *r, uint16_t attr);
+uint8_t nftnl_rule_attr_get_u8(const struct nftnl_rule *r, uint16_t attr);
+uint32_t nftnl_rule_attr_get_u32(const struct nftnl_rule *r, uint16_t attr);
+uint64_t nftnl_rule_attr_get_u64(const struct nftnl_rule *r, uint16_t attr);
-void nft_rule_add_expr(struct nft_rule *r, struct nft_rule_expr *expr);
+void nftnl_rule_add_expr(struct nftnl_rule *r, struct nftnl_rule_expr *expr);
struct nlmsghdr;
-void nft_rule_nlmsg_build_payload(struct nlmsghdr *nlh, struct nft_rule *t);
+void nftnl_rule_nlmsg_build_payload(struct nlmsghdr *nlh, struct nftnl_rule *t);
-int nft_rule_parse(struct nft_rule *r, enum nft_parse_type type,
- const char *data, struct nft_parse_err *err);
-int nft_rule_parse_file(struct nft_rule *r, enum nft_parse_type type,
- FILE *fp, struct nft_parse_err *err);
-int nft_rule_snprintf(char *buf, size_t size, struct nft_rule *t, uint32_t type, uint32_t flags);
-int nft_rule_fprintf(FILE *fp, struct nft_rule *r, uint32_t type, uint32_t flags);
+int nftnl_rule_parse(struct nftnl_rule *r, enum nftnl_parse_type type,
+ const char *data, struct nftnl_parse_err *err);
+int nftnl_rule_parse_file(struct nftnl_rule *r, enum nftnl_parse_type type,
+ FILE *fp, struct nftnl_parse_err *err);
+int nftnl_rule_snprintf(char *buf, size_t size, struct nftnl_rule *t, uint32_t type, uint32_t flags);
+int nftnl_rule_fprintf(FILE *fp, struct nftnl_rule *r, uint32_t type, uint32_t flags);
-#define nft_rule_nlmsg_build_hdr nft_nlmsg_build_hdr
-int nft_rule_nlmsg_parse(const struct nlmsghdr *nlh, struct nft_rule *t);
+#define nftnl_rule_nlmsg_build_hdr nftnl_nlmsg_build_hdr
+int nftnl_rule_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_rule *t);
-int nft_rule_expr_foreach(struct nft_rule *r,
- int (*cb)(struct nft_rule_expr *e, void *data),
+int nftnl_rule_expr_foreach(struct nftnl_rule *r,
+ int (*cb)(struct nftnl_rule_expr *e, void *data),
void *data);
-struct nft_rule_expr_iter;
+struct nftnl_rule_expr_iter;
-struct nft_rule_expr_iter *nft_rule_expr_iter_create(struct nft_rule *r);
-struct nft_rule_expr *nft_rule_expr_iter_next(struct nft_rule_expr_iter *iter);
-void nft_rule_expr_iter_destroy(struct nft_rule_expr_iter *iter);
+struct nftnl_rule_expr_iter *nftnl_rule_expr_iter_create(struct nftnl_rule *r);
+struct nftnl_rule_expr *nftnl_rule_expr_iter_next(struct nftnl_rule_expr_iter *iter);
+void nftnl_rule_expr_iter_destroy(struct nftnl_rule_expr_iter *iter);
-struct nft_rule_list;
+struct nftnl_rule_list;
-struct nft_rule_list *nft_rule_list_alloc(void);
-void nft_rule_list_free(struct nft_rule_list *list);
-int nft_rule_list_is_empty(struct nft_rule_list *list);
-void nft_rule_list_add(struct nft_rule *r, struct nft_rule_list *list);
-void nft_rule_list_add_tail(struct nft_rule *r, struct nft_rule_list *list);
-void nft_rule_list_del(struct nft_rule *r);
-int nft_rule_list_foreach(struct nft_rule_list *rule_list, int (*cb)(struct nft_rule *t, void *data), void *data);
+struct nftnl_rule_list *nftnl_rule_list_alloc(void);
+void nftnl_rule_list_free(struct nftnl_rule_list *list);
+int nftnl_rule_list_is_empty(struct nftnl_rule_list *list);
+void nftnl_rule_list_add(struct nftnl_rule *r, struct nftnl_rule_list *list);
+void nftnl_rule_list_add_tail(struct nftnl_rule *r, struct nftnl_rule_list *list);
+void nftnl_rule_list_del(struct nftnl_rule *r);
+int nftnl_rule_list_foreach(struct nftnl_rule_list *rule_list, int (*cb)(struct nftnl_rule *t, void *data), void *data);
-struct nft_rule_list_iter;
+struct nftnl_rule_list_iter;
-struct nft_rule_list_iter *nft_rule_list_iter_create(struct nft_rule_list *l);
-struct nft_rule *nft_rule_list_iter_cur(struct nft_rule_list_iter *iter);
-struct nft_rule *nft_rule_list_iter_next(struct nft_rule_list_iter *iter);
-void nft_rule_list_iter_destroy(struct nft_rule_list_iter *iter);
+struct nftnl_rule_list_iter *nftnl_rule_list_iter_create(struct nftnl_rule_list *l);
+struct nftnl_rule *nftnl_rule_list_iter_cur(struct nftnl_rule_list_iter *iter);
+struct nftnl_rule *nftnl_rule_list_iter_next(struct nftnl_rule_list_iter *iter);
+void nftnl_rule_list_iter_destroy(struct nftnl_rule_list_iter *iter);
#ifdef __cplusplus
} /* extern "C" */
diff --git a/include/libnftnl/ruleset.h b/include/libnftnl/ruleset.h
index fe5e44f..12e2495 100644
--- a/include/libnftnl/ruleset.h
+++ b/include/libnftnl/ruleset.h
@@ -13,62 +13,62 @@
extern "C" {
#endif
-struct nft_ruleset;
+struct nftnl_ruleset;
-struct nft_ruleset *nft_ruleset_alloc(void);
-void nft_ruleset_free(struct nft_ruleset *r);
+struct nftnl_ruleset *nftnl_ruleset_alloc(void);
+void nftnl_ruleset_free(struct nftnl_ruleset *r);
enum {
- NFT_RULESET_ATTR_TABLELIST = 0,
- NFT_RULESET_ATTR_CHAINLIST,
- NFT_RULESET_ATTR_SETLIST,
- NFT_RULESET_ATTR_RULELIST,
+ NFTNL_RULESET_ATTR_TABLELIST = 0,
+ NFTNL_RULESET_ATTR_CHAINLIST,
+ NFTNL_RULESET_ATTR_SETLIST,
+ NFTNL_RULESET_ATTR_RULELIST,
};
-enum nft_ruleset_type {
- NFT_RULESET_UNSPEC = 0,
- NFT_RULESET_RULESET,
- NFT_RULESET_TABLE,
- NFT_RULESET_CHAIN,
- NFT_RULESET_RULE,
- NFT_RULESET_SET,
- NFT_RULESET_SET_ELEMS,
+enum nftnl_ruleset_type {
+ NFTNL_RULESET_UNSPEC = 0,
+ NFTNL_RULESET_RULESET,
+ NFTNL_RULESET_TABLE,
+ NFTNL_RULESET_CHAIN,
+ NFTNL_RULESET_RULE,
+ NFTNL_RULESET_SET,
+ NFTNL_RULESET_SET_ELEMS,
};
-bool nft_ruleset_attr_is_set(const struct nft_ruleset *r, uint16_t attr);
-void nft_ruleset_attr_unset(struct nft_ruleset *r, uint16_t attr);
-void nft_ruleset_attr_set(struct nft_ruleset *r, uint16_t attr, void *data);
-void *nft_ruleset_attr_get(const struct nft_ruleset *r, uint16_t attr);
+bool nftnl_ruleset_attr_is_set(const struct nftnl_ruleset *r, uint16_t attr);
+void nftnl_ruleset_attr_unset(struct nftnl_ruleset *r, uint16_t attr);
+void nftnl_ruleset_attr_set(struct nftnl_ruleset *r, uint16_t attr, void *data);
+void *nftnl_ruleset_attr_get(const struct nftnl_ruleset *r, uint16_t attr);
enum {
- NFT_RULESET_CTX_CMD = 0,
- NFT_RULESET_CTX_TYPE,
- NFT_RULESET_CTX_TABLE,
- NFT_RULESET_CTX_CHAIN,
- NFT_RULESET_CTX_RULE,
- NFT_RULESET_CTX_SET,
- NFT_RULESET_CTX_DATA,
+ NFTNL_RULESET_CTX_CMD = 0,
+ NFTNL_RULESET_CTX_TYPE,
+ NFTNL_RULESET_CTX_TABLE,
+ NFTNL_RULESET_CTX_CHAIN,
+ NFTNL_RULESET_CTX_RULE,
+ NFTNL_RULESET_CTX_SET,
+ NFTNL_RULESET_CTX_DATA,
};
-struct nft_parse_ctx;
-void nft_ruleset_ctx_free(const struct nft_parse_ctx *ctx);
-bool nft_ruleset_ctx_is_set(const struct nft_parse_ctx *ctx, uint16_t attr);
-void *nft_ruleset_ctx_get(const struct nft_parse_ctx *ctx, uint16_t attr);
-uint32_t nft_ruleset_ctx_get_u32(const struct nft_parse_ctx *ctx,
+struct nftnl_parse_ctx;
+void nftnl_ruleset_ctx_free(const struct nftnl_parse_ctx *ctx);
+bool nftnl_ruleset_ctx_is_set(const struct nftnl_parse_ctx *ctx, uint16_t attr);
+void *nftnl_ruleset_ctx_get(const struct nftnl_parse_ctx *ctx, uint16_t attr);
+uint32_t nftnl_ruleset_ctx_get_u32(const struct nftnl_parse_ctx *ctx,
uint16_t attr);
-int nft_ruleset_parse_file_cb(enum nft_parse_type type, FILE *fp,
- struct nft_parse_err *err, void *data,
- int (*cb)(const struct nft_parse_ctx *ctx));
-int nft_ruleset_parse_buffer_cb(enum nft_parse_type type, const char *buffer,
- struct nft_parse_err *err, void *data,
- int (*cb)(const struct nft_parse_ctx *ctx));
-int nft_ruleset_parse(struct nft_ruleset *rs, enum nft_parse_type type,
- const char *data, struct nft_parse_err *err);
-int nft_ruleset_parse_file(struct nft_ruleset *rs, enum nft_parse_type type,
- FILE *fp, struct nft_parse_err *err);
-int nft_ruleset_snprintf(char *buf, size_t size, const struct nft_ruleset *rs, uint32_t type, uint32_t flags);
-int nft_ruleset_fprintf(FILE *fp, const struct nft_ruleset *rs, uint32_t type, uint32_t flags);
+int nftnl_ruleset_parse_file_cb(enum nftnl_parse_type type, FILE *fp,
+ struct nftnl_parse_err *err, void *data,
+ int (*cb)(const struct nftnl_parse_ctx *ctx));
+int nftnl_ruleset_parse_buffer_cb(enum nftnl_parse_type type, const char *buffer,
+ struct nftnl_parse_err *err, void *data,
+ int (*cb)(const struct nftnl_parse_ctx *ctx));
+int nftnl_ruleset_parse(struct nftnl_ruleset *rs, enum nftnl_parse_type type,
+ const char *data, struct nftnl_parse_err *err);
+int nftnl_ruleset_parse_file(struct nftnl_ruleset *rs, enum nftnl_parse_type type,
+ FILE *fp, struct nftnl_parse_err *err);
+int nftnl_ruleset_snprintf(char *buf, size_t size, const struct nftnl_ruleset *rs, uint32_t type, uint32_t flags);
+int nftnl_ruleset_fprintf(FILE *fp, const struct nftnl_ruleset *rs, uint32_t type, uint32_t flags);
#ifdef __cplusplus
} /* extern "C" */
diff --git a/include/libnftnl/set.h b/include/libnftnl/set.h
index 4efc7d4..d3958f6 100644
--- a/include/libnftnl/set.h
+++ b/include/libnftnl/set.h
@@ -9,135 +9,135 @@
#include <libnftnl/common.h>
enum {
- NFT_SET_ATTR_TABLE,
- NFT_SET_ATTR_NAME,
- NFT_SET_ATTR_FLAGS,
- NFT_SET_ATTR_KEY_TYPE,
- NFT_SET_ATTR_KEY_LEN,
- NFT_SET_ATTR_DATA_TYPE,
- NFT_SET_ATTR_DATA_LEN,
- NFT_SET_ATTR_FAMILY,
- NFT_SET_ATTR_ID,
- NFT_SET_ATTR_POLICY,
- NFT_SET_ATTR_DESC_SIZE,
- NFT_SET_ATTR_TIMEOUT,
- NFT_SET_ATTR_GC_INTERVAL,
- __NFT_SET_ATTR_MAX
+ NFTNL_SET_ATTR_TABLE,
+ NFTNL_SET_ATTR_NAME,
+ NFTNL_SET_ATTR_FLAGS,
+ NFTNL_SET_ATTR_KEY_TYPE,
+ NFTNL_SET_ATTR_KEY_LEN,
+ NFTNL_SET_ATTR_DATA_TYPE,
+ NFTNL_SET_ATTR_DATA_LEN,
+ NFTNL_SET_ATTR_FAMILY,
+ NFTNL_SET_ATTR_ID,
+ NFTNL_SET_ATTR_POLICY,
+ NFTNL_SET_ATTR_DESC_SIZE,
+ NFTNL_SET_ATTR_TIMEOUT,
+ NFTNL_SET_ATTR_GC_INTERVAL,
+ __NFTNL_SET_ATTR_MAX
};
-#define NFT_SET_ATTR_MAX (__NFT_SET_ATTR_MAX - 1)
+#define NFTNL_SET_ATTR_MAX (__NFTNL_SET_ATTR_MAX - 1)
-struct nft_set;
+struct nftnl_set;
-struct nft_set *nft_set_alloc(void);
-void nft_set_free(struct nft_set *s);
+struct nftnl_set *nftnl_set_alloc(void);
+void nftnl_set_free(struct nftnl_set *s);
-struct nft_set *nft_set_clone(const struct nft_set *set);
+struct nftnl_set *nftnl_set_clone(const struct nftnl_set *set);
-bool nft_set_attr_is_set(const struct nft_set *s, uint16_t attr);
-void nft_set_attr_unset(struct nft_set *s, uint16_t attr);
-void nft_set_attr_set(struct nft_set *s, uint16_t attr, const void *data);
-void nft_set_attr_set_data(struct nft_set *s, uint16_t attr, const void *data,
+bool nftnl_set_attr_is_set(const struct nftnl_set *s, uint16_t attr);
+void nftnl_set_attr_unset(struct nftnl_set *s, uint16_t attr);
+void nftnl_set_attr_set(struct nftnl_set *s, uint16_t attr, const void *data);
+void nftnl_set_attr_set_data(struct nftnl_set *s, uint16_t attr, const void *data,
uint32_t data_len);
-void nft_set_attr_set_u32(struct nft_set *s, uint16_t attr, uint32_t val);
-void nft_set_attr_set_u64(struct nft_set *s, uint16_t attr, uint64_t val);
-void nft_set_attr_set_str(struct nft_set *s, uint16_t attr, const char *str);
+void nftnl_set_attr_set_u32(struct nftnl_set *s, uint16_t attr, uint32_t val);
+void nftnl_set_attr_set_u64(struct nftnl_set *s, uint16_t attr, uint64_t val);
+void nftnl_set_attr_set_str(struct nftnl_set *s, uint16_t attr, const char *str);
-const void *nft_set_attr_get(struct nft_set *s, uint16_t attr);
-const void *nft_set_attr_get_data(struct nft_set *s, uint16_t attr,
+const void *nftnl_set_attr_get(struct nftnl_set *s, uint16_t attr);
+const void *nftnl_set_attr_get_data(struct nftnl_set *s, uint16_t attr,
uint32_t *data_len);
-const char *nft_set_attr_get_str(struct nft_set *s, uint16_t attr);
-uint32_t nft_set_attr_get_u32(struct nft_set *s, uint16_t attr);
-uint64_t nft_set_attr_get_u64(struct nft_set *s, uint16_t attr);
+const char *nftnl_set_attr_get_str(struct nftnl_set *s, uint16_t attr);
+uint32_t nftnl_set_attr_get_u32(struct nftnl_set *s, uint16_t attr);
+uint64_t nftnl_set_attr_get_u64(struct nftnl_set *s, uint16_t attr);
struct nlmsghdr;
-#define nft_set_nlmsg_build_hdr nft_nlmsg_build_hdr
-void nft_set_nlmsg_build_payload(struct nlmsghdr *nlh, struct nft_set *s);
-int nft_set_nlmsg_parse(const struct nlmsghdr *nlh, struct nft_set *s);
-int nft_set_elems_nlmsg_parse(const struct nlmsghdr *nlh, struct nft_set *s);
+#define nftnl_set_nlmsg_build_hdr nftnl_nlmsg_build_hdr
+void nftnl_set_nlmsg_build_payload(struct nlmsghdr *nlh, struct nftnl_set *s);
+int nftnl_set_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_set *s);
+int nftnl_set_elems_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_set *s);
-int nft_set_snprintf(char *buf, size_t size, struct nft_set *s, uint32_t type, uint32_t flags);
-int nft_set_fprintf(FILE *fp, struct nft_set *s, uint32_t type, uint32_t flags);
+int nftnl_set_snprintf(char *buf, size_t size, struct nftnl_set *s, uint32_t type, uint32_t flags);
+int nftnl_set_fprintf(FILE *fp, struct nftnl_set *s, uint32_t type, uint32_t flags);
-struct nft_set_list;
+struct nftnl_set_list;
-struct nft_set_list *nft_set_list_alloc(void);
-void nft_set_list_free(struct nft_set_list *list);
-int nft_set_list_is_empty(struct nft_set_list *list);
-void nft_set_list_add(struct nft_set *s, struct nft_set_list *list);
-void nft_set_list_add_tail(struct nft_set *s, struct nft_set_list *list);
-void nft_set_list_del(struct nft_set *s);
-int nft_set_list_foreach(struct nft_set_list *set_list, int (*cb)(struct nft_set *t, void *data), void *data);
+struct nftnl_set_list *nftnl_set_list_alloc(void);
+void nftnl_set_list_free(struct nftnl_set_list *list);
+int nftnl_set_list_is_empty(struct nftnl_set_list *list);
+void nftnl_set_list_add(struct nftnl_set *s, struct nftnl_set_list *list);
+void nftnl_set_list_add_tail(struct nftnl_set *s, struct nftnl_set_list *list);
+void nftnl_set_list_del(struct nftnl_set *s);
+int nftnl_set_list_foreach(struct nftnl_set_list *set_list, int (*cb)(struct nftnl_set *t, void *data), void *data);
-struct nft_set_list_iter;
-struct nft_set_list_iter *nft_set_list_iter_create(struct nft_set_list *l);
-struct nft_set *nft_set_list_iter_cur(struct nft_set_list_iter *iter);
-struct nft_set *nft_set_list_iter_next(struct nft_set_list_iter *iter);
-void nft_set_list_iter_destroy(struct nft_set_list_iter *iter);
+struct nftnl_set_list_iter;
+struct nftnl_set_list_iter *nftnl_set_list_iter_create(struct nftnl_set_list *l);
+struct nftnl_set *nftnl_set_list_iter_cur(struct nftnl_set_list_iter *iter);
+struct nftnl_set *nftnl_set_list_iter_next(struct nftnl_set_list_iter *iter);
+void nftnl_set_list_iter_destroy(struct nftnl_set_list_iter *iter);
-int nft_set_parse(struct nft_set *s, enum nft_parse_type type,
- const char *data, struct nft_parse_err *err);
-int nft_set_parse_file(struct nft_set *s, enum nft_parse_type type,
- FILE *fp, struct nft_parse_err *err);
+int nftnl_set_parse(struct nftnl_set *s, enum nftnl_parse_type type,
+ const char *data, struct nftnl_parse_err *err);
+int nftnl_set_parse_file(struct nftnl_set *s, enum nftnl_parse_type type,
+ FILE *fp, struct nftnl_parse_err *err);
/*
* Set elements
*/
enum {
- NFT_SET_ELEM_ATTR_FLAGS,
- NFT_SET_ELEM_ATTR_KEY,
- NFT_SET_ELEM_ATTR_VERDICT,
- NFT_SET_ELEM_ATTR_CHAIN,
- NFT_SET_ELEM_ATTR_DATA,
- NFT_SET_ELEM_ATTR_TIMEOUT,
- NFT_SET_ELEM_ATTR_EXPIRATION,
- NFT_SET_ELEM_ATTR_USERDATA,
- NFT_SET_ELEM_ATTR_EXPR,
+ NFTNL_SET_ELEM_ATTR_FLAGS,
+ NFTNL_SET_ELEM_ATTR_KEY,
+ NFTNL_SET_ELEM_ATTR_VERDICT,
+ NFTNL_SET_ELEM_ATTR_CHAIN,
+ NFTNL_SET_ELEM_ATTR_DATA,
+ NFTNL_SET_ELEM_ATTR_TIMEOUT,
+ NFTNL_SET_ELEM_ATTR_EXPIRATION,
+ NFTNL_SET_ELEM_ATTR_USERDATA,
+ NFTNL_SET_ELEM_ATTR_EXPR,
};
-struct nft_set_elem;
+struct nftnl_set_elem;
-struct nft_set_elem *nft_set_elem_alloc(void);
-void nft_set_elem_free(struct nft_set_elem *s);
+struct nftnl_set_elem *nftnl_set_elem_alloc(void);
+void nftnl_set_elem_free(struct nftnl_set_elem *s);
-struct nft_set_elem *nft_set_elem_clone(struct nft_set_elem *elem);
+struct nftnl_set_elem *nftnl_set_elem_clone(struct nftnl_set_elem *elem);
-void nft_set_elem_add(struct nft_set *s, struct nft_set_elem *elem);
+void nftnl_set_elem_add(struct nftnl_set *s, struct nftnl_set_elem *elem);
-void nft_set_elem_attr_unset(struct nft_set_elem *s, uint16_t attr);
-void nft_set_elem_attr_set(struct nft_set_elem *s, uint16_t attr, const void *data, uint32_t data_len);
-void nft_set_elem_attr_set_u32(struct nft_set_elem *s, uint16_t attr, uint32_t val);
-void nft_set_elem_attr_set_u64(struct nft_set_elem *s, uint16_t attr, uint64_t val);
-void nft_set_elem_attr_set_str(struct nft_set_elem *s, uint16_t attr, const char *str);
+void nftnl_set_elem_attr_unset(struct nftnl_set_elem *s, uint16_t attr);
+void nftnl_set_elem_attr_set(struct nftnl_set_elem *s, uint16_t attr, const void *data, uint32_t data_len);
+void nftnl_set_elem_attr_set_u32(struct nftnl_set_elem *s, uint16_t attr, uint32_t val);
+void nftnl_set_elem_attr_set_u64(struct nftnl_set_elem *s, uint16_t attr, uint64_t val);
+void nftnl_set_elem_attr_set_str(struct nftnl_set_elem *s, uint16_t attr, const char *str);
-const void *nft_set_elem_attr_get(struct nft_set_elem *s, uint16_t attr, uint32_t *data_len);
-const char *nft_set_elem_attr_get_str(struct nft_set_elem *s, uint16_t attr);
-uint32_t nft_set_elem_attr_get_u32(struct nft_set_elem *s, uint16_t attr);
-uint64_t nft_set_elem_attr_get_u64(struct nft_set_elem *s, uint16_t attr);
+const void *nftnl_set_elem_attr_get(struct nftnl_set_elem *s, uint16_t attr, uint32_t *data_len);
+const char *nftnl_set_elem_attr_get_str(struct nftnl_set_elem *s, uint16_t attr);
+uint32_t nftnl_set_elem_attr_get_u32(struct nftnl_set_elem *s, uint16_t attr);
+uint64_t nftnl_set_elem_attr_get_u64(struct nftnl_set_elem *s, uint16_t attr);
-bool nft_set_elem_attr_is_set(const struct nft_set_elem *s, uint16_t attr);
+bool nftnl_set_elem_attr_is_set(const struct nftnl_set_elem *s, uint16_t attr);
-#define nft_set_elem_nlmsg_build_hdr nft_nlmsg_build_hdr
-void nft_set_elems_nlmsg_build_payload(struct nlmsghdr *nlh, struct nft_set *s);
-void nft_set_elem_nlmsg_build_payload(struct nlmsghdr *nlh, struct nft_set_elem *e);
+#define nftnl_set_elem_nlmsg_build_hdr nftnl_nlmsg_build_hdr
+void nftnl_set_elems_nlmsg_build_payload(struct nlmsghdr *nlh, struct nftnl_set *s);
+void nftnl_set_elem_nlmsg_build_payload(struct nlmsghdr *nlh, struct nftnl_set_elem *e);
-int nft_set_elem_parse(struct nft_set_elem *e, enum nft_parse_type type,
- const char *data, struct nft_parse_err *err);
-int nft_set_elem_parse_file(struct nft_set_elem *e, enum nft_parse_type type,
- FILE *fp, struct nft_parse_err *err);
-int nft_set_elem_snprintf(char *buf, size_t size, struct nft_set_elem *s, uint32_t type, uint32_t flags);
-int nft_set_elem_fprintf(FILE *fp, struct nft_set_elem *se, uint32_t type, uint32_t flags);
+int nftnl_set_elem_parse(struct nftnl_set_elem *e, enum nftnl_parse_type type,
+ const char *data, struct nftnl_parse_err *err);
+int nftnl_set_elem_parse_file(struct nftnl_set_elem *e, enum nftnl_parse_type type,
+ FILE *fp, struct nftnl_parse_err *err);
+int nftnl_set_elem_snprintf(char *buf, size_t size, struct nftnl_set_elem *s, uint32_t type, uint32_t flags);
+int nftnl_set_elem_fprintf(FILE *fp, struct nftnl_set_elem *se, uint32_t type, uint32_t flags);
-int nft_set_elem_foreach(struct nft_set *s, int (*cb)(struct nft_set_elem *e, void *data), void *data);
+int nftnl_set_elem_foreach(struct nftnl_set *s, int (*cb)(struct nftnl_set_elem *e, void *data), void *data);
-struct nft_set_elems_iter;
-struct nft_set_elems_iter *nft_set_elems_iter_create(struct nft_set *s);
-struct nft_set_elem *nft_set_elems_iter_cur(struct nft_set_elems_iter *iter);
-struct nft_set_elem *nft_set_elems_iter_next(struct nft_set_elems_iter *iter);
-void nft_set_elems_iter_destroy(struct nft_set_elems_iter *iter);
+struct nftnl_set_elems_iter;
+struct nftnl_set_elems_iter *nftnl_set_elems_iter_create(struct nftnl_set *s);
+struct nftnl_set_elem *nftnl_set_elems_iter_cur(struct nftnl_set_elems_iter *iter);
+struct nftnl_set_elem *nftnl_set_elems_iter_next(struct nftnl_set_elems_iter *iter);
+void nftnl_set_elems_iter_destroy(struct nftnl_set_elems_iter *iter);
-int nft_set_elems_nlmsg_build_payload_iter(struct nlmsghdr *nlh,
- struct nft_set_elems_iter *iter);
+int nftnl_set_elems_nlmsg_build_payload_iter(struct nlmsghdr *nlh,
+ struct nftnl_set_elems_iter *iter);
#endif /* _LIBNFTNL_SET_H_ */
diff --git a/include/libnftnl/table.h b/include/libnftnl/table.h
index fac79e7..0f0589b 100644
--- a/include/libnftnl/table.h
+++ b/include/libnftnl/table.h
@@ -12,66 +12,66 @@
extern "C" {
#endif
-struct nft_table;
+struct nftnl_table;
-struct nft_table *nft_table_alloc(void);
-void nft_table_free(struct nft_table *);
+struct nftnl_table *nftnl_table_alloc(void);
+void nftnl_table_free(struct nftnl_table *);
enum {
- NFT_TABLE_ATTR_NAME = 0,
- NFT_TABLE_ATTR_FAMILY,
- NFT_TABLE_ATTR_FLAGS,
- NFT_TABLE_ATTR_USE,
- __NFT_TABLE_ATTR_MAX
+ NFTNL_TABLE_ATTR_NAME = 0,
+ NFTNL_TABLE_ATTR_FAMILY,
+ NFTNL_TABLE_ATTR_FLAGS,
+ NFTNL_TABLE_ATTR_USE,
+ __NFTNL_TABLE_ATTR_MAX
};
-#define NFT_TABLE_ATTR_MAX (__NFT_TABLE_ATTR_MAX - 1)
+#define NFTNL_TABLE_ATTR_MAX (__NFTNL_TABLE_ATTR_MAX - 1)
-bool nft_table_attr_is_set(const struct nft_table *t, uint16_t attr);
-void nft_table_attr_unset(struct nft_table *t, uint16_t attr);
-void nft_table_attr_set(struct nft_table *t, uint16_t attr, const void *data);
-void nft_table_attr_set_data(struct nft_table *t, uint16_t attr,
+bool nftnl_table_attr_is_set(const struct nftnl_table *t, uint16_t attr);
+void nftnl_table_attr_unset(struct nftnl_table *t, uint16_t attr);
+void nftnl_table_attr_set(struct nftnl_table *t, uint16_t attr, const void *data);
+void nftnl_table_attr_set_data(struct nftnl_table *t, uint16_t attr,
const void *data, uint32_t data_len);
-const void *nft_table_attr_get(struct nft_table *t, uint16_t attr);
-const void *nft_table_attr_get_data(struct nft_table *t, uint16_t attr,
+const void *nftnl_table_attr_get(struct nftnl_table *t, uint16_t attr);
+const void *nftnl_table_attr_get_data(struct nftnl_table *t, uint16_t attr,
uint32_t *data_len);
-void nft_table_attr_set_u8(struct nft_table *t, uint16_t attr, uint8_t data);
-void nft_table_attr_set_u32(struct nft_table *t, uint16_t attr, uint32_t data);
-void nft_table_attr_set_str(struct nft_table *t, uint16_t attr, const char *str);
-uint8_t nft_table_attr_get_u8(struct nft_table *t, uint16_t attr);
-uint32_t nft_table_attr_get_u32(struct nft_table *t, uint16_t attr);
-const char *nft_table_attr_get_str(struct nft_table *t, uint16_t attr);
+void nftnl_table_attr_set_u8(struct nftnl_table *t, uint16_t attr, uint8_t data);
+void nftnl_table_attr_set_u32(struct nftnl_table *t, uint16_t attr, uint32_t data);
+void nftnl_table_attr_set_str(struct nftnl_table *t, uint16_t attr, const char *str);
+uint8_t nftnl_table_attr_get_u8(struct nftnl_table *t, uint16_t attr);
+uint32_t nftnl_table_attr_get_u32(struct nftnl_table *t, uint16_t attr);
+const char *nftnl_table_attr_get_str(struct nftnl_table *t, uint16_t attr);
struct nlmsghdr;
-void nft_table_nlmsg_build_payload(struct nlmsghdr *nlh, const struct nft_table *t);
+void nftnl_table_nlmsg_build_payload(struct nlmsghdr *nlh, const struct nftnl_table *t);
-int nft_table_parse(struct nft_table *t, enum nft_parse_type type,
- const char *data, struct nft_parse_err *err);
-int nft_table_parse_file(struct nft_table *t, enum nft_parse_type type,
- FILE *fp, struct nft_parse_err *err);
-int nft_table_snprintf(char *buf, size_t size, struct nft_table *t, uint32_t type, uint32_t flags);
-int nft_table_fprintf(FILE *fp, struct nft_table *t, uint32_t type, uint32_t flags);
+int nftnl_table_parse(struct nftnl_table *t, enum nftnl_parse_type type,
+ const char *data, struct nftnl_parse_err *err);
+int nftnl_table_parse_file(struct nftnl_table *t, enum nftnl_parse_type type,
+ FILE *fp, struct nftnl_parse_err *err);
+int nftnl_table_snprintf(char *buf, size_t size, struct nftnl_table *t, uint32_t type, uint32_t flags);
+int nftnl_table_fprintf(FILE *fp, struct nftnl_table *t, uint32_t type, uint32_t flags);
-#define nft_table_nlmsg_build_hdr nft_nlmsg_build_hdr
-int nft_table_nlmsg_parse(const struct nlmsghdr *nlh, struct nft_table *t);
+#define nftnl_table_nlmsg_build_hdr nftnl_nlmsg_build_hdr
+int nftnl_table_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_table *t);
-struct nft_table_list;
+struct nftnl_table_list;
-struct nft_table_list *nft_table_list_alloc(void);
-void nft_table_list_free(struct nft_table_list *list);
-int nft_table_list_is_empty(struct nft_table_list *list);
-int nft_table_list_foreach(struct nft_table_list *table_list, int (*cb)(struct nft_table *t, void *data), void *data);
+struct nftnl_table_list *nftnl_table_list_alloc(void);
+void nftnl_table_list_free(struct nftnl_table_list *list);
+int nftnl_table_list_is_empty(struct nftnl_table_list *list);
+int nftnl_table_list_foreach(struct nftnl_table_list *table_list, int (*cb)(struct nftnl_table *t, void *data), void *data);
-void nft_table_list_add(struct nft_table *r, struct nft_table_list *list);
-void nft_table_list_add_tail(struct nft_table *r, struct nft_table_list *list);
-void nft_table_list_del(struct nft_table *r);
+void nftnl_table_list_add(struct nftnl_table *r, struct nftnl_table_list *list);
+void nftnl_table_list_add_tail(struct nftnl_table *r, struct nftnl_table_list *list);
+void nftnl_table_list_del(struct nftnl_table *r);
-struct nft_table_list_iter;
+struct nftnl_table_list_iter;
-struct nft_table_list_iter *nft_table_list_iter_create(struct nft_table_list *l);
-struct nft_table *nft_table_list_iter_next(struct nft_table_list_iter *iter);
-void nft_table_list_iter_destroy(struct nft_table_list_iter *iter);
+struct nftnl_table_list_iter *nftnl_table_list_iter_create(struct nftnl_table_list *l);
+struct nftnl_table *nftnl_table_list_iter_next(struct nftnl_table_list_iter *iter);
+void nftnl_table_list_iter_destroy(struct nftnl_table_list_iter *iter);
#ifdef __cplusplus
} /* extern "C" */
diff --git a/include/set.h b/include/set.h
index 008ed6e..1addd0f 100644
--- a/include/set.h
+++ b/include/set.h
@@ -3,7 +3,7 @@
#include <linux/netfilter/nf_tables.h>
-struct nft_set {
+struct nftnl_set {
struct list_head head;
uint32_t family;
@@ -26,9 +26,9 @@ struct nft_set {
uint64_t timeout;
};
-struct nft_set_list;
-struct nft_rule_expr;
-int nft_set_lookup_id(struct nft_rule_expr *e, struct nft_set_list *set_list,
+struct nftnl_set_list;
+struct nftnl_rule_expr;
+int nftnl_set_lookup_id(struct nftnl_rule_expr *e, struct nftnl_set_list *set_list,
uint32_t *set_id);
#endif
diff --git a/include/set_elem.h b/include/set_elem.h
index bdefe4b..13e096c 100644
--- a/include/set_elem.h
+++ b/include/set_elem.h
@@ -3,12 +3,12 @@
#include <data_reg.h>
-struct nft_set_elem {
+struct nftnl_set_elem {
struct list_head head;
uint32_t set_elem_flags;
- union nft_data_reg key;
- union nft_data_reg data;
- struct nft_rule_expr *expr;
+ union nftnl_data_reg key;
+ union nftnl_data_reg data;
+ struct nftnl_rule_expr *expr;
uint32_t flags;
uint64_t timeout;
uint64_t expiration;
diff --git a/include/utils.h b/include/utils.h
index fad64e8..7a46725 100644
--- a/include/utils.h
+++ b/include/utils.h
@@ -10,7 +10,7 @@
#include "config.h"
#ifdef HAVE_VISIBILITY_HIDDEN
# define __visible __attribute__((visibility("default")))
-# define EXPORT_SYMBOL(y, x) typeof(x) (x) __visible; __typeof (x) y __attribute ((alias (#x), visibility ("default")))
+# define EXPORT_SYMBOL(x, y) typeof(x) (x) __visible; __typeof (x) y __attribute ((alias (#x), visibility ("default")))
#else
# define EXPORT_SYMBOL
#endif
@@ -26,19 +26,19 @@ void __noreturn __abi_breakage(const char *file, int line, const char *reason);
#define abi_breakage() \
__abi_breakage(__FILE__, __LINE__, strerror(errno));
-void __nft_assert_fail(uint16_t attr, const char *filename, int line);
+void __nftnl_assert_fail(uint16_t attr, const char *filename, int line);
-#define nft_assert(val, attr, expr) \
+#define nftnl_assert(val, attr, expr) \
((!val || expr) \
? (void)0 \
- : __nft_assert_fail(attr, __FILE__, __LINE__))
+ : __nftnl_assert_fail(attr, __FILE__, __LINE__))
-#define nft_assert_validate(data, _validate_array, _attr, _data_len) \
+#define nftnl_assert_validate(data, _validate_array, _attr, _data_len) \
({ \
if (!data) \
- __nft_assert_fail(attr, __FILE__, __LINE__); \
+ __nftnl_assert_fail(attr, __FILE__, __LINE__); \
if (_validate_array[_attr]) \
- nft_assert(data, attr, _validate_array[_attr] == _data_len); \
+ nftnl_assert(data, attr, _validate_array[_attr] == _data_len); \
})
#define SNPRINTF_BUFFER_SIZE(ret, size, len, offset) \
@@ -50,32 +50,32 @@ void __nft_assert_fail(uint16_t attr, const char *filename, int line);
size += ret; \
len -= ret;
-const char *nft_family2str(uint32_t family);
-int nft_str2family(const char *family);
-
-enum nft_type {
- NFT_TYPE_U8,
- NFT_TYPE_U16,
- NFT_TYPE_U32,
- NFT_TYPE_U64,
- NFT_TYPE_S8,
- NFT_TYPE_S16,
- NFT_TYPE_S32,
- NFT_TYPE_S64,
+const char *nftnl_family2str(uint32_t family);
+int nftnl_str2family(const char *family);
+
+enum nftnl_type {
+ NFTNL_TYPE_U8,
+ NFTNL_TYPE_U16,
+ NFTNL_TYPE_U32,
+ NFTNL_TYPE_U64,
+ NFTNL_TYPE_S8,
+ NFTNL_TYPE_S16,
+ NFTNL_TYPE_S32,
+ NFTNL_TYPE_S64,
};
-int nft_strtoi(const char *string, int base, void *number, enum nft_type type);
-int nft_get_value(enum nft_type type, void *val, void *out);
+int nftnl_strtoi(const char *string, int base, void *number, enum nftnl_type type);
+int nftnl_get_value(enum nftnl_type type, void *val, void *out);
-const char *nft_verdict2str(uint32_t verdict);
-int nft_str2verdict(const char *verdict, int *verdict_num);
+const char *nftnl_verdict2str(uint32_t verdict);
+int nftnl_str2verdict(const char *verdict, int *verdict_num);
-const char *nft_cmd2tag(enum nft_cmd_type cmd);
-uint32_t nft_str2cmd(const char *cmd);
+const char *nftnl_cmd2tag(enum nftnl_cmd_type cmd);
+uint32_t nftnl_str2cmd(const char *cmd);
-enum nft_cmd_type nft_flag2cmd(uint32_t flags);
+enum nftnl_cmd_type nftnl_flag2cmd(uint32_t flags);
-int nft_fprintf(FILE *fp, void *obj, uint32_t cmd, uint32_t type,
+int nftnl_fprintf(FILE *fp, void *obj, uint32_t cmd, uint32_t type,
uint32_t flags, int (*snprintf_cb)(char *buf, size_t bufsiz,
void *obj, uint32_t cmd, uint32_t type, uint32_t flags));
diff --git a/include/xml.h b/include/xml.h
index 5137034..454de44 100644
--- a/include/xml.h
+++ b/include/xml.h
@@ -5,52 +5,52 @@
#include <mxml.h>
#include "common.h"
-#define NFT_XML_MAND 0
-#define NFT_XML_OPT (1 << 0)
+#define NFTNL_XML_MAND 0
+#define NFTNL_XML_OPT (1 << 0)
-struct nft_table;
-struct nft_chain;
-struct nft_rule;
-struct nft_set;
-struct nft_set_elem;
-struct nft_set_list;
-union nft_data_reg;
+struct nftnl_table;
+struct nftnl_chain;
+struct nftnl_rule;
+struct nftnl_set;
+struct nftnl_set_elem;
+struct nftnl_set_list;
+union nftnl_data_reg;
-mxml_node_t *nft_mxml_build_tree(const void *data, const char *treename,
- struct nft_parse_err *err, enum nft_parse_input input);
-struct nft_rule_expr *nft_mxml_expr_parse(mxml_node_t *node,
- struct nft_parse_err *err,
- struct nft_set_list *set_list);
-int nft_mxml_reg_parse(mxml_node_t *tree, const char *reg_name, uint32_t *reg,
+mxml_node_t *nftnl_mxml_build_tree(const void *data, const char *treename,
+ struct nftnl_parse_err *err, enum nftnl_parse_input input);
+struct nftnl_rule_expr *nftnl_mxml_expr_parse(mxml_node_t *node,
+ struct nftnl_parse_err *err,
+ struct nftnl_set_list *set_list);
+int nftnl_mxml_reg_parse(mxml_node_t *tree, const char *reg_name, uint32_t *reg,
uint32_t mxmlflags, uint32_t flags,
- struct nft_parse_err *err);
-int nft_mxml_data_reg_parse(mxml_node_t *tree, const char *node_name,
- union nft_data_reg *data_reg, uint16_t flags,
- struct nft_parse_err *err);
-int nft_mxml_num_parse(mxml_node_t *tree, const char *node_name,
+ struct nftnl_parse_err *err);
+int nftnl_mxml_data_reg_parse(mxml_node_t *tree, const char *node_name,
+ union nftnl_data_reg *data_reg, uint16_t flags,
+ struct nftnl_parse_err *err);
+int nftnl_mxml_num_parse(mxml_node_t *tree, const char *node_name,
uint32_t mxml_flags, int base, void *number,
- enum nft_type type, uint16_t flags,
- struct nft_parse_err *err);
-const char *nft_mxml_str_parse(mxml_node_t *tree, const char *node_name,
+ enum nftnl_type type, uint16_t flags,
+ struct nftnl_parse_err *err);
+const char *nftnl_mxml_str_parse(mxml_node_t *tree, const char *node_name,
uint32_t mxml_flags, uint16_t flags,
- struct nft_parse_err *err);
-int nft_mxml_family_parse(mxml_node_t *tree, const char *node_name,
+ struct nftnl_parse_err *err);
+int nftnl_mxml_family_parse(mxml_node_t *tree, const char *node_name,
uint32_t mxml_flags, uint16_t flags,
- struct nft_parse_err *err);
-int nft_mxml_set_elem_parse(mxml_node_t *node, struct nft_set_elem *e,
- struct nft_parse_err *err);
-int nft_mxml_table_parse(mxml_node_t *tree, struct nft_table *t,
- struct nft_parse_err *err);
-int nft_mxml_chain_parse(mxml_node_t *tree, struct nft_chain *c,
- struct nft_parse_err *err);
-int nft_mxml_rule_parse(mxml_node_t *tree, struct nft_rule *r,
- struct nft_parse_err *err,
- struct nft_set_list *set_list);
-int nft_mxml_set_parse(mxml_node_t *tree, struct nft_set *s,
- struct nft_parse_err *err);
+ struct nftnl_parse_err *err);
+int nftnl_mxml_set_elem_parse(mxml_node_t *node, struct nftnl_set_elem *e,
+ struct nftnl_parse_err *err);
+int nftnl_mxml_table_parse(mxml_node_t *tree, struct nftnl_table *t,
+ struct nftnl_parse_err *err);
+int nftnl_mxml_chain_parse(mxml_node_t *tree, struct nftnl_chain *c,
+ struct nftnl_parse_err *err);
+int nftnl_mxml_rule_parse(mxml_node_t *tree, struct nftnl_rule *r,
+ struct nftnl_parse_err *err,
+ struct nftnl_set_list *set_list);
+int nftnl_mxml_set_parse(mxml_node_t *tree, struct nftnl_set *s,
+ struct nftnl_parse_err *err);
-int nft_data_reg_xml_parse(union nft_data_reg *reg, mxml_node_t *tree,
- struct nft_parse_err *err);
+int nftnl_data_reg_xml_parse(union nftnl_data_reg *reg, mxml_node_t *tree,
+ struct nftnl_parse_err *err);
#else
#define mxml_node_t void
#endif