src: set: Do not print unset values in json

It changes the parse and the snprint functions to omit unset values.

This json file is gotten for a set:
{
  "set": {
    "name": "mi6set3",
    "table": "test6",
    "flags": "0",
    "family": "unknown",
    "key_type": "0",
    "key_len": "0",
    "set_elem": [
      {
        "flags": "0",
        "key": {
          "data_reg": {
            "type": "value",
            "len": "16",
            "data0": "0x000080fe",
            "data1": "0x00000000",
            "data2": "0xffb30202",
            "data3": "0x89001efe"

Now, This json file is gotten for a set without unset elements.
{
  "set": {
    "name": "mi6set3",
    "table": "test6",
    "family": "unknown",
    "set_elem": [
      {
        "key": {
          "data_reg": {
            "type": "value",
            "len": "16",
            "data0": "0x000080fe",
            "data1": "0x00000000",
            "data2": "0xffb30202",
            "data3": "0x89001efe"

[ Note: These fields are unset when they are obtained from the set element
  information --pablo. ]

Signed-off-by: Ana Rey <anarey@gmail.com>
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>

3 files changed, 83 insertions, 67 deletions

diff --git a/src/jansson.c b/src/jansson.c
index affe8fe..377d06e 100644
--- a/src/jansson.c
+++ b/src/jansson.c
@@ -240,18 +240,14 @@ int nft_jansson_data_reg_parse(json_t *root, const char *node_name,
 int nft_jansson_set_elem_parse(struct nft_set_elem *e, json_t *root,
 			       struct nft_parse_err *err)
 {
-	uint32_t uval32;
 	int set_elem_data;
+	uint32_t flags;
 
-	if (nft_jansson_parse_val(root, "flags", NFT_TYPE_U32, &uval32, err) < 0)
-		return -1;
-
-	nft_set_elem_attr_set_u32(e, NFT_SET_ELEM_ATTR_FLAGS, uval32);
+	if (nft_jansson_parse_val(root, "flags", NFT_TYPE_U32, &flags, err) == 0)
+		nft_set_elem_attr_set_u32(e, NFT_SET_ELEM_ATTR_FLAGS, flags);
 
-	if (nft_jansson_data_reg_parse(root, "key", &e->key, err) != DATA_VALUE)
-		return -1;
-
-	e->flags |= (1 << NFT_SET_ELEM_ATTR_KEY);
+	if (nft_jansson_data_reg_parse(root, "key", &e->key, err) == DATA_VALUE)
+		e->flags |= (1 << NFT_SET_ELEM_ATTR_KEY);
 
 	if (nft_jansson_node_exist(root, "data")) {
 		set_elem_data = nft_jansson_data_reg_parse(root, "data",
@@ -264,7 +260,6 @@ int nft_jansson_set_elem_parse(struct nft_set_elem *e, json_t *root,
 			e->flags |= (1 << NFT_SET_ELEM_ATTR_VERDICT);
 			if (e->data.chain != NULL)
 				e->flags |= (1 << NFT_SET_ELEM_ATTR_CHAIN);
-
 			break;
 		case DATA_NONE:
 		default:
diff --git a/src/set.c b/src/set.c
index 4fbc09f..6088796 100644
--- a/src/set.c
+++ b/src/set.c
@@ -339,63 +339,55 @@ int nft_jansson_parse_set(struct nft_set *s, json_t *tree,
 			  struct nft_parse_err *err)
 {
 	json_t *root, *array, *json_elem;
-	uint32_t uval32;
+	uint32_t flags, key_type, key_len, data_type, data_len;
 	int family, i;
-	const char *valstr;
+	const char *name, *table;
 	struct nft_set_elem *elem;
 
 	root = nft_jansson_get_node(tree, "set", err);
 	if (root == NULL)
 		return -1;
 
-	valstr = nft_jansson_parse_str(root, "name", err);
-	if (valstr == NULL)
-		return -1;
-
-	nft_set_attr_set_str(s, NFT_SET_ATTR_NAME, valstr);
-
-	valstr = nft_jansson_parse_str(root, "table", err);
-	if (valstr == NULL)
-		return -1;
-
-	nft_set_attr_set_str(s, NFT_SET_ATTR_TABLE, valstr);
-
-	if (nft_jansson_parse_val(root, "flags", NFT_TYPE_U32, &uval32, err) < 0)
+	name = nft_jansson_parse_str(root, "name", err);
+	if (name == NULL)
 		return -1;
 
-	nft_set_attr_set_u32(s, NFT_SET_ATTR_FLAGS, uval32);
+	nft_set_attr_set_str(s, NFT_SET_ATTR_NAME, name);
 
-	if (nft_jansson_parse_family(root, &family, err) < 0)
+	table = nft_jansson_parse_str(root, "table", err);
+	if (table == NULL)
 		return -1;
 
-	nft_set_attr_set_u32(s, NFT_SET_ATTR_FAMILY, family);
+	nft_set_attr_set_str(s, NFT_SET_ATTR_TABLE, table);
 
-	if (nft_jansson_parse_val(root, "key_type", NFT_TYPE_U32, &uval32,
-				  err) < 0)
-		return -1;
+	if (nft_jansson_parse_family(root, &family, err) == 0)
+		nft_set_attr_set_u32(s, NFT_SET_ATTR_FAMILY, family);
 
-	nft_set_attr_set_u32(s, NFT_SET_ATTR_KEY_TYPE, uval32);
+	if (nft_jansson_parse_val(root, "flags", NFT_TYPE_U32, &flags, err) == 0)
+		nft_set_attr_set_u32(s, NFT_SET_ATTR_FLAGS, flags);
 
-	if (nft_jansson_parse_val(root, "key_len", NFT_TYPE_U32, &uval32,
-				  err) < 0)
-		return -1;
+	if (nft_jansson_parse_val(root, "key_type", NFT_TYPE_U32, &key_type,
+				  err) == 0)
+		nft_set_attr_set_u32(s, NFT_SET_ATTR_KEY_TYPE, key_type);
 
-	nft_set_attr_set_u32(s, NFT_SET_ATTR_KEY_LEN, uval32);
+	if (nft_jansson_parse_val(root, "key_len", NFT_TYPE_U32, &key_len,
+				  err) == 0)
+		nft_set_attr_set_u32(s, NFT_SET_ATTR_KEY_LEN, key_len);
 
 	if (nft_jansson_node_exist(root, "data_type")) {
 		if (nft_jansson_parse_val(root, "data_type", NFT_TYPE_U32,
-					  &uval32, err) < 0)
+					  &data_type, err) < 0)
 			goto err;
 
-		nft_set_attr_set_u32(s, NFT_SET_ATTR_DATA_TYPE, uval32);
+		nft_set_attr_set_u32(s, NFT_SET_ATTR_DATA_TYPE, data_type);
 	}
 
 	if (nft_jansson_node_exist(root, "data_len")) {
 		if (nft_jansson_parse_val(root, "data_len", NFT_TYPE_U32,
-					  &uval32, err) < 0)
+					  &data_len, err) < 0)
 			goto err;
 
-		nft_set_attr_set_u32(s, NFT_SET_ATTR_DATA_LEN, uval32);
+		nft_set_attr_set_u32(s, NFT_SET_ATTR_DATA_LEN, data_len);
 	}
 
 	if (nft_jansson_node_exist(root, "set_elem")) {
@@ -584,46 +576,73 @@ static int nft_set_snprintf_json(char *buf, size_t size, struct nft_set *s,
 	int len = size, offset = 0, ret;
 	struct nft_set_elem *elem;
 
-	ret = snprintf(buf, len, "{\"set\":{\"name\":\"%s\","
-				  "\"table\":\"%s\","
-				  "\"flags\":%u,\"family\":\"%s\","
-				  "\"key_type\":%u,\"key_len\":%u",
-			s->name, s->table, s->set_flags,
-			nft_family2str(s->family), s->key_type, s->key_len);
+	ret = snprintf(buf, len, "{\"set\":{");
 	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
 
-	if(s->flags & (1 << NFT_SET_ATTR_DATA_TYPE) &&
-	   s->flags & (1 << NFT_SET_ATTR_DATA_LEN)){
-		ret = snprintf(buf+offset, len,
-				  ",\"data_type\":%u,\"data_len\":%u",
-			s->data_type, s->data_len);
+	if (s->flags & (1 << NFT_SET_ATTR_NAME)) {
+		ret = snprintf(buf + offset, len, "\"name\":\"%s\"",
+			       s->name);
+		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	}
+	if (s->flags & (1 << NFT_SET_ATTR_TABLE)) {
+		ret = snprintf(buf + offset, len, ",\"table\":\"%s\"",
+			       s->table);
+		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	}
+	if (s->flags & (1 << NFT_SET_ATTR_FLAGS)) {
+		ret = snprintf(buf + offset, len, ",\"flags\":%u",
+			       s->set_flags);
+		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	}
+	if (s->flags & (1 << NFT_SET_ATTR_FAMILY)) {
+		ret = snprintf(buf + offset, len, ",\"family\":\"%s\"",
+			       nft_family2str(s->family));
+		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	}
+	if (s->flags & (1 << NFT_SET_ATTR_KEY_TYPE)) {
+		ret = snprintf(buf + offset, len, ",\"key_type\":%u",
+			       s->key_type);
+		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	}
+	if (s->flags & (1 << NFT_SET_ATTR_KEY_LEN)) {
+		ret = snprintf(buf + offset, len, ",\"key_len\":%u",
+			       s->key_len);
+		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	}
+	if(s->flags & (1 << NFT_SET_ATTR_DATA_TYPE)) {
+		ret = snprintf(buf + offset, len,
+				  ",\"data_type\":%u", s->data_type);
+		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	}
+	if(s->flags & (1 << NFT_SET_ATTR_DATA_LEN)) {
+		ret = snprintf(buf + offset, len, ",\"data_len\":%u", s->data_len);
 		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
 	}
-
 	/* Empty set? Skip printinf of elements */
 	if (list_empty(&s->element_list)){
-		ret = snprintf(buf+offset, len, "}}");
+		ret = snprintf(buf + offset, len, "}}");
 		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
 		return offset;
 	}
 
-	ret = snprintf(buf+offset, len, ",\"set_elem\":[");
+	ret = snprintf(buf + offset, len, ",\"set_elem\":[");
 	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
 
 	list_for_each_entry(elem, &s->element_list, head) {
-		ret = snprintf(buf+offset, len, "{");
+		ret = snprintf(buf + offset, len, "{");
 		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
 
-		ret = nft_set_elem_snprintf(buf+offset, len, elem, type, flags);
+		ret = nft_set_elem_snprintf(buf + offset, len, elem, type,
+					    flags);
 		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
 
-		ret = snprintf(buf+offset, len, "},");
+		ret = snprintf(buf + offset, len, "},");
 		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
 	}
 	/* Overwrite trailing ", " from last set element */
 	offset --;
 
-	ret = snprintf(buf+offset, len, "]}}");
+	ret = snprintf(buf + offset, len, "]}}");
 	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
 
 	return offset;
diff --git a/src/set_elem.c b/src/set_elem.c
index d954cb8..3b27317 100644
--- a/src/set_elem.c
+++ b/src/set_elem.c
@@ -493,17 +493,19 @@ static int nft_set_elem_snprintf_json(char *buf, size_t size,
 {
 	int ret, len = size, offset = 0, type = -1;
 
-	ret = snprintf(buf, len, "\"flags\":%u", e->set_elem_flags);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	if (e->flags & (1 << NFT_SET_ELEM_ATTR_FLAGS)) {
+		ret = snprintf(buf, len, "\"flags\":%u,", e->set_elem_flags);
+		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	}
 
-	ret = snprintf(buf+offset, len, ",\"key\":{");
+	ret = snprintf(buf + offset, len, "\"key\":{");
 	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
 
-	ret = nft_data_reg_snprintf(buf+offset, len, &e->key,
+	ret = nft_data_reg_snprintf(buf + offset, len, &e->key,
 				    NFT_OUTPUT_JSON, flags, DATA_VALUE);
 	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
 
-	ret = snprintf(buf+offset, len, "}");
+	ret = snprintf(buf + offset, len, "}");
 	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
 
 	if (e->flags & (1 << NFT_SET_ELEM_ATTR_DATA))
@@ -514,14 +516,14 @@ static int nft_set_elem_snprintf_json(char *buf, size_t size,
 		type = DATA_VERDICT;
 
 	if (type != -1) {
-		ret = snprintf(buf+offset, len, ",\"data\":{");
+		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 = nft_data_reg_snprintf(buf + offset, len, &e->data,
+					    NFT_OUTPUT_JSON, flags, type);
 			SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
 
-		ret = snprintf(buf+offset, len, "}");
+		ret = snprintf(buf + offset, len, "}");
 		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
 	}