* [libnftables PATCH 1/2] ruleset: factorize json/xml tagging
@ 2013-10-28 10:57 Arturo Borrero Gonzalez
2013-10-28 10:57 ` [libnftables PATCH 2/2] src: add fprintf API functions Arturo Borrero Gonzalez
2013-11-03 21:13 ` [libnftables PATCH 1/2] ruleset: factorize json/xml tagging Pablo Neira Ayuso
0 siblings, 2 replies; 3+ messages in thread
From: Arturo Borrero Gonzalez @ 2013-10-28 10:57 UTC (permalink / raw)
To: netfilter-devel
This factorization of JSON/XML open & close tag allows reutilice code in future
patches (for example, the fprintf API functions).
Signed-off-by: Arturo Borrero Gonzalez <arturo.borrero.glez@gmail.com>
---
src/ruleset.c | 107 +++++++++++++++++++++++++++++----------------------------
1 file changed, 54 insertions(+), 53 deletions(-)
diff --git a/src/ruleset.c b/src/ruleset.c
index 8944da6..24b849b 100644
--- a/src/ruleset.c
+++ b/src/ruleset.c
@@ -579,18 +579,42 @@ int nft_ruleset_parse(struct nft_ruleset *r, enum nft_ruleset_parse_type type,
}
EXPORT_SYMBOL(nft_ruleset_parse);
-static int separator_snprintf(char *buf, size_t size, void *obj, uint32_t type)
+static const char *nft_ruleset_o_opentag(uint32_t type)
+{
+ switch (type) {
+ case NFT_RULESET_O_XML:
+ return "<nftables>";
+ case NFT_RULESET_O_JSON:
+ return "{\"nftables\":[";
+ default:
+ return "";
+ }
+}
+
+static const char *nft_ruleset_o_separator(void *obj, uint32_t type)
{
if (obj == NULL)
- return 0;
+ return "";
switch (type) {
case NFT_RULESET_O_JSON:
- return snprintf(buf, size, ",");
+ return ",";
case NFT_RULESET_O_DEFAULT:
- return snprintf(buf, size, "\n");
+ return "\n";
default:
- return 0;
+ return "";
+ }
+}
+
+static const char *nft_ruleset_o_closetag(uint32_t type)
+{
+ switch (type) {
+ case NFT_RULESET_O_XML:
+ return "</nftables>";
+ case NFT_RULESET_O_JSON:
+ return "]}";
+ default:
+ return "";
}
}
@@ -613,7 +637,9 @@ nft_ruleset_snprintf_table(char *buf, size_t size,
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
t = nft_table_list_iter_next(ti);
- ret = separator_snprintf(buf+offset, len, t, type);
+
+ ret = snprintf(buf+offset, len, "%s",
+ nft_ruleset_o_separator(t, type));
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
nft_table_list_iter_destroy(ti);
@@ -640,7 +666,9 @@ nft_ruleset_snprintf_chain(char *buf, size_t size,
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
c = nft_chain_list_iter_next(ci);
- ret = separator_snprintf(buf+offset, len, c, type);
+
+ ret = snprintf(buf+offset, len, "%s",
+ nft_ruleset_o_separator(c, type));
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
nft_chain_list_iter_destroy(ci);
@@ -667,7 +695,9 @@ nft_ruleset_snprintf_set(char *buf, size_t size,
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
s = nft_set_list_iter_next(si);
- ret = separator_snprintf(buf+offset, len, s, type);
+
+ ret = snprintf(buf+offset, len, "%s",
+ nft_ruleset_o_separator(s, type));
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
nft_set_list_iter_destroy(si);
@@ -694,7 +724,9 @@ nft_ruleset_snprintf_rule(char *buf, size_t size,
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
r = nft_rule_list_iter_next(ri);
- ret = separator_snprintf(buf+offset, len, r, type);
+
+ ret = snprintf(buf+offset, len, "%s",
+ nft_ruleset_o_separator(r, type));
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
nft_rule_list_iter_destroy(ri);
@@ -709,6 +741,9 @@ nft_ruleset_do_snprintf(char *buf, size_t size, const struct nft_ruleset *rs,
int ret, len = size, offset = 0;
void *prev = NULL;
+ ret = snprintf(buf+offset, size, "%s", nft_ruleset_o_opentag(type));
+ SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+
if (nft_ruleset_attr_is_set(rs, NFT_RULESET_ATTR_TABLELIST) &&
(!nft_table_list_is_empty(rs->table_list))) {
ret = nft_ruleset_snprintf_table(buf+offset, len, rs,
@@ -721,7 +756,8 @@ nft_ruleset_do_snprintf(char *buf, size_t size, const struct nft_ruleset *rs,
if (nft_ruleset_attr_is_set(rs, NFT_RULESET_ATTR_CHAINLIST) &&
(!nft_chain_list_is_empty(rs->chain_list))) {
- ret = separator_snprintf(buf+offset, len, prev, type);
+ ret = snprintf(buf+offset, len, "%s",
+ nft_ruleset_o_separator(prev, type));
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
ret = nft_ruleset_snprintf_chain(buf+offset, len, rs,
@@ -734,7 +770,8 @@ nft_ruleset_do_snprintf(char *buf, size_t size, const struct nft_ruleset *rs,
if (nft_ruleset_attr_is_set(rs, NFT_RULESET_ATTR_SETLIST) &&
(!nft_set_list_is_empty(rs->set_list))) {
- ret = separator_snprintf(buf+offset, len, prev, type);
+ ret = snprintf(buf+offset, len, "%s",
+ nft_ruleset_o_separator(prev, type));
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
ret = nft_ruleset_snprintf_set(buf+offset, len, rs,
@@ -747,7 +784,8 @@ nft_ruleset_do_snprintf(char *buf, size_t size, const struct nft_ruleset *rs,
if (nft_ruleset_attr_is_set(rs, NFT_RULESET_ATTR_RULELIST) &&
(!nft_rule_list_is_empty(rs->rule_list))) {
- ret = separator_snprintf(buf+offset, len, prev, type);
+ ret = snprintf(buf+offset, len, "%s",
+ nft_ruleset_o_separator(prev, type));
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
ret = nft_ruleset_snprintf_rule(buf+offset, len, rs,
@@ -755,42 +793,7 @@ nft_ruleset_do_snprintf(char *buf, size_t size, const struct nft_ruleset *rs,
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
}
- return offset;
-}
-
-static int
-nft_ruleset_snprintf_xml(char *buf, size_t size, const struct nft_ruleset *rs,
- uint32_t flags)
-{
- int ret, len = size, offset = 0;
-
- ret = snprintf(buf, size, "<nftables>");
- SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-
- ret = nft_ruleset_do_snprintf(buf+offset, len, rs, NFT_RULESET_O_XML,
- flags);
- SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-
- ret = snprintf(buf+offset, len, "</nftables>");
- SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-
- return offset;
-}
-
-static int
-nft_ruleset_snprintf_json(char *buf, size_t size, const struct nft_ruleset *rs,
- uint32_t flags)
-{
- int ret, len = size, offset = 0;
-
- ret = snprintf(buf, size, "{\"nftables\":[");
- SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-
- ret = nft_ruleset_do_snprintf(buf+offset, len, rs, NFT_RULESET_O_JSON,
- flags);
- SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-
- ret = snprintf(buf+offset, len, "]}");
+ ret = snprintf(buf+offset, size, "%s", nft_ruleset_o_closetag(type));
SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
return offset;
@@ -801,14 +804,12 @@ int nft_ruleset_snprintf(char *buf, size_t size, const struct nft_ruleset *r,
{
switch (type) {
case NFT_RULESET_O_DEFAULT:
- return nft_ruleset_do_snprintf(buf, size, r, type, flags);
case NFT_RULESET_O_XML:
- return nft_ruleset_snprintf_xml(buf, size, r, flags);
case NFT_RULESET_O_JSON:
- return nft_ruleset_snprintf_json(buf, size, r, flags);
+ return nft_ruleset_do_snprintf(buf, size, r, type, flags);
default:
- break;
+ errno = EOPNOTSUPP;
+ return -1;
}
- return -1;
}
EXPORT_SYMBOL(nft_ruleset_snprintf);
^ permalink raw reply related [flat|nested] 3+ messages in thread
* [libnftables PATCH 2/2] src: add fprintf API functions
2013-10-28 10:57 [libnftables PATCH 1/2] ruleset: factorize json/xml tagging Arturo Borrero Gonzalez
@ 2013-10-28 10:57 ` Arturo Borrero Gonzalez
2013-11-03 21:13 ` [libnftables PATCH 1/2] ruleset: factorize json/xml tagging Pablo Neira Ayuso
1 sibling, 0 replies; 3+ messages in thread
From: Arturo Borrero Gonzalez @ 2013-10-28 10:57 UTC (permalink / raw)
To: netfilter-devel
Now it's possible to print directly from libnftables to a file or other stream.
In order to don't force any format, the caller must print any trailing '\n'.
The error reporting of fprintf (< 0) is respected.
Signed-off-by: Arturo Borrero Gonzalez <arturo.borrero.glez@gmail.com>
---
include/libnftables/chain.h | 1
include/libnftables/rule.h | 1
include/libnftables/ruleset.h | 1
include/libnftables/set.h | 2
include/libnftables/table.h | 1
src/chain.c | 13 +++
src/internal.h | 4 +
src/libnftables.map | 6 +
src/rule.c | 13 +++
src/ruleset.c | 203 +++++++++++++++++++++++++++++++++++++++++
src/set.c | 13 +++
src/set_elem.c | 13 +++
src/table.c | 13 +++
src/utils.c | 27 +++++
14 files changed, 311 insertions(+)
diff --git a/include/libnftables/chain.h b/include/libnftables/chain.h
index d85a2a2..4ca0105 100644
--- a/include/libnftables/chain.h
+++ b/include/libnftables/chain.h
@@ -60,6 +60,7 @@ enum nft_chain_parse_type {
int nft_chain_parse(struct nft_chain *c, enum nft_chain_parse_type type, const char *data);
int nft_chain_snprintf(char *buf, size_t size, struct nft_chain *t, uint32_t type, uint32_t flags);
+int nft_chain_fprintf(FILE *fp, struct nft_chain *c, uint32_t type, uint32_t flags);
struct nlmsghdr *nft_chain_nlmsg_build_hdr(char *buf, uint16_t cmd, uint16_t family, uint16_t type, uint32_t seq);
int nft_chain_nlmsg_parse(const struct nlmsghdr *nlh, struct nft_chain *t);
diff --git a/include/libnftables/rule.h b/include/libnftables/rule.h
index a501d2d..5fb70d3 100644
--- a/include/libnftables/rule.h
+++ b/include/libnftables/rule.h
@@ -58,6 +58,7 @@ enum nft_rule_parse_type {
int nft_rule_parse(struct nft_rule *r, enum nft_rule_parse_type type, const char *data);
int nft_rule_snprintf(char *buf, size_t size, struct nft_rule *t, uint32_t type, uint32_t flags);
+int nft_rule_fprintf(FILE *fp, struct nft_rule *r, uint32_t type, uint32_t flags);
struct nlmsghdr *nft_rule_nlmsg_build_hdr(char *buf, uint16_t cmd, uint16_t family, uint16_t type, uint32_t seq);
int nft_rule_nlmsg_parse(const struct nlmsghdr *nlh, struct nft_rule *t);
diff --git a/include/libnftables/ruleset.h b/include/libnftables/ruleset.h
index a4a1279..980276d 100644
--- a/include/libnftables/ruleset.h
+++ b/include/libnftables/ruleset.h
@@ -37,6 +37,7 @@ enum nft_ruleset_parse_type {
int nft_ruleset_parse(struct nft_ruleset *rs, enum nft_ruleset_parse_type type, const char *data);
int nft_ruleset_snprintf(char *buf, size_t size, const struct nft_ruleset *rs, uint32_t type, uint32_t flags);
+int nft_ruleset_fprintf(FILE *fp, const struct nft_ruleset *rs, uint32_t type, uint32_t flags);
#ifdef __cplusplus
} /* extern "C" */
diff --git a/include/libnftables/set.h b/include/libnftables/set.h
index 14a6327..2e22a82 100644
--- a/include/libnftables/set.h
+++ b/include/libnftables/set.h
@@ -38,6 +38,7 @@ int nft_set_nlmsg_parse(const struct nlmsghdr *nlh, struct nft_set *s);
int nft_set_elems_nlmsg_parse(const struct nlmsghdr *nlh, struct nft_set *s);
int nft_set_snprintf(char *buf, size_t size, struct nft_set *s, uint32_t type, uint32_t flags);
+int nft_set_fprintf(FILE *fp, struct nft_set *s, uint32_t type, uint32_t flags);
struct nft_set_list;
@@ -108,6 +109,7 @@ int nft_set_elem_nlmsg_parse(const struct nlmsghdr *nlh, struct nft_set_elem *s)
int nft_set_elem_parse(struct nft_set_elem *e, enum nft_set_parse_type type, const char *data);
int nft_set_elem_snprintf(char *buf, size_t size, struct nft_set_elem *s, uint32_t type, uint32_t flags);
+int nft_set_elem_fprintf(FILE *fp, struct nft_set_elem *se, uint32_t type, uint32_t flags);
int nft_set_elem_foreach(struct nft_set *s, int (*cb)(struct nft_set_elem *e, void *data), void *data);
diff --git a/include/libnftables/table.h b/include/libnftables/table.h
index 42a4aa7..ec3a769 100644
--- a/include/libnftables/table.h
+++ b/include/libnftables/table.h
@@ -48,6 +48,7 @@ enum nft_table_parse_type {
int nft_table_parse(struct nft_table *t, enum nft_table_parse_type type, const char *data);
int nft_table_snprintf(char *buf, size_t size, struct nft_table *t, uint32_t type, uint32_t flags);
+int nft_table_fprintf(FILE *fp, struct nft_table *t, uint32_t type, uint32_t flags);
struct nlmsghdr *nft_table_nlmsg_build_hdr(char *buf, uint16_t cmd, uint16_t family, uint16_t type, uint32_t seq);
int nft_table_nlmsg_parse(const struct nlmsghdr *nlh, struct nft_table *t);
diff --git a/src/chain.c b/src/chain.c
index 6179f68..cdb398f 100644
--- a/src/chain.c
+++ b/src/chain.c
@@ -851,6 +851,19 @@ int nft_chain_snprintf(char *buf, size_t size, struct nft_chain *c,
}
EXPORT_SYMBOL(nft_chain_snprintf);
+static inline int nft_chain_do_snprintf(char *buf, size_t size, void *c,
+ uint32_t type, uint32_t flags)
+{
+ return nft_chain_snprintf(buf, size, c, type, flags);
+}
+
+int nft_chain_fprintf(FILE *fp, struct nft_chain *c, uint32_t type,
+ uint32_t flags)
+{
+ return nft_fprintf(fp, c, type, flags, nft_chain_do_snprintf);
+}
+EXPORT_SYMBOL(nft_chain_fprintf);
+
struct nft_chain_list {
struct list_head list;
};
diff --git a/src/internal.h b/src/internal.h
index b29288a..6449a9f 100644
--- a/src/internal.h
+++ b/src/internal.h
@@ -17,6 +17,8 @@
#define BASE_DEC 10
#define BASE_HEX 16
+#define NFT_SNPRINTF_BUFSIZ 4096
+
enum nft_type {
NFT_TYPE_U8,
NFT_TYPE_U16,
@@ -88,6 +90,8 @@ const char *nft_verdict2str(uint32_t verdict);
int nft_str2verdict(const char *verdict);
int nft_get_value(enum nft_type type, void *val, void *out);
+int nft_fprintf(FILE *fp, void *obj, uint32_t type, uint32_t flags, int (*snprintf_cb)(char *buf, size_t bufsiz, void *obj, uint32_t type, uint32_t flags));
+
void xfree(const void *ptr);
struct expr_ops;
diff --git a/src/libnftables.map b/src/libnftables.map
index 1223403..aa47714 100644
--- a/src/libnftables.map
+++ b/src/libnftables.map
@@ -12,6 +12,7 @@ global:
nft_table_attr_get_str;
nft_table_parse;
nft_table_snprintf;
+ nft_table_fprintf;
nft_table_nlmsg_build_hdr;
nft_table_nlmsg_build_payload;
nft_table_nlmsg_parse;
@@ -42,6 +43,7 @@ global:
nft_chain_attr_get_str;
nft_chain_parse;
nft_chain_snprintf;
+ nft_chain_fprintf;
nft_chain_nlmsg_build_hdr;
nft_chain_nlmsg_build_payload;
nft_chain_nlmsg_parse;
@@ -71,6 +73,7 @@ global:
nft_rule_attr_get_str;
nft_rule_parse;
nft_rule_snprintf;
+ nft_rule_fprintf;
nft_rule_nlmsg_build_hdr;
nft_rule_nlmsg_build_payload;
nft_rule_nlmsg_parse;
@@ -126,6 +129,7 @@ global:
nft_set_nlmsg_parse;
nft_set_parse;
nft_set_snprintf;
+ nft_set_fprintf;
nft_set_list_alloc;
nft_set_list_free;
@@ -157,6 +161,7 @@ global:
nft_set_elem_nlmsg_parse;
nft_set_elem_parse;
nft_set_elem_snprintf;
+ nft_set_elem_fprinf;
nft_set_elems_nlmsg_build_payload;
nft_set_elems_nlmsg_parse;
@@ -176,6 +181,7 @@ global:
nft_ruleset_attr_get;
nft_ruleset_parse;
nft_ruleset_snprintf;
+ nft_ruleset_fprintf;
local: *;
};
diff --git a/src/rule.c b/src/rule.c
index d135f38..3b45dc7 100644
--- a/src/rule.c
+++ b/src/rule.c
@@ -819,6 +819,19 @@ int nft_rule_snprintf(char *buf, size_t size, struct nft_rule *r,
}
EXPORT_SYMBOL(nft_rule_snprintf);
+static inline int nft_rule_do_snprintf(char *buf, size_t size, void *r,
+ uint32_t type, uint32_t flags)
+{
+ return nft_rule_snprintf(buf, size, r, type, flags);
+}
+
+int nft_rule_fprintf(FILE *fp, struct nft_rule *r, uint32_t type,
+ uint32_t flags)
+{
+ return nft_fprintf(fp, r, type, flags, nft_rule_do_snprintf);
+}
+EXPORT_SYMBOL(nft_rule_fprintf);
+
int nft_rule_expr_foreach(struct nft_rule *r,
int (*cb)(struct nft_rule_expr *e, void *data),
void *data)
diff --git a/src/ruleset.c b/src/ruleset.c
index 24b849b..ee2c60a 100644
--- a/src/ruleset.c
+++ b/src/ruleset.c
@@ -813,3 +813,206 @@ int nft_ruleset_snprintf(char *buf, size_t size, const struct nft_ruleset *r,
}
}
EXPORT_SYMBOL(nft_ruleset_snprintf);
+
+static int nft_ruleset_fprintf_tables(FILE *fp, const struct nft_ruleset *rs,
+ uint32_t type, uint32_t flags)
+{
+ int len = 0, ret = 0;
+ struct nft_table *t;
+ struct nft_table_list_iter *ti;
+
+ ti = nft_table_list_iter_create(rs->table_list);
+ if (ti == NULL)
+ return -1;
+
+ t = nft_table_list_iter_next(ti);
+ while (t != NULL) {
+ ret = nft_table_fprintf(fp, t, type, flags);
+ if (ret < 0)
+ goto err;
+
+ len += ret;
+
+ t = nft_table_list_iter_next(ti);
+
+ ret = fprintf(fp, "%s", nft_ruleset_o_separator(t, type));
+ if (ret < 0)
+ goto err;
+
+ len += ret;
+ }
+ nft_table_list_iter_destroy(ti);
+
+ return len;
+err:
+ nft_table_list_iter_destroy(ti);
+ return -1;
+}
+
+static int nft_ruleset_fprintf_chains(FILE *fp, const struct nft_ruleset *rs,
+ uint32_t type, uint32_t flags)
+{
+ int len = 0, ret = 0;
+ struct nft_chain *o;
+ struct nft_chain_list_iter *i;
+
+ i = nft_chain_list_iter_create(rs->chain_list);
+ if (i == NULL)
+ return -1;
+
+ o = nft_chain_list_iter_next(i);
+ while (o != NULL) {
+ ret = nft_chain_fprintf(fp, o, type, flags);
+ if (ret < 0)
+ goto err;
+
+ len += ret;
+
+ o = nft_chain_list_iter_next(i);
+
+ ret = fprintf(fp, "%s", nft_ruleset_o_separator(o, type));
+ if (ret < 0)
+ goto err;
+
+ len += ret;
+ }
+ nft_chain_list_iter_destroy(i);
+
+ return len;
+err:
+ nft_chain_list_iter_destroy(i);
+ return -1;
+}
+
+static int nft_ruleset_fprintf_sets(FILE *fp, const struct nft_ruleset *rs,
+ uint32_t type, uint32_t flags)
+{
+ int len = 0, ret = 0;
+ struct nft_set *o;
+ struct nft_set_list_iter *i;
+
+ i = nft_set_list_iter_create(rs->set_list);
+ if (i == NULL)
+ return -1;
+
+ o = nft_set_list_iter_next(i);
+ while (o != NULL) {
+ ret = nft_set_fprintf(fp, o, type, flags);
+ if (ret < 0)
+ goto err;
+
+ len += ret;
+
+ o = nft_set_list_iter_next(i);
+
+ ret = fprintf(fp, "%s", nft_ruleset_o_separator(o, type));
+ if (ret < 0)
+ goto err;
+
+ len += ret;
+ }
+ nft_set_list_iter_destroy(i);
+
+ return len;
+err:
+ nft_set_list_iter_destroy(i);
+ return -1;
+}
+
+static int nft_ruleset_fprintf_rules(FILE *fp, const struct nft_ruleset *rs,
+ uint32_t type, uint32_t flags)
+{
+ int len = 0, ret = 0;
+ struct nft_rule *o;
+ struct nft_rule_list_iter *i;
+
+ i = nft_rule_list_iter_create(rs->rule_list);
+ if (i == NULL)
+ return -1;
+
+ o = nft_rule_list_iter_next(i);
+ while (o != NULL) {
+ ret = nft_rule_fprintf(fp, o, type, flags);
+ if (ret < 0)
+ goto err;
+
+ len += ret;
+
+ o = nft_rule_list_iter_next(i);
+
+ ret = fprintf(fp, "%s", nft_ruleset_o_separator(o, type));
+ if (ret < 0)
+ goto err;
+
+ len += ret;
+ }
+ nft_rule_list_iter_destroy(i);
+
+ return len;
+err:
+ nft_rule_list_iter_destroy(i);
+ return -1;
+}
+
+#define NFT_FPRINTF_RETURN_OR_FIXLEN(ret, len) \
+ if (ret < 0) \
+ return -1; \
+ len += ret;
+
+int nft_ruleset_fprintf(FILE *fp, const struct nft_ruleset *rs, uint32_t type,
+ uint32_t flags)
+{
+ int len = 0, ret = 0;
+ void *prev = NULL;
+
+ ret = fprintf(fp, "%s", nft_ruleset_o_opentag(type));
+ NFT_FPRINTF_RETURN_OR_FIXLEN(ret, len);
+
+ if ((nft_ruleset_attr_is_set(rs, NFT_RULESET_ATTR_TABLELIST)) &&
+ (!nft_table_list_is_empty(rs->table_list))) {
+ ret = nft_ruleset_fprintf_tables(fp, rs, type, flags);
+ NFT_FPRINTF_RETURN_OR_FIXLEN(ret, len);
+
+ if (ret > 0)
+ prev = rs->table_list;
+ }
+
+ if ((nft_ruleset_attr_is_set(rs, NFT_RULESET_ATTR_CHAINLIST)) &&
+ (!nft_chain_list_is_empty(rs->chain_list))) {
+ ret = fprintf(fp, "%s", nft_ruleset_o_separator(prev, type));
+ NFT_FPRINTF_RETURN_OR_FIXLEN(ret, len);
+
+ ret = nft_ruleset_fprintf_chains(fp, rs, type, flags);
+ NFT_FPRINTF_RETURN_OR_FIXLEN(ret, len);
+
+ if (ret > 0)
+ prev = rs->chain_list;
+ }
+
+ if ((nft_ruleset_attr_is_set(rs, NFT_RULESET_ATTR_SETLIST)) &&
+ (!nft_set_list_is_empty(rs->set_list))) {
+ ret = fprintf(fp, "%s", nft_ruleset_o_separator(prev, type));
+ NFT_FPRINTF_RETURN_OR_FIXLEN(ret, len);
+
+ ret = nft_ruleset_fprintf_sets(fp, rs, type, flags);
+ NFT_FPRINTF_RETURN_OR_FIXLEN(ret, len);
+
+ if (ret > 0)
+ prev = rs->set_list;
+ }
+
+ if ((nft_ruleset_attr_is_set(rs, NFT_RULESET_ATTR_RULELIST)) &&
+ (!nft_rule_list_is_empty(rs->rule_list))) {
+ ret = fprintf(fp, "%s", nft_ruleset_o_separator(prev, type));
+ NFT_FPRINTF_RETURN_OR_FIXLEN(ret, len);
+
+ ret = nft_ruleset_fprintf_rules(fp, rs, type, flags);
+ NFT_FPRINTF_RETURN_OR_FIXLEN(ret, len);
+ }
+
+ ret = fprintf(fp, "%s", nft_ruleset_o_closetag(type));
+ NFT_FPRINTF_RETURN_OR_FIXLEN(ret, len);
+
+ return len;
+}
+EXPORT_SYMBOL(nft_ruleset_fprintf);
diff --git a/src/set.c b/src/set.c
index 2c6e6a6..9620006 100644
--- a/src/set.c
+++ b/src/set.c
@@ -668,6 +668,19 @@ int nft_set_snprintf(char *buf, size_t size, struct nft_set *s,
}
EXPORT_SYMBOL(nft_set_snprintf);
+static inline int nft_set_do_snprintf(char *buf, size_t size, void *s,
+ uint32_t type, uint32_t flags)
+{
+ return nft_set_snprintf(buf, size, s, type, flags);
+}
+
+int nft_set_fprintf(FILE *fp, struct nft_set *s, uint32_t type,
+ uint32_t flags)
+{
+ return nft_fprintf(fp, s, type, flags, nft_set_do_snprintf);
+}
+EXPORT_SYMBOL(nft_set_fprintf);
+
void nft_set_elem_add(struct nft_set *s, struct nft_set_elem *elem)
{
list_add_tail(&elem->head, &s->element_list);
diff --git a/src/set_elem.c b/src/set_elem.c
index 5ef46f2..516905d 100644
--- a/src/set_elem.c
+++ b/src/set_elem.c
@@ -577,6 +577,19 @@ int nft_set_elem_snprintf(char *buf, size_t size, struct nft_set_elem *e,
}
EXPORT_SYMBOL(nft_set_elem_snprintf);
+static inline int nft_set_elem_do_snprintf(char *buf, size_t size, void *e,
+ uint32_t type, uint32_t flags)
+{
+ return nft_set_elem_snprintf(buf, size, e, type, flags);
+}
+
+int nft_set_elem_fprintf(FILE *fp, struct nft_set_elem *se, uint32_t type,
+ uint32_t flags)
+{
+ return nft_fprintf(fp, se, type, flags, nft_set_elem_do_snprintf);
+}
+EXPORT_SYMBOL(nft_set_elem_fprintf);
+
int nft_set_elem_foreach(struct nft_set *s,
int (*cb)(struct nft_set_elem *e, void *data),
void *data)
diff --git a/src/table.c b/src/table.c
index d3ff188..d1acc7c 100644
--- a/src/table.c
+++ b/src/table.c
@@ -388,6 +388,19 @@ int nft_table_snprintf(char *buf, size_t size, struct nft_table *t,
}
EXPORT_SYMBOL(nft_table_snprintf);
+static inline int nft_table_do_snprintf(char *buf, size_t size, void *t,
+ uint32_t type, uint32_t flags)
+{
+ return nft_table_snprintf(buf, size, t, type, flags);
+}
+
+int nft_table_fprintf(FILE *fp, struct nft_table *t, uint32_t type,
+ uint32_t flags)
+{
+ return nft_fprintf(fp, t, type, flags, nft_table_do_snprintf);
+}
+EXPORT_SYMBOL(nft_table_fprintf);
+
struct nft_table_list {
struct list_head list;
};
diff --git a/src/utils.c b/src/utils.c
index 9a0bcfe..2415917 100644
--- a/src/utils.c
+++ b/src/utils.c
@@ -174,3 +174,30 @@ void xfree(const void *ptr)
{
free((void *)ptr);
}
+
+int nft_fprintf(FILE *fp, void *obj, uint32_t type, uint32_t flags,
+ int (*snprintf_cb)(char *buf, size_t bufsiz, void *obj,
+ uint32_t type, uint32_t flags))
+{
+ char _buf[NFT_SNPRINTF_BUFSIZ];
+ char *buf = _buf;
+ size_t bufsiz = sizeof(_buf);
+ int ret;
+
+ ret = snprintf_cb(buf, bufsiz, obj, type, flags);
+ if (ret > NFT_SNPRINTF_BUFSIZ) {
+ buf = calloc(1, ret);
+ if (buf == NULL)
+ return -1;
+
+ bufsiz = ret;
+ ret = snprintf_cb(buf, bufsiz, obj, type, flags);
+ }
+
+ ret = fprintf(fp, "%s", buf);
+
+ if (buf != _buf)
+ xfree(buf);
+
+ return ret;
+}
^ permalink raw reply related [flat|nested] 3+ messages in thread
* Re: [libnftables PATCH 1/2] ruleset: factorize json/xml tagging
2013-10-28 10:57 [libnftables PATCH 1/2] ruleset: factorize json/xml tagging Arturo Borrero Gonzalez
2013-10-28 10:57 ` [libnftables PATCH 2/2] src: add fprintf API functions Arturo Borrero Gonzalez
@ 2013-11-03 21:13 ` Pablo Neira Ayuso
1 sibling, 0 replies; 3+ messages in thread
From: Pablo Neira Ayuso @ 2013-11-03 21:13 UTC (permalink / raw)
To: Arturo Borrero Gonzalez; +Cc: netfilter-devel
On Mon, Oct 28, 2013 at 11:57:47AM +0100, Arturo Borrero Gonzalez wrote:
> This factorization of JSON/XML open & close tag allows reutilice code in future
> patches (for example, the fprintf API functions).
Applied, thanks.
^ permalink raw reply [flat|nested] 3+ messages in thread
end of thread, other threads:[~2013-11-03 21:13 UTC | newest]
Thread overview: 3+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2013-10-28 10:57 [libnftables PATCH 1/2] ruleset: factorize json/xml tagging Arturo Borrero Gonzalez
2013-10-28 10:57 ` [libnftables PATCH 2/2] src: add fprintf API functions Arturo Borrero Gonzalez
2013-11-03 21:13 ` [libnftables PATCH 1/2] ruleset: factorize json/xml tagging Pablo Neira Ayuso
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).