};
};
-int nftnl_data_reg_snprintf(char *buf, size_t size, union nftnl_data_reg *reg,
- uint32_t output_format, uint32_t flags, int reg_type);
+int nftnl_data_reg_snprintf(char *buf, size_t size,
+ const union nftnl_data_reg *reg,
+ uint32_t output_format, uint32_t flags,
+ int reg_type);
struct nlattr;
int nftnl_parse_data(union nftnl_data_reg *data, struct nlattr *attr, int *type);
-void nftnl_free_verdict(union nftnl_data_reg *data);
+void nftnl_free_verdict(const union nftnl_data_reg *data);
#endif
const char *name;
uint32_t alloc_len;
int max_attr;
- void (*free)(struct nftnl_expr *e);
+ void (*free)(const struct nftnl_expr *e);
int (*set)(struct nftnl_expr *e, uint16_t type, const void *data, uint32_t data_len);
const void *(*get)(const struct nftnl_expr *e, uint16_t type, uint32_t *data_len);
int (*parse)(struct nftnl_expr *e, struct nlattr *attr);
- void (*build)(struct nlmsghdr *nlh, struct nftnl_expr *e);
- int (*snprintf)(char *buf, size_t len, uint32_t type, uint32_t flags, struct nftnl_expr *e);
+ void (*build)(struct nlmsghdr *nlh, const struct nftnl_expr *e);
+ int (*snprintf)(char *buf, size_t len, uint32_t type, uint32_t flags, const struct nftnl_expr *e);
int (*xml_parse)(struct nftnl_expr *e, mxml_node_t *tree,
struct nftnl_parse_err *err);
int (*json_parse)(struct nftnl_expr *e, json_t *data,
struct nftnl_chain;
struct nftnl_chain *nftnl_chain_alloc(void);
-void nftnl_chain_free(struct nftnl_chain *);
+void nftnl_chain_free(const struct nftnl_chain *);
enum nftnl_chain_attr {
NFTNL_CHAIN_NAME = 0,
const char *data, struct nftnl_parse_err *err);
int nftnl_chain_parse_file(struct nftnl_chain *c, enum nftnl_parse_type type,
FILE *fp, struct nftnl_parse_err *err);
-int nftnl_chain_snprintf(char *buf, size_t size, struct nftnl_chain *t, uint32_t type, uint32_t flags);
-int nftnl_chain_fprintf(FILE *fp, struct nftnl_chain *c, uint32_t type, uint32_t flags);
+int nftnl_chain_snprintf(char *buf, size_t size, const struct nftnl_chain *t, uint32_t type, uint32_t flags);
+int nftnl_chain_fprintf(FILE *fp, const struct nftnl_chain *c, uint32_t type, uint32_t flags);
#define nftnl_chain_nlmsg_build_hdr nftnl_nlmsg_build_hdr
int nftnl_chain_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_chain *t);
struct nftnl_chain_list *nftnl_chain_list_alloc(void);
void nftnl_chain_list_free(struct nftnl_chain_list *list);
-int nftnl_chain_list_is_empty(struct nftnl_chain_list *list);
+int nftnl_chain_list_is_empty(const struct nftnl_chain_list *list);
int nftnl_chain_list_foreach(struct nftnl_chain_list *chain_list, int (*cb)(struct nftnl_chain *t, void *data), void *data);
void nftnl_chain_list_add(struct nftnl_chain *r, struct nftnl_chain_list *list);
};
struct nftnl_expr *nftnl_expr_alloc(const char *name);
-void nftnl_expr_free(struct nftnl_expr *expr);
+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);
uint64_t nftnl_expr_get_u64(const struct nftnl_expr *expr, uint16_t type);
const char *nftnl_expr_get_str(const struct nftnl_expr *expr, uint16_t type);
-int nftnl_expr_snprintf(char *buf, size_t buflen, struct nftnl_expr *expr, uint32_t type, uint32_t flags);
+int nftnl_expr_snprintf(char *buf, size_t buflen, const struct nftnl_expr *expr, uint32_t type, uint32_t flags);
enum {
NFTNL_EXPR_PAYLOAD_DREG = NFTNL_EXPR_BASE,
struct nftnl_gen;
struct nftnl_gen *nftnl_gen_alloc(void);
-void nftnl_gen_free(struct nftnl_gen *);
+void nftnl_gen_free(const struct nftnl_gen *);
enum {
NFTNL_GEN_ID = 0,
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);
-const void *nftnl_gen_get(struct nftnl_gen *gen, uint16_t attr);
-const void *nftnl_gen_get_data(struct nftnl_gen *gen, uint16_t attr,
- 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);
void nftnl_gen_set_u32(struct nftnl_gen *gen, uint16_t attr, uint32_t data);
-uint32_t nftnl_gen_get_u32(struct nftnl_gen *gen, uint16_t attr);
+uint32_t nftnl_gen_get_u32(const struct nftnl_gen *gen, uint16_t attr);
struct nlmsghdr;
int nftnl_gen_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_gen *gen);
-int nftnl_gen_snprintf(char *buf, size_t size, struct nftnl_gen *gen, uint32_t type, uint32_t flags);
-int nftnl_gen_fprintf(FILE *fp, struct nftnl_gen *gen, uint32_t type, uint32_t flags);
+int nftnl_gen_snprintf(char *buf, size_t size, const struct nftnl_gen *gen, uint32_t type, uint32_t flags);
+int nftnl_gen_fprintf(FILE *fp, const struct nftnl_gen *gen, uint32_t type, uint32_t flags);
#define nftnl_gen_nlmsg_build_hdr nftnl_nlmsg_build_hdr
int nftnl_gen_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_gen *gen);
struct nftnl_expr;
struct nftnl_rule *nftnl_rule_alloc(void);
-void nftnl_rule_free(struct nftnl_rule *);
+void nftnl_rule_free(const struct nftnl_rule *);
enum nftnl_rule_attr {
NFTNL_RULE_FAMILY = 0,
const char *data, struct nftnl_parse_err *err);
int nftnl_rule_parse_file(struct nftnl_rule *r, enum nftnl_parse_type type,
FILE *fp, struct nftnl_parse_err *err);
-int nftnl_rule_snprintf(char *buf, size_t size, struct nftnl_rule *t, uint32_t type, uint32_t flags);
-int nftnl_rule_fprintf(FILE *fp, struct nftnl_rule *r, uint32_t type, uint32_t flags);
+int nftnl_rule_snprintf(char *buf, size_t size, const struct nftnl_rule *t, uint32_t type, uint32_t flags);
+int nftnl_rule_fprintf(FILE *fp, const struct nftnl_rule *r, uint32_t type, uint32_t flags);
#define nftnl_rule_nlmsg_build_hdr nftnl_nlmsg_build_hdr
int nftnl_rule_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_rule *t);
struct nftnl_rule_list *nftnl_rule_list_alloc(void);
void nftnl_rule_list_free(struct nftnl_rule_list *list);
-int nftnl_rule_list_is_empty(struct nftnl_rule_list *list);
+int nftnl_rule_list_is_empty(const struct nftnl_rule_list *list);
void nftnl_rule_list_add(struct nftnl_rule *r, struct nftnl_rule_list *list);
void nftnl_rule_list_add_tail(struct nftnl_rule *r, struct nftnl_rule_list *list);
void nftnl_rule_list_del(struct nftnl_rule *r);
struct nftnl_rule_list_iter *nftnl_rule_list_iter_create(struct nftnl_rule_list *l);
struct nftnl_rule *nftnl_rule_list_iter_cur(struct nftnl_rule_list_iter *iter);
struct nftnl_rule *nftnl_rule_list_iter_next(struct nftnl_rule_list_iter *iter);
-void nftnl_rule_list_iter_destroy(struct nftnl_rule_list_iter *iter);
+void nftnl_rule_list_iter_destroy(const struct nftnl_rule_list_iter *iter);
/*
* Compat
struct nftnl_ruleset;
struct nftnl_ruleset *nftnl_ruleset_alloc(void);
-void nftnl_ruleset_free(struct nftnl_ruleset *r);
+void nftnl_ruleset_free(const struct nftnl_ruleset *r);
enum {
NFTNL_RULESET_TABLELIST = 0,
struct nftnl_set;
struct nftnl_set *nftnl_set_alloc(void);
-void nftnl_set_free(struct nftnl_set *s);
+void nftnl_set_free(const struct nftnl_set *s);
struct nftnl_set *nftnl_set_clone(const struct nftnl_set *set);
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);
-const void *nftnl_set_get(struct nftnl_set *s, uint16_t attr);
-const void *nftnl_set_get_data(struct nftnl_set *s, uint16_t attr,
- uint32_t *data_len);
-const char *nftnl_set_get_str(struct nftnl_set *s, uint16_t attr);
-uint32_t nftnl_set_get_u32(struct nftnl_set *s, uint16_t attr);
-uint64_t nftnl_set_get_u64(struct nftnl_set *s, uint16_t attr);
+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,
+ uint32_t *data_len);
+const char *nftnl_set_get_str(const struct nftnl_set *s, uint16_t attr);
+uint32_t nftnl_set_get_u32(const struct nftnl_set *s, uint16_t attr);
+uint64_t nftnl_set_get_u64(const struct nftnl_set *s, uint16_t attr);
struct nlmsghdr;
int nftnl_set_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_set *s);
int nftnl_set_elems_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_set *s);
-int nftnl_set_snprintf(char *buf, size_t size, struct nftnl_set *s, uint32_t type, uint32_t flags);
-int nftnl_set_fprintf(FILE *fp, struct nftnl_set *s, uint32_t type, uint32_t flags);
+int nftnl_set_snprintf(char *buf, size_t size, const struct nftnl_set *s, uint32_t type, uint32_t flags);
+int nftnl_set_fprintf(FILE *fp, const struct nftnl_set *s, uint32_t type, uint32_t flags);
struct nftnl_set_list;
struct nftnl_set_list *nftnl_set_list_alloc(void);
void nftnl_set_list_free(struct nftnl_set_list *list);
-int nftnl_set_list_is_empty(struct nftnl_set_list *list);
+int nftnl_set_list_is_empty(const struct nftnl_set_list *list);
void nftnl_set_list_add(struct nftnl_set *s, struct nftnl_set_list *list);
void nftnl_set_list_add_tail(struct nftnl_set *s, struct nftnl_set_list *list);
void nftnl_set_list_del(struct nftnl_set *s);
struct nftnl_set_list_iter *nftnl_set_list_iter_create(struct nftnl_set_list *l);
struct nftnl_set *nftnl_set_list_iter_cur(struct nftnl_set_list_iter *iter);
struct nftnl_set *nftnl_set_list_iter_next(struct nftnl_set_list_iter *iter);
-void nftnl_set_list_iter_destroy(struct nftnl_set_list_iter *iter);
+void nftnl_set_list_iter_destroy(const struct nftnl_set_list_iter *iter);
int nftnl_set_parse(struct nftnl_set *s, enum nftnl_parse_type type,
const char *data, struct nftnl_parse_err *err);
const char *data, struct nftnl_parse_err *err);
int nftnl_set_elem_parse_file(struct nftnl_set_elem *e, enum nftnl_parse_type type,
FILE *fp, struct nftnl_parse_err *err);
-int nftnl_set_elem_snprintf(char *buf, size_t size, struct nftnl_set_elem *s, uint32_t type, uint32_t flags);
+int nftnl_set_elem_snprintf(char *buf, size_t size, const struct nftnl_set_elem *s, uint32_t type, uint32_t flags);
int nftnl_set_elem_fprintf(FILE *fp, struct nftnl_set_elem *se, uint32_t type, uint32_t flags);
int nftnl_set_elem_foreach(struct nftnl_set *s, int (*cb)(struct nftnl_set_elem *e, void *data), void *data);
struct nftnl_table;
struct nftnl_table *nftnl_table_alloc(void);
-void nftnl_table_free(struct nftnl_table *);
+void nftnl_table_free(const struct nftnl_table *);
enum nftnl_table_attr {
NFTNL_TABLE_NAME = 0,
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);
-const void *nftnl_table_get(struct nftnl_table *t, uint16_t attr);
-const void *nftnl_table_get_data(struct nftnl_table *t, uint16_t attr,
- 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);
-uint8_t nftnl_table_get_u8(struct nftnl_table *t, uint16_t attr);
-uint32_t nftnl_table_get_u32(struct nftnl_table *t, uint16_t attr);
-const char *nftnl_table_get_str(struct nftnl_table *t, uint16_t attr);
+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);
struct nlmsghdr;
const char *data, struct nftnl_parse_err *err);
int nftnl_table_parse_file(struct nftnl_table *t, enum nftnl_parse_type type,
FILE *fp, struct nftnl_parse_err *err);
-int nftnl_table_snprintf(char *buf, size_t size, struct nftnl_table *t, uint32_t type, uint32_t flags);
-int nftnl_table_fprintf(FILE *fp, struct nftnl_table *t, uint32_t type, uint32_t flags);
+int nftnl_table_snprintf(char *buf, size_t size, const struct nftnl_table *t, uint32_t type, uint32_t flags);
+int nftnl_table_fprintf(FILE *fp, const struct nftnl_table *t, uint32_t type, uint32_t flags);
#define nftnl_table_nlmsg_build_hdr nftnl_nlmsg_build_hdr
int nftnl_table_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_table *t);
struct nftnl_table_list *nftnl_table_list_alloc(void);
void nftnl_table_list_free(struct nftnl_table_list *list);
-int nftnl_table_list_is_empty(struct nftnl_table_list *list);
+int nftnl_table_list_is_empty(const struct nftnl_table_list *list);
int nftnl_table_list_foreach(struct nftnl_table_list *table_list, int (*cb)(struct nftnl_table *t, void *data), void *data);
void nftnl_table_list_add(struct nftnl_table *r, struct nftnl_table_list *list);
struct nftnl_table_list_iter *nftnl_table_list_iter_create(struct nftnl_table_list *l);
struct nftnl_table *nftnl_table_list_iter_next(struct nftnl_table_list_iter *iter);
-void nftnl_table_list_iter_destroy(struct nftnl_table_list_iter *iter);
+void nftnl_table_list_iter_destroy(const struct nftnl_table_list_iter *iter);
/*
* Compat
struct nftnl_trace;
struct nftnl_trace *nftnl_trace_alloc(void);
-void nftnl_trace_free(struct nftnl_trace *trace);
+void nftnl_trace_free(const struct nftnl_trace *trace);
bool nftnl_trace_is_set(const struct nftnl_trace *trace, uint16_t type);
/* nftnl_udata_buf */
struct nftnl_udata_buf *nftnl_udata_buf_alloc(uint32_t data_size);
-void nftnl_udata_buf_free(struct nftnl_udata_buf *buf);
+void nftnl_udata_buf_free(const struct nftnl_udata_buf *buf);
uint32_t nftnl_udata_buf_len(const struct nftnl_udata_buf *buf);
void *nftnl_udata_buf_data(const struct nftnl_udata_buf *buf);
void nftnl_udata_buf_put(struct nftnl_udata_buf *buf, const void *data,
enum nftnl_cmd_type nftnl_flag2cmd(uint32_t flags);
-int nftnl_fprintf(FILE *fp, void *obj, uint32_t cmd, uint32_t type,
- uint32_t flags, int (*snprintf_cb)(char *buf, size_t bufsiz,
- void *obj, uint32_t cmd, uint32_t type, uint32_t flags));
+int nftnl_fprintf(FILE *fpconst, const void *obj, uint32_t cmd, uint32_t type,
+ uint32_t flags,
+ int (*snprintf_cb)(char *buf, size_t bufsiz, const void *obj,
+ uint32_t cmd, uint32_t type,
+ uint32_t flags));
#endif
}
EXPORT_SYMBOL_ALIAS(nftnl_chain_alloc, nft_chain_alloc);
-void nftnl_chain_free(struct nftnl_chain *c)
+void nftnl_chain_free(const struct nftnl_chain *c)
{
if (c->table != NULL)
xfree(c->table);
}
EXPORT_SYMBOL_ALIAS(nftnl_chain_parse_file, nft_chain_parse_file);
-static int nftnl_chain_export(char *buf, size_t size, struct nftnl_chain *c,
- int type)
+static int nftnl_chain_export(char *buf, size_t size,
+ const struct nftnl_chain *c, int type)
{
NFTNL_BUF_INIT(b, buf, size);
}
static int nftnl_chain_snprintf_default(char *buf, size_t size,
- struct nftnl_chain *c)
+ const struct nftnl_chain *c)
{
int ret, len = size, offset = 0;
return offset;
}
-static int nftnl_chain_cmd_snprintf(char *buf, size_t size, struct nftnl_chain *c,
- uint32_t cmd, uint32_t type, uint32_t flags)
+static int nftnl_chain_cmd_snprintf(char *buf, size_t size,
+ const struct nftnl_chain *c, uint32_t cmd,
+ uint32_t type, uint32_t flags)
{
int ret, len = size, offset = 0;
return offset;
}
-int nftnl_chain_snprintf(char *buf, size_t size, struct nftnl_chain *c,
- uint32_t type, uint32_t flags)
+int nftnl_chain_snprintf(char *buf, size_t size, const struct nftnl_chain *c,
+ uint32_t type, uint32_t flags)
{
return nftnl_chain_cmd_snprintf(buf, size, c, nftnl_flag2cmd(flags), type,
flags);
}
EXPORT_SYMBOL_ALIAS(nftnl_chain_snprintf, nft_chain_snprintf);
-static inline int nftnl_chain_do_snprintf(char *buf, size_t size, void *c,
- uint32_t cmd, uint32_t type,
- uint32_t flags)
+static inline int nftnl_chain_do_snprintf(char *buf, size_t size, const void *c,
+ uint32_t cmd, uint32_t type,
+ uint32_t flags)
{
return nftnl_chain_snprintf(buf, size, c, type, flags);
}
-int nftnl_chain_fprintf(FILE *fp, struct nftnl_chain *c, uint32_t type,
- uint32_t flags)
+int nftnl_chain_fprintf(FILE *fp, const struct nftnl_chain *c, uint32_t type,
+ uint32_t flags)
{
return nftnl_fprintf(fp, c, NFTNL_CMD_UNSPEC, type, flags,
nftnl_chain_do_snprintf);
}
EXPORT_SYMBOL_ALIAS(nftnl_chain_list_free, nft_chain_list_free);
-int nftnl_chain_list_is_empty(struct nftnl_chain_list *list)
+int nftnl_chain_list_is_empty(const struct nftnl_chain_list *list)
{
return list_empty(&list->list);
}
return nftnl_buf_done(&b);
}
-static int nftnl_cmd_header_fprintf_cb(char *buf, size_t size, void *obj,
- uint32_t cmd, uint32_t type,
- uint32_t flags)
+static int nftnl_cmd_header_fprintf_cb(char *buf, size_t size, const void *obj,
+ uint32_t cmd, uint32_t type,
+ uint32_t flags)
{
return nftnl_cmd_header_snprintf(buf, size, cmd, type, flags);
}
return nftnl_buf_done(&b);
}
-static int nftnl_cmd_footer_fprintf_cb(char *buf, size_t size, void *obj,
- uint32_t cmd, uint32_t type,
- uint32_t flags)
+static int nftnl_cmd_footer_fprintf_cb(char *buf, size_t size, const void *obj,
+ uint32_t cmd, uint32_t type,
+ uint32_t flags)
{
return nftnl_cmd_footer_snprintf(buf, size, cmd, type, flags);
}
}
EXPORT_SYMBOL_ALIAS(nftnl_expr_alloc, nft_rule_expr_alloc);
-void nftnl_expr_free(struct nftnl_expr *expr)
+void nftnl_expr_free(const struct nftnl_expr *expr)
{
if (expr->ops->free)
expr->ops->free(expr);
return NULL;
}
-int nftnl_expr_snprintf(char *buf, size_t size, struct nftnl_expr *expr,
- uint32_t type, uint32_t flags)
+int nftnl_expr_snprintf(char *buf, size_t size, const struct nftnl_expr *expr,
+ uint32_t type, uint32_t flags)
{
int ret;
unsigned int offset = 0, len = size;
}
static void
-nftnl_expr_bitwise_build(struct nlmsghdr *nlh, struct nftnl_expr *e)
+nftnl_expr_bitwise_build(struct nlmsghdr *nlh, const struct nftnl_expr *e)
{
struct nftnl_expr_bitwise *bitwise = nftnl_expr_data(e);
}
static int nftnl_expr_bitwise_export(char *buf, size_t size,
- struct nftnl_expr *e, int type)
+ const struct nftnl_expr *e, int type)
{
struct nftnl_expr_bitwise *bitwise = nftnl_expr_data(e);
NFTNL_BUF_INIT(b, buf, size);
}
static int nftnl_expr_bitwise_snprintf_default(char *buf, size_t size,
- struct nftnl_expr *e)
+ const struct nftnl_expr *e)
{
struct nftnl_expr_bitwise *bitwise = nftnl_expr_data(e);
int len = size, offset = 0, ret;
static int
nftnl_expr_bitwise_snprintf(char *buf, size_t size, uint32_t type,
- uint32_t flags, struct nftnl_expr *e)
+ uint32_t flags, const struct nftnl_expr *e)
{
switch (type) {
case NFTNL_OUTPUT_DEFAULT:
}
static void
-nftnl_expr_byteorder_build(struct nlmsghdr *nlh, struct nftnl_expr *e)
+nftnl_expr_byteorder_build(struct nlmsghdr *nlh, const struct nftnl_expr *e)
{
struct nftnl_expr_byteorder *byteorder = nftnl_expr_data(e);
}
static int nftnl_expr_byteorder_export(char *buf, size_t size,
- struct nftnl_expr *e, int type)
+ const struct nftnl_expr *e, int type)
{
struct nftnl_expr_byteorder *byteorder = nftnl_expr_data(e);
NFTNL_BUF_INIT(b, buf, size);
}
static int nftnl_expr_byteorder_snprintf_default(char *buf, size_t size,
- struct nftnl_expr *e)
+ const struct nftnl_expr *e)
{
struct nftnl_expr_byteorder *byteorder = nftnl_expr_data(e);
int len = size, offset = 0, ret;
static int
nftnl_expr_byteorder_snprintf(char *buf, size_t size, uint32_t type,
- uint32_t flags, struct nftnl_expr *e)
+ uint32_t flags, const struct nftnl_expr *e)
{
switch (type) {
case NFTNL_OUTPUT_DEFAULT:
}
static void
-nftnl_expr_cmp_build(struct nlmsghdr *nlh, struct nftnl_expr *e)
+nftnl_expr_cmp_build(struct nlmsghdr *nlh, const struct nftnl_expr *e)
{
struct nftnl_expr_cmp *cmp = nftnl_expr_data(e);
}
static int nftnl_expr_cmp_export(char *buf, size_t size,
- struct nftnl_expr *e, int type)
+ const struct nftnl_expr *e, int type)
{
struct nftnl_expr_cmp *cmp = nftnl_expr_data(e);
NFTNL_BUF_INIT(b, buf, size);
}
static int nftnl_expr_cmp_snprintf_default(char *buf, size_t size,
- struct nftnl_expr *e)
+ const struct nftnl_expr *e)
{
struct nftnl_expr_cmp *cmp = nftnl_expr_data(e);
int len = size, offset = 0, ret;
static int
nftnl_expr_cmp_snprintf(char *buf, size_t size, uint32_t type,
- uint32_t flags, struct nftnl_expr *e)
+ uint32_t flags, const struct nftnl_expr *e)
{
switch (type) {
case NFTNL_OUTPUT_DEFAULT:
}
static void
-nftnl_expr_counter_build(struct nlmsghdr *nlh, struct nftnl_expr *e)
+nftnl_expr_counter_build(struct nlmsghdr *nlh, const struct nftnl_expr *e)
{
struct nftnl_expr_counter *ctr = nftnl_expr_data(e);
}
static int nftnl_expr_counter_export(char *buf, size_t size,
- struct nftnl_expr *e, int type)
+ const struct nftnl_expr *e, int type)
{
struct nftnl_expr_counter *ctr = nftnl_expr_data(e);
NFTNL_BUF_INIT(b, buf, size);
}
static int nftnl_expr_counter_snprintf_default(char *buf, size_t len,
- struct nftnl_expr *e)
+ const struct nftnl_expr *e)
{
struct nftnl_expr_counter *ctr = nftnl_expr_data(e);
}
static int nftnl_expr_counter_snprintf(char *buf, size_t len, uint32_t type,
- uint32_t flags,
- struct nftnl_expr *e)
+ uint32_t flags,
+ const struct nftnl_expr *e)
{
switch (type) {
case NFTNL_OUTPUT_DEFAULT:
}
static void
-nftnl_expr_ct_build(struct nlmsghdr *nlh, struct nftnl_expr *e)
+nftnl_expr_ct_build(struct nlmsghdr *nlh, const struct nftnl_expr *e)
{
struct nftnl_expr_ct *ct = nftnl_expr_data(e);
}
static int
-nftnl_expr_ct_export(char *buf, size_t size, struct nftnl_expr *e, int type)
+nftnl_expr_ct_export(char *buf, size_t size, const struct nftnl_expr *e,
+ int type)
{
struct nftnl_expr_ct *ct = nftnl_expr_data(e);
NFTNL_BUF_INIT(b, buf, size);
}
static int
-nftnl_expr_ct_snprintf_default(char *buf, size_t size, struct nftnl_expr *e)
+nftnl_expr_ct_snprintf_default(char *buf, size_t size,
+ const struct nftnl_expr *e)
{
int ret, len = size, offset = 0;
struct nftnl_expr_ct *ct = nftnl_expr_data(e);
static int
nftnl_expr_ct_snprintf(char *buf, size_t len, uint32_t type,
- uint32_t flags, struct nftnl_expr *e)
+ uint32_t flags, const struct nftnl_expr *e)
{
switch (type) {
case NFTNL_OUTPUT_DEFAULT:
static int
nftnl_data_reg_value_snprintf_json(char *buf, size_t size,
- union nftnl_data_reg *reg,
- uint32_t flags)
+ const union nftnl_data_reg *reg,
+ uint32_t flags)
{
int len = size, offset = 0, ret, i, j;
uint32_t utemp;
static
int nftnl_data_reg_value_snprintf_xml(char *buf, size_t size,
- union nftnl_data_reg *reg, uint32_t flags)
+ const union nftnl_data_reg *reg,
+ uint32_t flags)
{
int len = size, offset = 0, ret, i, j;
uint32_t be;
static int
nftnl_data_reg_value_snprintf_default(char *buf, size_t size,
- union nftnl_data_reg *reg, uint32_t flags)
+ const union nftnl_data_reg *reg,
+ uint32_t flags)
{
int len = size, offset = 0, ret, i;
static int
nftnl_data_reg_verdict_snprintf_def(char *buf, size_t size,
- union nftnl_data_reg *reg, uint32_t flags)
+ const union nftnl_data_reg *reg,
+ uint32_t flags)
{
int len = size, offset = 0, ret = 0;
static int
nftnl_data_reg_verdict_snprintf_xml(char *buf, size_t size,
- union nftnl_data_reg *reg, uint32_t flags)
+ const union nftnl_data_reg *reg,
+ uint32_t flags)
{
int len = size, offset = 0, ret = 0;
static int
nftnl_data_reg_verdict_snprintf_json(char *buf, size_t size,
- union nftnl_data_reg *reg, uint32_t flags)
+ const union nftnl_data_reg *reg,
+ uint32_t flags)
{
int len = size, offset = 0, ret = 0;
return offset;
}
-int nftnl_data_reg_snprintf(char *buf, size_t size, union nftnl_data_reg *reg,
- uint32_t output_format, uint32_t flags, int reg_type)
+int nftnl_data_reg_snprintf(char *buf, size_t size,
+ const union nftnl_data_reg *reg,
+ uint32_t output_format, uint32_t flags,
+ int reg_type)
{
switch(reg_type) {
case DATA_VALUE:
return ret;
}
-void nftnl_free_verdict(union nftnl_data_reg *data)
+void nftnl_free_verdict(const union nftnl_data_reg *data)
{
switch(data->verdict) {
case NFT_JUMP:
return MNL_CB_OK;
}
-static void nftnl_expr_dup_build(struct nlmsghdr *nlh, struct nftnl_expr *e)
+static void nftnl_expr_dup_build(struct nlmsghdr *nlh,
+ const struct nftnl_expr *e)
{
struct nftnl_expr_dup *dup = nftnl_expr_data(e);
#endif
}
-static int nftnl_expr_dup_export(char *buf, size_t size, struct nftnl_expr *e,
- int type)
+static int nftnl_expr_dup_export(char *buf, size_t size,
+ const struct nftnl_expr *e, int type)
{
struct nftnl_expr_dup *dup = nftnl_expr_data(e);
NFTNL_BUF_INIT(b, buf, size);
}
static int nftnl_expr_dup_snprintf_default(char *buf, size_t len,
- struct nftnl_expr *e, uint32_t flags)
+ const struct nftnl_expr *e,
+ uint32_t flags)
{
int size = len, offset = 0, ret;
struct nftnl_expr_dup *dup = nftnl_expr_data(e);
}
static int nftnl_expr_dup_snprintf(char *buf, size_t len, uint32_t type,
- uint32_t flags, struct nftnl_expr *e)
+ uint32_t flags, const struct nftnl_expr *e)
{
switch (type) {
case NFTNL_OUTPUT_DEFAULT:
}
static void
-nftnl_expr_dynset_build(struct nlmsghdr *nlh, struct nftnl_expr *e)
+nftnl_expr_dynset_build(struct nlmsghdr *nlh, const struct nftnl_expr *e)
{
struct nftnl_expr_dynset *dynset = nftnl_expr_data(e);
struct nlattr *nest;
static int
nftnl_expr_dynset_export(char *buf, size_t size,
- struct nftnl_expr *e, int type)
+ const struct nftnl_expr *e, int type)
{
struct nftnl_expr_dynset *dynset = nftnl_expr_data(e);
NFTNL_BUF_INIT(b, buf, size);
static int
nftnl_expr_dynset_snprintf_default(char *buf, size_t size,
- struct nftnl_expr *e)
+ const struct nftnl_expr *e)
{
struct nftnl_expr_dynset *dynset = nftnl_expr_data(e);
struct nftnl_expr *expr;
static int
nftnl_expr_dynset_snprintf(char *buf, size_t size, uint32_t type,
- uint32_t flags, struct nftnl_expr *e)
+ uint32_t flags, const struct nftnl_expr *e)
{
switch (type) {
return -1;
}
-static void nftnl_expr_dynset_free(struct nftnl_expr *e)
+static void nftnl_expr_dynset_free(const struct nftnl_expr *e)
{
struct nftnl_expr_dynset *dynset = nftnl_expr_data(e);
}
static void
-nftnl_expr_exthdr_build(struct nlmsghdr *nlh, struct nftnl_expr *e)
+nftnl_expr_exthdr_build(struct nlmsghdr *nlh, const struct nftnl_expr *e)
{
struct nftnl_expr_exthdr *exthdr = nftnl_expr_data(e);
}
static int nftnl_expr_exthdr_export(char *buf, size_t len,
- struct nftnl_expr *e, int type)
+ const struct nftnl_expr *e, int type)
{
struct nftnl_expr_exthdr *exthdr = nftnl_expr_data(e);
NFTNL_BUF_INIT(b, buf, len);
}
static int nftnl_expr_exthdr_snprintf_default(char *buf, size_t len,
- struct nftnl_expr *e)
+ const struct nftnl_expr *e)
{
struct nftnl_expr_exthdr *exthdr = nftnl_expr_data(e);
static int
nftnl_expr_exthdr_snprintf(char *buf, size_t len, uint32_t type,
- uint32_t flags, struct nftnl_expr *e)
+ uint32_t flags, const struct nftnl_expr *e)
{
switch (type) {
case NFTNL_OUTPUT_DEFAULT:
return MNL_CB_OK;
}
-static void nftnl_expr_fwd_build(struct nlmsghdr *nlh, struct nftnl_expr *e)
+static void nftnl_expr_fwd_build(struct nlmsghdr *nlh,
+ const struct nftnl_expr *e)
{
struct nftnl_expr_fwd *fwd = nftnl_expr_data(e);
#endif
}
-static int nftnl_expr_fwd_export(char *buf, size_t size, struct nftnl_expr *e,
- int type)
+static int nftnl_expr_fwd_export(char *buf, size_t size,
+ const struct nftnl_expr *e, int type)
{
struct nftnl_expr_fwd *fwd = nftnl_expr_data(e);
NFTNL_BUF_INIT(b, buf, size);
}
static int nftnl_expr_fwd_snprintf_default(char *buf, size_t len,
- struct nftnl_expr *e, uint32_t flags)
+ const struct nftnl_expr *e,
+ uint32_t flags)
{
int size = len, offset = 0, ret;
struct nftnl_expr_fwd *fwd = nftnl_expr_data(e);
}
static int nftnl_expr_fwd_snprintf(char *buf, size_t len, uint32_t type,
- uint32_t flags, struct nftnl_expr *e)
+ uint32_t flags, const struct nftnl_expr *e)
{
switch (type) {
case NFTNL_OUTPUT_DEFAULT:
}
static void
-nftnl_expr_immediate_build(struct nlmsghdr *nlh, struct nftnl_expr *e)
+nftnl_expr_immediate_build(struct nlmsghdr *nlh, const struct nftnl_expr *e)
{
struct nftnl_expr_immediate *imm = nftnl_expr_data(e);
}
static int
-nftnl_expr_immediate_export(char *buf, size_t size, struct nftnl_expr *e,
- int type)
+nftnl_expr_immediate_export(char *buf, size_t size, const struct nftnl_expr *e,
+ int type)
{
struct nftnl_expr_immediate *imm = nftnl_expr_data(e);
NFTNL_BUF_INIT(b, buf, size);
static int
nftnl_expr_immediate_snprintf_default(char *buf, size_t len,
- struct nftnl_expr *e, uint32_t flags)
+ const struct nftnl_expr *e,
+ uint32_t flags)
{
int size = len, offset = 0, ret;
struct nftnl_expr_immediate *imm = nftnl_expr_data(e);
static int
nftnl_expr_immediate_snprintf(char *buf, size_t len, uint32_t type,
- uint32_t flags, struct nftnl_expr *e)
+ uint32_t flags, const struct nftnl_expr *e)
{
switch(type) {
case NFTNL_OUTPUT_DEFAULT:
return -1;
}
-static void nftnl_expr_immediate_free(struct nftnl_expr *e)
+static void nftnl_expr_immediate_free(const struct nftnl_expr *e)
{
struct nftnl_expr_immediate *imm = nftnl_expr_data(e);
}
static void
-nftnl_expr_limit_build(struct nlmsghdr *nlh, struct nftnl_expr *e)
+nftnl_expr_limit_build(struct nlmsghdr *nlh, const struct nftnl_expr *e)
{
struct nftnl_expr_limit *limit = nftnl_expr_data(e);
}
static int nftnl_expr_limit_export(char *buf, size_t size,
- struct nftnl_expr *e, int type)
+ const struct nftnl_expr *e, int type)
{
struct nftnl_expr_limit *limit = nftnl_expr_data(e);
NFTNL_BUF_INIT(b, buf, size);
}
static int nftnl_expr_limit_snprintf_default(char *buf, size_t len,
- struct nftnl_expr *e)
+ const struct nftnl_expr *e)
{
struct nftnl_expr_limit *limit = nftnl_expr_data(e);
static int
nftnl_expr_limit_snprintf(char *buf, size_t len, uint32_t type,
- uint32_t flags, struct nftnl_expr *e)
+ uint32_t flags, const struct nftnl_expr *e)
{
switch(type) {
case NFTNL_OUTPUT_DEFAULT:
}
static void
-nftnl_expr_log_build(struct nlmsghdr *nlh, struct nftnl_expr *e)
+nftnl_expr_log_build(struct nlmsghdr *nlh, const struct nftnl_expr *e)
{
struct nftnl_expr_log *log = nftnl_expr_data(e);
}
static int nftnl_expr_log_snprintf_default(char *buf, size_t size,
- struct nftnl_expr *e)
+ const struct nftnl_expr *e)
{
struct nftnl_expr_log *log = nftnl_expr_data(e);
int ret, offset = 0, len = size;
}
static int nftnl_expr_log_export(char *buf, size_t size,
- struct nftnl_expr *e, int type)
+ const struct nftnl_expr *e, int type)
{
struct nftnl_expr_log *log = nftnl_expr_data(e);
NFTNL_BUF_INIT(b, buf, size);
static int
nftnl_expr_log_snprintf(char *buf, size_t len, uint32_t type,
- uint32_t flags, struct nftnl_expr *e)
+ uint32_t flags, const struct nftnl_expr *e)
{
switch(type) {
case NFTNL_OUTPUT_DEFAULT:
return -1;
}
-static void nftnl_expr_log_free(struct nftnl_expr *e)
+static void nftnl_expr_log_free(const struct nftnl_expr *e)
{
struct nftnl_expr_log *log = nftnl_expr_data(e);
}
static void
-nftnl_expr_lookup_build(struct nlmsghdr *nlh, struct nftnl_expr *e)
+nftnl_expr_lookup_build(struct nlmsghdr *nlh, const struct nftnl_expr *e)
{
struct nftnl_expr_lookup *lookup = nftnl_expr_data(e);
static int
nftnl_expr_lookup_export(char *buf, size_t size,
- struct nftnl_expr *e, int type)
+ const struct nftnl_expr *e, int type)
{
struct nftnl_expr_lookup *l = nftnl_expr_data(e);
NFTNL_BUF_INIT(b, buf, size);
static int
nftnl_expr_lookup_snprintf_default(char *buf, size_t size,
- struct nftnl_expr *e)
+ const struct nftnl_expr *e)
{
int len = size, offset = 0, ret;
struct nftnl_expr_lookup *l = nftnl_expr_data(e);
static int
nftnl_expr_lookup_snprintf(char *buf, size_t size, uint32_t type,
- uint32_t flags, struct nftnl_expr *e)
+ uint32_t flags, const struct nftnl_expr *e)
{
switch(type) {
return -1;
}
-static void nftnl_expr_lookup_free(struct nftnl_expr *e)
+static void nftnl_expr_lookup_free(const struct nftnl_expr *e)
{
struct nftnl_expr_lookup *lookup = nftnl_expr_data(e);
}
static void
-nftnl_expr_masq_build(struct nlmsghdr *nlh, struct nftnl_expr *e)
+nftnl_expr_masq_build(struct nlmsghdr *nlh, const struct nftnl_expr *e)
{
struct nftnl_expr_masq *masq = nftnl_expr_data(e);
#endif
}
static int nftnl_expr_masq_export(char *buf, size_t size,
- struct nftnl_expr *e, int type)
+ const struct nftnl_expr *e, int type)
{
struct nftnl_expr_masq *masq = nftnl_expr_data(e);
NFTNL_BUF_INIT(b, buf, size);
}
static int nftnl_expr_masq_snprintf_default(char *buf, size_t len,
- struct nftnl_expr *e)
+ const struct nftnl_expr *e)
{
struct nftnl_expr_masq *masq = nftnl_expr_data(e);
}
static int nftnl_expr_masq_snprintf(char *buf, size_t len, uint32_t type,
- uint32_t flags, struct nftnl_expr *e)
+ uint32_t flags, const struct nftnl_expr *e)
{
switch (type) {
case NFTNL_OUTPUT_DEFAULT:
}
static void
-nftnl_expr_match_build(struct nlmsghdr *nlh, struct nftnl_expr *e)
+nftnl_expr_match_build(struct nlmsghdr *nlh, const struct nftnl_expr *e)
{
struct nftnl_expr_match *mt = nftnl_expr_data(e);
}
static int nftnl_expr_match_export(char *buf, size_t size,
- struct nftnl_expr *e, int type)
+ const struct nftnl_expr *e, int type)
{
struct nftnl_expr_match *mt = nftnl_expr_data(e);
NFTNL_BUF_INIT(b, buf, size);
static int
nftnl_expr_match_snprintf(char *buf, size_t len, uint32_t type,
- uint32_t flags, struct nftnl_expr *e)
+ uint32_t flags, const struct nftnl_expr *e)
{
struct nftnl_expr_match *match = nftnl_expr_data(e);
return -1;
}
-static void nftnl_expr_match_free(struct nftnl_expr *e)
+static void nftnl_expr_match_free(const struct nftnl_expr *e)
{
struct nftnl_expr_match *match = nftnl_expr_data(e);
}
static void
-nftnl_expr_meta_build(struct nlmsghdr *nlh, struct nftnl_expr *e)
+nftnl_expr_meta_build(struct nlmsghdr *nlh, const struct nftnl_expr *e)
{
struct nftnl_expr_meta *meta = nftnl_expr_data(e);
static int
nftnl_expr_meta_snprintf_default(char *buf, size_t len,
- struct nftnl_expr *e)
+ const struct nftnl_expr *e)
{
struct nftnl_expr_meta *meta = nftnl_expr_data(e);
}
static int nftnl_expr_meta_export(char *buf, size_t size,
- struct nftnl_expr *e, int type)
+ const struct nftnl_expr *e, int type)
{
struct nftnl_expr_meta *meta = nftnl_expr_data(e);
NFTNL_BUF_INIT(b, buf, size);
static int
nftnl_expr_meta_snprintf(char *buf, size_t len, uint32_t type,
- uint32_t flags, struct nftnl_expr *e)
+ uint32_t flags, const struct nftnl_expr *e)
{
switch (type) {
case NFTNL_OUTPUT_DEFAULT:
}
static void
-nftnl_expr_nat_build(struct nlmsghdr *nlh, struct nftnl_expr *e)
+nftnl_expr_nat_build(struct nlmsghdr *nlh, const struct nftnl_expr *e)
{
struct nftnl_expr_nat *nat = nftnl_expr_data(e);
}
static int nftnl_expr_nat_export(char *buf, size_t size,
- struct nftnl_expr *e, int type)
+ const struct nftnl_expr *e, int type)
{
struct nftnl_expr_nat *nat = nftnl_expr_data(e);
NFTNL_BUF_INIT(b, buf, size);
static int
nftnl_expr_nat_snprintf_default(char *buf, size_t size,
- struct nftnl_expr *e)
+ const struct nftnl_expr *e)
{
struct nftnl_expr_nat *nat = nftnl_expr_data(e);
int len = size, offset = 0, ret = 0;
static int
nftnl_expr_nat_snprintf(char *buf, size_t size, uint32_t type,
- uint32_t flags, struct nftnl_expr *e)
+ uint32_t flags, const struct nftnl_expr *e)
{
switch (type) {
case NFTNL_OUTPUT_DEFAULT:
}
static void
-nftnl_expr_payload_build(struct nlmsghdr *nlh, struct nftnl_expr *e)
+nftnl_expr_payload_build(struct nlmsghdr *nlh, const struct nftnl_expr *e)
{
struct nftnl_expr_payload *payload = nftnl_expr_data(e);
}
static int nftnl_expr_payload_export(char *buf, size_t size, uint32_t flags,
- struct nftnl_expr *e, int type)
+ const struct nftnl_expr *e, int type)
{
struct nftnl_expr_payload *payload = nftnl_expr_data(e);
NFTNL_BUF_INIT(b, buf, size);
static int
nftnl_expr_payload_snprintf(char *buf, size_t len, uint32_t type,
- uint32_t flags, struct nftnl_expr *e)
+ uint32_t flags, const struct nftnl_expr *e)
{
struct nftnl_expr_payload *payload = nftnl_expr_data(e);
}
static void
-nftnl_expr_queue_build(struct nlmsghdr *nlh, struct nftnl_expr *e)
+nftnl_expr_queue_build(struct nlmsghdr *nlh, const struct nftnl_expr *e)
{
struct nftnl_expr_queue *queue = nftnl_expr_data(e);
}
static int nftnl_expr_queue_snprintf_default(char *buf, size_t len,
- struct nftnl_expr *e)
+ const struct nftnl_expr *e)
{
struct nftnl_expr_queue *queue = nftnl_expr_data(e);
int ret, size = len, offset = 0;
}
static int nftnl_expr_queue_export(char *buf, size_t size,
- struct nftnl_expr *e, int type)
+ const struct nftnl_expr *e, int type)
{
struct nftnl_expr_queue *queue = nftnl_expr_data(e);
NFTNL_BUF_INIT(b, buf, size);
static int
nftnl_expr_queue_snprintf(char *buf, size_t len, uint32_t type,
- uint32_t flags, struct nftnl_expr *e)
+ uint32_t flags, const struct nftnl_expr *e)
{
switch (type) {
}
static void
-nftnl_expr_redir_build(struct nlmsghdr *nlh, struct nftnl_expr *e)
+nftnl_expr_redir_build(struct nlmsghdr *nlh, const struct nftnl_expr *e)
{
struct nftnl_expr_redir *redir = nftnl_expr_data(e);
}
static int nftnl_expr_redir_export(char *buf, size_t size,
- struct nftnl_expr *e, int type)
+ const struct nftnl_expr *e, int type)
{
struct nftnl_expr_redir *redir = nftnl_expr_data(e);
NFTNL_BUF_INIT(b, buf, size);
}
static int nftnl_expr_redir_snprintf_default(char *buf, size_t len,
- struct nftnl_expr *e)
+ const struct nftnl_expr *e)
{
int ret, size = len, offset = 0;
struct nftnl_expr_redir *redir = nftnl_expr_data(e);
static int
nftnl_expr_redir_snprintf(char *buf, size_t len, uint32_t type,
- uint32_t flags, struct nftnl_expr *e)
+ uint32_t flags, const struct nftnl_expr *e)
{
switch (type) {
case NFTNL_OUTPUT_DEFAULT:
}
static void
-nftnl_expr_reject_build(struct nlmsghdr *nlh, struct nftnl_expr *e)
+nftnl_expr_reject_build(struct nlmsghdr *nlh, const struct nftnl_expr *e)
{
struct nftnl_expr_reject *reject = nftnl_expr_data(e);
}
static int nftnl_expr_reject_snprintf_default(char *buf, size_t len,
- struct nftnl_expr *e)
+ const struct nftnl_expr *e)
{
struct nftnl_expr_reject *reject = nftnl_expr_data(e);
}
static int nftnl_expr_reject_export(char *buf, size_t size,
- struct nftnl_expr *e, int type)
+ const struct nftnl_expr *e, int type)
{
struct nftnl_expr_reject *reject = nftnl_expr_data(e);
NFTNL_BUF_INIT(b, buf, size);
static int
nftnl_expr_reject_snprintf(char *buf, size_t len, uint32_t type,
- uint32_t flags, struct nftnl_expr *e)
+ uint32_t flags, const struct nftnl_expr *e)
{
switch (type) {
case NFTNL_OUTPUT_DEFAULT:
}
static void
-nftnl_expr_target_build(struct nlmsghdr *nlh, struct nftnl_expr *e)
+nftnl_expr_target_build(struct nlmsghdr *nlh, const struct nftnl_expr *e)
{
struct nftnl_expr_target *tg = nftnl_expr_data(e);
}
static int nftnl_rule_exp_target_export(char *buf, size_t size,
- struct nftnl_expr *e, int type)
+ const struct nftnl_expr *e, int type)
{
struct nftnl_expr_target *target = nftnl_expr_data(e);
NFTNL_BUF_INIT(b, buf, size);
static int
nftnl_expr_target_snprintf(char *buf, size_t len, uint32_t type,
- uint32_t flags, struct nftnl_expr *e)
+ uint32_t flags, const struct nftnl_expr *e)
{
struct nftnl_expr_target *target = nftnl_expr_data(e);
return -1;
}
-static void nftnl_expr_target_free(struct nftnl_expr *e)
+static void nftnl_expr_target_free(const struct nftnl_expr *e)
{
struct nftnl_expr_target *target = nftnl_expr_data(e);
}
EXPORT_SYMBOL_ALIAS(nftnl_gen_alloc, nft_gen_alloc);
-void nftnl_gen_free(struct nftnl_gen *gen)
+void nftnl_gen_free(const struct nftnl_gen *gen)
{
xfree(gen);
}
}
EXPORT_SYMBOL_ALIAS(nftnl_gen_set_u32, nft_gen_attr_set_u32);
-const void *nftnl_gen_get_data(struct nftnl_gen *gen, uint16_t attr,
- uint32_t *data_len)
+const void *nftnl_gen_get_data(const struct nftnl_gen *gen, uint16_t attr,
+ uint32_t *data_len)
{
if (!(gen->flags & (1 << attr)))
return NULL;
}
EXPORT_SYMBOL_ALIAS(nftnl_gen_get_data, nft_gen_attr_get_data);
-const void *nftnl_gen_get(struct nftnl_gen *gen, uint16_t attr)
+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);
-uint32_t nftnl_gen_get_u32(struct nftnl_gen *gen, uint16_t attr)
+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_nlmsg_parse, nft_gen_nlmsg_parse);
-static int nftnl_gen_snprintf_default(char *buf, size_t size, struct nftnl_gen *gen)
+static int nftnl_gen_snprintf_default(char *buf, size_t size,
+ const struct nftnl_gen *gen)
{
return snprintf(buf, size, "ruleset generation ID %u", gen->id);
}
-static int nftnl_gen_cmd_snprintf(char *buf, size_t size, struct nftnl_gen *gen,
- uint32_t cmd, uint32_t type, uint32_t flags)
+static int nftnl_gen_cmd_snprintf(char *buf, size_t size,
+ const struct nftnl_gen *gen, uint32_t cmd,
+ uint32_t type, uint32_t flags)
{
int ret, len = size, offset = 0;
return offset;
}
-int nftnl_gen_snprintf(char *buf, size_t size, struct nftnl_gen *gen, uint32_t type,
- uint32_t flags)
+int nftnl_gen_snprintf(char *buf, size_t size, const struct nftnl_gen *gen,
+ uint32_t type, uint32_t flags)
{;
return nftnl_gen_cmd_snprintf(buf, size, gen, nftnl_flag2cmd(flags), type,
flags);
}
EXPORT_SYMBOL_ALIAS(nftnl_gen_snprintf, nft_gen_snprintf);
-static inline int nftnl_gen_do_snprintf(char *buf, size_t size, void *gen,
- uint32_t cmd, uint32_t type,
- uint32_t flags)
+static inline int nftnl_gen_do_snprintf(char *buf, size_t size, const void *gen,
+ uint32_t cmd, uint32_t type,
+ uint32_t flags)
{
return nftnl_gen_snprintf(buf, size, gen, type, flags);
}
-int nftnl_gen_fprintf(FILE *fp, struct nftnl_gen *gen, uint32_t type,
- uint32_t flags)
+int nftnl_gen_fprintf(FILE *fp, const struct nftnl_gen *gen, uint32_t type,
+ uint32_t flags)
{
return nftnl_fprintf(fp, gen, NFTNL_CMD_UNSPEC, type, flags,
nftnl_gen_do_snprintf);
}
EXPORT_SYMBOL_ALIAS(nftnl_rule_alloc, nft_rule_alloc);
-void nftnl_rule_free(struct nftnl_rule *r)
+void nftnl_rule_free(const struct nftnl_rule *r)
{
struct nftnl_expr *e, *tmp;
}
EXPORT_SYMBOL_ALIAS(nftnl_rule_parse_file, nft_rule_parse_file);
-static int nftnl_rule_snprintf_json(char *buf, size_t size, struct nftnl_rule *r,
- uint32_t type, uint32_t flags)
+static int nftnl_rule_snprintf_json(char *buf, size_t size,
+ const struct nftnl_rule *r,
+ uint32_t type, uint32_t flags)
{
int ret, len = size, offset = 0;
struct nftnl_expr *expr;
return offset;
}
-static int nftnl_rule_snprintf_xml(char *buf, size_t size, struct nftnl_rule *r,
- uint32_t type, uint32_t flags)
+static int nftnl_rule_snprintf_xml(char *buf, size_t size,
+ const struct nftnl_rule *r,
+ uint32_t type, uint32_t flags)
{
int ret, len = size, offset = 0;
struct nftnl_expr *expr;
return offset;
}
-static int nftnl_rule_snprintf_default(char *buf, size_t size, struct nftnl_rule *r,
- uint32_t type, uint32_t flags)
+static int nftnl_rule_snprintf_default(char *buf, size_t size,
+ const struct nftnl_rule *r,
+ uint32_t type, uint32_t flags)
{
struct nftnl_expr *expr;
int ret, len = size, offset = 0, i;
return offset;
}
-static int nftnl_rule_cmd_snprintf(char *buf, size_t size, struct nftnl_rule *r,
- uint32_t cmd, uint32_t type, uint32_t flags)
+static int nftnl_rule_cmd_snprintf(char *buf, size_t size,
+ const struct nftnl_rule *r, uint32_t cmd,
+ uint32_t type, uint32_t flags)
{
int ret, len = size, offset = 0;
uint32_t inner_flags = flags;
return offset;
}
-int nftnl_rule_snprintf(char *buf, size_t size, struct nftnl_rule *r,
- uint32_t type, uint32_t flags)
+int nftnl_rule_snprintf(char *buf, size_t size, const struct nftnl_rule *r,
+ uint32_t type, uint32_t flags)
{
return nftnl_rule_cmd_snprintf(buf, size, r, nftnl_flag2cmd(flags), type,
flags);
}
EXPORT_SYMBOL_ALIAS(nftnl_rule_snprintf, nft_rule_snprintf);
-static inline int nftnl_rule_do_snprintf(char *buf, size_t size, void *r,
- uint32_t cmd, uint32_t type,
- uint32_t flags)
+static inline int nftnl_rule_do_snprintf(char *buf, size_t size, const void *r,
+ uint32_t cmd, uint32_t type,
+ uint32_t flags)
{
return nftnl_rule_snprintf(buf, size, r, type, flags);
}
-int nftnl_rule_fprintf(FILE *fp, struct nftnl_rule *r, uint32_t type,
- uint32_t flags)
+int nftnl_rule_fprintf(FILE *fp, const struct nftnl_rule *r, uint32_t type,
+ uint32_t flags)
{
return nftnl_fprintf(fp, r, NFTNL_CMD_UNSPEC, type, flags,
nftnl_rule_do_snprintf);
}
EXPORT_SYMBOL_ALIAS(nftnl_rule_list_free, nft_rule_list_free);
-int nftnl_rule_list_is_empty(struct nftnl_rule_list *list)
+int nftnl_rule_list_is_empty(const struct nftnl_rule_list *list)
{
return list_empty(&list->list);
}
}
EXPORT_SYMBOL_ALIAS(nftnl_rule_list_iter_next, nft_rule_list_iter_next);
-void nftnl_rule_list_iter_destroy(struct nftnl_rule_list_iter *iter)
+void nftnl_rule_list_iter_destroy(const struct nftnl_rule_list_iter *iter)
{
xfree(iter);
}
}
EXPORT_SYMBOL_ALIAS(nftnl_ruleset_alloc, nft_ruleset_alloc);
-void nftnl_ruleset_free(struct nftnl_ruleset *r)
+void nftnl_ruleset_free(const struct nftnl_ruleset *r)
{
if (r->flags & (1 << NFTNL_RULESET_TABLELIST))
nftnl_table_list_free(r->table_list);
}
EXPORT_SYMBOL_ALIAS(nftnl_set_alloc, nft_set_alloc);
-void nftnl_set_free(struct nftnl_set *s)
+void nftnl_set_free(const struct nftnl_set *s)
{
struct nftnl_set_elem *elem, *tmp;
}
EXPORT_SYMBOL_ALIAS(nftnl_set_set_str, nft_set_attr_set_str);
-const void *nftnl_set_get_data(struct nftnl_set *s, uint16_t attr,
- uint32_t *data_len)
+const void *nftnl_set_get_data(const struct nftnl_set *s, uint16_t attr,
+ uint32_t *data_len)
{
if (!(s->flags & (1 << attr)))
return NULL;
}
EXPORT_SYMBOL_ALIAS(nftnl_set_get_data, nft_set_attr_get_data);
-const void *nftnl_set_get(struct nftnl_set *s, uint16_t attr)
+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);
-const char *nftnl_set_get_str(struct nftnl_set *s, uint16_t attr)
+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);
-uint32_t nftnl_set_get_u32(struct nftnl_set *s, uint16_t attr)
+uint32_t nftnl_set_get_u32(const struct nftnl_set *s, uint16_t attr)
{
uint32_t data_len;
const uint32_t *val = nftnl_set_get_data(s, attr, &data_len);
}
EXPORT_SYMBOL_ALIAS(nftnl_set_get_u32, nft_set_attr_get_u32);
-uint64_t nftnl_set_get_u64(struct nftnl_set *s, uint16_t attr)
+uint64_t nftnl_set_get_u64(const struct nftnl_set *s, uint16_t attr)
{
uint32_t data_len;
const uint64_t *val = nftnl_set_get_data(s, attr, &data_len);
}
EXPORT_SYMBOL_ALIAS(nftnl_set_parse_file, nft_set_parse_file);
-static int nftnl_set_snprintf_json(char *buf, size_t size, struct nftnl_set *s,
- uint32_t type, uint32_t flags)
+static int nftnl_set_snprintf_json(char *buf, size_t size,
+ const struct nftnl_set *s,
+ uint32_t type, uint32_t flags)
{
int len = size, offset = 0, ret;
struct nftnl_set_elem *elem;
return offset;
}
-static int nftnl_set_snprintf_default(char *buf, size_t size, struct nftnl_set *s,
- uint32_t type, uint32_t flags)
+static int nftnl_set_snprintf_default(char *buf, size_t size,
+ const struct nftnl_set *s,
+ uint32_t type, uint32_t flags)
{
int ret;
int len = size, offset = 0;
return offset;
}
-static int nftnl_set_snprintf_xml(char *buf, size_t size, struct nftnl_set *s,
- uint32_t flags)
+static int nftnl_set_snprintf_xml(char *buf, size_t size,
+ const struct nftnl_set *s, uint32_t flags)
{
int ret;
int len = size, offset = 0;
return offset;
}
-static int nftnl_set_cmd_snprintf(char *buf, size_t size, struct nftnl_set *s,
- uint32_t cmd, uint32_t type, uint32_t flags)
+static int nftnl_set_cmd_snprintf(char *buf, size_t size,
+ const struct nftnl_set *s, uint32_t cmd,
+ uint32_t type, uint32_t flags)
{
int ret, len = size, offset = 0;
uint32_t inner_flags = flags;
return offset;
}
-int nftnl_set_snprintf(char *buf, size_t size, struct nftnl_set *s,
- uint32_t type, uint32_t flags)
+int nftnl_set_snprintf(char *buf, size_t size, const struct nftnl_set *s,
+ uint32_t type, uint32_t flags)
{
return nftnl_set_cmd_snprintf(buf, size, s, nftnl_flag2cmd(flags), type,
flags);
}
EXPORT_SYMBOL_ALIAS(nftnl_set_snprintf, nft_set_snprintf);
-static inline int nftnl_set_do_snprintf(char *buf, size_t size, void *s,
- uint32_t cmd, uint32_t type,
- uint32_t flags)
+static inline int nftnl_set_do_snprintf(char *buf, size_t size, const void *s,
+ uint32_t cmd, uint32_t type,
+ uint32_t flags)
{
return nftnl_set_snprintf(buf, size, s, type, flags);
}
-int nftnl_set_fprintf(FILE *fp, struct nftnl_set *s, uint32_t type,
- uint32_t flags)
+int nftnl_set_fprintf(FILE *fp, const struct nftnl_set *s, uint32_t type,
+ uint32_t flags)
{
return nftnl_fprintf(fp, s, NFTNL_CMD_UNSPEC, type, flags,
nftnl_set_do_snprintf);
}
EXPORT_SYMBOL_ALIAS(nftnl_set_list_free, nft_set_list_free);
-int nftnl_set_list_is_empty(struct nftnl_set_list *list)
+int nftnl_set_list_is_empty(const struct nftnl_set_list *list)
{
return list_empty(&list->list);
}
}
EXPORT_SYMBOL_ALIAS(nftnl_set_list_iter_next, nft_set_list_iter_next);
-void nftnl_set_list_iter_destroy(struct nftnl_set_list_iter *iter)
+void nftnl_set_list_iter_destroy(const struct nftnl_set_list_iter *iter)
{
xfree(iter);
}
EXPORT_SYMBOL_ALIAS(nftnl_set_elem_parse_file, nft_set_elem_parse_file);
static int nftnl_set_elem_snprintf_json(char *buf, size_t size,
- struct nftnl_set_elem *e, uint32_t flags)
+ const struct nftnl_set_elem *e,
+ uint32_t flags)
{
int ret, len = size, offset = 0, type = -1;
}
static int nftnl_set_elem_snprintf_default(char *buf, size_t size,
- struct nftnl_set_elem *e)
+ const struct nftnl_set_elem *e)
{
int ret, len = size, offset = 0, i;
}
static int nftnl_set_elem_snprintf_xml(char *buf, size_t size,
- struct nftnl_set_elem *e, uint32_t flags)
+ const struct nftnl_set_elem *e,
+ uint32_t flags)
{
int ret, len = size, offset = 0, type = DATA_NONE;
}
static int nftnl_set_elem_cmd_snprintf(char *buf, size_t size,
- struct nftnl_set_elem *e, uint32_t cmd,
- uint32_t type, uint32_t flags)
+ const struct nftnl_set_elem *e,
+ uint32_t cmd, uint32_t type,
+ uint32_t flags)
{
int ret, len = size, offset = 0;
return offset;
}
-int nftnl_set_elem_snprintf(char *buf, size_t size, struct nftnl_set_elem *e,
- uint32_t type, uint32_t flags)
+int nftnl_set_elem_snprintf(char *buf, size_t size,
+ const struct nftnl_set_elem *e,
+ uint32_t type, uint32_t flags)
{
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);
-static inline int nftnl_set_elem_do_snprintf(char *buf, size_t size, void *e,
- uint32_t cmd, uint32_t type,
- uint32_t flags)
+static inline int nftnl_set_elem_do_snprintf(char *buf, size_t size,
+ const void *e, uint32_t cmd,
+ uint32_t type, uint32_t flags)
{
return nftnl_set_elem_snprintf(buf, size, e, type, flags);
}
}
EXPORT_SYMBOL_ALIAS(nftnl_table_alloc, nft_table_alloc);
-void nftnl_table_free(struct nftnl_table *t)
+void nftnl_table_free(const struct nftnl_table *t)
{
if (t->flags & (1 << NFTNL_TABLE_NAME))
xfree(t->name);
}
EXPORT_SYMBOL_ALIAS(nftnl_table_set_str, nft_table_attr_set_str);
-const void *nftnl_table_get_data(struct nftnl_table *t, uint16_t attr,
- uint32_t *data_len)
+const void *nftnl_table_get_data(const struct nftnl_table *t, uint16_t attr,
+ uint32_t *data_len)
{
if (!(t->flags & (1 << attr)))
return NULL;
}
EXPORT_SYMBOL_ALIAS(nftnl_table_get_data, nft_table_attr_get_data);
-const void *nftnl_table_get(struct nftnl_table *t, uint16_t attr)
+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);
-uint32_t nftnl_table_get_u32(struct nftnl_table *t, uint16_t attr)
+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);
-uint8_t nftnl_table_get_u8(struct nftnl_table *t, uint16_t attr)
+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);
-const char *nftnl_table_get_str(struct nftnl_table *t, uint16_t attr)
+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_parse_file, nft_table_parse_file);
-static int nftnl_table_export(char *buf, size_t size, struct nftnl_table *t,
- int type)
+static int nftnl_table_export(char *buf, size_t size,
+ const struct nftnl_table *t, int type)
{
NFTNL_BUF_INIT(b, buf, size);
return nftnl_buf_done(&b);
}
-static int nftnl_table_snprintf_default(char *buf, size_t size, struct nftnl_table *t)
+static int nftnl_table_snprintf_default(char *buf, size_t size,
+ const struct nftnl_table *t)
{
return snprintf(buf, size, "table %s %s flags %x use %d",
t->name, nftnl_family2str(t->family),
t->table_flags, t->use);
}
-static int nftnl_table_cmd_snprintf(char *buf, size_t size, struct nftnl_table *t,
- uint32_t cmd, uint32_t type, uint32_t flags)
+static int nftnl_table_cmd_snprintf(char *buf, size_t size,
+ const struct nftnl_table *t, uint32_t cmd,
+ uint32_t type, uint32_t flags)
{
int ret, len = size, offset = 0;
return offset;
}
-int nftnl_table_snprintf(char *buf, size_t size, struct nftnl_table *t,
- uint32_t type, uint32_t flags)
+int nftnl_table_snprintf(char *buf, size_t size, const struct nftnl_table *t,
+ uint32_t type, uint32_t flags)
{
return nftnl_table_cmd_snprintf(buf, size, t, nftnl_flag2cmd(flags), type,
flags);
}
EXPORT_SYMBOL_ALIAS(nftnl_table_snprintf, nft_table_snprintf);
-static inline int nftnl_table_do_snprintf(char *buf, size_t size, void *t,
- uint32_t cmd, uint32_t type,
- uint32_t flags)
+static inline int nftnl_table_do_snprintf(char *buf, size_t size, const void *t,
+ uint32_t cmd, uint32_t type,
+ uint32_t flags)
{
return nftnl_table_snprintf(buf, size, t, type, flags);
}
-int nftnl_table_fprintf(FILE *fp, struct nftnl_table *t, uint32_t type,
- uint32_t flags)
+int nftnl_table_fprintf(FILE *fp, const struct nftnl_table *t, uint32_t type,
+ uint32_t flags)
{
return nftnl_fprintf(fp, t, NFTNL_CMD_UNSPEC, type, flags,
nftnl_table_do_snprintf);
}
EXPORT_SYMBOL_ALIAS(nftnl_table_list_free, nft_table_list_free);
-int nftnl_table_list_is_empty(struct nftnl_table_list *list)
+int nftnl_table_list_is_empty(const struct nftnl_table_list *list)
{
return list_empty(&list->list);
}
}
EXPORT_SYMBOL_ALIAS(nftnl_table_list_iter_next, nft_table_list_iter_next);
-void nftnl_table_list_iter_destroy(struct nftnl_table_list_iter *iter)
+void nftnl_table_list_iter_destroy(const struct nftnl_table_list_iter *iter)
{
xfree(iter);
}
}
EXPORT_SYMBOL(nftnl_trace_free);
-void nftnl_trace_free(struct nftnl_trace *t)
+void nftnl_trace_free(const struct nftnl_trace *t)
{
xfree(t->chain);
xfree(t->table);
}
EXPORT_SYMBOL(nftnl_udata_buf_alloc);
-void nftnl_udata_buf_free(struct nftnl_udata_buf *buf)
+void nftnl_udata_buf_free(const struct nftnl_udata_buf *buf)
{
- free(buf);
+ xfree(buf);
}
EXPORT_SYMBOL(nftnl_udata_buf_free);
return NFTNL_CMD_UNSPEC;
}
-int nftnl_fprintf(FILE *fp, void *obj, uint32_t cmd, uint32_t type, uint32_t flags,
- int (*snprintf_cb)(char *buf, size_t bufsiz, void *obj,
- uint32_t cmd, uint32_t type, uint32_t flags))
+int nftnl_fprintf(FILE *fp, const void *obj, uint32_t cmd, uint32_t type,
+ uint32_t flags,
+ int (*snprintf_cb)(char *buf, size_t bufsiz, const void *obj,
+ uint32_t cmd, uint32_t type,
+ uint32_t flags))
{
char _buf[NFTNL_SNPRINTF_BUFSIZ];
char *buf = _buf;
projects / thirdparty / libnftnl.git / commitdiff
