* [PATCH libnftnl 1/9] src: get rid of aliases
@ 2016-06-14 13:18 Pablo Neira Ayuso
2016-06-14 13:18 ` [PATCH libnftnl 2/9] src: assert when setting unknown attributes Pablo Neira Ayuso
` (7 more replies)
0 siblings, 8 replies; 9+ messages in thread
From: Pablo Neira Ayuso @ 2016-06-14 13:18 UTC (permalink / raw)
To: netfilter-devel
This machinery was introduced to avoid sudden compilation breakage of
old nftables releases. With the release of 0.6 (and 0.5 which is now 9
months old) this is not required anymore. Moreover, users gain nothing
from older releases since they are half-boiled and full of bugs.
So let's get rid of aliases now. Bump LIBVERSION and update map file.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
---
Make_global.am | 2 +-
doxygen.cfg.in | 2 +-
include/libnftnl/batch.h | 16 ---
include/libnftnl/chain.h | 77 -------------
include/libnftnl/common.h | 53 ---------
include/libnftnl/expr.h | 171 -----------------------------
include/libnftnl/gen.h | 36 ------
include/libnftnl/rule.h | 83 --------------
include/libnftnl/ruleset.h | 61 -----------
include/libnftnl/set.h | 136 -----------------------
include/libnftnl/table.h | 65 -----------
include/utils.h | 2 -
src/batch.c | 14 +--
src/chain.c | 68 ++++++------
src/common.c | 14 +--
src/expr.c | 32 +++---
src/gen.c | 26 ++---
src/libnftnl.map | 265 +--------------------------------------------
src/rule.c | 74 ++++++-------
src/ruleset.c | 32 +++---
src/set.c | 64 +++++------
src/set_elem.c | 48 ++++----
src/table.c | 60 +++++-----
23 files changed, 220 insertions(+), 1181 deletions(-)
diff --git a/Make_global.am b/Make_global.am
index 94c5dfc..f836dea 100644
--- a/Make_global.am
+++ b/Make_global.am
@@ -18,7 +18,7 @@
# set age to 0.
# </snippet>
#
-LIBVERSION=5:0:1
+LIBVERSION=6:0:0
AM_CPPFLAGS = ${regular_CPPFLAGS} -I${top_srcdir}/include ${LIBMNL_CFLAGS} ${LIBMXML_CFLAGS}
AM_CFLAGS = ${regular_CFLAGS} ${GCC_FVISIBILITY_HIDDEN}
diff --git a/doxygen.cfg.in b/doxygen.cfg.in
index 042060b..23fcad4 100644
--- a/doxygen.cfg.in
+++ b/doxygen.cfg.in
@@ -72,7 +72,7 @@ RECURSIVE = YES
EXCLUDE =
EXCLUDE_SYMLINKS = NO
EXCLUDE_PATTERNS = */.git/* .*.d
-EXCLUDE_SYMBOLS = EXPORT_SYMBOL EXPORT_SYMBOL_ALIAS nft_table
+EXCLUDE_SYMBOLS = EXPORT_SYMBOL
EXAMPLE_PATH =
EXAMPLE_PATTERNS =
EXAMPLE_RECURSIVE = NO
diff --git a/include/libnftnl/batch.h b/include/libnftnl/batch.h
index bd18733..ea1ea66 100644
--- a/include/libnftnl/batch.h
+++ b/include/libnftnl/batch.h
@@ -15,20 +15,4 @@ uint32_t nftnl_batch_buffer_len(struct nftnl_batch *batch);
int nftnl_batch_iovec_len(struct nftnl_batch *batch);
void nftnl_batch_iovec(struct nftnl_batch *batch, struct iovec *iov, uint32_t iovlen);
-/*
- * Compat
- */
-
-struct nft_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);
-
-void *nft_batch_buffer(struct nft_batch *batch);
-uint32_t nft_batch_buffer_len(struct nft_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);
-
#endif
diff --git a/include/libnftnl/chain.h b/include/libnftnl/chain.h
index 954b39f..b72741f 100644
--- a/include/libnftnl/chain.h
+++ b/include/libnftnl/chain.h
@@ -85,83 +85,6 @@ struct nftnl_chain_list_iter *nftnl_chain_list_iter_create(struct nftnl_chain_li
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);
-/*
- * Compat
- */
-
-struct nft_chain;
-
-struct nft_chain *nft_chain_alloc(void);
-void nft_chain_free(struct nft_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
-};
-#define NFT_CHAIN_ATTR_MAX (__NFT_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,
- 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,
- 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);
-
-struct nlmsghdr;
-
-void nft_chain_nlmsg_build_payload(struct nlmsghdr *nlh, const struct nft_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);
-
-#define nft_chain_nlmsg_build_hdr nft_nlmsg_build_hdr
-int nft_chain_nlmsg_parse(const struct nlmsghdr *nlh, struct nft_chain *t);
-
-struct nft_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);
-
-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);
-
-struct nft_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);
-
#ifdef __cplusplus
} /* extern "C" */
#endif
diff --git a/include/libnftnl/common.h b/include/libnftnl/common.h
index a40688c..b9c6ff3 100644
--- a/include/libnftnl/common.h
+++ b/include/libnftnl/common.h
@@ -52,57 +52,4 @@ int nftnl_batch_is_supported(void);
void nftnl_batch_begin(char *buf, uint32_t seq);
void nftnl_batch_end(char *buf, uint32_t seq);
-/*
- * Compat
- */
-
-enum {
- NFT_PARSE_EBADINPUT = 0,
- NFT_PARSE_EMISSINGNODE,
- NFT_PARSE_EBADTYPE,
- NFT_PARSE_EOPNOTSUPP,
-};
-
-enum nft_output_type {
- NFT_OUTPUT_DEFAULT = 0,
- NFT_OUTPUT_XML,
- NFT_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 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 nft_parse_type {
- NFT_PARSE_NONE = 0,
- NFT_PARSE_XML,
- NFT_PARSE_JSON,
- NFT_PARSE_MAX,
-};
-
-struct nft_parse_err;
-
-struct nlmsghdr *nft_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);
-
-int nft_batch_is_supported(void);
-void nft_batch_begin(char *buf, uint32_t seq);
-void nft_batch_end(char *buf, uint32_t seq);
-
#endif
diff --git a/include/libnftnl/expr.h b/include/libnftnl/expr.h
index f192103..aa6dfdd 100644
--- a/include/libnftnl/expr.h
+++ b/include/libnftnl/expr.h
@@ -190,177 +190,6 @@ enum {
NFTNL_EXPR_FWD_SREG_DEV = NFTNL_EXPR_BASE,
};
-/*
- * Compat
- */
-
-struct nft_rule_expr;
-
-enum {
- NFT_RULE_EXPR_ATTR_NAME = 0,
- NFT_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);
-
-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);
-
-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);
-
-int nft_rule_expr_snprintf(char *buf, size_t buflen, struct nft_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,
- NFT_EXPR_PAYLOAD_SREG,
- NFT_EXPR_PAYLOAD_CSUM_TYPE,
- NFT_EXPR_PAYLOAD_CSUM_OFFSET,
-};
-
-enum {
- NFT_EXPR_META_KEY = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_META_DREG,
- NFT_EXPR_META_SREG,
-};
-
-enum {
- NFT_EXPR_CMP_SREG = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_CMP_OP,
- NFT_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,
-};
-
-enum {
- NFT_EXPR_CTR_PACKETS = NFT_RULE_EXPR_ATTR_BASE,
- NFT_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,
-};
-
-enum {
- NFT_EXPR_TG_NAME = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_TG_REV,
- NFT_EXPR_TG_INFO,
-};
-
-enum {
- NFT_EXPR_MT_NAME = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_MT_REV,
- NFT_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,
-};
-
-enum {
- NFT_EXPR_LOOKUP_SREG = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_LOOKUP_DREG,
- NFT_EXPR_LOOKUP_SET,
- NFT_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,
-};
-
-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,
-};
-
-enum {
- NFT_EXPR_EXTHDR_DREG = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_EXTHDR_TYPE,
- NFT_EXPR_EXTHDR_OFFSET,
- NFT_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,
-};
-
-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,
-};
-
-enum {
- NFT_EXPR_LIMIT_RATE = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_LIMIT_UNIT,
-};
-
-enum {
- NFT_EXPR_REJECT_TYPE = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_REJECT_CODE,
-};
-
-enum {
- NFT_EXPR_QUEUE_NUM = NFT_RULE_EXPR_ATTR_BASE,
- NFT_EXPR_QUEUE_TOTAL,
- NFT_EXPR_QUEUE_FLAGS,
-};
-
-enum {
- NFT_EXPR_MASQ_FLAGS = NFT_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,
-};
-
#ifdef __cplusplus
} /* extern "C" */
#endif
diff --git a/include/libnftnl/gen.h b/include/libnftnl/gen.h
index d0f638f..f69bf2f 100644
--- a/include/libnftnl/gen.h
+++ b/include/libnftnl/gen.h
@@ -44,42 +44,6 @@ int nftnl_gen_fprintf(FILE *fp, const struct nftnl_gen *gen, uint32_t type, uint
#define nftnl_gen_nlmsg_build_hdr nftnl_nlmsg_build_hdr
int nftnl_gen_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_gen *gen);
-/*
- * Compat
- */
-
-struct nft_gen;
-
-struct nft_gen *nft_gen_alloc(void);
-void nft_gen_free(struct nft_gen *);
-
-enum {
- NFT_GEN_ID = 0,
- __NFT_GEN_MAX
-};
-#define NFT_GEN_MAX (__NFT_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,
- 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,
- 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);
-
-struct nlmsghdr;
-int nft_gen_nlmsg_parse(const struct nlmsghdr *nlh, struct nft_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);
-
-#define nft_gen_nlmsg_build_hdr nft_nlmsg_build_hdr
-int nft_gen_nlmsg_parse(const struct nlmsghdr *nlh, struct nft_gen *gen);
-
#ifdef __cplusplus
} /* extern "C" */
#endif
diff --git a/include/libnftnl/rule.h b/include/libnftnl/rule.h
index 6f9d8c1..d9a8e12 100644
--- a/include/libnftnl/rule.h
+++ b/include/libnftnl/rule.h
@@ -91,89 +91,6 @@ 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(const struct nftnl_rule_list_iter *iter);
-/*
- * Compat
- */
-
-struct nft_rule;
-struct nft_rule_expr;
-
-struct nft_rule *nft_rule_alloc(void);
-void nft_rule_free(struct nft_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
-};
-#define NFT_RULE_ATTR_MAX (__NFT_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,
- 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);
-
-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,
- 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);
-
-void nft_rule_add_expr(struct nft_rule *r, struct nft_rule_expr *expr);
-
-struct nlmsghdr;
-
-void nft_rule_nlmsg_build_payload(struct nlmsghdr *nlh, struct nft_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);
-
-#define nft_rule_nlmsg_build_hdr nft_nlmsg_build_hdr
-int nft_rule_nlmsg_parse(const struct nlmsghdr *nlh, struct nft_rule *t);
-
-int nft_rule_expr_foreach(struct nft_rule *r,
- int (*cb)(struct nft_rule_expr *e, void *data),
- void *data);
-
-struct nft_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 nft_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 nft_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);
-
#ifdef __cplusplus
} /* extern "C" */
#endif
diff --git a/include/libnftnl/ruleset.h b/include/libnftnl/ruleset.h
index 83c2334..fb40736 100644
--- a/include/libnftnl/ruleset.h
+++ b/include/libnftnl/ruleset.h
@@ -70,67 +70,6 @@ int nftnl_ruleset_parse_file(struct nftnl_ruleset *rs, enum nftnl_parse_type typ
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);
-/*
- * Compat
- */
-
-struct nft_ruleset;
-
-struct nft_ruleset *nft_ruleset_alloc(void);
-void nft_ruleset_free(struct nft_ruleset *r);
-
-enum {
- NFT_RULESET_ATTR_TABLELIST = 0,
- NFT_RULESET_ATTR_CHAINLIST,
- NFT_RULESET_ATTR_SETLIST,
- NFT_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,
-};
-
-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);
-
-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,
-};
-
-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,
- 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);
-
#ifdef __cplusplus
} /* extern "C" */
#endif
diff --git a/include/libnftnl/set.h b/include/libnftnl/set.h
index c9a879a..00868c5 100644
--- a/include/libnftnl/set.h
+++ b/include/libnftnl/set.h
@@ -140,140 +140,4 @@ void nftnl_set_elems_iter_destroy(struct nftnl_set_elems_iter *iter);
int nftnl_set_elems_nlmsg_build_payload_iter(struct nlmsghdr *nlh,
struct nftnl_set_elems_iter *iter);
-/*
- * Compat
- */
-
-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
-};
-#define NFT_SET_ATTR_MAX (__NFT_SET_ATTR_MAX - 1)
-
-struct nft_set;
-
-struct nft_set *nft_set_alloc(void);
-void nft_set_free(struct nft_set *s);
-
-struct nft_set *nft_set_clone(const struct nft_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,
- 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);
-
-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,
- 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);
-
-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);
-
-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);
-
-struct nft_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 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);
-
-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);
-
-/*
- * 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,
-};
-
-struct nft_set_elem;
-
-struct nft_set_elem *nft_set_elem_alloc(void);
-void nft_set_elem_free(struct nft_set_elem *s);
-
-struct nft_set_elem *nft_set_elem_clone(struct nft_set_elem *elem);
-
-void nft_set_elem_add(struct nft_set *s, struct nft_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);
-
-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);
-
-bool nft_set_elem_attr_is_set(const struct nft_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);
-
-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 nft_set_elem_foreach(struct nft_set *s, int (*cb)(struct nft_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);
-
-int nft_set_elems_nlmsg_build_payload_iter(struct nlmsghdr *nlh,
- struct nft_set_elems_iter *iter);
-
#endif /* _LIBNFTNL_SET_H_ */
diff --git a/include/libnftnl/table.h b/include/libnftnl/table.h
index 8972d09..d2557ba 100644
--- a/include/libnftnl/table.h
+++ b/include/libnftnl/table.h
@@ -73,71 +73,6 @@ struct nftnl_table_list_iter *nftnl_table_list_iter_create(struct nftnl_table_li
struct nftnl_table *nftnl_table_list_iter_next(struct nftnl_table_list_iter *iter);
void nftnl_table_list_iter_destroy(const struct nftnl_table_list_iter *iter);
-/*
- * Compat
- */
-
-struct nft_table;
-
-struct nft_table *nft_table_alloc(void);
-void nft_table_free(struct nft_table *);
-
-enum {
- NFT_TABLE_ATTR_NAME = 0,
- NFT_TABLE_ATTR_FAMILY,
- NFT_TABLE_ATTR_FLAGS,
- NFT_TABLE_ATTR_USE,
- __NFT_TABLE_ATTR_MAX
-};
-#define NFT_TABLE_ATTR_MAX (__NFT_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,
- 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,
- 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);
-
-struct nlmsghdr;
-
-void nft_table_nlmsg_build_payload(struct nlmsghdr *nlh, const struct nft_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);
-
-#define nft_table_nlmsg_build_hdr nft_nlmsg_build_hdr
-int nft_table_nlmsg_parse(const struct nlmsghdr *nlh, struct nft_table *t);
-
-struct nft_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);
-
-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);
-
-struct nft_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);
-
#ifdef __cplusplus
} /* extern "C" */
#endif
diff --git a/include/utils.h b/include/utils.h
index 46ff18a..1684b5a 100644
--- a/include/utils.h
+++ b/include/utils.h
@@ -11,10 +11,8 @@
#ifdef HAVE_VISIBILITY_HIDDEN
# define __visible __attribute__((visibility("default")))
# define EXPORT_SYMBOL(x) typeof(x) (x) __visible;
-# define EXPORT_SYMBOL_ALIAS(x, y) typeof(x) (x) __visible; __typeof (y) y __attribute ((alias (#x), visibility ("default")))
#else
# define EXPORT_SYMBOL
-# define EXPORT_SYMBOL_ALIAS
#endif
#define __noreturn __attribute__((__noreturn__))
diff --git a/src/batch.c b/src/batch.c
index 7299ff6..5ee3fd7 100644
--- a/src/batch.c
+++ b/src/batch.c
@@ -80,7 +80,7 @@ err1:
free(batch);
return NULL;
}
-EXPORT_SYMBOL_ALIAS(nftnl_batch_alloc, nft_batch_alloc);
+EXPORT_SYMBOL(nftnl_batch_alloc);
void nftnl_batch_free(struct nftnl_batch *batch)
{
@@ -94,7 +94,7 @@ void nftnl_batch_free(struct nftnl_batch *batch)
free(batch);
}
-EXPORT_SYMBOL_ALIAS(nftnl_batch_free, nft_batch_free);
+EXPORT_SYMBOL(nftnl_batch_free);
int nftnl_batch_update(struct nftnl_batch *batch)
{
@@ -119,19 +119,19 @@ int nftnl_batch_update(struct nftnl_batch *batch)
err1:
return -1;
}
-EXPORT_SYMBOL_ALIAS(nftnl_batch_update, nft_batch_update);
+EXPORT_SYMBOL(nftnl_batch_update);
void *nftnl_batch_buffer(struct nftnl_batch *batch)
{
return mnl_nlmsg_batch_current(batch->current_page->batch);
}
-EXPORT_SYMBOL_ALIAS(nftnl_batch_buffer, nft_batch_buffer);
+EXPORT_SYMBOL(nftnl_batch_buffer);
uint32_t nftnl_batch_buffer_len(struct nftnl_batch *batch)
{
return mnl_nlmsg_batch_size(batch->current_page->batch);
}
-EXPORT_SYMBOL_ALIAS(nftnl_batch_buffer_len, nft_batch_buffer_len);
+EXPORT_SYMBOL(nftnl_batch_buffer_len);
int nftnl_batch_iovec_len(struct nftnl_batch *batch)
{
@@ -143,7 +143,7 @@ int nftnl_batch_iovec_len(struct nftnl_batch *batch)
return num_pages;
}
-EXPORT_SYMBOL_ALIAS(nftnl_batch_iovec_len, nft_batch_iovec_len);
+EXPORT_SYMBOL(nftnl_batch_iovec_len);
void nftnl_batch_iovec(struct nftnl_batch *batch, struct iovec *iov,
uint32_t iovlen)
@@ -160,4 +160,4 @@ void nftnl_batch_iovec(struct nftnl_batch *batch, struct iovec *iov,
i++;
}
}
-EXPORT_SYMBOL_ALIAS(nftnl_batch_iovec, nft_batch_iovec);
+EXPORT_SYMBOL(nftnl_batch_iovec);
diff --git a/src/chain.c b/src/chain.c
index 990c576..70daaf3 100644
--- a/src/chain.c
+++ b/src/chain.c
@@ -91,7 +91,7 @@ struct nftnl_chain *nftnl_chain_alloc(void)
{
return calloc(1, sizeof(struct nftnl_chain));
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_alloc, nft_chain_alloc);
+EXPORT_SYMBOL(nftnl_chain_alloc);
void nftnl_chain_free(const struct nftnl_chain *c)
{
@@ -104,13 +104,13 @@ void nftnl_chain_free(const struct nftnl_chain *c)
xfree(c);
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_free, nft_chain_free);
+EXPORT_SYMBOL(nftnl_chain_free);
bool nftnl_chain_is_set(const struct nftnl_chain *c, uint16_t attr)
{
return c->flags & (1 << attr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_is_set, nft_chain_attr_is_set);
+EXPORT_SYMBOL(nftnl_chain_is_set);
void nftnl_chain_unset(struct nftnl_chain *c, uint16_t attr)
{
@@ -153,7 +153,7 @@ void nftnl_chain_unset(struct nftnl_chain *c, uint16_t attr)
c->flags &= ~(1 << attr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_unset, nft_chain_attr_unset);
+EXPORT_SYMBOL(nftnl_chain_unset);
static uint32_t nftnl_chain_validate[NFTNL_CHAIN_MAX + 1] = {
[NFTNL_CHAIN_HOOKNUM] = sizeof(uint32_t),
@@ -222,43 +222,43 @@ void nftnl_chain_set_data(struct nftnl_chain *c, uint16_t attr,
}
c->flags |= (1 << attr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_set_data, nft_chain_attr_set_data);
+EXPORT_SYMBOL(nftnl_chain_set_data);
void nftnl_chain_set(struct nftnl_chain *c, uint16_t attr, const void *data)
{
nftnl_chain_set_data(c, attr, data, nftnl_chain_validate[attr]);
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_set, nft_chain_attr_set);
+EXPORT_SYMBOL(nftnl_chain_set);
void nftnl_chain_set_u32(struct nftnl_chain *c, uint16_t attr, uint32_t data)
{
nftnl_chain_set_data(c, attr, &data, sizeof(uint32_t));
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_set_u32, nft_chain_attr_set_u32);
+EXPORT_SYMBOL(nftnl_chain_set_u32);
void nftnl_chain_set_s32(struct nftnl_chain *c, uint16_t attr, int32_t data)
{
nftnl_chain_set_data(c, attr, &data, sizeof(int32_t));
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_set_s32, nft_chain_attr_set_s32);
+EXPORT_SYMBOL(nftnl_chain_set_s32);
void nftnl_chain_set_u64(struct nftnl_chain *c, uint16_t attr, uint64_t data)
{
nftnl_chain_set_data(c, attr, &data, sizeof(uint64_t));
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_set_u64, nft_chain_attr_set_u64);
+EXPORT_SYMBOL(nftnl_chain_set_u64);
void nftnl_chain_set_u8(struct nftnl_chain *c, uint16_t attr, uint8_t data)
{
nftnl_chain_set_data(c, attr, &data, sizeof(uint8_t));
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_set_u8, nft_chain_attr_set_u8);
+EXPORT_SYMBOL(nftnl_chain_set_u8);
void nftnl_chain_set_str(struct nftnl_chain *c, uint16_t attr, const char *str)
{
nftnl_chain_set_data(c, attr, str, strlen(str));
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_set_str, nft_chain_attr_set_str);
+EXPORT_SYMBOL(nftnl_chain_set_str);
const void *nftnl_chain_get_data(const struct nftnl_chain *c, uint16_t attr,
uint32_t *data_len)
@@ -303,20 +303,20 @@ const void *nftnl_chain_get_data(const struct nftnl_chain *c, uint16_t attr,
}
return NULL;
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_get_data, nft_chain_attr_get_data);
+EXPORT_SYMBOL(nftnl_chain_get_data);
const void *nftnl_chain_get(const struct nftnl_chain *c, uint16_t attr)
{
uint32_t data_len;
return nftnl_chain_get_data(c, attr, &data_len);
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_get, nft_chain_attr_get);
+EXPORT_SYMBOL(nftnl_chain_get);
const char *nftnl_chain_get_str(const struct nftnl_chain *c, uint16_t attr)
{
return nftnl_chain_get(c, attr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_get_str, nft_chain_attr_get_str);
+EXPORT_SYMBOL(nftnl_chain_get_str);
uint32_t nftnl_chain_get_u32(const struct nftnl_chain *c, uint16_t attr)
{
@@ -327,7 +327,7 @@ uint32_t nftnl_chain_get_u32(const struct nftnl_chain *c, uint16_t attr)
return val ? *val : 0;
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_get_u32, nft_chain_attr_get_u32);
+EXPORT_SYMBOL(nftnl_chain_get_u32);
int32_t nftnl_chain_get_s32(const struct nftnl_chain *c, uint16_t attr)
{
@@ -338,7 +338,7 @@ int32_t nftnl_chain_get_s32(const struct nftnl_chain *c, uint16_t attr)
return val ? *val : 0;
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_get_s32, nft_chain_attr_get_s32);
+EXPORT_SYMBOL(nftnl_chain_get_s32);
uint64_t nftnl_chain_get_u64(const struct nftnl_chain *c, uint16_t attr)
{
@@ -349,7 +349,7 @@ uint64_t nftnl_chain_get_u64(const struct nftnl_chain *c, uint16_t attr)
return val ? *val : 0;
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_get_u64, nft_chain_attr_get_u64);
+EXPORT_SYMBOL(nftnl_chain_get_u64);
uint8_t nftnl_chain_get_u8(const struct nftnl_chain *c, uint16_t attr)
{
@@ -360,7 +360,7 @@ uint8_t nftnl_chain_get_u8(const struct nftnl_chain *c, uint16_t attr)
return val ? *val : 0;
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_get_u8, nft_chain_attr_get_u8);
+EXPORT_SYMBOL(nftnl_chain_get_u8);
void nftnl_chain_nlmsg_build_payload(struct nlmsghdr *nlh, const struct nftnl_chain *c)
{
@@ -397,7 +397,7 @@ void nftnl_chain_nlmsg_build_payload(struct nlmsghdr *nlh, const struct nftnl_ch
if (c->flags & (1 << NFTNL_CHAIN_TYPE))
mnl_attr_put_strz(nlh, NFTA_CHAIN_TYPE, c->type);
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_nlmsg_build_payload, nft_chain_nlmsg_build_payload);
+EXPORT_SYMBOL(nftnl_chain_nlmsg_build_payload);
static int nftnl_chain_parse_attr_cb(const struct nlattr *attr, void *data)
{
@@ -572,7 +572,7 @@ int nftnl_chain_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_chain *c)
return ret;
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_nlmsg_parse, nft_chain_nlmsg_parse);
+EXPORT_SYMBOL(nftnl_chain_nlmsg_parse);
static inline int nftnl_str2hooknum(int family, const char *hook)
{
@@ -824,14 +824,14 @@ int nftnl_chain_parse(struct nftnl_chain *c, enum nftnl_parse_type type,
{
return nftnl_chain_do_parse(c, type, data, err, NFTNL_PARSE_BUFFER);
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_parse, nft_chain_parse);
+EXPORT_SYMBOL(nftnl_chain_parse);
int nftnl_chain_parse_file(struct nftnl_chain *c, enum nftnl_parse_type type,
FILE *fp, struct nftnl_parse_err *err)
{
return nftnl_chain_do_parse(c, type, fp, err, NFTNL_PARSE_FILE);
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_parse_file, nft_chain_parse_file);
+EXPORT_SYMBOL(nftnl_chain_parse_file);
static int nftnl_chain_export(char *buf, size_t size,
const struct nftnl_chain *c, int type)
@@ -934,7 +934,7 @@ int nftnl_chain_snprintf(char *buf, size_t size, const struct nftnl_chain *c,
return nftnl_chain_cmd_snprintf(buf, size, c, nftnl_flag2cmd(flags), type,
flags);
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_snprintf, nft_chain_snprintf);
+EXPORT_SYMBOL(nftnl_chain_snprintf);
static int nftnl_chain_do_snprintf(char *buf, size_t size, const void *c,
uint32_t cmd, uint32_t type, uint32_t flags)
@@ -948,7 +948,7 @@ int nftnl_chain_fprintf(FILE *fp, const struct nftnl_chain *c, uint32_t type,
return nftnl_fprintf(fp, c, NFTNL_CMD_UNSPEC, type, flags,
nftnl_chain_do_snprintf);
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_fprintf, nft_chain_fprintf);
+EXPORT_SYMBOL(nftnl_chain_fprintf);
struct nftnl_chain_list {
struct list_head list;
@@ -966,7 +966,7 @@ struct nftnl_chain_list *nftnl_chain_list_alloc(void)
return list;
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_list_alloc, nft_chain_list_alloc);
+EXPORT_SYMBOL(nftnl_chain_list_alloc);
void nftnl_chain_list_free(struct nftnl_chain_list *list)
{
@@ -978,31 +978,31 @@ void nftnl_chain_list_free(struct nftnl_chain_list *list)
}
xfree(list);
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_list_free, nft_chain_list_free);
+EXPORT_SYMBOL(nftnl_chain_list_free);
int nftnl_chain_list_is_empty(const struct nftnl_chain_list *list)
{
return list_empty(&list->list);
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_list_is_empty, nft_chain_list_is_empty);
+EXPORT_SYMBOL(nftnl_chain_list_is_empty);
void nftnl_chain_list_add(struct nftnl_chain *r, struct nftnl_chain_list *list)
{
list_add(&r->head, &list->list);
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_list_add, nft_chain_list_add);
+EXPORT_SYMBOL(nftnl_chain_list_add);
void nftnl_chain_list_add_tail(struct nftnl_chain *r, struct nftnl_chain_list *list)
{
list_add_tail(&r->head, &list->list);
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_list_add_tail, nft_chain_list_add_tail);
+EXPORT_SYMBOL(nftnl_chain_list_add_tail);
void nftnl_chain_list_del(struct nftnl_chain *r)
{
list_del(&r->head);
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_list_del, nft_chain_list_del);
+EXPORT_SYMBOL(nftnl_chain_list_del);
int nftnl_chain_list_foreach(struct nftnl_chain_list *chain_list,
int (*cb)(struct nftnl_chain *r, void *data),
@@ -1018,7 +1018,7 @@ int nftnl_chain_list_foreach(struct nftnl_chain_list *chain_list,
}
return 0;
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_list_foreach, nft_chain_list_foreach);
+EXPORT_SYMBOL(nftnl_chain_list_foreach);
struct nftnl_chain_list_iter {
struct nftnl_chain_list *list;
@@ -1041,7 +1041,7 @@ struct nftnl_chain_list_iter *nftnl_chain_list_iter_create(struct nftnl_chain_li
return iter;
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_list_iter_create, nft_chain_list_iter_create);
+EXPORT_SYMBOL(nftnl_chain_list_iter_create);
struct nftnl_chain *nftnl_chain_list_iter_next(struct nftnl_chain_list_iter *iter)
{
@@ -1057,10 +1057,10 @@ struct nftnl_chain *nftnl_chain_list_iter_next(struct nftnl_chain_list_iter *ite
return r;
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_list_iter_next, nft_chain_list_iter_next);
+EXPORT_SYMBOL(nftnl_chain_list_iter_next);
void nftnl_chain_list_iter_destroy(struct nftnl_chain_list_iter *iter)
{
xfree(iter);
}
-EXPORT_SYMBOL_ALIAS(nftnl_chain_list_iter_destroy, nft_chain_list_iter_destroy);
+EXPORT_SYMBOL(nftnl_chain_list_iter_destroy);
diff --git a/src/common.c b/src/common.c
index bf4176c..8b001fe 100644
--- a/src/common.c
+++ b/src/common.c
@@ -40,7 +40,7 @@ struct nlmsghdr *nftnl_nlmsg_build_hdr(char *buf, uint16_t cmd, uint16_t family,
return nlh;
}
-EXPORT_SYMBOL_ALIAS(nftnl_nlmsg_build_hdr, nft_nlmsg_build_hdr);
+EXPORT_SYMBOL(nftnl_nlmsg_build_hdr);
struct nftnl_parse_err *nftnl_parse_err_alloc(void)
{
@@ -54,13 +54,13 @@ struct nftnl_parse_err *nftnl_parse_err_alloc(void)
return err;
}
-EXPORT_SYMBOL_ALIAS(nftnl_parse_err_alloc, nft_parse_err_alloc);
+EXPORT_SYMBOL(nftnl_parse_err_alloc);
void nftnl_parse_err_free(struct nftnl_parse_err *err)
{
xfree(err);
}
-EXPORT_SYMBOL_ALIAS(nftnl_parse_err_free, nft_parse_err_free);
+EXPORT_SYMBOL(nftnl_parse_err_free);
int nftnl_parse_perror(const char *msg, struct nftnl_parse_err *err)
{
@@ -80,7 +80,7 @@ int nftnl_parse_perror(const char *msg, struct nftnl_parse_err *err)
return fprintf(stderr, "%s: Undefined error\n", msg);
}
}
-EXPORT_SYMBOL_ALIAS(nftnl_parse_perror, nft_parse_perror);
+EXPORT_SYMBOL(nftnl_parse_perror);
int nftnl_cmd_header_snprintf(char *buf, size_t size, uint32_t cmd, uint32_t type,
uint32_t flags)
@@ -176,13 +176,13 @@ void nftnl_batch_begin(char *buf, uint32_t seq)
{
nftnl_batch_build_hdr(buf, NFNL_MSG_BATCH_BEGIN, seq);
}
-EXPORT_SYMBOL_ALIAS(nftnl_batch_begin, nft_batch_begin);
+EXPORT_SYMBOL(nftnl_batch_begin);
void nftnl_batch_end(char *buf, uint32_t seq)
{
nftnl_batch_build_hdr(buf, NFNL_MSG_BATCH_END, seq);
}
-EXPORT_SYMBOL_ALIAS(nftnl_batch_end, nft_batch_end);
+EXPORT_SYMBOL(nftnl_batch_end);
int nftnl_batch_is_supported(void)
{
@@ -241,4 +241,4 @@ err:
mnl_nlmsg_batch_stop(b);
return -1;
}
-EXPORT_SYMBOL_ALIAS(nftnl_batch_is_supported, nft_batch_is_supported);
+EXPORT_SYMBOL(nftnl_batch_is_supported);
diff --git a/src/expr.c b/src/expr.c
index ed07dc4..aa920dd 100644
--- a/src/expr.c
+++ b/src/expr.c
@@ -43,7 +43,7 @@ struct nftnl_expr *nftnl_expr_alloc(const char *name)
return expr;
}
-EXPORT_SYMBOL_ALIAS(nftnl_expr_alloc, nft_rule_expr_alloc);
+EXPORT_SYMBOL(nftnl_expr_alloc);
void nftnl_expr_free(const struct nftnl_expr *expr)
{
@@ -52,13 +52,13 @@ void nftnl_expr_free(const struct nftnl_expr *expr)
xfree(expr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_expr_free, nft_rule_expr_free);
+EXPORT_SYMBOL(nftnl_expr_free);
bool nftnl_expr_is_set(const struct nftnl_expr *expr, uint16_t type)
{
return expr->flags & (1 << type);
}
-EXPORT_SYMBOL_ALIAS(nftnl_expr_is_set, nft_rule_expr_is_set);
+EXPORT_SYMBOL(nftnl_expr_is_set);
void
nftnl_expr_set(struct nftnl_expr *expr, uint16_t type,
@@ -73,42 +73,42 @@ nftnl_expr_set(struct nftnl_expr *expr, uint16_t type,
}
expr->flags |= (1 << type);
}
-EXPORT_SYMBOL_ALIAS(nftnl_expr_set, nft_rule_expr_set);
+EXPORT_SYMBOL(nftnl_expr_set);
void
nftnl_expr_set_u8(struct nftnl_expr *expr, uint16_t type, uint8_t data)
{
nftnl_expr_set(expr, type, &data, sizeof(uint8_t));
}
-EXPORT_SYMBOL_ALIAS(nftnl_expr_set_u8, nft_rule_expr_set_u8);
+EXPORT_SYMBOL(nftnl_expr_set_u8);
void
nftnl_expr_set_u16(struct nftnl_expr *expr, uint16_t type, uint16_t data)
{
nftnl_expr_set(expr, type, &data, sizeof(uint16_t));
}
-EXPORT_SYMBOL_ALIAS(nftnl_expr_set_u16, nft_rule_expr_set_u16);
+EXPORT_SYMBOL(nftnl_expr_set_u16);
void
nftnl_expr_set_u32(struct nftnl_expr *expr, uint16_t type, uint32_t data)
{
nftnl_expr_set(expr, type, &data, sizeof(uint32_t));
}
-EXPORT_SYMBOL_ALIAS(nftnl_expr_set_u32, nft_rule_expr_set_u32);
+EXPORT_SYMBOL(nftnl_expr_set_u32);
void
nftnl_expr_set_u64(struct nftnl_expr *expr, uint16_t type, uint64_t data)
{
nftnl_expr_set(expr, type, &data, sizeof(uint64_t));
}
-EXPORT_SYMBOL_ALIAS(nftnl_expr_set_u64, nft_rule_expr_set_u64);
+EXPORT_SYMBOL(nftnl_expr_set_u64);
void
nftnl_expr_set_str(struct nftnl_expr *expr, uint16_t type, const char *str)
{
nftnl_expr_set(expr, type, str, strlen(str)+1);
}
-EXPORT_SYMBOL_ALIAS(nftnl_expr_set_str, nft_rule_expr_set_str);
+EXPORT_SYMBOL(nftnl_expr_set_str);
const void *nftnl_expr_get(const struct nftnl_expr *expr,
uint16_t type, uint32_t *data_len)
@@ -129,7 +129,7 @@ const void *nftnl_expr_get(const struct nftnl_expr *expr,
return ret;
}
-EXPORT_SYMBOL_ALIAS(nftnl_expr_get, nft_rule_expr_get);
+EXPORT_SYMBOL(nftnl_expr_get);
uint8_t nftnl_expr_get_u8(const struct nftnl_expr *expr, uint16_t type)
{
@@ -145,7 +145,7 @@ uint8_t nftnl_expr_get_u8(const struct nftnl_expr *expr, uint16_t type)
return *((uint8_t *)data);
}
-EXPORT_SYMBOL_ALIAS(nftnl_expr_get_u8, nft_rule_expr_get_u8);
+EXPORT_SYMBOL(nftnl_expr_get_u8);
uint16_t nftnl_expr_get_u16(const struct nftnl_expr *expr, uint16_t type)
{
@@ -161,7 +161,7 @@ uint16_t nftnl_expr_get_u16(const struct nftnl_expr *expr, uint16_t type)
return *((uint16_t *)data);
}
-EXPORT_SYMBOL_ALIAS(nftnl_expr_get_u16, nft_rule_expr_get_u16);
+EXPORT_SYMBOL(nftnl_expr_get_u16);
uint32_t nftnl_expr_get_u32(const struct nftnl_expr *expr, uint16_t type)
{
@@ -177,7 +177,7 @@ uint32_t nftnl_expr_get_u32(const struct nftnl_expr *expr, uint16_t type)
return *((uint32_t *)data);
}
-EXPORT_SYMBOL_ALIAS(nftnl_expr_get_u32, nft_rule_expr_get_u32);
+EXPORT_SYMBOL(nftnl_expr_get_u32);
uint64_t nftnl_expr_get_u64(const struct nftnl_expr *expr, uint16_t type)
{
@@ -193,7 +193,7 @@ uint64_t nftnl_expr_get_u64(const struct nftnl_expr *expr, uint16_t type)
return *((uint64_t *)data);
}
-EXPORT_SYMBOL_ALIAS(nftnl_expr_get_u64, nft_rule_expr_get_u64);
+EXPORT_SYMBOL(nftnl_expr_get_u64);
const char *nftnl_expr_get_str(const struct nftnl_expr *expr, uint16_t type)
{
@@ -201,7 +201,7 @@ const char *nftnl_expr_get_str(const struct nftnl_expr *expr, uint16_t type)
return (const char *)nftnl_expr_get(expr, type, &data_len);
}
-EXPORT_SYMBOL_ALIAS(nftnl_expr_get_str, nft_rule_expr_get_str);
+EXPORT_SYMBOL(nftnl_expr_get_str);
void
nftnl_expr_build_payload(struct nlmsghdr *nlh, struct nftnl_expr *expr)
@@ -273,4 +273,4 @@ int nftnl_expr_snprintf(char *buf, size_t size, const struct nftnl_expr *expr,
return offset;
}
-EXPORT_SYMBOL_ALIAS(nftnl_expr_snprintf, nft_rule_expr_snprintf);
+EXPORT_SYMBOL(nftnl_expr_snprintf);
diff --git a/src/gen.c b/src/gen.c
index 115a105..8533f38 100644
--- a/src/gen.c
+++ b/src/gen.c
@@ -33,19 +33,19 @@ struct nftnl_gen *nftnl_gen_alloc(void)
{
return calloc(1, sizeof(struct nftnl_gen));
}
-EXPORT_SYMBOL_ALIAS(nftnl_gen_alloc, nft_gen_alloc);
+EXPORT_SYMBOL(nftnl_gen_alloc);
void nftnl_gen_free(const struct nftnl_gen *gen)
{
xfree(gen);
}
-EXPORT_SYMBOL_ALIAS(nftnl_gen_free, nft_gen_free);
+EXPORT_SYMBOL(nftnl_gen_free);
bool nftnl_gen_is_set(const struct nftnl_gen *gen, uint16_t attr)
{
return gen->flags & (1 << attr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_gen_is_set, nft_gen_attr_is_set);
+EXPORT_SYMBOL(nftnl_gen_is_set);
void nftnl_gen_unset(struct nftnl_gen *gen, uint16_t attr)
{
@@ -58,7 +58,7 @@ void nftnl_gen_unset(struct nftnl_gen *gen, uint16_t attr)
}
gen->flags &= ~(1 << attr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_gen_unset, nft_gen_attr_unset);
+EXPORT_SYMBOL(nftnl_gen_unset);
static uint32_t nftnl_gen_validate[NFTNL_GEN_MAX + 1] = {
[NFTNL_GEN_ID] = sizeof(uint32_t),
@@ -79,19 +79,19 @@ void nftnl_gen_set_data(struct nftnl_gen *gen, uint16_t attr,
}
gen->flags |= (1 << attr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_gen_set_data, nft_gen_attr_set_data);
+EXPORT_SYMBOL(nftnl_gen_set_data);
void nftnl_gen_set(struct nftnl_gen *gen, uint16_t attr, const void *data)
{
nftnl_gen_set_data(gen, attr, data, nftnl_gen_validate[attr]);
}
-EXPORT_SYMBOL_ALIAS(nftnl_gen_set, nft_gen_attr_set);
+EXPORT_SYMBOL(nftnl_gen_set);
void nftnl_gen_set_u32(struct nftnl_gen *gen, uint16_t attr, uint32_t val)
{
nftnl_gen_set_data(gen, attr, &val, sizeof(uint32_t));
}
-EXPORT_SYMBOL_ALIAS(nftnl_gen_set_u32, nft_gen_attr_set_u32);
+EXPORT_SYMBOL(nftnl_gen_set_u32);
const void *nftnl_gen_get_data(const struct nftnl_gen *gen, uint16_t attr,
uint32_t *data_len)
@@ -105,21 +105,21 @@ const void *nftnl_gen_get_data(const struct nftnl_gen *gen, uint16_t attr,
}
return NULL;
}
-EXPORT_SYMBOL_ALIAS(nftnl_gen_get_data, nft_gen_attr_get_data);
+EXPORT_SYMBOL(nftnl_gen_get_data);
const void *nftnl_gen_get(const struct nftnl_gen *gen, uint16_t attr)
{
uint32_t data_len;
return nftnl_gen_get_data(gen, attr, &data_len);
}
-EXPORT_SYMBOL_ALIAS(nftnl_gen_get, nft_gen_attr_get);
+EXPORT_SYMBOL(nftnl_gen_get);
uint32_t nftnl_gen_get_u32(const struct nftnl_gen *gen, uint16_t attr)
{
const void *ret = nftnl_gen_get(gen, attr);
return ret == NULL ? 0 : *((uint32_t *)ret);
}
-EXPORT_SYMBOL_ALIAS(nftnl_gen_get_u32, nft_gen_attr_get_u32);
+EXPORT_SYMBOL(nftnl_gen_get_u32);
static int nftnl_gen_parse_attr_cb(const struct nlattr *attr, void *data)
{
@@ -154,7 +154,7 @@ int nftnl_gen_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_gen *gen)
}
return 0;
}
-EXPORT_SYMBOL_ALIAS(nftnl_gen_nlmsg_parse, nft_gen_nlmsg_parse);
+EXPORT_SYMBOL(nftnl_gen_nlmsg_parse);
static int nftnl_gen_snprintf_default(char *buf, size_t size,
const struct nftnl_gen *gen)
@@ -192,7 +192,7 @@ int nftnl_gen_snprintf(char *buf, size_t size, const struct nftnl_gen *gen,
return nftnl_gen_cmd_snprintf(buf, size, gen, nftnl_flag2cmd(flags), type,
flags);
}
-EXPORT_SYMBOL_ALIAS(nftnl_gen_snprintf, nft_gen_snprintf);
+EXPORT_SYMBOL(nftnl_gen_snprintf);
static int nftnl_gen_do_snprintf(char *buf, size_t size, const void *gen,
uint32_t cmd, uint32_t type, uint32_t flags)
@@ -206,4 +206,4 @@ int nftnl_gen_fprintf(FILE *fp, const struct nftnl_gen *gen, uint32_t type,
return nftnl_fprintf(fp, gen, NFTNL_CMD_UNSPEC, type, flags,
nftnl_gen_do_snprintf);
}
-EXPORT_SYMBOL_ALIAS(nftnl_gen_fprintf, nft_gen_fprintf);
+EXPORT_SYMBOL(nftnl_gen_fprintf);
diff --git a/src/libnftnl.map b/src/libnftnl.map
index c38e081..ed933c2 100644
--- a/src/libnftnl.map
+++ b/src/libnftnl.map
@@ -1,205 +1,5 @@
-LIBNFTNL_4 {
+LIBNFTNL_5 {
global:
- nft_table_alloc;
- nft_table_free;
- nft_table_attr_is_set;
- nft_table_attr_unset;
- nft_table_attr_set;
- nft_table_attr_get;
- nft_table_attr_set_u8;
- nft_table_attr_set_u32;
- nft_table_attr_set_str;
- nft_table_attr_get_u8;
- nft_table_attr_get_u32;
- nft_table_attr_get_str;
- nft_table_parse;
- nft_table_parse_file;
- nft_table_snprintf;
- nft_table_fprintf;
- nft_table_nlmsg_build_payload;
- nft_table_nlmsg_parse;
- nft_table_list_alloc;
- nft_table_list_free;
- nft_table_list_is_empty;
- nft_table_list_foreach;
- nft_table_list_add;
- nft_table_list_add_tail;
- nft_table_list_del;
- nft_table_list_iter_create;
- nft_table_list_iter_next;
- nft_table_list_iter_destroy;
-
- nft_chain_alloc;
- nft_chain_free;
- nft_chain_attr_is_set;
- nft_chain_attr_unset;
- nft_chain_attr_set;
- nft_chain_attr_set_u8;
- nft_chain_attr_set_u32;
- nft_chain_attr_set_s32;
- nft_chain_attr_set_u64;
- nft_chain_attr_set_str;
- nft_chain_attr_get;
- nft_chain_attr_get_u8;
- nft_chain_attr_get_u32;
- nft_chain_attr_get_s32;
- nft_chain_attr_get_u64;
- nft_chain_attr_get_str;
- nft_chain_parse;
- nft_chain_parse_file;
- nft_chain_snprintf;
- nft_chain_fprintf;
- nft_chain_nlmsg_build_payload;
- nft_chain_nlmsg_parse;
- nft_chain_list_alloc;
- nft_chain_list_free;
- nft_chain_list_is_empty;
- nft_chain_list_add;
- nft_chain_list_add_tail;
- nft_chain_list_del;
- nft_chain_list_foreach;
- nft_chain_list_iter_create;
- nft_chain_list_iter_next;
- nft_chain_list_iter_destroy;
-
- nft_rule_alloc;
- nft_rule_free;
- nft_rule_attr_is_set;
- nft_rule_attr_unset;
- nft_rule_attr_set;
- nft_rule_attr_set_u32;
- nft_rule_attr_set_u64;
- nft_rule_attr_set_str;
- nft_rule_attr_get;
- nft_rule_attr_get_u8;
- nft_rule_attr_get_u32;
- nft_rule_attr_get_u64;
- nft_rule_attr_get_str;
- nft_rule_parse;
- nft_rule_parse_file;
- nft_rule_snprintf;
- nft_rule_fprintf;
- nft_rule_nlmsg_build_payload;
- nft_rule_nlmsg_parse;
- nft_rule_add_expr;
-
- nft_rule_expr_foreach;
- nft_rule_expr_iter_create;
- nft_rule_expr_iter_next;
- nft_rule_expr_iter_destroy;
-
- nft_rule_expr_alloc;
- nft_rule_expr_is_set;
- nft_rule_expr_set;
- nft_rule_expr_set_u8;
- nft_rule_expr_set_u16;
- nft_rule_expr_set_u32;
- nft_rule_expr_set_u64;
- nft_rule_expr_set_str;
- nft_rule_expr_get;
- nft_rule_expr_get_u8;
- nft_rule_expr_get_u16;
- nft_rule_expr_get_u32;
- nft_rule_expr_get_u64;
- nft_rule_expr_get_str;
- nft_rule_expr_snprintf;
- nft_rule_expr_free;
-
- nft_rule_list_alloc;
- nft_rule_list_free;
- nft_rule_list_is_empty;
- nft_rule_list_add;
- nft_rule_list_add_tail;
- nft_rule_list_del;
- nft_rule_list_foreach;
- nft_rule_list_iter_create;
- nft_rule_list_iter_cur;
- nft_rule_list_iter_next;
- nft_rule_list_iter_destroy;
-
- nft_set_alloc;
- nft_set_free;
- nft_set_attr_unset;
- nft_set_attr_is_set;
- nft_set_attr_set;
- nft_set_attr_set_u32;
- nft_set_attr_set_u64;
- nft_set_attr_set_str;
- nft_set_attr_get;
- nft_set_attr_get_str;
- nft_set_attr_get_u32;
- nft_set_attr_get_u64;
- nft_set_nlmsg_build_payload;
- nft_set_nlmsg_parse;
- nft_set_parse;
- nft_set_parse_file;
- nft_set_snprintf;
- nft_set_fprintf;
-
- nft_set_list_alloc;
- nft_set_list_free;
- nft_set_list_add;
- nft_set_list_add_tail;
- nft_set_list_del;
- nft_set_list_is_empty;
- nft_set_list_foreach;
-
- nft_set_list_iter_create;
- nft_set_list_iter_cur;
- nft_set_list_iter_next;
- nft_set_list_iter_destroy;
-
- nft_set_elem_alloc;
- nft_set_elem_free;
- nft_set_elem_add;
- nft_set_elem_foreach;
- nft_set_elem_attr_is_set;
- nft_set_elem_attr_unset;
- nft_set_elem_attr_set;
- nft_set_elem_attr_set_u32;
- nft_set_elem_attr_set_u64;
- nft_set_elem_attr_set_str;
- nft_set_elem_attr_get;
- nft_set_elem_attr_get_str;
- nft_set_elem_attr_get_u32;
- nft_set_elem_attr_get_u64;
- nft_set_elem_nlmsg_build_payload;
- nft_set_elem_parse;
- nft_set_elem_parse_file;
- nft_set_elem_snprintf;
- nft_set_elem_fprinf;
-
- nft_set_elems_nlmsg_build_payload;
- nft_set_elems_nlmsg_parse;
-
- nft_set_elems_foreach;
-
- nft_set_elems_iter_create;
- nft_set_elems_iter_cur;
- nft_set_elems_iter_next;
- nft_set_elems_iter_destroy;
-
- nft_ruleset_alloc;
- nft_ruleset_free;
- nft_ruleset_attr_is_set;
- nft_ruleset_attr_unset;
- nft_ruleset_attr_set;
- nft_ruleset_attr_get;
- nft_ruleset_parse;
- nft_ruleset_parse_file;
- nft_ruleset_snprintf;
- nft_ruleset_fprintf;
-
- nft_nlmsg_build_hdr;
-
- nft_parse_err_alloc;
- nft_parse_err_free;
- nft_parse_perror;
-
-#
-# aliases
-#
-
nftnl_table_alloc;
nftnl_table_free;
nftnl_table_is_set;
@@ -396,20 +196,6 @@ global:
nftnl_parse_err_free;
nftnl_parse_perror;
-
- nft_table_attr_set_data;
- nft_table_attr_get_data;
- nft_chain_attr_set_data;
- nft_chain_attr_get_data;
- nft_rule_attr_set_data;
- nft_rule_attr_get_data;
- nft_set_attr_set_data;
- nft_set_attr_get_data;
-
-#
-# aliases
-#
-
nftnl_table_set_data;
nftnl_table_get_data;
nftnl_chain_set_data;
@@ -419,29 +205,6 @@ global:
nftnl_set_set_data;
nftnl_set_get_data;
- nft_set_elems_nlmsg_build_payload_iter;
- nft_batch_is_supported;
- nft_batch_begin;
- nft_batch_end;
-
- nft_gen_alloc;
- nft_gen_free;
- nft_gen_attr_is_set;
- nft_gen_attr_unset;
- nft_gen_attr_set_data;
- nft_gen_attr_set;
- nft_gen_attr_set_u32;
- nft_gen_attr_get_data;
- nft_gen_attr_get;
- nft_gen_attr_get_u32;
- nft_gen_nlmsg_parse;
- nft_gen_snprintf;
- nft_gen_fprintf;
-
-#
-# aliases
-#
-
nftnl_set_elems_nlmsg_build_payload_iter;
nftnl_batch_is_supported;
nftnl_batch_begin;
@@ -461,26 +224,6 @@ global:
nftnl_gen_snprintf;
nftnl_gen_fprintf;
-
- nft_ruleset_ctx_is_set;
- nft_ruleset_ctx_get;
- nft_ruleset_ctx_get_u32;
- nft_ruleset_parse_file_cb;
- nft_ruleset_parse_buffer_cb;
- nft_ruleset_ctx_free;
-
- nft_batch_alloc;
- nft_batch_update;
- nft_batch_free;
- nft_batch_buffer;
- nft_batch_buffer_len;
- nft_batch_iovec_len;
- nft_batch_iovec;
-
-#
-# aliases
-#
-
nftnl_ruleset_ctx_is_set;
nftnl_ruleset_ctx_get;
nftnl_ruleset_ctx_get_u32;
@@ -496,10 +239,6 @@ global:
nftnl_batch_iovec_len;
nftnl_batch_iovec;
-local: *;
-};
-
-LIBNFTNL_4.1 {
nftnl_trace_alloc;
nftnl_trace_free;
@@ -527,4 +266,4 @@ LIBNFTNL_4.1 {
nftnl_udata_get;
nftnl_udata_next;
nftnl_udata_parse;
-} LIBNFTNL_4;
+};
diff --git a/src/rule.c b/src/rule.c
index 8ee8648..1e1a138 100644
--- a/src/rule.c
+++ b/src/rule.c
@@ -62,7 +62,7 @@ struct nftnl_rule *nftnl_rule_alloc(void)
return r;
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_alloc, nft_rule_alloc);
+EXPORT_SYMBOL(nftnl_rule_alloc);
void nftnl_rule_free(const struct nftnl_rule *r)
{
@@ -80,13 +80,13 @@ void nftnl_rule_free(const struct nftnl_rule *r)
xfree(r);
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_free, nft_rule_free);
+EXPORT_SYMBOL(nftnl_rule_free);
bool nftnl_rule_is_set(const struct nftnl_rule *r, uint16_t attr)
{
return r->flags & (1 << attr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_is_set, nft_rule_attr_is_set);
+EXPORT_SYMBOL(nftnl_rule_is_set);
void nftnl_rule_unset(struct nftnl_rule *r, uint16_t attr)
{
@@ -117,7 +117,7 @@ void nftnl_rule_unset(struct nftnl_rule *r, uint16_t attr)
r->flags &= ~(1 << attr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_unset, nft_rule_attr_unset);
+EXPORT_SYMBOL(nftnl_rule_unset);
static uint32_t nftnl_rule_validate[NFTNL_RULE_MAX + 1] = {
[NFTNL_RULE_HANDLE] = sizeof(uint64_t),
@@ -177,31 +177,31 @@ void nftnl_rule_set_data(struct nftnl_rule *r, uint16_t attr,
}
r->flags |= (1 << attr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_set_data, nft_rule_attr_set_data);
+EXPORT_SYMBOL(nftnl_rule_set_data);
void nftnl_rule_set(struct nftnl_rule *r, uint16_t attr, const void *data)
{
nftnl_rule_set_data(r, attr, data, nftnl_rule_validate[attr]);
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_set, nft_rule_attr_set);
+EXPORT_SYMBOL(nftnl_rule_set);
void nftnl_rule_set_u32(struct nftnl_rule *r, uint16_t attr, uint32_t val)
{
nftnl_rule_set_data(r, attr, &val, sizeof(uint32_t));
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_set_u32, nft_rule_attr_set_u32);
+EXPORT_SYMBOL(nftnl_rule_set_u32);
void nftnl_rule_set_u64(struct nftnl_rule *r, uint16_t attr, uint64_t val)
{
nftnl_rule_set_data(r, attr, &val, sizeof(uint64_t));
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_set_u64, nft_rule_attr_set_u64);
+EXPORT_SYMBOL(nftnl_rule_set_u64);
void nftnl_rule_set_str(struct nftnl_rule *r, uint16_t attr, const char *str)
{
nftnl_rule_set_data(r, attr, str, strlen(str));
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_set_str, nft_rule_attr_set_str);
+EXPORT_SYMBOL(nftnl_rule_set_str);
const void *nftnl_rule_get_data(const struct nftnl_rule *r, uint16_t attr,
uint32_t *data_len)
@@ -235,20 +235,20 @@ const void *nftnl_rule_get_data(const struct nftnl_rule *r, uint16_t attr,
}
return NULL;
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_get_data, nft_rule_attr_get_data);
+EXPORT_SYMBOL(nftnl_rule_get_data);
const void *nftnl_rule_get(const struct nftnl_rule *r, uint16_t attr)
{
uint32_t data_len;
return nftnl_rule_get_data(r, attr, &data_len);
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_get, nft_rule_attr_get);
+EXPORT_SYMBOL(nftnl_rule_get);
const char *nftnl_rule_get_str(const struct nftnl_rule *r, uint16_t attr)
{
return nftnl_rule_get(r, attr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_get_str, nft_rule_attr_get_str);
+EXPORT_SYMBOL(nftnl_rule_get_str);
uint32_t nftnl_rule_get_u32(const struct nftnl_rule *r, uint16_t attr)
{
@@ -259,7 +259,7 @@ uint32_t nftnl_rule_get_u32(const struct nftnl_rule *r, uint16_t attr)
return val ? *val : 0;
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_get_u32, nft_rule_attr_get_u32);
+EXPORT_SYMBOL(nftnl_rule_get_u32);
uint64_t nftnl_rule_get_u64(const struct nftnl_rule *r, uint16_t attr)
{
@@ -270,7 +270,7 @@ uint64_t nftnl_rule_get_u64(const struct nftnl_rule *r, uint16_t attr)
return val ? *val : 0;
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_get_u64, nft_rule_attr_get_u64);
+EXPORT_SYMBOL(nftnl_rule_get_u64);
uint8_t nftnl_rule_get_u8(const struct nftnl_rule *r, uint16_t attr)
{
@@ -281,7 +281,7 @@ uint8_t nftnl_rule_get_u8(const struct nftnl_rule *r, uint16_t attr)
return val ? *val : 0;
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_get_u8, nft_rule_attr_get_u8);
+EXPORT_SYMBOL(nftnl_rule_get_u8);
void nftnl_rule_nlmsg_build_payload(struct nlmsghdr *nlh, struct nftnl_rule *r)
{
@@ -322,13 +322,13 @@ void nftnl_rule_nlmsg_build_payload(struct nlmsghdr *nlh, struct nftnl_rule *r)
mnl_attr_nest_end(nlh, nest);
}
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_nlmsg_build_payload, nft_rule_nlmsg_build_payload);
+EXPORT_SYMBOL(nftnl_rule_nlmsg_build_payload);
void nftnl_rule_add_expr(struct nftnl_rule *r, struct nftnl_expr *expr)
{
list_add_tail(&expr->head, &r->expr_list);
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_add_expr, nft_rule_add_expr);
+EXPORT_SYMBOL(nftnl_rule_add_expr);
static int nftnl_rule_parse_attr_cb(const struct nlattr *attr, void *data)
{
@@ -477,7 +477,7 @@ int nftnl_rule_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_rule *r)
return ret;
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_nlmsg_parse, nft_rule_nlmsg_parse);
+EXPORT_SYMBOL(nftnl_rule_nlmsg_parse);
#ifdef JSON_PARSING
int nftnl_jansson_parse_rule(struct nftnl_rule *r, json_t *tree,
@@ -711,14 +711,14 @@ int nftnl_rule_parse(struct nftnl_rule *r, enum nftnl_parse_type type,
{
return nftnl_rule_do_parse(r, type, data, err, NFTNL_PARSE_BUFFER);
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_parse, nft_rule_parse);
+EXPORT_SYMBOL(nftnl_rule_parse);
int nftnl_rule_parse_file(struct nftnl_rule *r, enum nftnl_parse_type type,
FILE *fp, struct nftnl_parse_err *err)
{
return nftnl_rule_do_parse(r, type, fp, err, NFTNL_PARSE_FILE);
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_parse_file, nft_rule_parse_file);
+EXPORT_SYMBOL(nftnl_rule_parse_file);
static int nftnl_rule_snprintf_json(char *buf, size_t size,
const struct nftnl_rule *r,
@@ -980,7 +980,7 @@ int nftnl_rule_snprintf(char *buf, size_t size, const struct nftnl_rule *r,
return nftnl_rule_cmd_snprintf(buf, size, r, nftnl_flag2cmd(flags), type,
flags);
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_snprintf, nft_rule_snprintf);
+EXPORT_SYMBOL(nftnl_rule_snprintf);
static int nftnl_rule_do_snprintf(char *buf, size_t size, const void *r,
uint32_t cmd, uint32_t type, uint32_t flags)
@@ -994,7 +994,7 @@ int nftnl_rule_fprintf(FILE *fp, const struct nftnl_rule *r, uint32_t type,
return nftnl_fprintf(fp, r, NFTNL_CMD_UNSPEC, type, flags,
nftnl_rule_do_snprintf);
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_fprintf, nft_rule_fprintf);
+EXPORT_SYMBOL(nftnl_rule_fprintf);
int nftnl_expr_foreach(struct nftnl_rule *r,
int (*cb)(struct nftnl_expr *e, void *data),
@@ -1010,7 +1010,7 @@ int nftnl_expr_foreach(struct nftnl_rule *r,
}
return 0;
}
-EXPORT_SYMBOL_ALIAS(nftnl_expr_foreach, nft_rule_expr_foreach);
+EXPORT_SYMBOL(nftnl_expr_foreach);
struct nftnl_expr_iter {
struct nftnl_rule *r;
@@ -1034,7 +1034,7 @@ struct nftnl_expr_iter *nftnl_expr_iter_create(struct nftnl_rule *r)
return iter;
}
-EXPORT_SYMBOL_ALIAS(nftnl_expr_iter_create, nft_rule_expr_iter_create);
+EXPORT_SYMBOL(nftnl_expr_iter_create);
struct nftnl_expr *nftnl_expr_iter_next(struct nftnl_expr_iter *iter)
{
@@ -1050,13 +1050,13 @@ struct nftnl_expr *nftnl_expr_iter_next(struct nftnl_expr_iter *iter)
return expr;
}
-EXPORT_SYMBOL_ALIAS(nftnl_expr_iter_next, nft_rule_expr_iter_next);
+EXPORT_SYMBOL(nftnl_expr_iter_next);
void nftnl_expr_iter_destroy(struct nftnl_expr_iter *iter)
{
xfree(iter);
}
-EXPORT_SYMBOL_ALIAS(nftnl_expr_iter_destroy, nft_rule_expr_iter_destroy);
+EXPORT_SYMBOL(nftnl_expr_iter_destroy);
struct nftnl_rule_list {
struct list_head list;
@@ -1074,7 +1074,7 @@ struct nftnl_rule_list *nftnl_rule_list_alloc(void)
return list;
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_list_alloc, nft_rule_list_alloc);
+EXPORT_SYMBOL(nftnl_rule_list_alloc);
void nftnl_rule_list_free(struct nftnl_rule_list *list)
{
@@ -1086,31 +1086,31 @@ void nftnl_rule_list_free(struct nftnl_rule_list *list)
}
xfree(list);
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_list_free, nft_rule_list_free);
+EXPORT_SYMBOL(nftnl_rule_list_free);
int nftnl_rule_list_is_empty(const struct nftnl_rule_list *list)
{
return list_empty(&list->list);
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_list_is_empty, nft_rule_list_is_empty);
+EXPORT_SYMBOL(nftnl_rule_list_is_empty);
void nftnl_rule_list_add(struct nftnl_rule *r, struct nftnl_rule_list *list)
{
list_add(&r->head, &list->list);
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_list_add, nft_rule_list_add);
+EXPORT_SYMBOL(nftnl_rule_list_add);
void nftnl_rule_list_add_tail(struct nftnl_rule *r, struct nftnl_rule_list *list)
{
list_add_tail(&r->head, &list->list);
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_list_add_tail, nft_rule_list_add_tail);
+EXPORT_SYMBOL(nftnl_rule_list_add_tail);
void nftnl_rule_list_del(struct nftnl_rule *r)
{
list_del(&r->head);
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_list_del, nft_rule_list_del);
+EXPORT_SYMBOL(nftnl_rule_list_del);
int nftnl_rule_list_foreach(struct nftnl_rule_list *rule_list,
int (*cb)(struct nftnl_rule *r, void *data),
@@ -1126,7 +1126,7 @@ int nftnl_rule_list_foreach(struct nftnl_rule_list *rule_list,
}
return 0;
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_list_foreach, nft_rule_list_foreach);
+EXPORT_SYMBOL(nftnl_rule_list_foreach);
struct nftnl_rule_list_iter {
struct nftnl_rule_list *list;
@@ -1149,13 +1149,13 @@ struct nftnl_rule_list_iter *nftnl_rule_list_iter_create(struct nftnl_rule_list
return iter;
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_list_iter_create, nft_rule_list_iter_create);
+EXPORT_SYMBOL(nftnl_rule_list_iter_create);
struct nftnl_rule *nftnl_rule_list_iter_cur(struct nftnl_rule_list_iter *iter)
{
return iter->cur;
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_list_iter_cur, nft_rule_list_iter_cur);
+EXPORT_SYMBOL(nftnl_rule_list_iter_cur);
struct nftnl_rule *nftnl_rule_list_iter_next(struct nftnl_rule_list_iter *iter)
{
@@ -1171,10 +1171,10 @@ struct nftnl_rule *nftnl_rule_list_iter_next(struct nftnl_rule_list_iter *iter)
return r;
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_list_iter_next, nft_rule_list_iter_next);
+EXPORT_SYMBOL(nftnl_rule_list_iter_next);
void nftnl_rule_list_iter_destroy(const struct nftnl_rule_list_iter *iter)
{
xfree(iter);
}
-EXPORT_SYMBOL_ALIAS(nftnl_rule_list_iter_destroy, nft_rule_list_iter_destroy);
+EXPORT_SYMBOL(nftnl_rule_list_iter_destroy);
diff --git a/src/ruleset.c b/src/ruleset.c
index 414b7c4..cbe1438 100644
--- a/src/ruleset.c
+++ b/src/ruleset.c
@@ -62,7 +62,7 @@ struct nftnl_ruleset *nftnl_ruleset_alloc(void)
{
return calloc(1, sizeof(struct nftnl_ruleset));
}
-EXPORT_SYMBOL_ALIAS(nftnl_ruleset_alloc, nft_ruleset_alloc);
+EXPORT_SYMBOL(nftnl_ruleset_alloc);
void nftnl_ruleset_free(const struct nftnl_ruleset *r)
{
@@ -76,13 +76,13 @@ void nftnl_ruleset_free(const struct nftnl_ruleset *r)
nftnl_rule_list_free(r->rule_list);
xfree(r);
}
-EXPORT_SYMBOL_ALIAS(nftnl_ruleset_free, nft_ruleset_free);
+EXPORT_SYMBOL(nftnl_ruleset_free);
bool nftnl_ruleset_is_set(const struct nftnl_ruleset *r, uint16_t attr)
{
return r->flags & (1 << attr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_ruleset_is_set, nft_ruleset_attr_is_set);
+EXPORT_SYMBOL(nftnl_ruleset_is_set);
void nftnl_ruleset_unset(struct nftnl_ruleset *r, uint16_t attr)
{
@@ -109,7 +109,7 @@ void nftnl_ruleset_unset(struct nftnl_ruleset *r, uint16_t attr)
}
r->flags &= ~(1 << attr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_ruleset_unset, nft_ruleset_attr_unset);
+EXPORT_SYMBOL(nftnl_ruleset_unset);
void nftnl_ruleset_set(struct nftnl_ruleset *r, uint16_t attr, void *data)
{
@@ -135,7 +135,7 @@ void nftnl_ruleset_set(struct nftnl_ruleset *r, uint16_t attr, void *data)
}
r->flags |= (1 << attr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_ruleset_set, nft_ruleset_attr_set);
+EXPORT_SYMBOL(nftnl_ruleset_set);
void *nftnl_ruleset_get(const struct nftnl_ruleset *r, uint16_t attr)
{
@@ -155,7 +155,7 @@ void *nftnl_ruleset_get(const struct nftnl_ruleset *r, uint16_t attr)
return NULL;
}
}
-EXPORT_SYMBOL_ALIAS(nftnl_ruleset_get, nft_ruleset_attr_get);
+EXPORT_SYMBOL(nftnl_ruleset_get);
void nftnl_ruleset_ctx_free(const struct nftnl_parse_ctx *ctx)
{
@@ -178,13 +178,13 @@ void nftnl_ruleset_ctx_free(const struct nftnl_parse_ctx *ctx)
break;
}
}
-EXPORT_SYMBOL_ALIAS(nftnl_ruleset_ctx_free, nft_ruleset_ctx_free);
+EXPORT_SYMBOL(nftnl_ruleset_ctx_free);
bool nftnl_ruleset_ctx_is_set(const struct nftnl_parse_ctx *ctx, uint16_t attr)
{
return ctx->flags & (1 << attr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_ruleset_ctx_is_set, nft_ruleset_ctx_is_set);
+EXPORT_SYMBOL(nftnl_ruleset_ctx_is_set);
void *nftnl_ruleset_ctx_get(const struct nftnl_parse_ctx *ctx, uint16_t attr)
{
@@ -210,14 +210,14 @@ void *nftnl_ruleset_ctx_get(const struct nftnl_parse_ctx *ctx, uint16_t attr)
return NULL;
}
}
-EXPORT_SYMBOL_ALIAS(nftnl_ruleset_ctx_get, nft_ruleset_ctx_get);
+EXPORT_SYMBOL(nftnl_ruleset_ctx_get);
uint32_t nftnl_ruleset_ctx_get_u32(const struct nftnl_parse_ctx *ctx, uint16_t attr)
{
const void *ret = nftnl_ruleset_ctx_get(ctx, attr);
return ret == NULL ? 0 : *((uint32_t *)ret);
}
-EXPORT_SYMBOL_ALIAS(nftnl_ruleset_ctx_get_u32, nft_ruleset_ctx_get_u32);
+EXPORT_SYMBOL(nftnl_ruleset_ctx_get_u32);
#if defined(JSON_PARSING) || defined(XML_PARSING)
static void nftnl_ruleset_ctx_set(struct nftnl_parse_ctx *ctx, uint16_t attr,
@@ -751,7 +751,7 @@ int nftnl_ruleset_parse_file_cb(enum nftnl_parse_type type, FILE *fp,
{
return nftnl_ruleset_do_parse(type, fp, err, NFTNL_PARSE_FILE, data, cb);
}
-EXPORT_SYMBOL_ALIAS(nftnl_ruleset_parse_file_cb, nft_ruleset_parse_file_cb);
+EXPORT_SYMBOL(nftnl_ruleset_parse_file_cb);
int nftnl_ruleset_parse_buffer_cb(enum nftnl_parse_type type, const char *buffer,
struct nftnl_parse_err *err, void *data,
@@ -760,7 +760,7 @@ int nftnl_ruleset_parse_buffer_cb(enum nftnl_parse_type type, const char *buffer
return nftnl_ruleset_do_parse(type, buffer, err, NFTNL_PARSE_BUFFER, data,
cb);
}
-EXPORT_SYMBOL_ALIAS(nftnl_ruleset_parse_buffer_cb, nft_ruleset_parse_buffer_cb);
+EXPORT_SYMBOL(nftnl_ruleset_parse_buffer_cb);
static int nftnl_ruleset_cb(const struct nftnl_parse_ctx *ctx)
{
@@ -828,14 +828,14 @@ int nftnl_ruleset_parse(struct nftnl_ruleset *r, enum nftnl_parse_type type,
{
return nftnl_ruleset_parse_buffer_cb(type, data, err, r, nftnl_ruleset_cb);
}
-EXPORT_SYMBOL_ALIAS(nftnl_ruleset_parse, nft_ruleset_parse);
+EXPORT_SYMBOL(nftnl_ruleset_parse);
int nftnl_ruleset_parse_file(struct nftnl_ruleset *rs, enum nftnl_parse_type type,
FILE *fp, struct nftnl_parse_err *err)
{
return nftnl_ruleset_parse_file_cb(type, fp, err, rs, nftnl_ruleset_cb);
}
-EXPORT_SYMBOL_ALIAS(nftnl_ruleset_parse_file, nft_ruleset_parse_file);
+EXPORT_SYMBOL(nftnl_ruleset_parse_file);
static const char *nftnl_ruleset_o_opentag(uint32_t type)
{
@@ -1097,7 +1097,7 @@ int nftnl_ruleset_snprintf(char *buf, size_t size, const struct nftnl_ruleset *r
return -1;
}
}
-EXPORT_SYMBOL_ALIAS(nftnl_ruleset_snprintf, nft_ruleset_snprintf);
+EXPORT_SYMBOL(nftnl_ruleset_snprintf);
static int nftnl_ruleset_fprintf_tables(FILE *fp, const struct nftnl_ruleset *rs,
uint32_t type, uint32_t flags)
@@ -1317,4 +1317,4 @@ int nftnl_ruleset_fprintf(FILE *fp, const struct nftnl_ruleset *rs, uint32_t typ
return nftnl_ruleset_cmd_fprintf(fp, rs, nftnl_flag2cmd(flags), type,
flags);
}
-EXPORT_SYMBOL_ALIAS(nftnl_ruleset_fprintf, nft_ruleset_fprintf);
+EXPORT_SYMBOL(nftnl_ruleset_fprintf);
diff --git a/src/set.c b/src/set.c
index dbea93b..3caaf39 100644
--- a/src/set.c
+++ b/src/set.c
@@ -38,7 +38,7 @@ struct nftnl_set *nftnl_set_alloc(void)
INIT_LIST_HEAD(&s->element_list);
return s;
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_alloc, nft_set_alloc);
+EXPORT_SYMBOL(nftnl_set_alloc);
void nftnl_set_free(const struct nftnl_set *s)
{
@@ -55,13 +55,13 @@ void nftnl_set_free(const struct nftnl_set *s)
}
xfree(s);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_free, nft_set_free);
+EXPORT_SYMBOL(nftnl_set_free);
bool nftnl_set_is_set(const struct nftnl_set *s, uint16_t attr)
{
return s->flags & (1 << attr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_is_set, nft_set_attr_is_set);
+EXPORT_SYMBOL(nftnl_set_is_set);
void nftnl_set_unset(struct nftnl_set *s, uint16_t attr)
{
@@ -98,7 +98,7 @@ void nftnl_set_unset(struct nftnl_set *s, uint16_t attr)
s->flags &= ~(1 << attr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_unset, nft_set_attr_unset);
+EXPORT_SYMBOL(nftnl_set_unset);
static uint32_t nftnl_set_validate[NFTNL_SET_MAX + 1] = {
[NFTNL_SET_FLAGS] = sizeof(uint32_t),
@@ -170,31 +170,31 @@ void nftnl_set_set_data(struct nftnl_set *s, uint16_t attr, const void *data,
}
s->flags |= (1 << attr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_set_data, nft_set_attr_set_data);
+EXPORT_SYMBOL(nftnl_set_set_data);
void nftnl_set_set(struct nftnl_set *s, uint16_t attr, const void *data)
{
nftnl_set_set_data(s, attr, data, nftnl_set_validate[attr]);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_set, nft_set_attr_set);
+EXPORT_SYMBOL(nftnl_set_set);
void nftnl_set_set_u32(struct nftnl_set *s, uint16_t attr, uint32_t val)
{
nftnl_set_set(s, attr, &val);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_set_u32, nft_set_attr_set_u32);
+EXPORT_SYMBOL(nftnl_set_set_u32);
void nftnl_set_set_u64(struct nftnl_set *s, uint16_t attr, uint64_t val)
{
nftnl_set_set(s, attr, &val);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_set_u64, nft_set_attr_set_u64);
+EXPORT_SYMBOL(nftnl_set_set_u64);
void nftnl_set_set_str(struct nftnl_set *s, uint16_t attr, const char *str)
{
nftnl_set_set(s, attr, str);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_set_str, nft_set_attr_set_str);
+EXPORT_SYMBOL(nftnl_set_set_str);
const void *nftnl_set_get_data(const struct nftnl_set *s, uint16_t attr,
uint32_t *data_len)
@@ -243,20 +243,20 @@ const void *nftnl_set_get_data(const struct nftnl_set *s, uint16_t attr,
}
return NULL;
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_get_data, nft_set_attr_get_data);
+EXPORT_SYMBOL(nftnl_set_get_data);
const void *nftnl_set_get(const struct nftnl_set *s, uint16_t attr)
{
uint32_t data_len;
return nftnl_set_get_data(s, attr, &data_len);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_get, nft_set_attr_get);
+EXPORT_SYMBOL(nftnl_set_get);
const char *nftnl_set_get_str(const struct nftnl_set *s, uint16_t attr)
{
return nftnl_set_get(s, attr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_get_str, nft_set_attr_get_str);
+EXPORT_SYMBOL(nftnl_set_get_str);
uint32_t nftnl_set_get_u32(const struct nftnl_set *s, uint16_t attr)
{
@@ -267,7 +267,7 @@ uint32_t nftnl_set_get_u32(const struct nftnl_set *s, uint16_t attr)
return val ? *val : 0;
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_get_u32, nft_set_attr_get_u32);
+EXPORT_SYMBOL(nftnl_set_get_u32);
uint64_t nftnl_set_get_u64(const struct nftnl_set *s, uint16_t attr)
{
@@ -278,7 +278,7 @@ uint64_t nftnl_set_get_u64(const struct nftnl_set *s, uint16_t attr)
return val ? *val : 0;
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_get_u64, nft_set_attr_get_u64);
+EXPORT_SYMBOL(nftnl_set_get_u64);
struct nftnl_set *nftnl_set_clone(const struct nftnl_set *set)
{
@@ -349,7 +349,7 @@ void nftnl_set_nlmsg_build_payload(struct nlmsghdr *nlh, struct nftnl_set *s)
if (s->flags & (1 << NFTNL_SET_GC_INTERVAL))
mnl_attr_put_u32(nlh, NFTA_SET_GC_INTERVAL, htonl(s->gc_interval));
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_nlmsg_build_payload, nft_set_nlmsg_build_payload);
+EXPORT_SYMBOL(nftnl_set_nlmsg_build_payload);
static int nftnl_set_parse_attr_cb(const struct nlattr *attr, void *data)
{
@@ -488,7 +488,7 @@ int nftnl_set_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_set *s)
return ret;
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_nlmsg_parse, nft_set_nlmsg_parse);
+EXPORT_SYMBOL(nftnl_set_nlmsg_parse);
#ifdef JSON_PARSING
static int nftnl_jansson_parse_set_info(struct nftnl_set *s, json_t *tree,
@@ -762,14 +762,14 @@ int nftnl_set_parse(struct nftnl_set *s, enum nftnl_parse_type type,
{
return nftnl_set_do_parse(s, type, data, err, NFTNL_PARSE_BUFFER);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_parse, nft_set_parse);
+EXPORT_SYMBOL(nftnl_set_parse);
int nftnl_set_parse_file(struct nftnl_set *s, enum nftnl_parse_type type,
FILE *fp, struct nftnl_parse_err *err)
{
return nftnl_set_do_parse(s, type, fp, err, NFTNL_PARSE_FILE);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_parse_file, nft_set_parse_file);
+EXPORT_SYMBOL(nftnl_set_parse_file);
static int nftnl_set_snprintf_json(char *buf, size_t size,
const struct nftnl_set *s,
@@ -1039,7 +1039,7 @@ int nftnl_set_snprintf(char *buf, size_t size, const struct nftnl_set *s,
return nftnl_set_cmd_snprintf(buf, size, s, nftnl_flag2cmd(flags), type,
flags);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_snprintf, nft_set_snprintf);
+EXPORT_SYMBOL(nftnl_set_snprintf);
static int nftnl_set_do_snprintf(char *buf, size_t size, const void *s,
uint32_t cmd, uint32_t type, uint32_t flags)
@@ -1053,13 +1053,13 @@ int nftnl_set_fprintf(FILE *fp, const struct nftnl_set *s, uint32_t type,
return nftnl_fprintf(fp, s, NFTNL_CMD_UNSPEC, type, flags,
nftnl_set_do_snprintf);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_fprintf, nft_set_fprintf);
+EXPORT_SYMBOL(nftnl_set_fprintf);
void nftnl_set_elem_add(struct nftnl_set *s, struct nftnl_set_elem *elem)
{
list_add_tail(&elem->head, &s->element_list);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_elem_add, nft_set_elem_add);
+EXPORT_SYMBOL(nftnl_set_elem_add);
struct nftnl_set_list {
struct list_head list;
@@ -1077,7 +1077,7 @@ struct nftnl_set_list *nftnl_set_list_alloc(void)
return list;
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_list_alloc, nft_set_list_alloc);
+EXPORT_SYMBOL(nftnl_set_list_alloc);
void nftnl_set_list_free(struct nftnl_set_list *list)
{
@@ -1089,31 +1089,31 @@ void nftnl_set_list_free(struct nftnl_set_list *list)
}
xfree(list);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_list_free, nft_set_list_free);
+EXPORT_SYMBOL(nftnl_set_list_free);
int nftnl_set_list_is_empty(const struct nftnl_set_list *list)
{
return list_empty(&list->list);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_list_is_empty, nft_set_list_is_empty);
+EXPORT_SYMBOL(nftnl_set_list_is_empty);
void nftnl_set_list_add(struct nftnl_set *s, struct nftnl_set_list *list)
{
list_add(&s->head, &list->list);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_list_add, nft_set_list_add);
+EXPORT_SYMBOL(nftnl_set_list_add);
void nftnl_set_list_add_tail(struct nftnl_set *s, struct nftnl_set_list *list)
{
list_add_tail(&s->head, &list->list);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_list_add_tail, nft_set_list_add_tail);
+EXPORT_SYMBOL(nftnl_set_list_add_tail);
void nftnl_set_list_del(struct nftnl_set *s)
{
list_del(&s->head);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_list_del, nft_set_list_del);
+EXPORT_SYMBOL(nftnl_set_list_del);
int nftnl_set_list_foreach(struct nftnl_set_list *set_list,
int (*cb)(struct nftnl_set *t, void *data), void *data)
@@ -1128,7 +1128,7 @@ int nftnl_set_list_foreach(struct nftnl_set_list *set_list,
}
return 0;
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_list_foreach, nft_set_list_foreach);
+EXPORT_SYMBOL(nftnl_set_list_foreach);
struct nftnl_set_list_iter {
struct nftnl_set_list *list;
@@ -1151,13 +1151,13 @@ struct nftnl_set_list_iter *nftnl_set_list_iter_create(struct nftnl_set_list *l)
return iter;
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_list_iter_create, nft_set_list_iter_create);
+EXPORT_SYMBOL(nftnl_set_list_iter_create);
struct nftnl_set *nftnl_set_list_iter_cur(struct nftnl_set_list_iter *iter)
{
return iter->cur;
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_list_iter_cur, nft_set_list_iter_cur);
+EXPORT_SYMBOL(nftnl_set_list_iter_cur);
struct nftnl_set *nftnl_set_list_iter_next(struct nftnl_set_list_iter *iter)
{
@@ -1173,13 +1173,13 @@ struct nftnl_set *nftnl_set_list_iter_next(struct nftnl_set_list_iter *iter)
return s;
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_list_iter_next, nft_set_list_iter_next);
+EXPORT_SYMBOL(nftnl_set_list_iter_next);
void nftnl_set_list_iter_destroy(const struct nftnl_set_list_iter *iter)
{
xfree(iter);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_list_iter_destroy, nft_set_list_iter_destroy);
+EXPORT_SYMBOL(nftnl_set_list_iter_destroy);
static struct nftnl_set *nftnl_set_lookup(const char *this_set_name,
struct nftnl_set_list *set_list)
diff --git a/src/set_elem.c b/src/set_elem.c
index b9c7e1e..da30b02 100644
--- a/src/set_elem.c
+++ b/src/set_elem.c
@@ -37,7 +37,7 @@ struct nftnl_set_elem *nftnl_set_elem_alloc(void)
return s;
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_elem_alloc, nft_set_elem_alloc);
+EXPORT_SYMBOL(nftnl_set_elem_alloc);
void nftnl_set_elem_free(struct nftnl_set_elem *s)
{
@@ -56,13 +56,13 @@ void nftnl_set_elem_free(struct nftnl_set_elem *s)
xfree(s);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_elem_free, nft_set_elem_free);
+EXPORT_SYMBOL(nftnl_set_elem_free);
bool nftnl_set_elem_is_set(const struct nftnl_set_elem *s, uint16_t attr)
{
return s->flags & (1 << attr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_elem_is_set, nft_set_elem_attr_is_set);
+EXPORT_SYMBOL(nftnl_set_elem_is_set);
void nftnl_set_elem_unset(struct nftnl_set_elem *s, uint16_t attr)
{
@@ -95,7 +95,7 @@ void nftnl_set_elem_unset(struct nftnl_set_elem *s, uint16_t attr)
s->flags &= ~(1 << attr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_elem_unset, nft_set_elem_attr_unset);
+EXPORT_SYMBOL(nftnl_set_elem_unset);
void nftnl_set_elem_set(struct nftnl_set_elem *s, uint16_t attr,
const void *data, uint32_t data_len)
@@ -139,25 +139,25 @@ void nftnl_set_elem_set(struct nftnl_set_elem *s, uint16_t attr,
}
s->flags |= (1 << attr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_elem_set, nft_set_elem_attr_set);
+EXPORT_SYMBOL(nftnl_set_elem_set);
void nftnl_set_elem_set_u32(struct nftnl_set_elem *s, uint16_t attr, uint32_t val)
{
nftnl_set_elem_set(s, attr, &val, sizeof(uint32_t));
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_elem_set_u32, nft_set_elem_attr_set_u32);
+EXPORT_SYMBOL(nftnl_set_elem_set_u32);
void nftnl_set_elem_set_u64(struct nftnl_set_elem *s, uint16_t attr, uint64_t val)
{
nftnl_set_elem_set(s, attr, &val, sizeof(uint64_t));
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_elem_set_u64, nft_set_elem_attr_set_u64);
+EXPORT_SYMBOL(nftnl_set_elem_set_u64);
void nftnl_set_elem_set_str(struct nftnl_set_elem *s, uint16_t attr, const char *str)
{
nftnl_set_elem_set(s, attr, str, strlen(str));
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_elem_set_str, nft_set_elem_attr_set_str);
+EXPORT_SYMBOL(nftnl_set_elem_set_str);
const void *nftnl_set_elem_get(struct nftnl_set_elem *s, uint16_t attr, uint32_t *data_len)
{
@@ -189,7 +189,7 @@ const void *nftnl_set_elem_get(struct nftnl_set_elem *s, uint16_t attr, uint32_t
}
return NULL;
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_elem_get, nft_set_elem_attr_get);
+EXPORT_SYMBOL(nftnl_set_elem_get);
const char *nftnl_set_elem_get_str(struct nftnl_set_elem *s, uint16_t attr)
{
@@ -197,7 +197,7 @@ const char *nftnl_set_elem_get_str(struct nftnl_set_elem *s, uint16_t attr)
return nftnl_set_elem_get(s, attr, &size);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_elem_get_str, nft_set_elem_attr_get_str);
+EXPORT_SYMBOL(nftnl_set_elem_get_str);
uint32_t nftnl_set_elem_get_u32(struct nftnl_set_elem *s, uint16_t attr)
{
@@ -205,7 +205,7 @@ uint32_t nftnl_set_elem_get_u32(struct nftnl_set_elem *s, uint16_t attr)
uint32_t val = *((uint32_t *)nftnl_set_elem_get(s, attr, &size));
return val;
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_elem_get_u32, nft_set_elem_attr_get_u32);
+EXPORT_SYMBOL(nftnl_set_elem_get_u32);
uint64_t nftnl_set_elem_get_u64(struct nftnl_set_elem *s, uint16_t attr)
{
@@ -213,7 +213,7 @@ uint64_t nftnl_set_elem_get_u64(struct nftnl_set_elem *s, uint16_t attr)
uint64_t val = *((uint64_t *)nftnl_set_elem_get(s, attr, &size));
return val;
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_elem_get_u64, nft_set_elem_attr_get_u64);
+EXPORT_SYMBOL(nftnl_set_elem_get_u64);
struct nftnl_set_elem *nftnl_set_elem_clone(struct nftnl_set_elem *elem)
{
@@ -305,7 +305,7 @@ void nftnl_set_elems_nlmsg_build_payload(struct nlmsghdr *nlh, struct nftnl_set
mnl_attr_nest_end(nlh, nest1);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_elems_nlmsg_build_payload, nft_set_elems_nlmsg_build_payload);
+EXPORT_SYMBOL(nftnl_set_elems_nlmsg_build_payload);
static int nftnl_set_elem_parse_attr_cb(const struct nlattr *attr, void *data)
{
@@ -494,7 +494,7 @@ int nftnl_set_elems_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_set *s)
return ret;
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_elems_nlmsg_parse, nft_set_elems_nlmsg_parse);
+EXPORT_SYMBOL(nftnl_set_elems_nlmsg_parse);
#ifdef XML_PARSING
int nftnl_mxml_set_elem_parse(mxml_node_t *tree, struct nftnl_set_elem *e,
@@ -598,14 +598,14 @@ int nftnl_set_elem_parse(struct nftnl_set_elem *e, enum nftnl_parse_type type,
{
return nftnl_set_elem_do_parse(e, type, data, err, NFTNL_PARSE_BUFFER);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_elem_parse, nft_set_elem_parse);
+EXPORT_SYMBOL(nftnl_set_elem_parse);
int nftnl_set_elem_parse_file(struct nftnl_set_elem *e, enum nftnl_parse_type type,
FILE *fp, struct nftnl_parse_err *err)
{
return nftnl_set_elem_do_parse(e, type, fp, err, NFTNL_PARSE_FILE);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_elem_parse_file, nft_set_elem_parse_file);
+EXPORT_SYMBOL(nftnl_set_elem_parse_file);
static int nftnl_set_elem_snprintf_json(char *buf, size_t size,
const struct nftnl_set_elem *e,
@@ -784,7 +784,7 @@ int nftnl_set_elem_snprintf(char *buf, size_t size,
return nftnl_set_elem_cmd_snprintf(buf, size, e, nftnl_flag2cmd(flags),
type, flags);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_elem_snprintf, nft_set_elem_snprintf);
+EXPORT_SYMBOL(nftnl_set_elem_snprintf);
static int nftnl_set_elem_do_snprintf(char *buf, size_t size, const void *e,
uint32_t cmd, uint32_t type,
@@ -799,7 +799,7 @@ int nftnl_set_elem_fprintf(FILE *fp, struct nftnl_set_elem *se, uint32_t type,
return nftnl_fprintf(fp, se, NFTNL_CMD_UNSPEC, type, flags,
nftnl_set_elem_do_snprintf);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_elem_fprintf, nft_set_elem_fprintf);
+EXPORT_SYMBOL(nftnl_set_elem_fprintf);
int nftnl_set_elem_foreach(struct nftnl_set *s,
int (*cb)(struct nftnl_set_elem *e, void *data),
@@ -815,7 +815,7 @@ int nftnl_set_elem_foreach(struct nftnl_set *s,
}
return 0;
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_elem_foreach, nft_set_elem_foreach);
+EXPORT_SYMBOL(nftnl_set_elem_foreach);
struct nftnl_set_elems_iter {
struct nftnl_set *set;
@@ -841,13 +841,13 @@ struct nftnl_set_elems_iter *nftnl_set_elems_iter_create(struct nftnl_set *s)
return iter;
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_elems_iter_create, nft_set_elems_iter_create);
+EXPORT_SYMBOL(nftnl_set_elems_iter_create);
struct nftnl_set_elem *nftnl_set_elems_iter_cur(struct nftnl_set_elems_iter *iter)
{
return iter->cur;
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_elems_iter_cur, nft_set_elems_iter_cur);
+EXPORT_SYMBOL(nftnl_set_elems_iter_cur);
struct nftnl_set_elem *nftnl_set_elems_iter_next(struct nftnl_set_elems_iter *iter)
{
@@ -862,13 +862,13 @@ struct nftnl_set_elem *nftnl_set_elems_iter_next(struct nftnl_set_elems_iter *it
return s;
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_elems_iter_next, nft_set_elems_iter_next);
+EXPORT_SYMBOL(nftnl_set_elems_iter_next);
void nftnl_set_elems_iter_destroy(struct nftnl_set_elems_iter *iter)
{
xfree(iter);
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_elems_iter_destroy, nft_set_elems_iter_destroy);
+EXPORT_SYMBOL(nftnl_set_elems_iter_destroy);
static bool nftnl_attr_nest_overflow(struct nlmsghdr *nlh,
const struct nlattr *from,
@@ -913,4 +913,4 @@ int nftnl_set_elems_nlmsg_build_payload_iter(struct nlmsghdr *nlh,
return ret;
}
-EXPORT_SYMBOL_ALIAS(nftnl_set_elems_nlmsg_build_payload_iter, nft_set_elems_nlmsg_build_payload_iter);
+EXPORT_SYMBOL(nftnl_set_elems_nlmsg_build_payload_iter);
diff --git a/src/table.c b/src/table.c
index 42fe49f..6e5e267 100644
--- a/src/table.c
+++ b/src/table.c
@@ -40,7 +40,7 @@ struct nftnl_table *nftnl_table_alloc(void)
{
return calloc(1, sizeof(struct nftnl_table));
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_alloc, nft_table_alloc);
+EXPORT_SYMBOL(nftnl_table_alloc);
void nftnl_table_free(const struct nftnl_table *t)
{
@@ -49,13 +49,13 @@ void nftnl_table_free(const struct nftnl_table *t)
xfree(t);
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_free, nft_table_free);
+EXPORT_SYMBOL(nftnl_table_free);
bool nftnl_table_is_set(const struct nftnl_table *t, uint16_t attr)
{
return t->flags & (1 << attr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_is_set, nft_table_attr_is_set);
+EXPORT_SYMBOL(nftnl_table_is_set);
void nftnl_table_unset(struct nftnl_table *t, uint16_t attr)
{
@@ -77,7 +77,7 @@ void nftnl_table_unset(struct nftnl_table *t, uint16_t attr)
}
t->flags &= ~(1 << attr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_unset, nft_table_attr_unset);
+EXPORT_SYMBOL(nftnl_table_unset);
static uint32_t nftnl_table_validate[NFTNL_TABLE_MAX + 1] = {
[NFTNL_TABLE_FLAGS] = sizeof(uint32_t),
@@ -111,31 +111,31 @@ void nftnl_table_set_data(struct nftnl_table *t, uint16_t attr,
}
t->flags |= (1 << attr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_set_data, nft_table_attr_set_data);
+EXPORT_SYMBOL(nftnl_table_set_data);
void nftnl_table_set(struct nftnl_table *t, uint16_t attr, const void *data)
{
nftnl_table_set_data(t, attr, data, nftnl_table_validate[attr]);
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_set, nft_table_attr_set);
+EXPORT_SYMBOL(nftnl_table_set);
void nftnl_table_set_u32(struct nftnl_table *t, uint16_t attr, uint32_t val)
{
nftnl_table_set_data(t, attr, &val, sizeof(uint32_t));
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_set_u32, nft_table_attr_set_u32);
+EXPORT_SYMBOL(nftnl_table_set_u32);
void nftnl_table_set_u8(struct nftnl_table *t, uint16_t attr, uint8_t val)
{
nftnl_table_set_data(t, attr, &val, sizeof(uint8_t));
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_set_u8, nft_table_attr_set_u8);
+EXPORT_SYMBOL(nftnl_table_set_u8);
void nftnl_table_set_str(struct nftnl_table *t, uint16_t attr, const char *str)
{
nftnl_table_set_data(t, attr, str, 0);
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_set_str, nft_table_attr_set_str);
+EXPORT_SYMBOL(nftnl_table_set_str);
const void *nftnl_table_get_data(const struct nftnl_table *t, uint16_t attr,
uint32_t *data_len)
@@ -158,34 +158,34 @@ const void *nftnl_table_get_data(const struct nftnl_table *t, uint16_t attr,
}
return NULL;
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_get_data, nft_table_attr_get_data);
+EXPORT_SYMBOL(nftnl_table_get_data);
const void *nftnl_table_get(const struct nftnl_table *t, uint16_t attr)
{
uint32_t data_len;
return nftnl_table_get_data(t, attr, &data_len);
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_get, nft_table_attr_get);
+EXPORT_SYMBOL(nftnl_table_get);
uint32_t nftnl_table_get_u32(const struct nftnl_table *t, uint16_t attr)
{
const void *ret = nftnl_table_get(t, attr);
return ret == NULL ? 0 : *((uint32_t *)ret);
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_get_u32, nft_table_attr_get_u32);
+EXPORT_SYMBOL(nftnl_table_get_u32);
uint8_t nftnl_table_get_u8(const struct nftnl_table *t, uint16_t attr)
{
const void *ret = nftnl_table_get(t, attr);
return ret == NULL ? 0 : *((uint8_t *)ret);
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_get_u8, nft_table_attr_get_u8);
+EXPORT_SYMBOL(nftnl_table_get_u8);
const char *nftnl_table_get_str(const struct nftnl_table *t, uint16_t attr)
{
return nftnl_table_get(t, attr);
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_get_str, nft_table_attr_get_str);
+EXPORT_SYMBOL(nftnl_table_get_str);
void nftnl_table_nlmsg_build_payload(struct nlmsghdr *nlh, const struct nftnl_table *t)
{
@@ -194,7 +194,7 @@ void nftnl_table_nlmsg_build_payload(struct nlmsghdr *nlh, const struct nftnl_ta
if (t->flags & (1 << NFTNL_TABLE_FLAGS))
mnl_attr_put_u32(nlh, NFTA_TABLE_FLAGS, htonl(t->table_flags));
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_nlmsg_build_payload, nft_table_nlmsg_build_payload);
+EXPORT_SYMBOL(nftnl_table_nlmsg_build_payload);
static int nftnl_table_parse_attr_cb(const struct nlattr *attr, void *data)
{
@@ -247,7 +247,7 @@ int nftnl_table_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_table *t)
return 0;
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_nlmsg_parse, nft_table_nlmsg_parse);
+EXPORT_SYMBOL(nftnl_table_nlmsg_parse);
#ifdef XML_PARSING
int nftnl_mxml_table_parse(mxml_node_t *tree, struct nftnl_table *t,
@@ -384,14 +384,14 @@ int nftnl_table_parse(struct nftnl_table *t, enum nftnl_parse_type type,
{
return nftnl_table_do_parse(t, type, data, err, NFTNL_PARSE_BUFFER);
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_parse, nft_table_parse);
+EXPORT_SYMBOL(nftnl_table_parse);
int nftnl_table_parse_file(struct nftnl_table *t, enum nftnl_parse_type type,
FILE *fp, struct nftnl_parse_err *err)
{
return nftnl_table_do_parse(t, type, fp, err, NFTNL_PARSE_FILE);
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_parse_file, nft_table_parse_file);
+EXPORT_SYMBOL(nftnl_table_parse_file);
static int nftnl_table_export(char *buf, size_t size,
const struct nftnl_table *t, int type)
@@ -455,7 +455,7 @@ int nftnl_table_snprintf(char *buf, size_t size, const struct nftnl_table *t,
return nftnl_table_cmd_snprintf(buf, size, t, nftnl_flag2cmd(flags), type,
flags);
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_snprintf, nft_table_snprintf);
+EXPORT_SYMBOL(nftnl_table_snprintf);
static int nftnl_table_do_snprintf(char *buf, size_t size, const void *t,
uint32_t cmd, uint32_t type, uint32_t flags)
@@ -469,7 +469,7 @@ int nftnl_table_fprintf(FILE *fp, const struct nftnl_table *t, uint32_t type,
return nftnl_fprintf(fp, t, NFTNL_CMD_UNSPEC, type, flags,
nftnl_table_do_snprintf);
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_fprintf, nft_table_fprintf);
+EXPORT_SYMBOL(nftnl_table_fprintf);
struct nftnl_table_list {
struct list_head list;
@@ -487,7 +487,7 @@ struct nftnl_table_list *nftnl_table_list_alloc(void)
return list;
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_list_alloc, nft_table_list_alloc);
+EXPORT_SYMBOL(nftnl_table_list_alloc);
void nftnl_table_list_free(struct nftnl_table_list *list)
{
@@ -499,31 +499,31 @@ void nftnl_table_list_free(struct nftnl_table_list *list)
}
xfree(list);
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_list_free, nft_table_list_free);
+EXPORT_SYMBOL(nftnl_table_list_free);
int nftnl_table_list_is_empty(const struct nftnl_table_list *list)
{
return list_empty(&list->list);
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_list_is_empty, nft_table_list_is_empty);
+EXPORT_SYMBOL(nftnl_table_list_is_empty);
void nftnl_table_list_add(struct nftnl_table *r, struct nftnl_table_list *list)
{
list_add(&r->head, &list->list);
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_list_add, nft_table_list_add);
+EXPORT_SYMBOL(nftnl_table_list_add);
void nftnl_table_list_add_tail(struct nftnl_table *r, struct nftnl_table_list *list)
{
list_add_tail(&r->head, &list->list);
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_list_add_tail, nft_table_list_add_tail);
+EXPORT_SYMBOL(nftnl_table_list_add_tail);
void nftnl_table_list_del(struct nftnl_table *t)
{
list_del(&t->head);
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_list_del, nft_table_list_del);
+EXPORT_SYMBOL(nftnl_table_list_del);
int nftnl_table_list_foreach(struct nftnl_table_list *table_list,
int (*cb)(struct nftnl_table *t, void *data),
@@ -539,7 +539,7 @@ int nftnl_table_list_foreach(struct nftnl_table_list *table_list,
}
return 0;
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_list_foreach, nft_table_list_foreach);
+EXPORT_SYMBOL(nftnl_table_list_foreach);
struct nftnl_table_list_iter {
struct nftnl_table_list *list;
@@ -562,7 +562,7 @@ struct nftnl_table_list_iter *nftnl_table_list_iter_create(struct nftnl_table_li
return iter;
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_list_iter_create, nft_table_list_iter_create);
+EXPORT_SYMBOL(nftnl_table_list_iter_create);
struct nftnl_table *nftnl_table_list_iter_next(struct nftnl_table_list_iter *iter)
{
@@ -578,10 +578,10 @@ struct nftnl_table *nftnl_table_list_iter_next(struct nftnl_table_list_iter *ite
return r;
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_list_iter_next, nft_table_list_iter_next);
+EXPORT_SYMBOL(nftnl_table_list_iter_next);
void nftnl_table_list_iter_destroy(const struct nftnl_table_list_iter *iter)
{
xfree(iter);
}
-EXPORT_SYMBOL_ALIAS(nftnl_table_list_iter_destroy, nft_table_list_iter_destroy);
+EXPORT_SYMBOL(nftnl_table_list_iter_destroy);
--
2.1.4
^ permalink raw reply related [flat|nested] 9+ messages in thread* [PATCH libnftnl 2/9] src: assert when setting unknown attributes
2016-06-14 13:18 [PATCH libnftnl 1/9] src: get rid of aliases Pablo Neira Ayuso
@ 2016-06-14 13:18 ` Pablo Neira Ayuso
2016-06-14 13:18 ` [PATCH libnftnl 3/9] src: return value on setters that internally allocate memory Pablo Neira Ayuso
` (6 subsequent siblings)
7 siblings, 0 replies; 9+ messages in thread
From: Pablo Neira Ayuso @ 2016-06-14 13:18 UTC (permalink / raw)
To: netfilter-devel
If this attribute is not supported by the library, we should rise an
assertion so the client knows something is wrong, instead of silently
going through.
The only case I can think may hit this problem is version mismatch
between library and tools. This should not ever really happen, so better
bail out from the library itself in this case.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
---
include/utils.h | 9 +++++++++
src/chain.c | 4 +---
src/gen.c | 4 +---
src/rule.c | 4 +---
src/set.c | 4 +---
src/table.c | 4 +---
src/utils.c | 8 ++++++++
7 files changed, 22 insertions(+), 15 deletions(-)
diff --git a/include/utils.h b/include/utils.h
index 1684b5a..c7472be 100644
--- a/include/utils.h
+++ b/include/utils.h
@@ -41,6 +41,15 @@ void __nftnl_assert_fail(uint16_t attr, const char *filename, int line);
nftnl_assert(data, attr, _validate_array[_attr] == _data_len); \
})
+void __nftnl_assert_attr_exists(uint16_t attr, uint16_t attr_max,
+ const char *filename, int line);
+
+#define nftnl_assert_attr_exists(_attr, _attr_max) \
+({ \
+ if (_attr > _attr_max) \
+ __nftnl_assert_attr_exists(_attr, _attr_max, __FILE__, __LINE__); \
+})
+
#define SNPRINTF_BUFFER_SIZE(ret, size, len, offset) \
if (ret < 0) \
return ret; \
diff --git a/src/chain.c b/src/chain.c
index 70daaf3..4c487cc 100644
--- a/src/chain.c
+++ b/src/chain.c
@@ -168,9 +168,7 @@ static uint32_t nftnl_chain_validate[NFTNL_CHAIN_MAX + 1] = {
void nftnl_chain_set_data(struct nftnl_chain *c, uint16_t attr,
const void *data, uint32_t data_len)
{
- if (attr > NFTNL_CHAIN_MAX)
- return;
-
+ nftnl_assert_attr_exists(attr, NFTNL_CHAIN_MAX);
nftnl_assert_validate(data, nftnl_chain_validate, attr, data_len);
switch(attr) {
diff --git a/src/gen.c b/src/gen.c
index 8533f38..698b9b9 100644
--- a/src/gen.c
+++ b/src/gen.c
@@ -67,9 +67,7 @@ static uint32_t nftnl_gen_validate[NFTNL_GEN_MAX + 1] = {
void nftnl_gen_set_data(struct nftnl_gen *gen, uint16_t attr,
const void *data, uint32_t data_len)
{
- if (attr > NFTNL_GEN_MAX)
- return;
-
+ nftnl_assert_attr_exists(attr, NFTNL_GEN_MAX);
nftnl_assert_validate(data, nftnl_gen_validate, attr, data_len);
switch (attr) {
diff --git a/src/rule.c b/src/rule.c
index 1e1a138..21d94aa 100644
--- a/src/rule.c
+++ b/src/rule.c
@@ -130,9 +130,7 @@ static uint32_t nftnl_rule_validate[NFTNL_RULE_MAX + 1] = {
void nftnl_rule_set_data(struct nftnl_rule *r, uint16_t attr,
const void *data, uint32_t data_len)
{
- if (attr > NFTNL_RULE_MAX)
- return;
-
+ nftnl_assert_attr_exists(attr, NFTNL_RULE_MAX);
nftnl_assert_validate(data, nftnl_rule_validate, attr, data_len);
switch(attr) {
diff --git a/src/set.c b/src/set.c
index 3caaf39..bc8c8bc 100644
--- a/src/set.c
+++ b/src/set.c
@@ -116,9 +116,7 @@ static uint32_t nftnl_set_validate[NFTNL_SET_MAX + 1] = {
void nftnl_set_set_data(struct nftnl_set *s, uint16_t attr, const void *data,
uint32_t data_len)
{
- if (attr > NFTNL_SET_MAX)
- return;
-
+ nftnl_assert_attr_exists(attr, NFTNL_SET_MAX);
nftnl_assert_validate(data, nftnl_set_validate, attr, data_len);
switch(attr) {
diff --git a/src/table.c b/src/table.c
index 6e5e267..406babf 100644
--- a/src/table.c
+++ b/src/table.c
@@ -87,9 +87,7 @@ static uint32_t nftnl_table_validate[NFTNL_TABLE_MAX + 1] = {
void nftnl_table_set_data(struct nftnl_table *t, uint16_t attr,
const void *data, uint32_t data_len)
{
- if (attr > NFTNL_TABLE_MAX)
- return;
-
+ nftnl_assert_attr_exists(attr, NFTNL_TABLE_MAX);
nftnl_assert_validate(data, nftnl_table_validate, attr, data_len);
switch (attr) {
diff --git a/src/utils.c b/src/utils.c
index 22710b9..e2715a2 100644
--- a/src/utils.c
+++ b/src/utils.c
@@ -269,6 +269,14 @@ out:
return ret;
}
+void __nftnl_assert_attr_exists(uint16_t attr, uint16_t attr_max,
+ const char *filename, int line)
+{
+ fprintf(stderr, "libnftnl: attribute %d > %d (maximum) assertion failed in %s:%d\n",
+ attr, attr_max, filename, line);
+ exit(EXIT_FAILURE);
+}
+
void __nftnl_assert_fail(uint16_t attr, const char *filename, int line)
{
fprintf(stderr, "libnftnl: attribute %d assertion failed in %s:%d\n",
--
2.1.4
^ permalink raw reply related [flat|nested] 9+ messages in thread* [PATCH libnftnl 3/9] src: return value on setters that internally allocate memory
2016-06-14 13:18 [PATCH libnftnl 1/9] src: get rid of aliases Pablo Neira Ayuso
2016-06-14 13:18 ` [PATCH libnftnl 2/9] src: assert when setting unknown attributes Pablo Neira Ayuso
@ 2016-06-14 13:18 ` Pablo Neira Ayuso
2016-06-14 13:18 ` [PATCH libnftnl 4/9] src: check for strdup() errors from setters and parsers Pablo Neira Ayuso
` (5 subsequent siblings)
7 siblings, 0 replies; 9+ messages in thread
From: Pablo Neira Ayuso @ 2016-06-14 13:18 UTC (permalink / raw)
To: netfilter-devel
So the client can bail out of memory allocation errors. Or in case of
daemon, make sure things are left in consistent state before bailing
out.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
---
include/libnftnl/chain.h | 4 ++--
include/libnftnl/expr.h | 4 ++--
include/libnftnl/gen.h | 6 +++---
include/libnftnl/rule.h | 8 ++++----
include/libnftnl/set.h | 12 ++++++------
include/libnftnl/table.h | 6 +++---
src/chain.c | 15 +++++++++++----
src/expr.c | 15 +++++++--------
src/gen.c | 9 +++++----
src/rule.c | 19 ++++++++++++-------
src/set.c | 17 +++++++++++------
src/set_elem.c | 13 ++++++-------
src/table.c | 11 +++++++----
13 files changed, 79 insertions(+), 60 deletions(-)
diff --git a/include/libnftnl/chain.h b/include/libnftnl/chain.h
index b72741f..8d7ff9f 100644
--- a/include/libnftnl/chain.h
+++ b/include/libnftnl/chain.h
@@ -37,13 +37,13 @@ enum nftnl_chain_attr {
bool nftnl_chain_is_set(const struct nftnl_chain *c, uint16_t attr);
void nftnl_chain_unset(struct nftnl_chain *c, uint16_t attr);
void nftnl_chain_set(struct nftnl_chain *t, uint16_t attr, const void *data);
-void nftnl_chain_set_data(struct nftnl_chain *t, uint16_t attr,
+int nftnl_chain_set_data(struct nftnl_chain *t, uint16_t attr,
const void *data, uint32_t data_len);
void nftnl_chain_set_u8(struct nftnl_chain *t, uint16_t attr, uint8_t data);
void nftnl_chain_set_u32(struct nftnl_chain *t, uint16_t attr, uint32_t data);
void nftnl_chain_set_s32(struct nftnl_chain *t, uint16_t attr, int32_t data);
void nftnl_chain_set_u64(struct nftnl_chain *t, uint16_t attr, uint64_t data);
-void nftnl_chain_set_str(struct nftnl_chain *t, uint16_t attr, const char *str);
+int nftnl_chain_set_str(struct nftnl_chain *t, uint16_t attr, const char *str);
const void *nftnl_chain_get(const struct nftnl_chain *c, uint16_t attr);
const void *nftnl_chain_get_data(const struct nftnl_chain *c, uint16_t attr,
diff --git a/include/libnftnl/expr.h b/include/libnftnl/expr.h
index aa6dfdd..eea2b95 100644
--- a/include/libnftnl/expr.h
+++ b/include/libnftnl/expr.h
@@ -20,13 +20,13 @@ struct nftnl_expr *nftnl_expr_alloc(const char *name);
void nftnl_expr_free(const struct nftnl_expr *expr);
bool nftnl_expr_is_set(const struct nftnl_expr *expr, uint16_t type);
-void nftnl_expr_set(struct nftnl_expr *expr, uint16_t type, const void *data, uint32_t data_len);
+int nftnl_expr_set(struct nftnl_expr *expr, uint16_t type, const void *data, uint32_t data_len);
#define nftnl_expr_set_data nftnl_expr_set
void nftnl_expr_set_u8(struct nftnl_expr *expr, uint16_t type, uint8_t data);
void nftnl_expr_set_u16(struct nftnl_expr *expr, uint16_t type, uint16_t data);
void nftnl_expr_set_u32(struct nftnl_expr *expr, uint16_t type, uint32_t data);
void nftnl_expr_set_u64(struct nftnl_expr *expr, uint16_t type, uint64_t data);
-void nftnl_expr_set_str(struct nftnl_expr *expr, uint16_t type, const char *str);
+int nftnl_expr_set_str(struct nftnl_expr *expr, uint16_t type, const char *str);
const void *nftnl_expr_get(const struct nftnl_expr *expr, uint16_t type, uint32_t *data_len);
#define nftnl_expr_get_data nftnl_expr_get
diff --git a/include/libnftnl/gen.h b/include/libnftnl/gen.h
index f69bf2f..b55bded 100644
--- a/include/libnftnl/gen.h
+++ b/include/libnftnl/gen.h
@@ -25,9 +25,9 @@ enum {
bool nftnl_gen_is_set(const struct nftnl_gen *gen, uint16_t attr);
void nftnl_gen_unset(struct nftnl_gen *gen, uint16_t attr);
-void nftnl_gen_set(struct nftnl_gen *gen, uint16_t attr, const void *data);
-void nftnl_gen_set_data(struct nftnl_gen *gen, uint16_t attr,
- const void *data, uint32_t data_len);
+int nftnl_gen_set(struct nftnl_gen *gen, uint16_t attr, const void *data);
+int nftnl_gen_set_data(struct nftnl_gen *gen, uint16_t attr,
+ const void *data, uint32_t data_len);
const void *nftnl_gen_get(const struct nftnl_gen *gen, uint16_t attr);
const void *nftnl_gen_get_data(const struct nftnl_gen *gen, uint16_t attr,
uint32_t *data_len);
diff --git a/include/libnftnl/rule.h b/include/libnftnl/rule.h
index d9a8e12..eff68da 100644
--- a/include/libnftnl/rule.h
+++ b/include/libnftnl/rule.h
@@ -33,12 +33,12 @@ enum nftnl_rule_attr {
void nftnl_rule_unset(struct nftnl_rule *r, uint16_t attr);
bool nftnl_rule_is_set(const struct nftnl_rule *r, uint16_t attr);
-void nftnl_rule_set(struct nftnl_rule *r, uint16_t attr, const void *data);
-void nftnl_rule_set_data(struct nftnl_rule *r, uint16_t attr,
- const void *data, uint32_t data_len);
+int nftnl_rule_set(struct nftnl_rule *r, uint16_t attr, const void *data);
+int nftnl_rule_set_data(struct nftnl_rule *r, uint16_t attr,
+ const void *data, uint32_t data_len);
void nftnl_rule_set_u32(struct nftnl_rule *r, uint16_t attr, uint32_t val);
void nftnl_rule_set_u64(struct nftnl_rule *r, uint16_t attr, uint64_t val);
-void nftnl_rule_set_str(struct nftnl_rule *r, uint16_t attr, const char *str);
+int nftnl_rule_set_str(struct nftnl_rule *r, uint16_t attr, const char *str);
const void *nftnl_rule_get(const struct nftnl_rule *r, uint16_t attr);
const void *nftnl_rule_get_data(const struct nftnl_rule *r, uint16_t attr,
diff --git a/include/libnftnl/set.h b/include/libnftnl/set.h
index 00868c5..46fa8f4 100644
--- a/include/libnftnl/set.h
+++ b/include/libnftnl/set.h
@@ -35,12 +35,12 @@ struct nftnl_set *nftnl_set_clone(const struct nftnl_set *set);
bool nftnl_set_is_set(const struct nftnl_set *s, uint16_t attr);
void nftnl_set_unset(struct nftnl_set *s, uint16_t attr);
-void nftnl_set_set(struct nftnl_set *s, uint16_t attr, const void *data);
-void nftnl_set_set_data(struct nftnl_set *s, uint16_t attr, const void *data,
- uint32_t data_len);
+int nftnl_set_set(struct nftnl_set *s, uint16_t attr, const void *data);
+int nftnl_set_set_data(struct nftnl_set *s, uint16_t attr, const void *data,
+ uint32_t data_len);
void nftnl_set_set_u32(struct nftnl_set *s, uint16_t attr, uint32_t val);
void nftnl_set_set_u64(struct nftnl_set *s, uint16_t attr, uint64_t val);
-void nftnl_set_set_str(struct nftnl_set *s, uint16_t attr, const char *str);
+int nftnl_set_set_str(struct nftnl_set *s, uint16_t attr, const char *str);
const void *nftnl_set_get(const struct nftnl_set *s, uint16_t attr);
const void *nftnl_set_get_data(const struct nftnl_set *s, uint16_t attr,
@@ -106,10 +106,10 @@ struct nftnl_set_elem *nftnl_set_elem_clone(struct nftnl_set_elem *elem);
void nftnl_set_elem_add(struct nftnl_set *s, struct nftnl_set_elem *elem);
void nftnl_set_elem_unset(struct nftnl_set_elem *s, uint16_t attr);
-void nftnl_set_elem_set(struct nftnl_set_elem *s, uint16_t attr, const void *data, uint32_t data_len);
+int nftnl_set_elem_set(struct nftnl_set_elem *s, uint16_t attr, const void *data, uint32_t data_len);
void nftnl_set_elem_set_u32(struct nftnl_set_elem *s, uint16_t attr, uint32_t val);
void nftnl_set_elem_set_u64(struct nftnl_set_elem *s, uint16_t attr, uint64_t val);
-void nftnl_set_elem_set_str(struct nftnl_set_elem *s, uint16_t attr, const char *str);
+int nftnl_set_elem_set_str(struct nftnl_set_elem *s, uint16_t attr, const char *str);
const void *nftnl_set_elem_get(struct nftnl_set_elem *s, uint16_t attr, uint32_t *data_len);
const char *nftnl_set_elem_get_str(struct nftnl_set_elem *s, uint16_t attr);
diff --git a/include/libnftnl/table.h b/include/libnftnl/table.h
index d2557ba..87c51b4 100644
--- a/include/libnftnl/table.h
+++ b/include/libnftnl/table.h
@@ -29,15 +29,15 @@ enum nftnl_table_attr {
bool nftnl_table_is_set(const struct nftnl_table *t, uint16_t attr);
void nftnl_table_unset(struct nftnl_table *t, uint16_t attr);
void nftnl_table_set(struct nftnl_table *t, uint16_t attr, const void *data);
-void nftnl_table_set_data(struct nftnl_table *t, uint16_t attr,
- const void *data, uint32_t data_len);
+int nftnl_table_set_data(struct nftnl_table *t, uint16_t attr,
+ const void *data, uint32_t data_len);
const void *nftnl_table_get(const struct nftnl_table *t, uint16_t attr);
const void *nftnl_table_get_data(const struct nftnl_table *t, uint16_t attr,
uint32_t *data_len);
void nftnl_table_set_u8(struct nftnl_table *t, uint16_t attr, uint8_t data);
void nftnl_table_set_u32(struct nftnl_table *t, uint16_t attr, uint32_t data);
-void nftnl_table_set_str(struct nftnl_table *t, uint16_t attr, const char *str);
+int nftnl_table_set_str(struct nftnl_table *t, uint16_t attr, const char *str);
uint8_t nftnl_table_get_u8(const struct nftnl_table *t, uint16_t attr);
uint32_t nftnl_table_get_u32(const struct nftnl_table *t, uint16_t attr);
const char *nftnl_table_get_str(const struct nftnl_table *t, uint16_t attr);
diff --git a/src/chain.c b/src/chain.c
index 4c487cc..6a2cfae 100644
--- a/src/chain.c
+++ b/src/chain.c
@@ -165,8 +165,8 @@ static uint32_t nftnl_chain_validate[NFTNL_CHAIN_MAX + 1] = {
[NFTNL_CHAIN_FAMILY] = sizeof(uint32_t),
};
-void nftnl_chain_set_data(struct nftnl_chain *c, uint16_t attr,
- const void *data, uint32_t data_len)
+int nftnl_chain_set_data(struct nftnl_chain *c, uint16_t attr,
+ const void *data, uint32_t data_len)
{
nftnl_assert_attr_exists(attr, NFTNL_CHAIN_MAX);
nftnl_assert_validate(data, nftnl_chain_validate, attr, data_len);
@@ -180,6 +180,8 @@ void nftnl_chain_set_data(struct nftnl_chain *c, uint16_t attr,
xfree(c->table);
c->table = strdup(data);
+ if (!c->table)
+ return -1;
break;
case NFTNL_CHAIN_HOOKNUM:
memcpy(&c->hooknum, data, sizeof(c->hooknum));
@@ -210,15 +212,20 @@ void nftnl_chain_set_data(struct nftnl_chain *c, uint16_t attr,
xfree(c->type);
c->type = strdup(data);
+ if (!c->type)
+ return -1;
break;
case NFTNL_CHAIN_DEV:
if (c->dev)
xfree(c->dev);
c->dev = strdup(data);
+ if (!c->type)
+ return -1;
break;
}
c->flags |= (1 << attr);
+ return 0;
}
EXPORT_SYMBOL(nftnl_chain_set_data);
@@ -252,9 +259,9 @@ void nftnl_chain_set_u8(struct nftnl_chain *c, uint16_t attr, uint8_t data)
}
EXPORT_SYMBOL(nftnl_chain_set_u8);
-void nftnl_chain_set_str(struct nftnl_chain *c, uint16_t attr, const char *str)
+int nftnl_chain_set_str(struct nftnl_chain *c, uint16_t attr, const char *str)
{
- nftnl_chain_set_data(c, attr, str, strlen(str));
+ return nftnl_chain_set_data(c, attr, str, strlen(str));
}
EXPORT_SYMBOL(nftnl_chain_set_str);
diff --git a/src/expr.c b/src/expr.c
index aa920dd..40960f8 100644
--- a/src/expr.c
+++ b/src/expr.c
@@ -60,18 +60,18 @@ bool nftnl_expr_is_set(const struct nftnl_expr *expr, uint16_t type)
}
EXPORT_SYMBOL(nftnl_expr_is_set);
-void
-nftnl_expr_set(struct nftnl_expr *expr, uint16_t type,
- const void *data, uint32_t data_len)
+int nftnl_expr_set(struct nftnl_expr *expr, uint16_t type,
+ const void *data, uint32_t data_len)
{
switch(type) {
case NFTNL_EXPR_NAME: /* cannot be modified */
- return;
+ return 0;
default:
if (expr->ops->set(expr, type, data, data_len) < 0)
- return;
+ return -1;
}
expr->flags |= (1 << type);
+ return 0;
}
EXPORT_SYMBOL(nftnl_expr_set);
@@ -103,10 +103,9 @@ nftnl_expr_set_u64(struct nftnl_expr *expr, uint16_t type, uint64_t data)
}
EXPORT_SYMBOL(nftnl_expr_set_u64);
-void
-nftnl_expr_set_str(struct nftnl_expr *expr, uint16_t type, const char *str)
+int nftnl_expr_set_str(struct nftnl_expr *expr, uint16_t type, const char *str)
{
- nftnl_expr_set(expr, type, str, strlen(str)+1);
+ return nftnl_expr_set(expr, type, str, strlen(str) + 1);
}
EXPORT_SYMBOL(nftnl_expr_set_str);
diff --git a/src/gen.c b/src/gen.c
index 698b9b9..d303036 100644
--- a/src/gen.c
+++ b/src/gen.c
@@ -64,8 +64,8 @@ static uint32_t nftnl_gen_validate[NFTNL_GEN_MAX + 1] = {
[NFTNL_GEN_ID] = sizeof(uint32_t),
};
-void nftnl_gen_set_data(struct nftnl_gen *gen, uint16_t attr,
- const void *data, uint32_t data_len)
+int nftnl_gen_set_data(struct nftnl_gen *gen, uint16_t attr,
+ const void *data, uint32_t data_len)
{
nftnl_assert_attr_exists(attr, NFTNL_GEN_MAX);
nftnl_assert_validate(data, nftnl_gen_validate, attr, data_len);
@@ -76,12 +76,13 @@ void nftnl_gen_set_data(struct nftnl_gen *gen, uint16_t attr,
break;
}
gen->flags |= (1 << attr);
+ return 0;
}
EXPORT_SYMBOL(nftnl_gen_set_data);
-void nftnl_gen_set(struct nftnl_gen *gen, uint16_t attr, const void *data)
+int nftnl_gen_set(struct nftnl_gen *gen, uint16_t attr, const void *data)
{
- nftnl_gen_set_data(gen, attr, data, nftnl_gen_validate[attr]);
+ return nftnl_gen_set_data(gen, attr, data, nftnl_gen_validate[attr]);
}
EXPORT_SYMBOL(nftnl_gen_set);
diff --git a/src/rule.c b/src/rule.c
index 21d94aa..310332f 100644
--- a/src/rule.c
+++ b/src/rule.c
@@ -127,8 +127,8 @@ static uint32_t nftnl_rule_validate[NFTNL_RULE_MAX + 1] = {
[NFTNL_RULE_POSITION] = sizeof(uint64_t),
};
-void nftnl_rule_set_data(struct nftnl_rule *r, uint16_t attr,
- const void *data, uint32_t data_len)
+int nftnl_rule_set_data(struct nftnl_rule *r, uint16_t attr,
+ const void *data, uint32_t data_len)
{
nftnl_assert_attr_exists(attr, NFTNL_RULE_MAX);
nftnl_assert_validate(data, nftnl_rule_validate, attr, data_len);
@@ -139,12 +139,16 @@ void nftnl_rule_set_data(struct nftnl_rule *r, uint16_t attr,
xfree(r->table);
r->table = strdup(data);
+ if (!r->table)
+ return -1;
break;
case NFTNL_RULE_CHAIN:
if (r->chain)
xfree(r->chain);
r->chain = strdup(data);
+ if (!r->chain)
+ return -1;
break;
case NFTNL_RULE_HANDLE:
r->handle = *((uint64_t *)data);
@@ -167,19 +171,20 @@ void nftnl_rule_set_data(struct nftnl_rule *r, uint16_t attr,
r->user.data = malloc(data_len);
if (!r->user.data)
- return;
+ return -1;
memcpy(r->user.data, data, data_len);
r->user.len = data_len;
break;
}
r->flags |= (1 << attr);
+ return 0;
}
EXPORT_SYMBOL(nftnl_rule_set_data);
-void nftnl_rule_set(struct nftnl_rule *r, uint16_t attr, const void *data)
+int nftnl_rule_set(struct nftnl_rule *r, uint16_t attr, const void *data)
{
- nftnl_rule_set_data(r, attr, data, nftnl_rule_validate[attr]);
+ return nftnl_rule_set_data(r, attr, data, nftnl_rule_validate[attr]);
}
EXPORT_SYMBOL(nftnl_rule_set);
@@ -195,9 +200,9 @@ void nftnl_rule_set_u64(struct nftnl_rule *r, uint16_t attr, uint64_t val)
}
EXPORT_SYMBOL(nftnl_rule_set_u64);
-void nftnl_rule_set_str(struct nftnl_rule *r, uint16_t attr, const char *str)
+int nftnl_rule_set_str(struct nftnl_rule *r, uint16_t attr, const char *str)
{
- nftnl_rule_set_data(r, attr, str, strlen(str));
+ return nftnl_rule_set_data(r, attr, str, strlen(str));
}
EXPORT_SYMBOL(nftnl_rule_set_str);
diff --git a/src/set.c b/src/set.c
index bc8c8bc..797c6ca 100644
--- a/src/set.c
+++ b/src/set.c
@@ -113,8 +113,8 @@ static uint32_t nftnl_set_validate[NFTNL_SET_MAX + 1] = {
[NFTNL_SET_GC_INTERVAL] = sizeof(uint32_t),
};
-void nftnl_set_set_data(struct nftnl_set *s, uint16_t attr, const void *data,
- uint32_t data_len)
+int nftnl_set_set_data(struct nftnl_set *s, uint16_t attr, const void *data,
+ uint32_t data_len)
{
nftnl_assert_attr_exists(attr, NFTNL_SET_MAX);
nftnl_assert_validate(data, nftnl_set_validate, attr, data_len);
@@ -125,12 +125,16 @@ void nftnl_set_set_data(struct nftnl_set *s, uint16_t attr, const void *data,
xfree(s->table);
s->table = strdup(data);
+ if (!s->table)
+ return -1;
break;
case NFTNL_SET_NAME:
if (s->name)
xfree(s->name);
s->name = strdup(data);
+ if (!s->name)
+ return -1;
break;
case NFTNL_SET_FLAGS:
s->set_flags = *((uint32_t *)data);
@@ -167,12 +171,13 @@ void nftnl_set_set_data(struct nftnl_set *s, uint16_t attr, const void *data,
break;
}
s->flags |= (1 << attr);
+ return 0;
}
EXPORT_SYMBOL(nftnl_set_set_data);
-void nftnl_set_set(struct nftnl_set *s, uint16_t attr, const void *data)
+int nftnl_set_set(struct nftnl_set *s, uint16_t attr, const void *data)
{
- nftnl_set_set_data(s, attr, data, nftnl_set_validate[attr]);
+ return nftnl_set_set_data(s, attr, data, nftnl_set_validate[attr]);
}
EXPORT_SYMBOL(nftnl_set_set);
@@ -188,9 +193,9 @@ void nftnl_set_set_u64(struct nftnl_set *s, uint16_t attr, uint64_t val)
}
EXPORT_SYMBOL(nftnl_set_set_u64);
-void nftnl_set_set_str(struct nftnl_set *s, uint16_t attr, const char *str)
+int nftnl_set_set_str(struct nftnl_set *s, uint16_t attr, const char *str)
{
- nftnl_set_set(s, attr, str);
+ return nftnl_set_set(s, attr, str);
}
EXPORT_SYMBOL(nftnl_set_set_str);
diff --git a/src/set_elem.c b/src/set_elem.c
index da30b02..645bca8 100644
--- a/src/set_elem.c
+++ b/src/set_elem.c
@@ -97,8 +97,8 @@ void nftnl_set_elem_unset(struct nftnl_set_elem *s, uint16_t attr)
}
EXPORT_SYMBOL(nftnl_set_elem_unset);
-void nftnl_set_elem_set(struct nftnl_set_elem *s, uint16_t attr,
- const void *data, uint32_t data_len)
+int nftnl_set_elem_set(struct nftnl_set_elem *s, uint16_t attr,
+ const void *data, uint32_t data_len)
{
switch(attr) {
case NFTNL_SET_ELEM_FLAGS:
@@ -130,14 +130,13 @@ void nftnl_set_elem_set(struct nftnl_set_elem *s, uint16_t attr,
s->user.data = malloc(data_len);
if (!s->user.data)
- return;
+ return -1;
memcpy(s->user.data, data, data_len);
s->user.len = data_len;
break;
- default:
- return;
}
s->flags |= (1 << attr);
+ return -1;
}
EXPORT_SYMBOL(nftnl_set_elem_set);
@@ -153,9 +152,9 @@ void nftnl_set_elem_set_u64(struct nftnl_set_elem *s, uint16_t attr, uint64_t va
}
EXPORT_SYMBOL(nftnl_set_elem_set_u64);
-void nftnl_set_elem_set_str(struct nftnl_set_elem *s, uint16_t attr, const char *str)
+int nftnl_set_elem_set_str(struct nftnl_set_elem *s, uint16_t attr, const char *str)
{
- nftnl_set_elem_set(s, attr, str, strlen(str));
+ return nftnl_set_elem_set(s, attr, str, strlen(str));
}
EXPORT_SYMBOL(nftnl_set_elem_set_str);
diff --git a/src/table.c b/src/table.c
index 406babf..595b0ac 100644
--- a/src/table.c
+++ b/src/table.c
@@ -84,8 +84,8 @@ static uint32_t nftnl_table_validate[NFTNL_TABLE_MAX + 1] = {
[NFTNL_TABLE_FAMILY] = sizeof(uint32_t),
};
-void nftnl_table_set_data(struct nftnl_table *t, uint16_t attr,
- const void *data, uint32_t data_len)
+int nftnl_table_set_data(struct nftnl_table *t, uint16_t attr,
+ const void *data, uint32_t data_len)
{
nftnl_assert_attr_exists(attr, NFTNL_TABLE_MAX);
nftnl_assert_validate(data, nftnl_table_validate, attr, data_len);
@@ -96,6 +96,8 @@ void nftnl_table_set_data(struct nftnl_table *t, uint16_t attr,
xfree(t->name);
t->name = strdup(data);
+ if (!t->name)
+ return -1;
break;
case NFTNL_TABLE_FLAGS:
t->table_flags = *((uint32_t *)data);
@@ -108,6 +110,7 @@ void nftnl_table_set_data(struct nftnl_table *t, uint16_t attr,
break;
}
t->flags |= (1 << attr);
+ return 0;
}
EXPORT_SYMBOL(nftnl_table_set_data);
@@ -129,9 +132,9 @@ void nftnl_table_set_u8(struct nftnl_table *t, uint16_t attr, uint8_t val)
}
EXPORT_SYMBOL(nftnl_table_set_u8);
-void nftnl_table_set_str(struct nftnl_table *t, uint16_t attr, const char *str)
+int nftnl_table_set_str(struct nftnl_table *t, uint16_t attr, const char *str)
{
- nftnl_table_set_data(t, attr, str, 0);
+ return nftnl_table_set_data(t, attr, str, 0);
}
EXPORT_SYMBOL(nftnl_table_set_str);
--
2.1.4
^ permalink raw reply related [flat|nested] 9+ messages in thread* [PATCH libnftnl 4/9] src: check for strdup() errors from setters and parsers
2016-06-14 13:18 [PATCH libnftnl 1/9] src: get rid of aliases Pablo Neira Ayuso
2016-06-14 13:18 ` [PATCH libnftnl 2/9] src: assert when setting unknown attributes Pablo Neira Ayuso
2016-06-14 13:18 ` [PATCH libnftnl 3/9] src: return value on setters that internally allocate memory Pablo Neira Ayuso
@ 2016-06-14 13:18 ` Pablo Neira Ayuso
2016-06-14 13:18 ` [PATCH libnftnl 5/9] expr: data_reg: get rid of leftover perror() calls Pablo Neira Ayuso
` (4 subsequent siblings)
7 siblings, 0 replies; 9+ messages in thread
From: Pablo Neira Ayuso @ 2016-06-14 13:18 UTC (permalink / raw)
To: netfilter-devel
And pass up an error to the caller.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
---
src/chain.c | 6 ++++++
src/expr/data_reg.c | 3 +++
src/expr/dynset.c | 4 ++++
src/expr/immediate.c | 2 ++
src/expr/log.c | 4 ++++
src/expr/lookup.c | 4 ++++
src/rule.c | 4 ++++
src/set.c | 14 ++++++++++++--
src/set_elem.c | 14 +++++++++++++-
src/table.c | 2 ++
src/trace.c | 24 +++++++++++++++++-------
11 files changed, 71 insertions(+), 10 deletions(-)
diff --git a/src/chain.c b/src/chain.c
index 6a2cfae..0c79dd5 100644
--- a/src/chain.c
+++ b/src/chain.c
@@ -519,6 +519,8 @@ static int nftnl_chain_parse_hook(struct nlattr *attr, struct nftnl_chain *c)
}
if (tb[NFTA_HOOK_DEV]) {
c->dev = strdup(mnl_attr_get_str(tb[NFTA_HOOK_DEV]));
+ if (!c->dev)
+ return -1;
c->flags |= (1 << NFTNL_CHAIN_DEV);
}
@@ -542,6 +544,8 @@ int nftnl_chain_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_chain *c)
if (tb[NFTA_CHAIN_TABLE]) {
xfree(c->table);
c->table = strdup(mnl_attr_get_str(tb[NFTA_CHAIN_TABLE]));
+ if (!c->table)
+ return -1;
c->flags |= (1 << NFTNL_CHAIN_TABLE);
}
if (tb[NFTA_CHAIN_HOOK]) {
@@ -569,6 +573,8 @@ int nftnl_chain_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_chain *c)
if (tb[NFTA_CHAIN_TYPE]) {
xfree(c->type);
c->type = strdup(mnl_attr_get_str(tb[NFTA_CHAIN_TYPE]));
+ if (!c->type)
+ return -1;
c->flags |= (1 << NFTNL_CHAIN_TYPE);
}
diff --git a/src/expr/data_reg.c b/src/expr/data_reg.c
index 2a23285..6aa47bc 100644
--- a/src/expr/data_reg.c
+++ b/src/expr/data_reg.c
@@ -455,6 +455,9 @@ nftnl_parse_verdict(union nftnl_data_reg *data, const struct nlattr *attr, int *
return -1;
data->chain = strdup(mnl_attr_get_str(tb[NFTA_VERDICT_CHAIN]));
+ if (!data->chain)
+ return -1;
+
if (type)
*type = DATA_CHAIN;
break;
diff --git a/src/expr/dynset.c b/src/expr/dynset.c
index c8d97a5..0404359 100644
--- a/src/expr/dynset.c
+++ b/src/expr/dynset.c
@@ -53,6 +53,8 @@ nftnl_expr_dynset_set(struct nftnl_expr *e, uint16_t type,
break;
case NFTNL_EXPR_DYNSET_SET_NAME:
dynset->set_name = strdup((const char *)data);
+ if (!dynset->set_name)
+ return -1;
break;
case NFTNL_EXPR_DYNSET_SET_ID:
dynset->set_id = *((uint32_t *)data);
@@ -183,6 +185,8 @@ nftnl_expr_dynset_parse(struct nftnl_expr *e, struct nlattr *attr)
if (tb[NFTA_DYNSET_SET_NAME]) {
dynset->set_name =
strdup(mnl_attr_get_str(tb[NFTA_DYNSET_SET_NAME]));
+ if (!dynset->set_name)
+ return -1;
e->flags |= (1 << NFTNL_EXPR_DYNSET_SET_NAME);
}
if (tb[NFTA_DYNSET_SET_ID]) {
diff --git a/src/expr/immediate.c b/src/expr/immediate.c
index eb2ca0f..243f0e0 100644
--- a/src/expr/immediate.c
+++ b/src/expr/immediate.c
@@ -47,6 +47,8 @@ nftnl_expr_immediate_set(struct nftnl_expr *e, uint16_t type,
xfree(imm->data.chain);
imm->data.chain = strdup(data);
+ if (!imm->data.chain)
+ return -1;
break;
default:
return -1;
diff --git a/src/expr/log.c b/src/expr/log.c
index c3dc0a6..5b774a4 100644
--- a/src/expr/log.c
+++ b/src/expr/log.c
@@ -41,6 +41,8 @@ static int nftnl_expr_log_set(struct nftnl_expr *e, uint16_t type,
xfree(log->prefix);
log->prefix = strdup(data);
+ if (!log->prefix)
+ return -1;
break;
case NFTNL_EXPR_LOG_GROUP:
log->group = *((uint16_t *)data);
@@ -155,6 +157,8 @@ nftnl_expr_log_parse(struct nftnl_expr *e, struct nlattr *attr)
xfree(log->prefix);
log->prefix = strdup(mnl_attr_get_str(tb[NFTA_LOG_PREFIX]));
+ if (!log->prefix)
+ return -1;
e->flags |= (1 << NFTNL_EXPR_LOG_PREFIX);
}
if (tb[NFTA_LOG_GROUP]) {
diff --git a/src/expr/lookup.c b/src/expr/lookup.c
index ed32ba6..daafdb2 100644
--- a/src/expr/lookup.c
+++ b/src/expr/lookup.c
@@ -43,6 +43,8 @@ nftnl_expr_lookup_set(struct nftnl_expr *e, uint16_t type,
break;
case NFTNL_EXPR_LOOKUP_SET:
lookup->set_name = strdup((const char *)data);
+ if (!lookup->set_name)
+ return -1;
break;
case NFTNL_EXPR_LOOKUP_SET_ID:
lookup->set_id = *((uint32_t *)data);
@@ -137,6 +139,8 @@ nftnl_expr_lookup_parse(struct nftnl_expr *e, struct nlattr *attr)
if (tb[NFTA_LOOKUP_SET]) {
lookup->set_name =
strdup(mnl_attr_get_str(tb[NFTA_LOOKUP_SET]));
+ if (lookup->set_name)
+ return -1;
e->flags |= (1 << NFTNL_EXPR_LOOKUP_SET);
}
if (tb[NFTA_LOOKUP_SET_ID]) {
diff --git a/src/rule.c b/src/rule.c
index 310332f..293c0cf 100644
--- a/src/rule.c
+++ b/src/rule.c
@@ -439,11 +439,15 @@ int nftnl_rule_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_rule *r)
if (tb[NFTA_RULE_TABLE]) {
xfree(r->table);
r->table = strdup(mnl_attr_get_str(tb[NFTA_RULE_TABLE]));
+ if (!r->table)
+ return -1;
r->flags |= (1 << NFTNL_RULE_TABLE);
}
if (tb[NFTA_RULE_CHAIN]) {
xfree(r->chain);
r->chain = strdup(mnl_attr_get_str(tb[NFTA_RULE_CHAIN]));
+ if (!r->chain)
+ return -1;
r->flags |= (1 << NFTNL_RULE_CHAIN);
}
if (tb[NFTA_RULE_HANDLE]) {
diff --git a/src/set.c b/src/set.c
index 797c6ca..a35c4ec 100644
--- a/src/set.c
+++ b/src/set.c
@@ -294,10 +294,16 @@ struct nftnl_set *nftnl_set_clone(const struct nftnl_set *set)
memcpy(newset, set, sizeof(*set));
- if (set->flags & (1 << NFTNL_SET_TABLE))
+ if (set->flags & (1 << NFTNL_SET_TABLE)) {
newset->table = strdup(set->table);
- if (set->flags & (1 << NFTNL_SET_NAME))
+ if (!newset->table)
+ goto err;
+ }
+ if (set->flags & (1 << NFTNL_SET_NAME)) {
newset->name = strdup(set->name);
+ if (!newset->name)
+ goto err;
+ }
INIT_LIST_HEAD(&newset->element_list);
list_for_each_entry(elem, &set->element_list, head) {
@@ -440,11 +446,15 @@ int nftnl_set_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_set *s)
if (tb[NFTA_SET_TABLE]) {
xfree(s->table);
s->table = strdup(mnl_attr_get_str(tb[NFTA_SET_TABLE]));
+ if (!s->table)
+ return -1;
s->flags |= (1 << NFTNL_SET_TABLE);
}
if (tb[NFTA_SET_NAME]) {
xfree(s->name);
s->name = strdup(mnl_attr_get_str(tb[NFTA_SET_NAME]));
+ if (!s->name)
+ return -1;
s->flags |= (1 << NFTNL_SET_NAME);
}
if (tb[NFTA_SET_FLAGS]) {
diff --git a/src/set_elem.c b/src/set_elem.c
index 645bca8..ec0a4b7 100644
--- a/src/set_elem.c
+++ b/src/set_elem.c
@@ -116,6 +116,8 @@ int nftnl_set_elem_set(struct nftnl_set_elem *s, uint16_t attr,
xfree(s->data.chain);
s->data.chain = strdup(data);
+ if (!s->data.chain)
+ return -1;
break;
case NFTNL_SET_ELEM_DATA: /* NFTA_SET_ELEM_DATA */
memcpy(s->data.val, data, data_len);
@@ -224,10 +226,16 @@ struct nftnl_set_elem *nftnl_set_elem_clone(struct nftnl_set_elem *elem)
memcpy(newelem, elem, sizeof(*elem));
- if (elem->flags & (1 << NFTNL_SET_ELEM_CHAIN))
+ if (elem->flags & (1 << NFTNL_SET_ELEM_CHAIN)) {
newelem->data.chain = strdup(elem->data.chain);
+ if (!newelem->data.chain)
+ goto err;
+ }
return newelem;
+err:
+ nftnl_set_elem_free(newelem);
+ return NULL;
}
void nftnl_set_elem_nlmsg_build_payload(struct nlmsghdr *nlh,
@@ -473,12 +481,16 @@ int nftnl_set_elems_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_set *s)
xfree(s->table);
s->table =
strdup(mnl_attr_get_str(tb[NFTA_SET_ELEM_LIST_TABLE]));
+ if (!s->table)
+ return -1;
s->flags |= (1 << NFTNL_SET_TABLE);
}
if (tb[NFTA_SET_ELEM_LIST_SET]) {
xfree(s->name);
s->name =
strdup(mnl_attr_get_str(tb[NFTA_SET_ELEM_LIST_SET]));
+ if (!s->name)
+ return -1;
s->flags |= (1 << NFTNL_SET_NAME);
}
if (tb[NFTA_SET_ELEM_LIST_SET_ID]) {
diff --git a/src/table.c b/src/table.c
index 595b0ac..4f86426 100644
--- a/src/table.c
+++ b/src/table.c
@@ -232,6 +232,8 @@ int nftnl_table_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_table *t)
if (tb[NFTA_TABLE_NAME]) {
xfree(t->name);
t->name = strdup(mnl_attr_get_str(tb[NFTA_TABLE_NAME]));
+ if (!t->name)
+ return -1;
t->flags |= (1 << NFTNL_TABLE_NAME);
}
if (tb[NFTA_TABLE_FLAGS]) {
diff --git a/src/trace.c b/src/trace.c
index 921fa21..d8f561d 100644
--- a/src/trace.c
+++ b/src/trace.c
@@ -296,8 +296,8 @@ static int nftnl_trace_parse_verdict_cb(const struct nlattr *attr, void *data)
return MNL_CB_OK;
}
-static void
-nftnl_trace_parse_verdict(const struct nlattr *attr, struct nftnl_trace *t)
+static int nftnl_trace_parse_verdict(const struct nlattr *attr,
+ struct nftnl_trace *t)
{
struct nlattr *tb[NFTA_VERDICT_MAX+1];
@@ -315,13 +315,16 @@ nftnl_trace_parse_verdict(const struct nlattr *attr, struct nftnl_trace *t)
if (!tb[NFTA_VERDICT_CHAIN])
abi_breakage();
t->jump_target = strdup(mnl_attr_get_str(tb[NFTA_VERDICT_CHAIN]));
- if (t->jump_target)
- t->flags |= (1 << NFTNL_TRACE_JUMP_TARGET);
+ if (!t->jump_target)
+ return -1;
+
+ t->flags |= (1 << NFTNL_TRACE_JUMP_TARGET);
break;
}
+ return 0;
}
-
EXPORT_SYMBOL(nftnl_trace_nlmsg_parse);
+
int nftnl_trace_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_trace *t)
{
struct nfgenmsg *nfg = mnl_nlmsg_get_payload(nlh);
@@ -347,11 +350,17 @@ int nftnl_trace_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_trace *t)
if (tb[NFTA_TRACE_TABLE]) {
t->table = strdup(mnl_attr_get_str(tb[NFTA_TRACE_TABLE]));
+ if (!t->table)
+ return -1;
+
t->flags |= (1 << NFTNL_TRACE_TABLE);
}
if (tb[NFTA_TRACE_CHAIN]) {
t->chain = strdup(mnl_attr_get_str(tb[NFTA_TRACE_CHAIN]));
+ if (!t->chain)
+ return -1;
+
t->flags |= (1 << NFTNL_TRACE_CHAIN);
}
@@ -385,8 +394,9 @@ int nftnl_trace_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_trace *t)
t->flags |= (1 << NFTNL_TRACE_RULE_HANDLE);
}
- if (tb[NFTA_TRACE_VERDICT])
- nftnl_trace_parse_verdict(tb[NFTA_TRACE_VERDICT], t);
+ if (tb[NFTA_TRACE_VERDICT] &&
+ nftnl_trace_parse_verdict(tb[NFTA_TRACE_VERDICT], t) < 0)
+ return -1;
if (nftnl_trace_nlmsg_parse_hdrdata(tb[NFTA_TRACE_LL_HEADER], &t->ll))
t->flags |= (1 << NFTNL_TRACE_LL_HEADER);
--
2.1.4
^ permalink raw reply related [flat|nested] 9+ messages in thread* [PATCH libnftnl 5/9] expr: data_reg: get rid of leftover perror() calls
2016-06-14 13:18 [PATCH libnftnl 1/9] src: get rid of aliases Pablo Neira Ayuso
` (2 preceding siblings ...)
2016-06-14 13:18 ` [PATCH libnftnl 4/9] src: check for strdup() errors from setters and parsers Pablo Neira Ayuso
@ 2016-06-14 13:18 ` Pablo Neira Ayuso
2016-06-14 13:18 ` [PATCH libnftnl 6/9] src: simplify unsetters Pablo Neira Ayuso
` (3 subsequent siblings)
7 siblings, 0 replies; 9+ messages in thread
From: Pablo Neira Ayuso @ 2016-06-14 13:18 UTC (permalink / raw)
To: netfilter-devel
Let the client of this library decide when to display error messages.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
---
src/expr/data_reg.c | 9 +++------
1 file changed, 3 insertions(+), 6 deletions(-)
diff --git a/src/expr/data_reg.c b/src/expr/data_reg.c
index 6aa47bc..688823b 100644
--- a/src/expr/data_reg.c
+++ b/src/expr/data_reg.c
@@ -428,10 +428,8 @@ nftnl_parse_verdict(union nftnl_data_reg *data, const struct nlattr *attr, int *
{
struct nlattr *tb[NFTA_VERDICT_MAX+1];
- if (mnl_attr_parse_nested(attr, nftnl_verdict_parse_cb, tb) < 0) {
- perror("mnl_attr_parse_nested");
+ if (mnl_attr_parse_nested(attr, nftnl_verdict_parse_cb, tb) < 0)
return -1;
- }
if (!tb[NFTA_VERDICT_CODE])
return -1;
@@ -491,10 +489,9 @@ int nftnl_parse_data(union nftnl_data_reg *data, struct nlattr *attr, int *type)
struct nlattr *tb[NFTA_DATA_MAX+1] = {};
int ret = 0;
- if (mnl_attr_parse_nested(attr, nftnl_data_parse_cb, tb) < 0) {
- perror("mnl_attr_parse_nested");
+ if (mnl_attr_parse_nested(attr, nftnl_data_parse_cb, tb) < 0)
return -1;
- }
+
if (tb[NFTA_DATA_VALUE]) {
if (type)
*type = DATA_VALUE;
--
2.1.4
^ permalink raw reply related [flat|nested] 9+ messages in thread* [PATCH libnftnl 6/9] src: simplify unsetters
2016-06-14 13:18 [PATCH libnftnl 1/9] src: get rid of aliases Pablo Neira Ayuso
` (3 preceding siblings ...)
2016-06-14 13:18 ` [PATCH libnftnl 5/9] expr: data_reg: get rid of leftover perror() calls Pablo Neira Ayuso
@ 2016-06-14 13:18 ` Pablo Neira Ayuso
2016-06-14 13:18 ` [PATCH libnftnl 7/9] src: check for flags before releasing attributes Pablo Neira Ayuso
` (2 subsequent siblings)
7 siblings, 0 replies; 9+ messages in thread
From: Pablo Neira Ayuso @ 2016-06-14 13:18 UTC (permalink / raw)
To: netfilter-devel
If the attribute is set as we already check at the beginning of this
function, then we can release the object.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
---
src/chain.c | 15 +++------------
src/rule.c | 10 ++--------
src/ruleset.c | 4 ----
src/set.c | 15 +++++----------
src/set_elem.c | 15 +++++----------
src/table.c | 5 +----
6 files changed, 16 insertions(+), 48 deletions(-)
diff --git a/src/chain.c b/src/chain.c
index 0c79dd5..e0f548c 100644
--- a/src/chain.c
+++ b/src/chain.c
@@ -119,18 +119,12 @@ void nftnl_chain_unset(struct nftnl_chain *c, uint16_t attr)
switch (attr) {
case NFTNL_CHAIN_TABLE:
- if (c->table) {
- xfree(c->table);
- c->table = NULL;
- }
+ xfree(c->table);
break;
case NFTNL_CHAIN_USE:
break;
case NFTNL_CHAIN_TYPE:
- if (c->type) {
- xfree(c->type);
- c->type = NULL;
- }
+ xfree(c->type);
break;
case NFTNL_CHAIN_NAME:
case NFTNL_CHAIN_HOOKNUM:
@@ -142,10 +136,7 @@ void nftnl_chain_unset(struct nftnl_chain *c, uint16_t attr)
case NFTNL_CHAIN_FAMILY:
break;
case NFTNL_CHAIN_DEV:
- if (c->dev) {
- xfree(c->dev);
- c->dev = NULL;
- }
+ xfree(c->dev);
break;
default:
return;
diff --git a/src/rule.c b/src/rule.c
index 293c0cf..375552e 100644
--- a/src/rule.c
+++ b/src/rule.c
@@ -95,16 +95,10 @@ void nftnl_rule_unset(struct nftnl_rule *r, uint16_t attr)
switch (attr) {
case NFTNL_RULE_TABLE:
- if (r->table) {
- xfree(r->table);
- r->table = NULL;
- }
+ xfree(r->table);
break;
case NFTNL_RULE_CHAIN:
- if (r->chain) {
- xfree(r->chain);
- r->chain = NULL;
- }
+ xfree(r->chain);
break;
case NFTNL_RULE_HANDLE:
case NFTNL_RULE_COMPAT_PROTO:
diff --git a/src/ruleset.c b/src/ruleset.c
index cbe1438..971f531 100644
--- a/src/ruleset.c
+++ b/src/ruleset.c
@@ -92,19 +92,15 @@ void nftnl_ruleset_unset(struct nftnl_ruleset *r, uint16_t attr)
switch (attr) {
case NFTNL_RULESET_TABLELIST:
nftnl_table_list_free(r->table_list);
- r->table_list = NULL;
break;
case NFTNL_RULESET_CHAINLIST:
nftnl_chain_list_free(r->chain_list);
- r->chain_list = NULL;
break;
case NFTNL_RULESET_SETLIST:
nftnl_set_list_free(r->set_list);
- r->set_list = NULL;
break;
case NFTNL_RULESET_RULELIST:
nftnl_rule_list_free(r->rule_list);
- r->rule_list = NULL;
break;
}
r->flags &= ~(1 << attr);
diff --git a/src/set.c b/src/set.c
index a35c4ec..ccea313 100644
--- a/src/set.c
+++ b/src/set.c
@@ -65,20 +65,15 @@ EXPORT_SYMBOL(nftnl_set_is_set);
void nftnl_set_unset(struct nftnl_set *s, uint16_t attr)
{
+ if (!(s->flags & (1 << attr)))
+ return;
+
switch (attr) {
case NFTNL_SET_TABLE:
- if (s->flags & (1 << NFTNL_SET_TABLE))
- if (s->table) {
- xfree(s->table);
- s->table = NULL;
- }
+ xfree(s->table);
break;
case NFTNL_SET_NAME:
- if (s->flags & (1 << NFTNL_SET_NAME))
- if (s->name) {
- xfree(s->name);
- s->name = NULL;
- }
+ xfree(s->name);
break;
case NFTNL_SET_FLAGS:
case NFTNL_SET_KEY_TYPE:
diff --git a/src/set_elem.c b/src/set_elem.c
index ec0a4b7..dbf4176 100644
--- a/src/set_elem.c
+++ b/src/set_elem.c
@@ -66,14 +66,12 @@ EXPORT_SYMBOL(nftnl_set_elem_is_set);
void nftnl_set_elem_unset(struct nftnl_set_elem *s, uint16_t attr)
{
+ if (!(s->flags & (1 << attr)))
+ return;
+
switch (attr) {
case NFTNL_SET_ELEM_CHAIN:
- if (s->flags & (1 << NFTNL_SET_ELEM_CHAIN)) {
- if (s->data.chain) {
- xfree(s->data.chain);
- s->data.chain = NULL;
- }
- }
+ xfree(s->data.chain);
break;
case NFTNL_SET_ELEM_FLAGS:
case NFTNL_SET_ELEM_KEY: /* NFTA_SET_ELEM_KEY */
@@ -84,10 +82,7 @@ void nftnl_set_elem_unset(struct nftnl_set_elem *s, uint16_t attr)
case NFTNL_SET_ELEM_USERDATA: /* NFTA_SET_ELEM_USERDATA */
break;
case NFTNL_SET_ELEM_EXPR:
- if (s->flags & (1 << NFTNL_SET_ELEM_EXPR)) {
- nftnl_expr_free(s->expr);
- s->expr = NULL;
- }
+ nftnl_expr_free(s->expr);
break;
default:
return;
diff --git a/src/table.c b/src/table.c
index 4f86426..03b618f 100644
--- a/src/table.c
+++ b/src/table.c
@@ -64,10 +64,7 @@ void nftnl_table_unset(struct nftnl_table *t, uint16_t attr)
switch (attr) {
case NFTNL_TABLE_NAME:
- if (t->name) {
- xfree(t->name);
- t->name = NULL;
- }
+ xfree(t->name);
break;
case NFTNL_TABLE_FLAGS:
case NFTNL_TABLE_FAMILY:
--
2.1.4
^ permalink raw reply related [flat|nested] 9+ messages in thread* [PATCH libnftnl 7/9] src: check for flags before releasing attributes
2016-06-14 13:18 [PATCH libnftnl 1/9] src: get rid of aliases Pablo Neira Ayuso
` (4 preceding siblings ...)
2016-06-14 13:18 ` [PATCH libnftnl 6/9] src: simplify unsetters Pablo Neira Ayuso
@ 2016-06-14 13:18 ` Pablo Neira Ayuso
2016-06-14 13:18 ` [PATCH libnftnl 8/9] tests: shuffle values that are injected Pablo Neira Ayuso
2016-06-14 13:18 ` [PATCH libnftnl 9/9] chain: dynamically allocate name Pablo Neira Ayuso
7 siblings, 0 replies; 9+ messages in thread
From: Pablo Neira Ayuso @ 2016-06-14 13:18 UTC (permalink / raw)
To: netfilter-devel
Now that unsetters don't set pointers to NULL, check if the attribute is
set before trying to release it.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
---
src/chain.c | 18 ++++++++++--------
src/expr/immediate.c | 2 +-
src/expr/log.c | 2 +-
src/expr/match.c | 4 ++--
src/expr/target.c | 2 +-
src/rule.c | 20 +++++++++++---------
src/set.c | 14 ++++++++------
src/set_elem.c | 20 +++++++++-----------
src/table.c | 5 +++--
9 files changed, 46 insertions(+), 41 deletions(-)
diff --git a/src/chain.c b/src/chain.c
index e0f548c..86ccef6 100644
--- a/src/chain.c
+++ b/src/chain.c
@@ -95,11 +95,11 @@ EXPORT_SYMBOL(nftnl_chain_alloc);
void nftnl_chain_free(const struct nftnl_chain *c)
{
- if (c->table != NULL)
+ if (c->flags & (1 << NFTNL_CHAIN_TABLE))
xfree(c->table);
- if (c->type != NULL)
+ if (c->flags & (1 << NFTNL_CHAIN_TYPE))
xfree(c->type);
- if (c->dev != NULL)
+ if (c->flags & (1 << NFTNL_CHAIN_DEV))
xfree(c->dev);
xfree(c);
@@ -167,7 +167,7 @@ int nftnl_chain_set_data(struct nftnl_chain *c, uint16_t attr,
strncpy(c->name, data, NFT_CHAIN_MAXNAMELEN);
break;
case NFTNL_CHAIN_TABLE:
- if (c->table)
+ if (c->flags & (1 << NFTNL_CHAIN_TABLE))
xfree(c->table);
c->table = strdup(data);
@@ -199,7 +199,7 @@ int nftnl_chain_set_data(struct nftnl_chain *c, uint16_t attr,
c->family = *((uint32_t *)data);
break;
case NFTNL_CHAIN_TYPE:
- if (c->type)
+ if (c->flags & (1 << NFTNL_CHAIN_TYPE))
xfree(c->type);
c->type = strdup(data);
@@ -207,7 +207,7 @@ int nftnl_chain_set_data(struct nftnl_chain *c, uint16_t attr,
return -1;
break;
case NFTNL_CHAIN_DEV:
- if (c->dev)
+ if (c->flags & (1 << NFTNL_CHAIN_DEV))
xfree(c->dev);
c->dev = strdup(data);
@@ -533,7 +533,8 @@ int nftnl_chain_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_chain *c)
c->flags |= (1 << NFTNL_CHAIN_NAME);
}
if (tb[NFTA_CHAIN_TABLE]) {
- xfree(c->table);
+ if (c->flags & (1 << NFTNL_CHAIN_TABLE))
+ xfree(c->table);
c->table = strdup(mnl_attr_get_str(tb[NFTA_CHAIN_TABLE]));
if (!c->table)
return -1;
@@ -562,7 +563,8 @@ int nftnl_chain_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_chain *c)
c->flags |= (1 << NFTNL_CHAIN_HANDLE);
}
if (tb[NFTA_CHAIN_TYPE]) {
- xfree(c->type);
+ if (c->flags & (1 << NFTNL_CHAIN_TYPE))
+ xfree(c->type);
c->type = strdup(mnl_attr_get_str(tb[NFTA_CHAIN_TYPE]));
if (!c->type)
return -1;
diff --git a/src/expr/immediate.c b/src/expr/immediate.c
index 243f0e0..22ec864 100644
--- a/src/expr/immediate.c
+++ b/src/expr/immediate.c
@@ -43,7 +43,7 @@ nftnl_expr_immediate_set(struct nftnl_expr *e, uint16_t type,
imm->data.verdict = *((uint32_t *)data);
break;
case NFTNL_EXPR_IMM_CHAIN:
- if (imm->data.chain)
+ if (e->flags & (1 << NFTNL_EXPR_IMM_CHAIN))
xfree(imm->data.chain);
imm->data.chain = strdup(data);
diff --git a/src/expr/log.c b/src/expr/log.c
index 5b774a4..b9b3951 100644
--- a/src/expr/log.c
+++ b/src/expr/log.c
@@ -37,7 +37,7 @@ static int nftnl_expr_log_set(struct nftnl_expr *e, uint16_t type,
switch(type) {
case NFTNL_EXPR_LOG_PREFIX:
- if (log->prefix)
+ if (log->flags & (1 << NFTNL_EXPR_LOG_PREFIX))
xfree(log->prefix);
log->prefix = strdup(data);
diff --git a/src/expr/match.c b/src/expr/match.c
index 2929b43..3342e2c 100644
--- a/src/expr/match.c
+++ b/src/expr/match.c
@@ -49,7 +49,7 @@ nftnl_expr_match_set(struct nftnl_expr *e, uint16_t type,
mt->rev = *((uint32_t *)data);
break;
case NFTNL_EXPR_MT_INFO:
- if (mt->data)
+ if (e->flags & (1 << NFTNL_EXPR_MT_INFO))
xfree(mt->data);
mt->data = data;
@@ -146,7 +146,7 @@ static int nftnl_expr_match_parse(struct nftnl_expr *e, struct nlattr *attr)
uint32_t len = mnl_attr_get_payload_len(tb[NFTA_MATCH_INFO]);
void *match_data;
- if (match->data)
+ if (e->flags & (1 << NFTNL_EXPR_MT_INFO))
xfree(match->data);
match_data = calloc(1, len);
diff --git a/src/expr/target.c b/src/expr/target.c
index 68a7d8a..d4c0091 100644
--- a/src/expr/target.c
+++ b/src/expr/target.c
@@ -49,7 +49,7 @@ nftnl_expr_target_set(struct nftnl_expr *e, uint16_t type,
tg->rev = *((uint32_t *)data);
break;
case NFTNL_EXPR_TG_INFO:
- if (tg->data)
+ if (e->flags & (1 << NFTNL_EXPR_TG_INFO))
xfree(tg->data);
tg->data = data;
diff --git a/src/rule.c b/src/rule.c
index 375552e..c46c325 100644
--- a/src/rule.c
+++ b/src/rule.c
@@ -71,11 +71,11 @@ void nftnl_rule_free(const struct nftnl_rule *r)
list_for_each_entry_safe(e, tmp, &r->expr_list, head)
nftnl_expr_free(e);
- if (r->table != NULL)
+ if (r->flags & (1 << (NFTNL_RULE_TABLE)))
xfree(r->table);
- if (r->chain != NULL)
+ if (r->flags & (1 << (NFTNL_RULE_CHAIN)))
xfree(r->chain);
- if (r->user.data != NULL)
+ if (r->flags & (1 << (NFTNL_RULE_USERDATA)))
xfree(r->user.data);
xfree(r);
@@ -129,7 +129,7 @@ int nftnl_rule_set_data(struct nftnl_rule *r, uint16_t attr,
switch(attr) {
case NFTNL_RULE_TABLE:
- if (r->table)
+ if (r->flags & (1 << NFTNL_RULE_TABLE))
xfree(r->table);
r->table = strdup(data);
@@ -137,7 +137,7 @@ int nftnl_rule_set_data(struct nftnl_rule *r, uint16_t attr,
return -1;
break;
case NFTNL_RULE_CHAIN:
- if (r->chain)
+ if (r->flags & (1 << NFTNL_RULE_CHAIN))
xfree(r->chain);
r->chain = strdup(data);
@@ -160,7 +160,7 @@ int nftnl_rule_set_data(struct nftnl_rule *r, uint16_t attr,
r->position = *((uint64_t *)data);
break;
case NFTNL_RULE_USERDATA:
- if (r->user.data != NULL)
+ if (r->flags & (1 << NFTNL_RULE_USERDATA))
xfree(r->user.data);
r->user.data = malloc(data_len);
@@ -431,14 +431,16 @@ int nftnl_rule_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_rule *r)
return -1;
if (tb[NFTA_RULE_TABLE]) {
- xfree(r->table);
+ if (r->flags & (1 << NFTNL_RULE_TABLE))
+ xfree(r->table);
r->table = strdup(mnl_attr_get_str(tb[NFTA_RULE_TABLE]));
if (!r->table)
return -1;
r->flags |= (1 << NFTNL_RULE_TABLE);
}
if (tb[NFTA_RULE_CHAIN]) {
- xfree(r->chain);
+ if (r->flags & (1 << NFTNL_RULE_CHAIN))
+ xfree(r->chain);
r->chain = strdup(mnl_attr_get_str(tb[NFTA_RULE_CHAIN]));
if (!r->chain)
return -1;
@@ -460,7 +462,7 @@ int nftnl_rule_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_rule *r)
const void *udata =
mnl_attr_get_payload(tb[NFTA_RULE_USERDATA]);
- if (r->user.data)
+ if (r->flags & (1 << NFTNL_RULE_USERDATA))
xfree(r->user.data);
r->user.len = mnl_attr_get_payload_len(tb[NFTA_RULE_USERDATA]);
diff --git a/src/set.c b/src/set.c
index ccea313..132e913 100644
--- a/src/set.c
+++ b/src/set.c
@@ -44,9 +44,9 @@ void nftnl_set_free(const struct nftnl_set *s)
{
struct nftnl_set_elem *elem, *tmp;
- if (s->table != NULL)
+ if (s->flags & (1 << NFTNL_SET_TABLE))
xfree(s->table);
- if (s->name != NULL)
+ if (s->flags & (1 << NFTNL_SET_NAME))
xfree(s->name);
list_for_each_entry_safe(elem, tmp, &s->element_list, head) {
@@ -116,7 +116,7 @@ int nftnl_set_set_data(struct nftnl_set *s, uint16_t attr, const void *data,
switch(attr) {
case NFTNL_SET_TABLE:
- if (s->table)
+ if (s->flags & (1 << NFTNL_SET_TABLE))
xfree(s->table);
s->table = strdup(data);
@@ -124,7 +124,7 @@ int nftnl_set_set_data(struct nftnl_set *s, uint16_t attr, const void *data,
return -1;
break;
case NFTNL_SET_NAME:
- if (s->name)
+ if (s->flags & (1 << NFTNL_SET_NAME))
xfree(s->name);
s->name = strdup(data);
@@ -439,14 +439,16 @@ int nftnl_set_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_set *s)
return -1;
if (tb[NFTA_SET_TABLE]) {
- xfree(s->table);
+ if (s->flags & (1 << NFTNL_SET_TABLE))
+ xfree(s->table);
s->table = strdup(mnl_attr_get_str(tb[NFTA_SET_TABLE]));
if (!s->table)
return -1;
s->flags |= (1 << NFTNL_SET_TABLE);
}
if (tb[NFTA_SET_NAME]) {
- xfree(s->name);
+ if (s->flags & (1 << NFTNL_SET_NAME))
+ xfree(s->name);
s->name = strdup(mnl_attr_get_str(tb[NFTA_SET_NAME]));
if (!s->name)
return -1;
diff --git a/src/set_elem.c b/src/set_elem.c
index dbf4176..596ba8a 100644
--- a/src/set_elem.c
+++ b/src/set_elem.c
@@ -41,12 +41,8 @@ EXPORT_SYMBOL(nftnl_set_elem_alloc);
void nftnl_set_elem_free(struct nftnl_set_elem *s)
{
- if (s->flags & (1 << NFTNL_SET_ELEM_CHAIN)) {
- if (s->data.chain) {
- xfree(s->data.chain);
- s->data.chain = NULL;
- }
- }
+ if (s->flags & (1 << NFTNL_SET_ELEM_CHAIN))
+ xfree(s->data.chain);
if (s->flags & (1 << NFTNL_SET_ELEM_EXPR))
nftnl_expr_free(s->expr);
@@ -107,7 +103,7 @@ int nftnl_set_elem_set(struct nftnl_set_elem *s, uint16_t attr,
s->data.verdict = *((uint32_t *)data);
break;
case NFTNL_SET_ELEM_CHAIN: /* NFTA_SET_ELEM_DATA */
- if (s->data.chain)
+ if (s->flags & (1 << NFTNL_SET_ELEM_CHAIN))
xfree(s->data.chain);
s->data.chain = strdup(data);
@@ -122,7 +118,7 @@ int nftnl_set_elem_set(struct nftnl_set_elem *s, uint16_t attr,
s->timeout = *((uint64_t *)data);
break;
case NFTNL_SET_ELEM_USERDATA: /* NFTA_SET_ELEM_USERDATA */
- if (s->user.data != NULL)
+ if (s->flags & (1 << NFTNL_SET_ELEM_USERDATA))
xfree(s->user.data);
s->user.data = malloc(data_len);
@@ -400,7 +396,7 @@ static int nftnl_set_elems_parse2(struct nftnl_set *s, const struct nlattr *nest
const void *udata =
mnl_attr_get_payload(tb[NFTA_SET_ELEM_USERDATA]);
- if (e->user.data)
+ if (e->flags & (1 << NFTNL_RULE_USERDATA))
xfree(e->user.data);
e->user.len = mnl_attr_get_payload_len(tb[NFTA_SET_ELEM_USERDATA]);
@@ -473,7 +469,8 @@ int nftnl_set_elems_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_set *s)
return -1;
if (tb[NFTA_SET_ELEM_LIST_TABLE]) {
- xfree(s->table);
+ if (s->flags & (1 << NFTNL_SET_TABLE))
+ xfree(s->table);
s->table =
strdup(mnl_attr_get_str(tb[NFTA_SET_ELEM_LIST_TABLE]));
if (!s->table)
@@ -481,7 +478,8 @@ int nftnl_set_elems_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_set *s)
s->flags |= (1 << NFTNL_SET_TABLE);
}
if (tb[NFTA_SET_ELEM_LIST_SET]) {
- xfree(s->name);
+ if (s->flags & (1 << NFTNL_SET_NAME))
+ xfree(s->name);
s->name =
strdup(mnl_attr_get_str(tb[NFTA_SET_ELEM_LIST_SET]));
if (!s->name)
diff --git a/src/table.c b/src/table.c
index 03b618f..9231937 100644
--- a/src/table.c
+++ b/src/table.c
@@ -89,7 +89,7 @@ int nftnl_table_set_data(struct nftnl_table *t, uint16_t attr,
switch (attr) {
case NFTNL_TABLE_NAME:
- if (t->name)
+ if (t->flags & (1 << NFTNL_TABLE_NAME))
xfree(t->name);
t->name = strdup(data);
@@ -227,7 +227,8 @@ int nftnl_table_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_table *t)
return -1;
if (tb[NFTA_TABLE_NAME]) {
- xfree(t->name);
+ if (t->flags & (1 << NFTNL_TABLE_NAME))
+ xfree(t->name);
t->name = strdup(mnl_attr_get_str(tb[NFTA_TABLE_NAME]));
if (!t->name)
return -1;
--
2.1.4
^ permalink raw reply related [flat|nested] 9+ messages in thread* [PATCH libnftnl 8/9] tests: shuffle values that are injected
2016-06-14 13:18 [PATCH libnftnl 1/9] src: get rid of aliases Pablo Neira Ayuso
` (5 preceding siblings ...)
2016-06-14 13:18 ` [PATCH libnftnl 7/9] src: check for flags before releasing attributes Pablo Neira Ayuso
@ 2016-06-14 13:18 ` Pablo Neira Ayuso
2016-06-14 13:18 ` [PATCH libnftnl 9/9] chain: dynamically allocate name Pablo Neira Ayuso
7 siblings, 0 replies; 9+ messages in thread
From: Pablo Neira Ayuso @ 2016-06-14 13:18 UTC (permalink / raw)
To: netfilter-devel
Shuffle value that are used to set attributes, this variability should
help us catch more problems in the future.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
---
tests/nft-chain-test.c | 10 +++++-----
tests/nft-expr_bitwise-test.c | 4 ++--
tests/nft-expr_cmp-test.c | 2 +-
tests/nft-expr_counter-test.c | 2 +-
tests/nft-expr_ct-test.c | 2 +-
tests/nft-expr_exthdr-test.c | 4 ++--
tests/nft-expr_immediate-test.c | 10 +++++-----
tests/nft-expr_limit-test.c | 4 ++--
tests/nft-expr_log-test.c | 2 +-
tests/nft-expr_lookup-test.c | 2 +-
tests/nft-expr_meta-test.c | 2 +-
tests/nft-expr_payload-test.c | 6 +++---
tests/nft-expr_queue-test.c | 6 +++---
tests/nft-expr_redir-test.c | 6 +++---
tests/nft-expr_reject-test.c | 4 ++--
tests/nft-expr_target-test.c | 2 +-
16 files changed, 34 insertions(+), 34 deletions(-)
diff --git a/tests/nft-chain-test.c b/tests/nft-chain-test.c
index 3f5c5a5..d678d46 100644
--- a/tests/nft-chain-test.c
+++ b/tests/nft-chain-test.c
@@ -79,12 +79,12 @@ int main(int argc, char *argv[])
nftnl_chain_set_u32(a, NFTNL_CHAIN_FAMILY, AF_INET);
nftnl_chain_set_str(a, NFTNL_CHAIN_TABLE, "Table");
nftnl_chain_set_u32(a, NFTNL_CHAIN_POLICY,0x12345678);
- nftnl_chain_set_u32(a, NFTNL_CHAIN_HOOKNUM, 0x12345678);
- nftnl_chain_set_s32(a, NFTNL_CHAIN_PRIO, 0x12345678);
- nftnl_chain_set_u32(a, NFTNL_CHAIN_USE, 0x12345678 );
+ nftnl_chain_set_u32(a, NFTNL_CHAIN_HOOKNUM, 0x34567812);
+ nftnl_chain_set_s32(a, NFTNL_CHAIN_PRIO, 0x56781234);
+ nftnl_chain_set_u32(a, NFTNL_CHAIN_USE, 0x78123456);
nftnl_chain_set_u64(a, NFTNL_CHAIN_PACKETS, 0x1234567812345678);
- nftnl_chain_set_u64(a, NFTNL_CHAIN_BYTES, 0x1234567812345678);
- nftnl_chain_set_u64(a, NFTNL_CHAIN_HANDLE, 0x1234567812345678);
+ nftnl_chain_set_u64(a, NFTNL_CHAIN_BYTES, 0x7812345678123456);
+ nftnl_chain_set_u64(a, NFTNL_CHAIN_HANDLE, 0x5678123456781234);
nftnl_chain_set_str(a, NFTNL_CHAIN_TYPE, "Prueba");
nftnl_chain_set_str(a, NFTNL_CHAIN_DEV, "eth0");
diff --git a/tests/nft-expr_bitwise-test.c b/tests/nft-expr_bitwise-test.c
index 4b59751..64c1446 100644
--- a/tests/nft-expr_bitwise-test.c
+++ b/tests/nft-expr_bitwise-test.c
@@ -72,8 +72,8 @@ int main(int argc, char *argv[])
print_err("OOM");
nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_SREG, 0x12345678);
- nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_DREG, 0x12345678);
- nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_LEN, 0x12345678);
+ nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_DREG, 0x78123456);
+ nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_LEN, 0x56781234);
nftnl_expr_set(ex, NFTNL_EXPR_BITWISE_MASK, &mask, sizeof(mask));
nftnl_expr_set(ex, NFTNL_EXPR_BITWISE_XOR, &xor, sizeof(xor));
diff --git a/tests/nft-expr_cmp-test.c b/tests/nft-expr_cmp-test.c
index 23292c9..ec00bb9 100644
--- a/tests/nft-expr_cmp-test.c
+++ b/tests/nft-expr_cmp-test.c
@@ -64,7 +64,7 @@ int main(int argc, char *argv[])
nftnl_expr_set(ex, NFTNL_EXPR_CMP_DATA, &data_len, sizeof(data_len));
nftnl_expr_set_u32(ex, NFTNL_EXPR_CMP_SREG, 0x12345678);
- nftnl_expr_set_u32(ex, NFTNL_EXPR_CMP_OP, 0x12345678);
+ nftnl_expr_set_u32(ex, NFTNL_EXPR_CMP_OP, 0x78123456);
nftnl_rule_add_expr(a, ex);
diff --git a/tests/nft-expr_counter-test.c b/tests/nft-expr_counter-test.c
index d515952..519bc1f 100644
--- a/tests/nft-expr_counter-test.c
+++ b/tests/nft-expr_counter-test.c
@@ -57,7 +57,7 @@ int main(int argc, char *argv[])
print_err("OOM");
nftnl_expr_set_u64(ex, NFTNL_EXPR_CTR_BYTES, 0x123456789abcdef0);
- nftnl_expr_set_u64(ex, NFTNL_EXPR_CTR_PACKETS, 0x123456789abcdef0);
+ nftnl_expr_set_u64(ex, NFTNL_EXPR_CTR_PACKETS, 0xf0123456789abcde);
nftnl_rule_add_expr(a, ex);
nlh = nftnl_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
diff --git a/tests/nft-expr_ct-test.c b/tests/nft-expr_ct-test.c
index af69587..e98fbab 100644
--- a/tests/nft-expr_ct-test.c
+++ b/tests/nft-expr_ct-test.c
@@ -58,7 +58,7 @@ int main(int argc, char *argv[])
nftnl_expr_set_u32(ex, NFTNL_EXPR_CT_KEY, 0x1234568);
nftnl_expr_set_u32(ex, NFTNL_EXPR_CT_DIR, 0x12);
- nftnl_expr_set_u32(ex, NFTNL_EXPR_CT_DREG, 0x12345678);
+ nftnl_expr_set_u32(ex, NFTNL_EXPR_CT_DREG, 0x78123456);
nftnl_rule_add_expr(a, ex);
diff --git a/tests/nft-expr_exthdr-test.c b/tests/nft-expr_exthdr-test.c
index 622015c..fef2dd0 100644
--- a/tests/nft-expr_exthdr-test.c
+++ b/tests/nft-expr_exthdr-test.c
@@ -63,8 +63,8 @@ int main(int argc, char *argv[])
nftnl_expr_set_u32(ex, NFTNL_EXPR_EXTHDR_DREG, 0x12345678);
nftnl_expr_set_u32(ex, NFTNL_EXPR_EXTHDR_TYPE, 0x12);
- nftnl_expr_set_u32(ex, NFTNL_EXPR_EXTHDR_OFFSET, 0x12345678);
- nftnl_expr_set_u32(ex, NFTNL_EXPR_EXTHDR_LEN, 0x12345678);
+ nftnl_expr_set_u32(ex, NFTNL_EXPR_EXTHDR_OFFSET, 0x78123456);
+ nftnl_expr_set_u32(ex, NFTNL_EXPR_EXTHDR_LEN, 0x56781234);
nftnl_rule_add_expr(a, ex);
diff --git a/tests/nft-expr_immediate-test.c b/tests/nft-expr_immediate-test.c
index abde2e1..695e0b0 100644
--- a/tests/nft-expr_immediate-test.c
+++ b/tests/nft-expr_immediate-test.c
@@ -56,8 +56,8 @@ int main(int argc, char *argv[])
char buf[4096];
struct nftnl_expr_iter *iter_a, *iter_b;
struct nftnl_expr *rule_a, *rule_b;
- uint32_t chain_t = 0x12345678;
- uint32_t data_t = 0x12345678;
+ uint32_t chain = 0x12345678;
+ uint32_t data = 0x56781234;
a = nftnl_rule_alloc();
b = nftnl_rule_alloc();
@@ -68,9 +68,9 @@ int main(int argc, char *argv[])
print_err("OOM");
nftnl_expr_set_u32(ex, NFTNL_EXPR_IMM_DREG, 0x1234568);
- nftnl_expr_set(ex, NFTNL_EXPR_IMM_DATA, &chain_t, sizeof(chain_t));
- nftnl_expr_set_u32(ex, NFTNL_EXPR_IMM_VERDICT, 0x12345678);
- nftnl_expr_set(ex, NFTNL_EXPR_IMM_CHAIN, &data_t, sizeof(data_t));
+ nftnl_expr_set(ex, NFTNL_EXPR_IMM_DATA, &data, sizeof(data));
+ nftnl_expr_set_u32(ex, NFTNL_EXPR_IMM_VERDICT, 0x78123456);
+ nftnl_expr_set(ex, NFTNL_EXPR_IMM_CHAIN, &chain, sizeof(chain));
nftnl_rule_add_expr(a, ex);
diff --git a/tests/nft-expr_limit-test.c b/tests/nft-expr_limit-test.c
index 29fb489..2838941 100644
--- a/tests/nft-expr_limit-test.c
+++ b/tests/nft-expr_limit-test.c
@@ -66,10 +66,10 @@ int main(int argc, char *argv[])
print_err("OOM");
nftnl_expr_set_u64(ex, NFTNL_EXPR_LIMIT_RATE, 0x123456789abcdef0);
- nftnl_expr_set_u64(ex, NFTNL_EXPR_LIMIT_UNIT, 0x123456789abcdef0);
+ nftnl_expr_set_u64(ex, NFTNL_EXPR_LIMIT_UNIT, 0xf0123456789abcde);
nftnl_expr_set_u32(ex, NFTNL_EXPR_LIMIT_BURST, 0x89123456);
nftnl_expr_set_u32(ex, NFTNL_EXPR_LIMIT_TYPE, 0xdef01234);
- nftnl_expr_set_u32(ex, NFTNL_EXPR_LIMIT_FLAGS, 0xdef01234);
+ nftnl_expr_set_u32(ex, NFTNL_EXPR_LIMIT_FLAGS, 0x34def012);
nftnl_rule_add_expr(a, ex);
diff --git a/tests/nft-expr_log-test.c b/tests/nft-expr_log-test.c
index 3815778..b7aa302 100644
--- a/tests/nft-expr_log-test.c
+++ b/tests/nft-expr_log-test.c
@@ -63,7 +63,7 @@ int main(int argc, char *argv[])
nftnl_expr_set_u32(ex, NFTNL_EXPR_LOG_SNAPLEN, 0x12345678);
nftnl_expr_set_u16(ex, NFTNL_EXPR_LOG_GROUP, 0x1234);
- nftnl_expr_set_u16(ex, NFTNL_EXPR_LOG_QTHRESHOLD, 0x1234);
+ nftnl_expr_set_u16(ex, NFTNL_EXPR_LOG_QTHRESHOLD, 0x3412);
nftnl_expr_set_str(ex, NFTNL_EXPR_LOG_PREFIX, "test");
nftnl_rule_add_expr(a, ex);
diff --git a/tests/nft-expr_lookup-test.c b/tests/nft-expr_lookup-test.c
index ad028e9..83fa829 100644
--- a/tests/nft-expr_lookup-test.c
+++ b/tests/nft-expr_lookup-test.c
@@ -63,7 +63,7 @@ int main(int argc, char *argv[])
print_err("OOM");
nftnl_expr_set_u32(ex, NFTNL_EXPR_LOOKUP_SREG, 0x12345678);
- nftnl_expr_set_u32(ex, NFTNL_EXPR_LOOKUP_DREG, 0x12345678);
+ nftnl_expr_set_u32(ex, NFTNL_EXPR_LOOKUP_DREG, 0x78123456);
nftnl_expr_set(ex, NFTNL_EXPR_LOOKUP_SET, &lookup_set,
sizeof(lookup_set));
diff --git a/tests/nft-expr_meta-test.c b/tests/nft-expr_meta-test.c
index 82f8fcf..8fb7873 100644
--- a/tests/nft-expr_meta-test.c
+++ b/tests/nft-expr_meta-test.c
@@ -56,7 +56,7 @@ int main(int argc, char *argv[])
print_err("OOM");
nftnl_expr_set_u32(ex, NFTNL_EXPR_META_KEY, 0x1234568);
- nftnl_expr_set_u32(ex, NFTNL_EXPR_META_DREG, 0x12345678);
+ nftnl_expr_set_u32(ex, NFTNL_EXPR_META_DREG, 0x78123456);
nftnl_rule_add_expr(a, ex);
diff --git a/tests/nft-expr_payload-test.c b/tests/nft-expr_payload-test.c
index c652195..371372c 100644
--- a/tests/nft-expr_payload-test.c
+++ b/tests/nft-expr_payload-test.c
@@ -63,9 +63,9 @@ int main(int argc, char *argv[])
print_err("OOM");
nftnl_expr_set_u32(ex, NFTNL_EXPR_PAYLOAD_DREG, 0x1234568);
- nftnl_expr_set_u32(ex, NFTNL_EXPR_PAYLOAD_BASE, 0x12345678);
- nftnl_expr_set_u32(ex, NFTNL_EXPR_PAYLOAD_OFFSET, 0x12345678);
- nftnl_expr_set_u32(ex, NFTNL_EXPR_PAYLOAD_LEN, 0x12345678);
+ nftnl_expr_set_u32(ex, NFTNL_EXPR_PAYLOAD_BASE, 0x78123456);
+ nftnl_expr_set_u32(ex, NFTNL_EXPR_PAYLOAD_OFFSET, 0x56781234);
+ nftnl_expr_set_u32(ex, NFTNL_EXPR_PAYLOAD_LEN, 0x78561234);
nftnl_rule_add_expr(a, ex);
diff --git a/tests/nft-expr_queue-test.c b/tests/nft-expr_queue-test.c
index 654e13c..1cc39aa 100644
--- a/tests/nft-expr_queue-test.c
+++ b/tests/nft-expr_queue-test.c
@@ -58,9 +58,9 @@ int main(int argc, char *argv[])
if (ex == NULL)
print_err("OOM");
- nftnl_expr_set_u16(ex, NFTNL_EXPR_QUEUE_NUM, 0x123);
- nftnl_expr_set_u16(ex, NFTNL_EXPR_QUEUE_TOTAL, 0x2);
- nftnl_expr_set_u16(ex, NFTNL_EXPR_QUEUE_FLAGS, 0x2);
+ nftnl_expr_set_u16(ex, NFTNL_EXPR_QUEUE_NUM, 0x01010);
+ nftnl_expr_set_u16(ex, NFTNL_EXPR_QUEUE_TOTAL, 0x1234);
+ nftnl_expr_set_u16(ex, NFTNL_EXPR_QUEUE_FLAGS, 0x4321);
nftnl_rule_add_expr(a, ex);
diff --git a/tests/nft-expr_redir-test.c b/tests/nft-expr_redir-test.c
index 978cac6..6c8caec 100644
--- a/tests/nft-expr_redir-test.c
+++ b/tests/nft-expr_redir-test.c
@@ -56,9 +56,9 @@ int main(int argc, char *argv[])
if (ex == NULL)
print_err("OOM");
- nftnl_expr_set_u32(ex, NFTNL_EXPR_REDIR_REG_PROTO_MIN, 0x1234568);
- nftnl_expr_set_u32(ex, NFTNL_EXPR_REDIR_REG_PROTO_MAX, 0x23456);
- nftnl_expr_set_u32(ex, NFTNL_EXPR_REDIR_FLAGS, 0x1234568);
+ nftnl_expr_set_u32(ex, NFTNL_EXPR_REDIR_REG_PROTO_MIN, 0x12345678);
+ nftnl_expr_set_u32(ex, NFTNL_EXPR_REDIR_REG_PROTO_MAX, 0x56781234);
+ nftnl_expr_set_u32(ex, NFTNL_EXPR_REDIR_FLAGS, 0x12003400);
nftnl_rule_add_expr(a, ex);
diff --git a/tests/nft-expr_reject-test.c b/tests/nft-expr_reject-test.c
index 5fa4cda..d8189ea 100644
--- a/tests/nft-expr_reject-test.c
+++ b/tests/nft-expr_reject-test.c
@@ -56,8 +56,8 @@ int main(int argc, char *argv[])
if (ex == NULL)
print_err("OOM");
- nftnl_expr_set_u32(ex, NFTNL_EXPR_REJECT_TYPE, 0x1234568);
- nftnl_expr_set_u32(ex, NFTNL_EXPR_REJECT_CODE, 0x1234568);
+ nftnl_expr_set_u32(ex, NFTNL_EXPR_REJECT_TYPE, 0x12345678);
+ nftnl_expr_set_u32(ex, NFTNL_EXPR_REJECT_CODE, 0x45681234);
nftnl_rule_add_expr(a, ex);
diff --git a/tests/nft-expr_target-test.c b/tests/nft-expr_target-test.c
index 634fc0a..ba56b27 100644
--- a/tests/nft-expr_target-test.c
+++ b/tests/nft-expr_target-test.c
@@ -70,7 +70,7 @@ int main(int argc, char *argv[])
print_err("OOM");
nftnl_expr_set(ex, NFTNL_EXPR_TG_NAME, "test", strlen("test"));
- nftnl_expr_set_u32(ex, NFTNL_EXPR_TG_REV, 0x12345678);
+ nftnl_expr_set_u32(ex, NFTNL_EXPR_TG_REV, 0x56781234);
nftnl_expr_set(ex, NFTNL_EXPR_TG_INFO, strdup(data), sizeof(data));
nftnl_rule_add_expr(a, ex);
--
2.1.4
^ permalink raw reply related [flat|nested] 9+ messages in thread* [PATCH libnftnl 9/9] chain: dynamically allocate name
2016-06-14 13:18 [PATCH libnftnl 1/9] src: get rid of aliases Pablo Neira Ayuso
` (6 preceding siblings ...)
2016-06-14 13:18 ` [PATCH libnftnl 8/9] tests: shuffle values that are injected Pablo Neira Ayuso
@ 2016-06-14 13:18 ` Pablo Neira Ayuso
7 siblings, 0 replies; 9+ messages in thread
From: Pablo Neira Ayuso @ 2016-06-14 13:18 UTC (permalink / raw)
To: netfilter-devel
Just in case we ever support chain with larger names in the future,
this will ensure the library doesn't break. Although I don't expect
allocating more bytes for this anytime soon, but let's be conservative
here.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
---
src/chain.c | 23 +++++++++++++++++------
1 file changed, 17 insertions(+), 6 deletions(-)
diff --git a/src/chain.c b/src/chain.c
index 86ccef6..a7f6742 100644
--- a/src/chain.c
+++ b/src/chain.c
@@ -32,7 +32,7 @@
struct nftnl_chain {
struct list_head head;
- char name[NFT_CHAIN_MAXNAMELEN];
+ const char *name;
const char *type;
const char *table;
const char *dev;
@@ -95,13 +95,14 @@ EXPORT_SYMBOL(nftnl_chain_alloc);
void nftnl_chain_free(const struct nftnl_chain *c)
{
+ if (c->flags & (1 << NFTNL_CHAIN_NAME))
+ xfree(c->name);
if (c->flags & (1 << NFTNL_CHAIN_TABLE))
xfree(c->table);
if (c->flags & (1 << NFTNL_CHAIN_TYPE))
xfree(c->type);
if (c->flags & (1 << NFTNL_CHAIN_DEV))
xfree(c->dev);
-
xfree(c);
}
EXPORT_SYMBOL(nftnl_chain_free);
@@ -118,6 +119,9 @@ void nftnl_chain_unset(struct nftnl_chain *c, uint16_t attr)
return;
switch (attr) {
+ case NFTNL_CHAIN_NAME:
+ xfree(c->name);
+ break;
case NFTNL_CHAIN_TABLE:
xfree(c->table);
break;
@@ -126,7 +130,6 @@ void nftnl_chain_unset(struct nftnl_chain *c, uint16_t attr)
case NFTNL_CHAIN_TYPE:
xfree(c->type);
break;
- case NFTNL_CHAIN_NAME:
case NFTNL_CHAIN_HOOKNUM:
case NFTNL_CHAIN_PRIO:
case NFTNL_CHAIN_POLICY:
@@ -164,7 +167,12 @@ int nftnl_chain_set_data(struct nftnl_chain *c, uint16_t attr,
switch(attr) {
case NFTNL_CHAIN_NAME:
- strncpy(c->name, data, NFT_CHAIN_MAXNAMELEN);
+ if (c->flags & (1 << NFTNL_CHAIN_NAME))
+ xfree(c->name);
+
+ c->name = strdup(data);
+ if (!c->name)
+ return -1;
break;
case NFTNL_CHAIN_TABLE:
if (c->flags & (1 << NFTNL_CHAIN_TABLE))
@@ -528,8 +536,11 @@ int nftnl_chain_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_chain *c)
return -1;
if (tb[NFTA_CHAIN_NAME]) {
- strncpy(c->name, mnl_attr_get_str(tb[NFTA_CHAIN_NAME]),
- NFT_CHAIN_MAXNAMELEN);
+ if (c->flags & (1 << NFTNL_CHAIN_NAME))
+ xfree(c->name);
+ c->name = strdup(mnl_attr_get_str(tb[NFTA_CHAIN_NAME]));
+ if (!c->name)
+ return -1;
c->flags |= (1 << NFTNL_CHAIN_NAME);
}
if (tb[NFTA_CHAIN_TABLE]) {
--
2.1.4
^ permalink raw reply related [flat|nested] 9+ messages in thread
end of thread, other threads:[~2016-06-14 13:19 UTC | newest]
Thread overview: 9+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2016-06-14 13:18 [PATCH libnftnl 1/9] src: get rid of aliases Pablo Neira Ayuso
2016-06-14 13:18 ` [PATCH libnftnl 2/9] src: assert when setting unknown attributes Pablo Neira Ayuso
2016-06-14 13:18 ` [PATCH libnftnl 3/9] src: return value on setters that internally allocate memory Pablo Neira Ayuso
2016-06-14 13:18 ` [PATCH libnftnl 4/9] src: check for strdup() errors from setters and parsers Pablo Neira Ayuso
2016-06-14 13:18 ` [PATCH libnftnl 5/9] expr: data_reg: get rid of leftover perror() calls Pablo Neira Ayuso
2016-06-14 13:18 ` [PATCH libnftnl 6/9] src: simplify unsetters Pablo Neira Ayuso
2016-06-14 13:18 ` [PATCH libnftnl 7/9] src: check for flags before releasing attributes Pablo Neira Ayuso
2016-06-14 13:18 ` [PATCH libnftnl 8/9] tests: shuffle values that are injected Pablo Neira Ayuso
2016-06-14 13:18 ` [PATCH libnftnl 9/9] chain: dynamically allocate name Pablo Neira Ayuso
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.