src: get rid of aliases
Pablo Neira Ayuso
maintainerPATCH 1/9 src: get rid of aliases
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.
--- 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(-)
Make_global.am +1 -1
@@ -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}
doxygen.cfg.in +1 -1
@@ -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
include/libnftnl/batch.h +0 -16
@@ -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
include/libnftnl/chain.h +0 -77
83 lines not on this page · raw message
include/libnftnl/common.h +0 -53
57 lines not on this page · raw message
include/libnftnl/expr.h +0 -171
177 lines not on this page · raw message
include/libnftnl/gen.h +0 -36
@@ -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_hdrint 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
include/libnftnl/rule.h +0 -83
89 lines not on this page · raw message
include/libnftnl/ruleset.h +0 -61
67 lines not on this page · raw message
include/libnftnl/set.h +0 -136
140 lines not on this page · raw message
include/libnftnl/table.h +0 -65
71 lines not on this page · raw message
include/utils.h +0 -2
@@ -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__))
src/batch.c +7 -7
@@ -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);
src/chain.c +34 -34
256 lines not on this page · raw message
src/common.c +7 -7
@@ -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);
src/expr.c +16 -16
@@ -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);
src/gen.c +13 -13
@@ -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);
src/libnftnl.map +2 -263
296 lines not on this page · raw message
src/rule.c +37 -37
279 lines not on this page · raw message
src/ruleset.c +16 -16
@@ -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 *bufferreturn 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 *rreturn -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 typreturn 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);
src/set.c +32 -32
243 lines not on this page · raw message
src/set_elem.c +24 -24
183 lines not on this page · raw message
src/table.c +30 -30
226 lines not on this page · raw message
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 2/9 src: assert when setting unknown attributes
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.
--- 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(-)
include/utils.h +9 -0
@@ -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; \
src/chain.c +1 -3
@@ -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) {
src/gen.c +1 -3
@@ -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) {
src/rule.c +1 -3
@@ -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) {
src/set.c +1 -3
@@ -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) {
src/table.c +1 -3
@@ -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) {
src/utils.c +8 -0
@@ -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",
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 3/9 src: return value on setters that internally allocate memory
In reply to Pablo Neira AyusoSo 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.
--- 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(-)
include/libnftnl/chain.h +2 -2
@@ -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,
include/libnftnl/expr.h +2 -2
@@ -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_setvoid 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
include/libnftnl/gen.h +3 -3
@@ -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);
include/libnftnl/rule.h +4 -4
@@ -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,
include/libnftnl/set.h +6 -6
@@ -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);
include/libnftnl/table.h +3 -3
@@ -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);
src/chain.c +11 -4
@@ -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);
src/expr.c +7 -8
@@ -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);
src/gen.c +5 -4
@@ -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);
src/rule.c +12 -7
@@ -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);
src/set.c +11 -6
@@ -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);
src/set_elem.c +6 -7
@@ -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);
src/table.c +7 -4
@@ -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);
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 4/9 src: check for strdup() errors from setters and parsers
In reply to Pablo Neira AyusoAnd pass up an error to the caller.
--- 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(-)
src/chain.c +6 -0
@@ -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 ); }
src/expr/data_reg.c +3 -0
@@ -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 ;
src/expr/dynset.c +4 -0
@@ -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 ]) {
src/expr/immediate.c +2 -0
@@ -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 ;
src/expr/log.c +4 -0
@@ -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 ]) {
src/expr/lookup.c +4 -0
@@ -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 ]) {
src/rule.c +4 -0
@@ -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 ]) {
src/set.c +12 -2
@@ -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 ]) {
src/set_elem.c +13 -1
@@ -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 ]) {
src/table.c +2 -0
@@ -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 ]) {
src/trace.c +17 -7
@@ -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 );
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 5/9 expr: data_reg: get rid of leftover perror() calls
In reply to Pablo Neira AyusoLet the client of this library decide when to display error messages.
--- src/expr/data_reg.c | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-)
src/expr/data_reg.c +3 -6
@@ -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 ;
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 6/9 src: simplify unsetters
In reply to Pablo Neira AyusoIf the attribute is set as we already check at the beginning of this function, then we can release the object.
--- 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(-)
src/chain.c +3 -12
@@ -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 ;
src/rule.c +2 -8
@@ -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 :
src/ruleset.c +0 -4
@@ -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);
src/set.c +5 -10
@@ -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 :
src/set_elem.c +5 -10
@@ -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 ;
src/table.c +1 -4
@@ -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 :
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 7/9 src: check for flags before releasing attributes
In reply to Pablo Neira AyusoNow that unsetters don't set pointers to NULL, check if the attribute is set before trying to release it.
--- 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(-)
src/chain.c +10 -8
@@ -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 ;
src/expr/immediate.c +1 -1
@@ -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);
src/expr/log.c +1 -1
@@ -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);
src/expr/match.c +2 -2
@@ -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);
src/expr/target.c +1 -1
@@ -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;
src/rule.c +11 -9
@@ -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 ]);
src/set.c +8 -6
@@ -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 ;
src/set_elem.c +9 -11
@@ -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 *nestconst 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)
src/table.c +3 -2
@@ -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 ;
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 8/9 tests: shuffle values that are injected
In reply to Pablo Neira AyusoShuffle value that are used to set attributes, this variability should help us catch more problems in the future.
--- 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(-)
tests/nft-chain-test.c +5 -5
@@ -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" );
tests/nft-expr_bitwise-test.c +2 -2
@@ -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));
tests/nft-expr_cmp-test.c +1 -1
@@ -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);
tests/nft-expr_counter-test.c +1 -1
@@ -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 );
tests/nft-expr_ct-test.c +1 -1
@@ -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);
tests/nft-expr_exthdr-test.c +2 -2
@@ -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);
tests/nft-expr_immediate-test.c +5 -5
@@ -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);
tests/nft-expr_limit-test.c +2 -2
@@ -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);
tests/nft-expr_log-test.c +1 -1
@@ -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);
tests/nft-expr_lookup-test.c +1 -1
@@ -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));
tests/nft-expr_meta-test.c +1 -1
@@ -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);
tests/nft-expr_payload-test.c +3 -3
@@ -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);
tests/nft-expr_queue-test.c +3 -3
@@ -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);
tests/nft-expr_redir-test.c +3 -3
@@ -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);
tests/nft-expr_reject-test.c +2 -2
@@ -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);
tests/nft-expr_target-test.c +1 -1
@@ -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);
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 9/9 chain: dynamically allocate name
In reply to Pablo Neira AyusoJust 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.
--- src/chain.c | 23 +++++++++++++++++------ 1 file changed, 17 insertions(+), 6 deletions(-)
src/chain.c +17 -6
@@ -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 ]) {
Signature · 1 line
2.1.4