diff options
author | Pablo Neira Ayuso <pablo@netfilter.org> | 2015-09-01 20:19:56 +0200 |
---|---|---|
committer | Pablo Neira Ayuso <pablo@netfilter.org> | 2015-09-07 19:24:19 +0200 |
commit | 760768890e60617acfd144dce875a4a3be14513c (patch) | |
tree | 14a3a4f53e81fd9b44c8481e123f2c0ceb6f2bff /src/set_elem.c | |
parent | b7154e52fc417e927bef0bbfa5db6e7a71f28602 (diff) |
src: rename existing functions to use the nftnl_ prefix
So we can use the nft_* prefix anytime soon for our upcoming higher level
library.
After this patch, the nft_* symbols become an alias of the nftnl_* symbols.
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
Diffstat (limited to 'src/set_elem.c')
-rw-r--r-- | src/set_elem.c | 414 |
1 files changed, 207 insertions, 207 deletions
diff --git a/src/set_elem.c b/src/set_elem.c index a130cc3..4f68787 100644 --- a/src/set_elem.c +++ b/src/set_elem.c @@ -27,11 +27,11 @@ #include <libnftnl/rule.h> #include <libnftnl/expr.h> -struct nft_set_elem *nft_set_elem_alloc(void) +struct nftnl_set_elem *nftnl_set_elem_alloc(void) { - struct nft_set_elem *s; + struct nftnl_set_elem *s; - s = calloc(1, sizeof(struct nft_set_elem)); + s = calloc(1, sizeof(struct nftnl_set_elem)); if (s == NULL) return NULL; @@ -39,50 +39,50 @@ struct nft_set_elem *nft_set_elem_alloc(void) } EXPORT_SYMBOL(nftnl_set_elem_alloc, nft_set_elem_alloc); -void nft_set_elem_free(struct nft_set_elem *s) +void nftnl_set_elem_free(struct nftnl_set_elem *s) { - if (s->flags & (1 << NFT_SET_ELEM_ATTR_CHAIN)) { + if (s->flags & (1 << NFTNL_SET_ELEM_ATTR_CHAIN)) { if (s->data.chain) { xfree(s->data.chain); s->data.chain = NULL; } } - if (s->flags & (1 << NFT_SET_ELEM_ATTR_EXPR)) - nft_rule_expr_free(s->expr); + if (s->flags & (1 << NFTNL_SET_ELEM_ATTR_EXPR)) + nftnl_rule_expr_free(s->expr); xfree(s); } EXPORT_SYMBOL(nftnl_set_elem_free, nft_set_elem_free); -bool nft_set_elem_attr_is_set(const struct nft_set_elem *s, uint16_t attr) +bool nftnl_set_elem_attr_is_set(const struct nftnl_set_elem *s, uint16_t attr) { return s->flags & (1 << attr); } EXPORT_SYMBOL(nftnl_set_elem_attr_is_set, nft_set_elem_attr_is_set); -void nft_set_elem_attr_unset(struct nft_set_elem *s, uint16_t attr) +void nftnl_set_elem_attr_unset(struct nftnl_set_elem *s, uint16_t attr) { switch (attr) { - case NFT_SET_ELEM_ATTR_CHAIN: - if (s->flags & (1 << NFT_SET_ELEM_ATTR_CHAIN)) { + case NFTNL_SET_ELEM_ATTR_CHAIN: + if (s->flags & (1 << NFTNL_SET_ELEM_ATTR_CHAIN)) { if (s->data.chain) { xfree(s->data.chain); s->data.chain = NULL; } } break; - case NFT_SET_ELEM_ATTR_FLAGS: - case NFT_SET_ELEM_ATTR_KEY: /* NFTA_SET_ELEM_KEY */ - case NFT_SET_ELEM_ATTR_VERDICT: /* NFTA_SET_ELEM_DATA */ - case NFT_SET_ELEM_ATTR_DATA: /* NFTA_SET_ELEM_DATA */ - case NFT_SET_ELEM_ATTR_TIMEOUT: /* NFTA_SET_ELEM_TIMEOUT */ - case NFT_SET_ELEM_ATTR_EXPIRATION: /* NFTA_SET_ELEM_EXPIRATION */ - case NFT_SET_ELEM_ATTR_USERDATA: /* NFTA_SET_ELEM_USERDATA */ + case NFTNL_SET_ELEM_ATTR_FLAGS: + case NFTNL_SET_ELEM_ATTR_KEY: /* NFTA_SET_ELEM_KEY */ + case NFTNL_SET_ELEM_ATTR_VERDICT: /* NFTA_SET_ELEM_DATA */ + case NFTNL_SET_ELEM_ATTR_DATA: /* NFTA_SET_ELEM_DATA */ + case NFTNL_SET_ELEM_ATTR_TIMEOUT: /* NFTA_SET_ELEM_TIMEOUT */ + case NFTNL_SET_ELEM_ATTR_EXPIRATION: /* NFTA_SET_ELEM_EXPIRATION */ + case NFTNL_SET_ELEM_ATTR_USERDATA: /* NFTA_SET_ELEM_USERDATA */ break; - case NFT_SET_ELEM_ATTR_EXPR: - if (s->flags & (1 << NFT_SET_ELEM_ATTR_EXPR)) { - nft_rule_expr_free(s->expr); + case NFTNL_SET_ELEM_ATTR_EXPR: + if (s->flags & (1 << NFTNL_SET_ELEM_ATTR_EXPR)) { + nftnl_rule_expr_free(s->expr); s->expr = NULL; } break; @@ -94,34 +94,34 @@ void nft_set_elem_attr_unset(struct nft_set_elem *s, uint16_t attr) } EXPORT_SYMBOL(nftnl_set_elem_attr_unset, nft_set_elem_attr_unset); -void nft_set_elem_attr_set(struct nft_set_elem *s, uint16_t attr, +void nftnl_set_elem_attr_set(struct nftnl_set_elem *s, uint16_t attr, const void *data, uint32_t data_len) { switch(attr) { - case NFT_SET_ELEM_ATTR_FLAGS: + case NFTNL_SET_ELEM_ATTR_FLAGS: s->set_elem_flags = *((uint32_t *)data); break; - case NFT_SET_ELEM_ATTR_KEY: /* NFTA_SET_ELEM_KEY */ + case NFTNL_SET_ELEM_ATTR_KEY: /* NFTA_SET_ELEM_KEY */ memcpy(&s->key.val, data, data_len); s->key.len = data_len; break; - case NFT_SET_ELEM_ATTR_VERDICT: /* NFTA_SET_ELEM_DATA */ + case NFTNL_SET_ELEM_ATTR_VERDICT: /* NFTA_SET_ELEM_DATA */ s->data.verdict = *((uint32_t *)data); break; - case NFT_SET_ELEM_ATTR_CHAIN: /* NFTA_SET_ELEM_DATA */ + case NFTNL_SET_ELEM_ATTR_CHAIN: /* NFTA_SET_ELEM_DATA */ if (s->data.chain) xfree(s->data.chain); s->data.chain = strdup(data); break; - case NFT_SET_ELEM_ATTR_DATA: /* NFTA_SET_ELEM_DATA */ + case NFTNL_SET_ELEM_ATTR_DATA: /* NFTA_SET_ELEM_DATA */ memcpy(s->data.val, data, data_len); s->data.len = data_len; break; - case NFT_SET_ELEM_ATTR_TIMEOUT: /* NFTA_SET_ELEM_TIMEOUT */ + case NFTNL_SET_ELEM_ATTR_TIMEOUT: /* NFTA_SET_ELEM_TIMEOUT */ s->timeout = *((uint64_t *)data); break; - case NFT_SET_ELEM_ATTR_USERDATA: /* NFTA_SET_ELEM_USERDATA */ + case NFTNL_SET_ELEM_ATTR_USERDATA: /* NFTA_SET_ELEM_USERDATA */ s->user.data = (void *)data; s->user.len = data_len; break; @@ -132,173 +132,173 @@ void nft_set_elem_attr_set(struct nft_set_elem *s, uint16_t attr, } EXPORT_SYMBOL(nftnl_set_elem_attr_set, nft_set_elem_attr_set); -void nft_set_elem_attr_set_u32(struct nft_set_elem *s, uint16_t attr, uint32_t val) +void nftnl_set_elem_attr_set_u32(struct nftnl_set_elem *s, uint16_t attr, uint32_t val) { - nft_set_elem_attr_set(s, attr, &val, sizeof(uint32_t)); + nftnl_set_elem_attr_set(s, attr, &val, sizeof(uint32_t)); } EXPORT_SYMBOL(nftnl_set_elem_attr_set_u32, nft_set_elem_attr_set_u32); -void nft_set_elem_attr_set_u64(struct nft_set_elem *s, uint16_t attr, uint64_t val) +void nftnl_set_elem_attr_set_u64(struct nftnl_set_elem *s, uint16_t attr, uint64_t val) { - nft_set_elem_attr_set(s, attr, &val, sizeof(uint64_t)); + nftnl_set_elem_attr_set(s, attr, &val, sizeof(uint64_t)); } EXPORT_SYMBOL(nftnl_set_elem_attr_set_u64, nft_set_elem_attr_set_u64); -void nft_set_elem_attr_set_str(struct nft_set_elem *s, uint16_t attr, const char *str) +void nftnl_set_elem_attr_set_str(struct nftnl_set_elem *s, uint16_t attr, const char *str) { - nft_set_elem_attr_set(s, attr, str, strlen(str)); + nftnl_set_elem_attr_set(s, attr, str, strlen(str)); } EXPORT_SYMBOL(nftnl_set_elem_attr_set_str, nft_set_elem_attr_set_str); -const void *nft_set_elem_attr_get(struct nft_set_elem *s, uint16_t attr, uint32_t *data_len) +const void *nftnl_set_elem_attr_get(struct nftnl_set_elem *s, uint16_t attr, uint32_t *data_len) { if (!(s->flags & (1 << attr))) return NULL; switch(attr) { - case NFT_SET_ELEM_ATTR_FLAGS: + case NFTNL_SET_ELEM_ATTR_FLAGS: return &s->set_elem_flags; - case NFT_SET_ELEM_ATTR_KEY: /* NFTA_SET_ELEM_KEY */ + case NFTNL_SET_ELEM_ATTR_KEY: /* NFTA_SET_ELEM_KEY */ *data_len = s->key.len; return &s->key.val; - case NFT_SET_ELEM_ATTR_VERDICT: /* NFTA_SET_ELEM_DATA */ + case NFTNL_SET_ELEM_ATTR_VERDICT: /* NFTA_SET_ELEM_DATA */ return &s->data.verdict; - case NFT_SET_ELEM_ATTR_CHAIN: /* NFTA_SET_ELEM_DATA */ + case NFTNL_SET_ELEM_ATTR_CHAIN: /* NFTA_SET_ELEM_DATA */ return s->data.chain; - case NFT_SET_ELEM_ATTR_DATA: /* NFTA_SET_ELEM_DATA */ + case NFTNL_SET_ELEM_ATTR_DATA: /* NFTA_SET_ELEM_DATA */ *data_len = s->data.len; return &s->data.val; - case NFT_SET_ELEM_ATTR_TIMEOUT: /* NFTA_SET_ELEM_TIMEOUT */ + case NFTNL_SET_ELEM_ATTR_TIMEOUT: /* NFTA_SET_ELEM_TIMEOUT */ return &s->timeout; - case NFT_SET_ELEM_ATTR_EXPIRATION: /* NFTA_SET_ELEM_EXPIRATION */ + case NFTNL_SET_ELEM_ATTR_EXPIRATION: /* NFTA_SET_ELEM_EXPIRATION */ return &s->expiration; - case NFT_SET_ELEM_ATTR_USERDATA: + case NFTNL_SET_ELEM_ATTR_USERDATA: *data_len = s->user.len; return s->user.data; - case NFT_SET_ELEM_ATTR_EXPR: + case NFTNL_SET_ELEM_ATTR_EXPR: return s->expr; } return NULL; } EXPORT_SYMBOL(nftnl_set_elem_attr_get, nft_set_elem_attr_get); -const char *nft_set_elem_attr_get_str(struct nft_set_elem *s, uint16_t attr) +const char *nftnl_set_elem_attr_get_str(struct nftnl_set_elem *s, uint16_t attr) { uint32_t size; - return nft_set_elem_attr_get(s, attr, &size); + return nftnl_set_elem_attr_get(s, attr, &size); } EXPORT_SYMBOL(nftnl_set_elem_attr_get_str, nft_set_elem_attr_get_str); -uint32_t nft_set_elem_attr_get_u32(struct nft_set_elem *s, uint16_t attr) +uint32_t nftnl_set_elem_attr_get_u32(struct nftnl_set_elem *s, uint16_t attr) { uint32_t size; - uint32_t val = *((uint32_t *)nft_set_elem_attr_get(s, attr, &size)); + uint32_t val = *((uint32_t *)nftnl_set_elem_attr_get(s, attr, &size)); return val; } EXPORT_SYMBOL(nftnl_set_elem_attr_get_u32, nft_set_elem_attr_get_u32); -uint64_t nft_set_elem_attr_get_u64(struct nft_set_elem *s, uint16_t attr) +uint64_t nftnl_set_elem_attr_get_u64(struct nftnl_set_elem *s, uint16_t attr) { uint32_t size; - uint64_t val = *((uint64_t *)nft_set_elem_attr_get(s, attr, &size)); + uint64_t val = *((uint64_t *)nftnl_set_elem_attr_get(s, attr, &size)); return val; } EXPORT_SYMBOL(nftnl_set_elem_attr_get_u64, nft_set_elem_attr_get_u64); -struct nft_set_elem *nft_set_elem_clone(struct nft_set_elem *elem) +struct nftnl_set_elem *nftnl_set_elem_clone(struct nftnl_set_elem *elem) { - struct nft_set_elem *newelem; + struct nftnl_set_elem *newelem; - newelem = nft_set_elem_alloc(); + newelem = nftnl_set_elem_alloc(); if (newelem == NULL) return NULL; memcpy(newelem, elem, sizeof(*elem)); - if (elem->flags & (1 << NFT_SET_ELEM_ATTR_CHAIN)) + if (elem->flags & (1 << NFTNL_SET_ELEM_ATTR_CHAIN)) newelem->data.chain = strdup(elem->data.chain); return newelem; } -void nft_set_elem_nlmsg_build_payload(struct nlmsghdr *nlh, - struct nft_set_elem *e) +void nftnl_set_elem_nlmsg_build_payload(struct nlmsghdr *nlh, + struct nftnl_set_elem *e) { - if (e->flags & (1 << NFT_SET_ELEM_ATTR_FLAGS)) + if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_FLAGS)) mnl_attr_put_u32(nlh, NFTA_SET_ELEM_FLAGS, htonl(e->set_elem_flags)); - if (e->flags & (1 << NFT_SET_ELEM_ATTR_TIMEOUT)) + if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_TIMEOUT)) mnl_attr_put_u64(nlh, NFTA_SET_ELEM_TIMEOUT, htobe64(e->timeout)); - if (e->flags & (1 << NFT_SET_ELEM_ATTR_KEY)) { + if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_KEY)) { struct nlattr *nest1; nest1 = mnl_attr_nest_start(nlh, NFTA_SET_ELEM_KEY); mnl_attr_put(nlh, NFTA_DATA_VALUE, e->key.len, e->key.val); mnl_attr_nest_end(nlh, nest1); } - if (e->flags & (1 << NFT_SET_ELEM_ATTR_VERDICT)) { + if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_VERDICT)) { struct nlattr *nest1, *nest2; nest1 = mnl_attr_nest_start(nlh, NFTA_SET_ELEM_DATA); nest2 = mnl_attr_nest_start(nlh, NFTA_DATA_VERDICT); mnl_attr_put_u32(nlh, NFTA_VERDICT_CODE, htonl(e->data.verdict)); - if (e->flags & (1 << NFT_SET_ELEM_ATTR_CHAIN)) + if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_CHAIN)) mnl_attr_put_strz(nlh, NFTA_VERDICT_CHAIN, e->data.chain); mnl_attr_nest_end(nlh, nest1); mnl_attr_nest_end(nlh, nest2); } - if (e->flags & (1 << NFT_SET_ELEM_ATTR_DATA)) { + if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_DATA)) { struct nlattr *nest1; nest1 = mnl_attr_nest_start(nlh, NFTA_SET_ELEM_DATA); mnl_attr_put(nlh, NFTA_DATA_VALUE, e->data.len, e->data.val); mnl_attr_nest_end(nlh, nest1); } - if (e->flags & (1 << NFT_SET_ELEM_ATTR_USERDATA)) + if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_USERDATA)) mnl_attr_put(nlh, NFTA_SET_ELEM_USERDATA, e->user.len, e->user.data); } -static void nft_set_elem_nlmsg_build_def(struct nlmsghdr *nlh, - struct nft_set *s) +static void nftnl_set_elem_nlmsg_build_def(struct nlmsghdr *nlh, + struct nftnl_set *s) { - if (s->flags & (1 << NFT_SET_ATTR_NAME)) + if (s->flags & (1 << NFTNL_SET_ATTR_NAME)) mnl_attr_put_strz(nlh, NFTA_SET_ELEM_LIST_SET, s->name); - if (s->flags & (1 << NFT_SET_ATTR_ID)) + if (s->flags & (1 << NFTNL_SET_ATTR_ID)) mnl_attr_put_u32(nlh, NFTA_SET_ELEM_LIST_SET_ID, htonl(s->id)); - if (s->flags & (1 << NFT_SET_ATTR_TABLE)) + if (s->flags & (1 << NFTNL_SET_ATTR_TABLE)) mnl_attr_put_strz(nlh, NFTA_SET_ELEM_LIST_TABLE, s->table); } -static struct nlattr *nft_set_elem_attr_build(struct nlmsghdr *nlh, - struct nft_set_elem *elem, int i) +static struct nlattr *nftnl_set_elem_attr_build(struct nlmsghdr *nlh, + struct nftnl_set_elem *elem, int i) { struct nlattr *nest2; nest2 = mnl_attr_nest_start(nlh, i); - nft_set_elem_nlmsg_build_payload(nlh, elem); + nftnl_set_elem_nlmsg_build_payload(nlh, elem); mnl_attr_nest_end(nlh, nest2); return nest2; } -void nft_set_elems_nlmsg_build_payload(struct nlmsghdr *nlh, struct nft_set *s) +void nftnl_set_elems_nlmsg_build_payload(struct nlmsghdr *nlh, struct nftnl_set *s) { - struct nft_set_elem *elem; + struct nftnl_set_elem *elem; struct nlattr *nest1; int i = 0; - nft_set_elem_nlmsg_build_def(nlh, s); + nftnl_set_elem_nlmsg_build_def(nlh, s); nest1 = mnl_attr_nest_start(nlh, NFTA_SET_ELEM_LIST_ELEMENTS); list_for_each_entry(elem, &s->element_list, head) - nft_set_elem_attr_build(nlh, elem, ++i); + nftnl_set_elem_attr_build(nlh, elem, ++i); mnl_attr_nest_end(nlh, nest1); } EXPORT_SYMBOL(nftnl_set_elems_nlmsg_build_payload, nft_set_elems_nlmsg_build_payload); -static int nft_set_elem_parse_attr_cb(const struct nlattr *attr, void *data) +static int nftnl_set_elem_parse_attr_cb(const struct nlattr *attr, void *data) { const struct nlattr **tb = data; int type = mnl_attr_get_type(attr); @@ -332,58 +332,58 @@ static int nft_set_elem_parse_attr_cb(const struct nlattr *attr, void *data) return MNL_CB_OK; } -static int nft_set_elems_parse2(struct nft_set *s, const struct nlattr *nest) +static int nftnl_set_elems_parse2(struct nftnl_set *s, const struct nlattr *nest) { struct nlattr *tb[NFTA_SET_ELEM_MAX+1] = {}; - struct nft_set_elem *e; + struct nftnl_set_elem *e; int ret = 0, type; - e = nft_set_elem_alloc(); + e = nftnl_set_elem_alloc(); if (e == NULL) return -1; - if (mnl_attr_parse_nested(nest, nft_set_elem_parse_attr_cb, tb) < 0) { - nft_set_elem_free(e); + if (mnl_attr_parse_nested(nest, nftnl_set_elem_parse_attr_cb, tb) < 0) { + nftnl_set_elem_free(e); return -1; } if (tb[NFTA_SET_ELEM_FLAGS]) { e->set_elem_flags = ntohl(mnl_attr_get_u32(tb[NFTA_SET_ELEM_FLAGS])); - e->flags |= (1 << NFT_SET_ELEM_ATTR_FLAGS); + e->flags |= (1 << NFTNL_SET_ELEM_ATTR_FLAGS); } if (tb[NFTA_SET_ELEM_TIMEOUT]) { e->timeout = be64toh(mnl_attr_get_u64(tb[NFTA_SET_ELEM_TIMEOUT])); - e->flags |= (1 << NFT_SET_ELEM_ATTR_TIMEOUT); + e->flags |= (1 << NFTNL_SET_ELEM_ATTR_TIMEOUT); } if (tb[NFTA_SET_ELEM_EXPIRATION]) { e->expiration = be64toh(mnl_attr_get_u64(tb[NFTA_SET_ELEM_EXPIRATION])); - e->flags |= (1 << NFT_SET_ELEM_ATTR_EXPIRATION); + e->flags |= (1 << NFTNL_SET_ELEM_ATTR_EXPIRATION); } if (tb[NFTA_SET_ELEM_KEY]) { - ret = nft_parse_data(&e->key, tb[NFTA_SET_ELEM_KEY], &type); - e->flags |= (1 << NFT_SET_ELEM_ATTR_KEY); + ret = nftnl_parse_data(&e->key, tb[NFTA_SET_ELEM_KEY], &type); + e->flags |= (1 << NFTNL_SET_ELEM_ATTR_KEY); } if (tb[NFTA_SET_ELEM_DATA]) { - ret = nft_parse_data(&e->data, tb[NFTA_SET_ELEM_DATA], &type); + ret = nftnl_parse_data(&e->data, tb[NFTA_SET_ELEM_DATA], &type); switch(type) { case DATA_VERDICT: - e->flags |= (1 << NFT_SET_ELEM_ATTR_VERDICT); + e->flags |= (1 << NFTNL_SET_ELEM_ATTR_VERDICT); break; case DATA_CHAIN: - e->flags |= (1 << NFT_SET_ELEM_ATTR_VERDICT) | - (1 << NFT_SET_ELEM_ATTR_CHAIN); + e->flags |= (1 << NFTNL_SET_ELEM_ATTR_VERDICT) | + (1 << NFTNL_SET_ELEM_ATTR_CHAIN); break; case DATA_VALUE: - e->flags |= (1 << NFT_SET_ELEM_ATTR_DATA); + e->flags |= (1 << NFTNL_SET_ELEM_ATTR_DATA); break; } } if (tb[NFTA_SET_ELEM_EXPR]) { - e->expr = nft_rule_expr_parse(tb[NFTA_SET_ELEM_EXPR]); + e->expr = nftnl_rule_expr_parse(tb[NFTA_SET_ELEM_EXPR]); if (e->expr == NULL) goto err; - e->flags |= (1 << NFT_SET_ELEM_ATTR_EXPR); + e->flags |= (1 << NFTNL_SET_ELEM_ATTR_EXPR); } if (tb[NFTA_SET_ELEM_USERDATA]) { const void *udata = @@ -397,12 +397,12 @@ static int nft_set_elems_parse2(struct nft_set *s, const struct nlattr *nest) if (e->user.data == NULL) goto err; memcpy(e->user.data, udata, e->user.len); - e->flags |= (1 << NFT_RULE_ATTR_USERDATA); + e->flags |= (1 << NFTNL_RULE_ATTR_USERDATA); } if (ret < 0) { err: - nft_set_elem_free(e); + nftnl_set_elem_free(e); return -1; } @@ -413,7 +413,7 @@ err: } static int -nft_set_elem_list_parse_attr_cb(const struct nlattr *attr, void *data) +nftnl_set_elem_list_parse_attr_cb(const struct nlattr *attr, void *data) { const struct nlattr **tb = data; int type = mnl_attr_get_type(attr); @@ -437,7 +437,7 @@ nft_set_elem_list_parse_attr_cb(const struct nlattr *attr, void *data) return MNL_CB_OK; } -static int nft_set_elems_parse(struct nft_set *s, const struct nlattr *nest) +static int nftnl_set_elems_parse(struct nftnl_set *s, const struct nlattr *nest) { struct nlattr *attr; int ret = 0; @@ -446,74 +446,74 @@ static int nft_set_elems_parse(struct nft_set *s, const struct nlattr *nest) if (mnl_attr_get_type(attr) != NFTA_LIST_ELEM) return -1; - ret = nft_set_elems_parse2(s, attr); + ret = nftnl_set_elems_parse2(s, attr); } return ret; } -int nft_set_elems_nlmsg_parse(const struct nlmsghdr *nlh, struct nft_set *s) +int nftnl_set_elems_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_set *s) { struct nlattr *tb[NFTA_SET_ELEM_LIST_MAX+1] = {}; struct nfgenmsg *nfg = mnl_nlmsg_get_payload(nlh); int ret = 0; if (mnl_attr_parse(nlh, sizeof(*nfg), - nft_set_elem_list_parse_attr_cb, tb) < 0) + nftnl_set_elem_list_parse_attr_cb, tb) < 0) return -1; if (tb[NFTA_SET_ELEM_LIST_TABLE]) { xfree(s->table); s->table = strdup(mnl_attr_get_str(tb[NFTA_SET_ELEM_LIST_TABLE])); - s->flags |= (1 << NFT_SET_ATTR_TABLE); + s->flags |= (1 << NFTNL_SET_ATTR_TABLE); } if (tb[NFTA_SET_ELEM_LIST_SET]) { xfree(s->name); s->name = strdup(mnl_attr_get_str(tb[NFTA_SET_ELEM_LIST_SET])); - s->flags |= (1 << NFT_SET_ATTR_NAME); + s->flags |= (1 << NFTNL_SET_ATTR_NAME); } if (tb[NFTA_SET_ELEM_LIST_SET_ID]) { s->id = ntohl(mnl_attr_get_u32(tb[NFTA_SET_ELEM_LIST_SET_ID])); - s->flags |= (1 << NFT_SET_ATTR_ID); + s->flags |= (1 << NFTNL_SET_ATTR_ID); } if (tb[NFTA_SET_ELEM_LIST_ELEMENTS]) - ret = nft_set_elems_parse(s, tb[NFTA_SET_ELEM_LIST_ELEMENTS]); + ret = nftnl_set_elems_parse(s, tb[NFTA_SET_ELEM_LIST_ELEMENTS]); s->family = nfg->nfgen_family; - s->flags |= (1 << NFT_SET_ATTR_FAMILY); + s->flags |= (1 << NFTNL_SET_ATTR_FAMILY); return ret; } EXPORT_SYMBOL(nftnl_set_elems_nlmsg_parse, nft_set_elems_nlmsg_parse); #ifdef XML_PARSING -int nft_mxml_set_elem_parse(mxml_node_t *tree, struct nft_set_elem *e, - struct nft_parse_err *err) +int nftnl_mxml_set_elem_parse(mxml_node_t *tree, struct nftnl_set_elem *e, + struct nftnl_parse_err *err) { int set_elem_data; uint32_t set_elem_flags; - if (nft_mxml_num_parse(tree, "flags", MXML_DESCEND_FIRST, BASE_DEC, - &set_elem_flags, NFT_TYPE_U32, NFT_XML_MAND, + if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND_FIRST, BASE_DEC, + &set_elem_flags, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0) - nft_set_elem_attr_set_u32(e, NFT_SET_ELEM_ATTR_FLAGS, set_elem_flags); + nftnl_set_elem_attr_set_u32(e, NFTNL_SET_ELEM_ATTR_FLAGS, set_elem_flags); - if (nft_mxml_data_reg_parse(tree, "key", &e->key, - NFT_XML_MAND, err) == DATA_VALUE) - e->flags |= (1 << NFT_SET_ELEM_ATTR_KEY); + if (nftnl_mxml_data_reg_parse(tree, "key", &e->key, + NFTNL_XML_MAND, err) == DATA_VALUE) + e->flags |= (1 << NFTNL_SET_ELEM_ATTR_KEY); /* <set_elem_data> is not mandatory */ - set_elem_data = nft_mxml_data_reg_parse(tree, "data", - &e->data, NFT_XML_OPT, err); + set_elem_data = nftnl_mxml_data_reg_parse(tree, "data", + &e->data, NFTNL_XML_OPT, err); switch (set_elem_data) { case DATA_VALUE: - e->flags |= (1 << NFT_SET_ELEM_ATTR_DATA); + e->flags |= (1 << NFTNL_SET_ELEM_ATTR_DATA); break; case DATA_VERDICT: - e->flags |= (1 << NFT_SET_ELEM_ATTR_VERDICT); + e->flags |= (1 << NFTNL_SET_ELEM_ATTR_VERDICT); if (e->data.chain != NULL) - e->flags |= (1 << NFT_SET_ELEM_ATTR_CHAIN); + e->flags |= (1 << NFTNL_SET_ELEM_ATTR_CHAIN); break; } @@ -522,19 +522,19 @@ int nft_mxml_set_elem_parse(mxml_node_t *tree, struct nft_set_elem *e, } #endif -static int nft_set_elem_xml_parse(struct nft_set_elem *e, const void *xml, - struct nft_parse_err *err, - enum nft_parse_input input) +static int nftnl_set_elem_xml_parse(struct nftnl_set_elem *e, const void *xml, + struct nftnl_parse_err *err, + enum nftnl_parse_input input) { #ifdef XML_PARSING mxml_node_t *tree; int ret; - tree = nft_mxml_build_tree(xml, "set_elem", err, input); + tree = nftnl_mxml_build_tree(xml, "set_elem", err, input); if (tree == NULL) return -1; - ret = nft_mxml_set_elem_parse(tree, e, err); + ret = nftnl_mxml_set_elem_parse(tree, e, err); mxmlDelete(tree); return ret; #else @@ -543,19 +543,19 @@ static int nft_set_elem_xml_parse(struct nft_set_elem *e, const void *xml, #endif } -static int nft_set_elem_json_parse(struct nft_set_elem *e, const void *json, - struct nft_parse_err *err, - enum nft_parse_input input) +static int nftnl_set_elem_json_parse(struct nftnl_set_elem *e, const void *json, + struct nftnl_parse_err *err, + enum nftnl_parse_input input) { #ifdef JSON_PARSING json_t *tree; json_error_t error; - tree = nft_jansson_create_root(json, &error, err, input); + tree = nftnl_jansson_create_root(json, &error, err, input); if (tree == NULL) return -1; - return nft_jansson_set_elem_parse(e, tree, err); + return nftnl_jansson_set_elem_parse(e, tree, err); #else errno = EOPNOTSUPP; return -1; @@ -563,18 +563,18 @@ static int nft_set_elem_json_parse(struct nft_set_elem *e, const void *json, } static int -nft_set_elem_do_parse(struct nft_set_elem *e, enum nft_parse_type type, - const void *data, struct nft_parse_err *err, - enum nft_parse_input input) +nftnl_set_elem_do_parse(struct nftnl_set_elem *e, enum nftnl_parse_type type, + const void *data, struct nftnl_parse_err *err, + enum nftnl_parse_input input) { int ret; switch (type) { - case NFT_PARSE_XML: - ret = nft_set_elem_xml_parse(e, data, err, input); + case NFTNL_PARSE_XML: + ret = nftnl_set_elem_xml_parse(e, data, err, input); break; - case NFT_PARSE_JSON: - ret = nft_set_elem_json_parse(e, data, err, input); + case NFTNL_PARSE_JSON: + ret = nftnl_set_elem_json_parse(e, data, err, input); break; default: errno = EOPNOTSUPP; @@ -584,26 +584,26 @@ nft_set_elem_do_parse(struct nft_set_elem *e, enum nft_parse_type type, return ret; } -int nft_set_elem_parse(struct nft_set_elem *e, enum nft_parse_type type, - const char *data, struct nft_parse_err *err) +int nftnl_set_elem_parse(struct nftnl_set_elem *e, enum nftnl_parse_type type, + const char *data, struct nftnl_parse_err *err) { - return nft_set_elem_do_parse(e, type, data, err, NFT_PARSE_BUFFER); + return nftnl_set_elem_do_parse(e, type, data, err, NFTNL_PARSE_BUFFER); } EXPORT_SYMBOL(nftnl_set_elem_parse, nft_set_elem_parse); -int nft_set_elem_parse_file(struct nft_set_elem *e, enum nft_parse_type type, - FILE *fp, struct nft_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) { - return nft_set_elem_do_parse(e, type, fp, err, NFT_PARSE_FILE); + return nftnl_set_elem_do_parse(e, type, fp, err, NFTNL_PARSE_FILE); } EXPORT_SYMBOL(nftnl_set_elem_parse_file, nft_set_elem_parse_file); -static int nft_set_elem_snprintf_json(char *buf, size_t size, - struct nft_set_elem *e, uint32_t flags) +static int nftnl_set_elem_snprintf_json(char *buf, size_t size, + struct nftnl_set_elem *e, uint32_t flags) { int ret, len = size, offset = 0, type = -1; - if (e->flags & (1 << NFT_SET_ELEM_ATTR_FLAGS)) { + if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_FLAGS)) { ret = snprintf(buf, len, "\"flags\":%u,", e->set_elem_flags); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } @@ -611,26 +611,26 @@ static int nft_set_elem_snprintf_json(char *buf, size_t size, ret = snprintf(buf + offset, len, "\"key\":{"); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - ret = nft_data_reg_snprintf(buf + offset, len, &e->key, - NFT_OUTPUT_JSON, flags, DATA_VALUE); + ret = nftnl_data_reg_snprintf(buf + offset, len, &e->key, + NFTNL_OUTPUT_JSON, flags, DATA_VALUE); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = snprintf(buf + offset, len, "}"); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - if (e->flags & (1 << NFT_SET_ELEM_ATTR_DATA)) + if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_DATA)) type = DATA_VALUE; - else if (e->flags & (1 << NFT_SET_ELEM_ATTR_CHAIN)) + else if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_CHAIN)) type = DATA_CHAIN; - else if (e->flags & (1 << NFT_SET_ELEM_ATTR_VERDICT)) + else if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_VERDICT)) type = DATA_VERDICT; if (type != -1) { ret = snprintf(buf + offset, len, ",\"data\":{"); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - ret = nft_data_reg_snprintf(buf + offset, len, &e->data, - NFT_OUTPUT_JSON, flags, type); + ret = nftnl_data_reg_snprintf(buf + offset, len, &e->data, + NFTNL_OUTPUT_JSON, flags, type); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = snprintf(buf + offset, len, "}"); @@ -640,8 +640,8 @@ static int nft_set_elem_snprintf_json(char *buf, size_t size, return offset; } -static int nft_set_elem_snprintf_default(char *buf, size_t size, - struct nft_set_elem *e) +static int nftnl_set_elem_snprintf_default(char *buf, size_t size, + struct nftnl_set_elem *e) { int ret, len = size, offset = 0, i; @@ -683,45 +683,45 @@ static int nft_set_elem_snprintf_default(char *buf, size_t size, return offset; } -static int nft_set_elem_snprintf_xml(char *buf, size_t size, - struct nft_set_elem *e, uint32_t flags) +static int nftnl_set_elem_snprintf_xml(char *buf, size_t size, + struct nftnl_set_elem *e, uint32_t flags) { int ret, len = size, offset = 0, type = DATA_NONE; ret = snprintf(buf, size, "<set_elem>"); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - if (e->flags & (1 << NFT_SET_ELEM_ATTR_FLAGS)) { + if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_FLAGS)) { ret = snprintf(buf + offset, size, "<flags>%u</flags>", e->set_elem_flags); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (e->flags & (1 << NFT_SET_ELEM_ATTR_KEY)) { + if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_KEY)) { ret = snprintf(buf + offset, len, "<key>"); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - ret = nft_data_reg_snprintf(buf + offset, len, &e->key, - NFT_OUTPUT_XML, flags, DATA_VALUE); + ret = nftnl_data_reg_snprintf(buf + offset, len, &e->key, + NFTNL_OUTPUT_XML, flags, DATA_VALUE); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = snprintf(buf + offset, len, "</key>"); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } - if (e->flags & (1 << NFT_SET_ELEM_ATTR_DATA)) + if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_DATA)) type = DATA_VALUE; - else if (e->flags & (1 << NFT_SET_ELEM_ATTR_CHAIN)) + else if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_CHAIN)) type = DATA_CHAIN; - else if (e->flags & (1 << NFT_SET_ELEM_ATTR_VERDICT)) + else if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_VERDICT)) type = DATA_VERDICT; if (type != DATA_NONE) { ret = snprintf(buf + offset, len, "<data>"); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - ret = nft_data_reg_snprintf(buf + offset, len, &e->data, - NFT_OUTPUT_XML, flags, type); + ret = nftnl_data_reg_snprintf(buf + offset, len, &e->data, + NFTNL_OUTPUT_XML, flags, type); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); ret = snprintf(buf + offset, len, "</data>"); @@ -734,24 +734,24 @@ static int nft_set_elem_snprintf_xml(char *buf, size_t size, return offset; } -static int nft_set_elem_cmd_snprintf(char *buf, size_t size, - struct nft_set_elem *e, uint32_t cmd, +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) { int ret, len = size, offset = 0; - ret = nft_cmd_header_snprintf(buf + offset, len, cmd, type, flags); + ret = nftnl_cmd_header_snprintf(buf + offset, len, cmd, type, flags); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); switch(type) { - case NFT_OUTPUT_DEFAULT: - ret = nft_set_elem_snprintf_default(buf+offset, len, e); + case NFTNL_OUTPUT_DEFAULT: + ret = nftnl_set_elem_snprintf_default(buf+offset, len, e); break; - case NFT_OUTPUT_XML: - ret = nft_set_elem_snprintf_xml(buf+offset, len, e, flags); + case NFTNL_OUTPUT_XML: + ret = nftnl_set_elem_snprintf_xml(buf+offset, len, e, flags); break; - case NFT_OUTPUT_JSON: - ret = nft_set_elem_snprintf_json(buf+offset, len, e, flags); + case NFTNL_OUTPUT_JSON: + ret = nftnl_set_elem_snprintf_json(buf+offset, len, e, flags); break; default: return -1; @@ -759,40 +759,40 @@ static int nft_set_elem_cmd_snprintf(char *buf, size_t size, SNPRINTF_BUFFER_SIZE(ret, size, len, offset); - ret = nft_cmd_footer_snprintf(buf + offset, len, cmd, type, flags); + ret = nftnl_cmd_footer_snprintf(buf + offset, len, cmd, type, flags); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); return offset; } -int nft_set_elem_snprintf(char *buf, size_t size, struct nft_set_elem *e, +int nftnl_set_elem_snprintf(char *buf, size_t size, struct nftnl_set_elem *e, uint32_t type, uint32_t flags) { - return nft_set_elem_cmd_snprintf(buf, size, e, nft_flag2cmd(flags), + return nftnl_set_elem_cmd_snprintf(buf, size, e, nftnl_flag2cmd(flags), type, flags); } EXPORT_SYMBOL(nftnl_set_elem_snprintf, nft_set_elem_snprintf); -static inline int nft_set_elem_do_snprintf(char *buf, size_t size, void *e, +static inline int nftnl_set_elem_do_snprintf(char *buf, size_t size, void *e, uint32_t cmd, uint32_t type, uint32_t flags) { - return nft_set_elem_snprintf(buf, size, e, type, flags); + return nftnl_set_elem_snprintf(buf, size, e, type, flags); } -int nft_set_elem_fprintf(FILE *fp, struct nft_set_elem *se, uint32_t type, +int nftnl_set_elem_fprintf(FILE *fp, struct nftnl_set_elem *se, uint32_t type, uint32_t flags) { - return nft_fprintf(fp, se, NFT_CMD_UNSPEC, type, flags, - nft_set_elem_do_snprintf); + return nftnl_fprintf(fp, se, NFTNL_CMD_UNSPEC, type, flags, + nftnl_set_elem_do_snprintf); } EXPORT_SYMBOL(nftnl_set_elem_fprintf, nft_set_elem_fprintf); -int nft_set_elem_foreach(struct nft_set *s, - int (*cb)(struct nft_set_elem *e, void *data), +int nftnl_set_elem_foreach(struct nftnl_set *s, + int (*cb)(struct nftnl_set_elem *e, void *data), void *data) { - struct nft_set_elem *elem; + struct nftnl_set_elem *elem; int ret; list_for_each_entry(elem, &s->element_list, head) { @@ -804,17 +804,17 @@ int nft_set_elem_foreach(struct nft_set *s, } EXPORT_SYMBOL(nftnl_set_elem_foreach, nft_set_elem_foreach); -struct nft_set_elems_iter { - struct nft_set *set; +struct nftnl_set_elems_iter { + struct nftnl_set *set; struct list_head *list; - struct nft_set_elem *cur; + struct nftnl_set_elem *cur; }; -struct nft_set_elems_iter *nft_set_elems_iter_create(struct nft_set *s) +struct nftnl_set_elems_iter *nftnl_set_elems_iter_create(struct nftnl_set *s) { - struct nft_set_elems_iter *iter; + struct nftnl_set_elems_iter *iter; - iter = calloc(1, sizeof(struct nft_set_elems_iter)); + iter = calloc(1, sizeof(struct nftnl_set_elems_iter)); if (iter == NULL) return NULL; @@ -824,26 +824,26 @@ struct nft_set_elems_iter *nft_set_elems_iter_create(struct nft_set *s) iter->cur = NULL; else iter->cur = list_entry(s->element_list.next, - struct nft_set_elem, head); + struct nftnl_set_elem, head); return iter; } EXPORT_SYMBOL(nftnl_set_elems_iter_create, nft_set_elems_iter_create); -struct nft_set_elem *nft_set_elems_iter_cur(struct nft_set_elems_iter *iter) +struct nftnl_set_elem *nftnl_set_elems_iter_cur(struct nftnl_set_elems_iter *iter) { return iter->cur; } EXPORT_SYMBOL(nftnl_set_elems_iter_cur, nft_set_elems_iter_cur); -struct nft_set_elem *nft_set_elems_iter_next(struct nft_set_elems_iter *iter) +struct nftnl_set_elem *nftnl_set_elems_iter_next(struct nftnl_set_elems_iter *iter) { - struct nft_set_elem *s = iter->cur; + struct nftnl_set_elem *s = iter->cur; if (s == NULL) return NULL; - iter->cur = list_entry(iter->cur->head.next, struct nft_set_elem, head); + iter->cur = list_entry(iter->cur->head.next, struct nftnl_set_elem, head); if (&iter->cur->head == iter->list->next) return NULL; @@ -851,13 +851,13 @@ struct nft_set_elem *nft_set_elems_iter_next(struct nft_set_elems_iter *iter) } EXPORT_SYMBOL(nftnl_set_elems_iter_next, nft_set_elems_iter_next); -void nft_set_elems_iter_destroy(struct nft_set_elems_iter *iter) +void nftnl_set_elems_iter_destroy(struct nftnl_set_elems_iter *iter) { xfree(iter); } EXPORT_SYMBOL(nftnl_set_elems_iter_destroy, nft_set_elems_iter_destroy); -static bool nft_attr_nest_overflow(struct nlmsghdr *nlh, +static bool nftnl_attr_nest_overflow(struct nlmsghdr *nlh, const struct nlattr *from, const struct nlattr *to) { @@ -874,27 +874,27 @@ static bool nft_attr_nest_overflow(struct nlmsghdr *nlh, return false; } -int nft_set_elems_nlmsg_build_payload_iter(struct nlmsghdr *nlh, - struct nft_set_elems_iter *iter) +int nftnl_set_elems_nlmsg_build_payload_iter(struct nlmsghdr *nlh, + struct nftnl_set_elems_iter *iter) { - struct nft_set_elem *elem; + struct nftnl_set_elem *elem; struct nlattr *nest1, *nest2; int i = 0, ret = 0; - nft_set_elem_nlmsg_build_def(nlh, iter->set); + nftnl_set_elem_nlmsg_build_def(nlh, iter->set); nest1 = mnl_attr_nest_start(nlh, NFTA_SET_ELEM_LIST_ELEMENTS); - elem = nft_set_elems_iter_next(iter); + elem = nftnl_set_elems_iter_next(iter); while (elem != NULL) { - nest2 = nft_set_elem_attr_build(nlh, elem, ++i); - if (nft_attr_nest_overflow(nlh, nest1, nest2)) { + nest2 = nftnl_set_elem_attr_build(nlh, elem, ++i); + if (nftnl_attr_nest_overflow(nlh, nest1, nest2)) { /* Go back to previous not to miss this element */ iter->cur = list_entry(iter->cur->head.prev, - struct nft_set_elem, head); + struct nftnl_set_elem, head); ret = 1; break; } - elem = nft_set_elems_iter_next(iter); + elem = nftnl_set_elems_iter_next(iter); } mnl_attr_nest_end(nlh, nest1); |