src: Change parameters of SNPRINTF_BUFFER_SIZE macro.

SNPRINTF_BUFFER_SIZE() macro declaration and definition is changed so
that it accepts three arguments ret, remain and offset. Parameters size
and len are not required instead parameter remain keeps track of
available space in the buffer.

Signed-off-by: Varsha Rao <rvarsha016@gmail.com>

18 files changed, 162 insertions, 154 deletions

diff --git a/src/expr/bitwise.c b/src/expr/bitwise.c
index 0febc9d..a89734b 100644
--- a/src/expr/bitwise.c
+++ b/src/expr/bitwise.c
@@ -233,22 +233,22 @@ static int nftnl_expr_bitwise_snprintf_default(char *buf, size_t size,
 					       const struct nftnl_expr *e)
 {
 	struct nftnl_expr_bitwise *bitwise = nftnl_expr_data(e);
-	int len = size, offset = 0, ret;
+	int remain = size, offset = 0, ret;
 
-	ret = snprintf(buf, len, "reg %u = (reg=%u & ",
+	ret = snprintf(buf, remain, "reg %u = (reg=%u & ",
 		       bitwise->dreg, bitwise->sreg);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
-	ret = nftnl_data_reg_snprintf(buf+offset, len, &bitwise->mask,
+	ret = nftnl_data_reg_snprintf(buf + offset, remain, &bitwise->mask,
 				    NFTNL_OUTPUT_DEFAULT, 0, DATA_VALUE);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
-	ret = snprintf(buf+offset, len, ") ^ ");
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	ret = snprintf(buf + offset, remain, ") ^ ");
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
-	ret = nftnl_data_reg_snprintf(buf+offset, len, &bitwise->xor,
+	ret = nftnl_data_reg_snprintf(buf + offset, remain, &bitwise->xor,
 				    NFTNL_OUTPUT_DEFAULT, 0, DATA_VALUE);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	return offset;
 }
diff --git a/src/expr/byteorder.c b/src/expr/byteorder.c
index 3805307..47c04cf 100644
--- a/src/expr/byteorder.c
+++ b/src/expr/byteorder.c
@@ -258,12 +258,12 @@ static int nftnl_expr_byteorder_snprintf_default(char *buf, size_t size,
 						 const struct nftnl_expr *e)
 {
 	struct nftnl_expr_byteorder *byteorder = nftnl_expr_data(e);
-	int len = size, offset = 0, ret;
+	int remain = size, offset = 0, ret;
 
-	ret = snprintf(buf, len, "reg %u = %s(reg %u, %u, %u) ",
+	ret = snprintf(buf, remain, "reg %u = %s(reg %u, %u, %u) ",
 		       byteorder->dreg, bo2str(byteorder->op),
 		       byteorder->sreg, byteorder->size, byteorder->len);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	return offset;
 }
diff --git a/src/expr/cmp.c b/src/expr/cmp.c
index 353e907..b26d0eb 100644
--- a/src/expr/cmp.c
+++ b/src/expr/cmp.c
@@ -229,15 +229,15 @@ static int nftnl_expr_cmp_snprintf_default(char *buf, size_t size,
 					   const struct nftnl_expr *e)
 {
 	struct nftnl_expr_cmp *cmp = nftnl_expr_data(e);
-	int len = size, offset = 0, ret;
+	int remain = size, offset = 0, ret;
 
-	ret = snprintf(buf, len, "%s reg %u ",
+	ret = snprintf(buf, remain, "%s reg %u ",
 		       cmp2str(cmp->op), cmp->sreg);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
-	ret = nftnl_data_reg_snprintf(buf+offset, len, &cmp->data,
+	ret = nftnl_data_reg_snprintf(buf + offset, remain, &cmp->data,
 				    NFTNL_OUTPUT_DEFAULT, 0, DATA_VALUE);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	return offset;
 }
diff --git a/src/expr/ct.c b/src/expr/ct.c
index 676dfb6..6f87a72 100644
--- a/src/expr/ct.c
+++ b/src/expr/ct.c
@@ -289,25 +289,25 @@ static int
 nftnl_expr_ct_snprintf_default(char *buf, size_t size,
 			       const struct nftnl_expr *e)
 {
-	int ret, len = size, offset = 0;
+	int ret, remain = size, offset = 0;
 	struct nftnl_expr_ct *ct = nftnl_expr_data(e);
 
 	if (e->flags & (1 << NFTNL_EXPR_CT_SREG)) {
 		ret = snprintf(buf, size, "set %s with reg %u ",
 				ctkey2str(ct->key), ct->sreg);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 
 	if (e->flags & (1 << NFTNL_EXPR_CT_DREG)) {
-		ret = snprintf(buf, len, "load %s => reg %u ",
+		ret = snprintf(buf, remain, "load %s => reg %u ",
 			       ctkey2str(ct->key), ct->dreg);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 
 	if (nftnl_expr_is_set(e, NFTNL_EXPR_CT_DIR)) {
-		ret = snprintf(buf+offset, len, ", dir %s ",
+		ret = snprintf(buf + offset, remain, ", dir %s ",
 			       ctdir2str(ct->dir));
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 
 	return offset;
diff --git a/src/expr/data_reg.c b/src/expr/data_reg.c
index 0249258..a246952 100644
--- a/src/expr/data_reg.c
+++ b/src/expr/data_reg.c
@@ -101,34 +101,34 @@ nftnl_data_reg_value_snprintf_json(char *buf, size_t size,
 				   const union nftnl_data_reg *reg,
 				   uint32_t flags)
 {
-	int len = size, offset = 0, ret, i, j;
+	int remain = size, offset = 0, ret, i, j;
 	uint32_t utemp;
 	uint8_t *tmp;
 
-	ret = snprintf(buf, len, "\"reg\":{\"type\":\"value\",");
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	ret = snprintf(buf, remain, "\"reg\":{\"type\":\"value\",");
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
-	ret = snprintf(buf+offset, len, "\"len\":%u,", reg->len);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	ret = snprintf(buf + offset, remain, "\"len\":%u,", reg->len);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	for (i = 0; i < div_round_up(reg->len, sizeof(uint32_t)); i++) {
-		ret = snprintf(buf+offset, len, "\"data%d\":\"0x", i);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		ret = snprintf(buf + offset, remain, "\"data%d\":\"0x", i);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 		utemp = htonl(reg->val[i]);
 		tmp = (uint8_t *)&utemp;
 
 		for (j = 0; j<sizeof(uint32_t); j++) {
-			ret = snprintf(buf+offset, len, "%.02x", tmp[j]);
-			SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+			ret = snprintf(buf + offset, remain, "%.02x", tmp[j]);
+			SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 		}
 
-		ret = snprintf(buf+offset, len, "\",");
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		ret = snprintf(buf + offset, remain, "\",");
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 	offset--;
-	ret = snprintf(buf+offset, len, "}");
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	ret = snprintf(buf + offset, remain, "}");
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	return offset;
 }
@@ -138,11 +138,11 @@ nftnl_data_reg_value_snprintf_default(char *buf, size_t size,
 				      const union nftnl_data_reg *reg,
 				      uint32_t flags)
 {
-	int len = size, offset = 0, ret, i;
+	int remain = size, offset = 0, ret, i;
 
 	for (i = 0; i < div_round_up(reg->len, sizeof(uint32_t)); i++) {
-		ret = snprintf(buf+offset, len, "0x%.8x ", reg->val[i]);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		ret = snprintf(buf + offset, remain, "0x%.8x ", reg->val[i]);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 
 	return offset;
@@ -153,14 +153,14 @@ nftnl_data_reg_verdict_snprintf_def(char *buf, size_t size,
 				    const union nftnl_data_reg *reg,
 				    uint32_t flags)
 {
-	int len = size, offset = 0, ret = 0;
+	int remain = size, offset = 0, ret = 0;
 
 	ret = snprintf(buf, size, "%s ", nftnl_verdict2str(reg->verdict));
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	if (reg->chain != NULL) {
-		ret = snprintf(buf+offset, len, "-> %s ", reg->chain);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		ret = snprintf(buf + offset, remain, "-> %s ", reg->chain);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 
 	return offset;
@@ -171,20 +171,20 @@ nftnl_data_reg_verdict_snprintf_json(char *buf, size_t size,
 				     const union nftnl_data_reg *reg,
 				     uint32_t flags)
 {
-	int len = size, offset = 0, ret = 0;
+	int remain = size, offset = 0, ret = 0;
 
 	ret = snprintf(buf, size, "\"reg\":{\"type\":\"verdict\","
 		       "\"verdict\":\"%s\"", nftnl_verdict2str(reg->verdict));
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	if (reg->chain != NULL) {
-		ret = snprintf(buf+offset, len, ",\"chain\":\"%s\"",
+		ret = snprintf(buf + offset, remain, ",\"chain\":\"%s\"",
 			       reg->chain);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 
-	ret = snprintf(buf+offset, len, "}");
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	ret = snprintf(buf + offset, remain, "}");
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	return offset;
 }
diff --git a/src/expr/dup.c b/src/expr/dup.c
index 9aa332b..ed8e620 100644
--- a/src/expr/dup.c
+++ b/src/expr/dup.c
@@ -151,17 +151,17 @@ static int nftnl_expr_dup_snprintf_default(char *buf, size_t len,
 					   const struct nftnl_expr *e,
 					   uint32_t flags)
 {
-	int size = len, offset = 0, ret;
+	int remain = len, offset = 0, ret;
 	struct nftnl_expr_dup *dup = nftnl_expr_data(e);
 
 	if (e->flags & (1 << NFTNL_EXPR_DUP_SREG_ADDR)) {
 		ret = snprintf(buf + offset, len, "sreg_addr %u ", dup->sreg_addr);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 
 	if (e->flags & (1 << NFTNL_EXPR_DUP_SREG_DEV)) {
 		ret = snprintf(buf + offset, len, "sreg_dev %u ", dup->sreg_dev);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 
 	return offset;
diff --git a/src/expr/dynset.c b/src/expr/dynset.c
index f7b99ea..861879e 100644
--- a/src/expr/dynset.c
+++ b/src/expr/dynset.c
@@ -276,34 +276,35 @@ nftnl_expr_dynset_snprintf_default(char *buf, size_t size,
 {
 	struct nftnl_expr_dynset *dynset = nftnl_expr_data(e);
 	struct nftnl_expr *expr;
-	int len = size, offset = 0, ret;
+	int remain = size, offset = 0, ret;
 
-	ret = snprintf(buf, len, "%s reg_key %u set %s ",
+	ret = snprintf(buf, remain, "%s reg_key %u set %s ",
 		       op2str(dynset->op), dynset->sreg_key, dynset->set_name);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	if (e->flags & (1 << NFTNL_EXPR_DYNSET_SREG_DATA)) {
-		ret = snprintf(buf+offset, len, "sreg_data %u ", dynset->sreg_data);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		ret = snprintf(buf + offset, remain, "sreg_data %u ",
+			       dynset->sreg_data);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 	if (e->flags & (1 << NFTNL_EXPR_DYNSET_TIMEOUT)) {
-		ret = snprintf(buf+offset, len, "timeout %"PRIu64"ms ",
+		ret = snprintf(buf + offset, remain, "timeout %"PRIu64"ms ",
 			       dynset->timeout);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 	if (e->flags & (1 << NFTNL_EXPR_DYNSET_EXPR)) {
 		expr = dynset->expr;
-		ret = snprintf(buf+offset, len, "expr [ %s ",
+		ret = snprintf(buf + offset, remain, "expr [ %s ",
 			       expr->ops->name);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
-		ret = nftnl_expr_snprintf(buf+offset, len, expr,
+		ret = nftnl_expr_snprintf(buf + offset, remain, expr,
 					     NFTNL_OUTPUT_DEFAULT,
 					     NFTNL_OF_EVENT_ANY);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
-		ret = snprintf(buf+offset, len, "] ");
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		ret = snprintf(buf + offset, remain, "] ");
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 
 	return offset;
diff --git a/src/expr/fib.c b/src/expr/fib.c
index f3be081..b922b26 100644
--- a/src/expr/fib.c
+++ b/src/expr/fib.c
@@ -172,7 +172,7 @@ nftnl_expr_fib_snprintf_default(char *buf, size_t size,
 				const struct nftnl_expr *e)
 {
 	struct nftnl_expr_fib *fib = nftnl_expr_data(e);
-	int len = size, offset = 0, ret, i;
+	int remain = size, offset = 0, ret, i;
 	uint32_t flags = fib->flags & ~NFTA_FIB_F_PRESENT;
 	uint32_t present_flag = fib->flags & NFTA_FIB_F_PRESENT;
 	static const struct {
@@ -188,27 +188,29 @@ nftnl_expr_fib_snprintf_default(char *buf, size_t size,
 
 	for (i = 0; i < (sizeof(tab) / sizeof(tab[0])); i++) {
 		if (flags & tab[i].bit) {
-			ret = snprintf(buf + offset, len, "%s ", tab[i].name);
-			SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+			ret = snprintf(buf + offset, remain, "%s ",
+				       tab[i].name);
+			SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 			flags &= ~tab[i].bit;
 			if (flags) {
-				ret = snprintf(buf + offset, len, ". ");
-				SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+				ret = snprintf(buf + offset, remain, ". ");
+				SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 			}
 		}
 	}
 
 	if (flags) {
-		ret = snprintf(buf + offset, len, "unknown 0x%" PRIx32, flags);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		ret = snprintf(buf + offset, remain, "unknown 0x%" PRIx32,
+			       flags);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 
-	ret = snprintf(buf + offset, len, "%s%s => reg %d ",
+	ret = snprintf(buf + offset, remain, "%s%s => reg %d ",
 		       fib_type_str(fib->result),
 		       present_flag ? " present" : "",
 		       fib->dreg);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	return offset;
 }
diff --git a/src/expr/fwd.c b/src/expr/fwd.c
index c30d494..1312ea1 100644
--- a/src/expr/fwd.c
+++ b/src/expr/fwd.c
@@ -132,12 +132,13 @@ static int nftnl_expr_fwd_snprintf_default(char *buf, size_t len,
 					   const struct nftnl_expr *e,
 					   uint32_t flags)
 {
-	int size = len, offset = 0, ret;
+	int remain = len, offset = 0, ret;
 	struct nftnl_expr_fwd *fwd = nftnl_expr_data(e);
 
 	if (e->flags & (1 << NFTNL_EXPR_FWD_SREG_DEV)) {
-		ret = snprintf(buf + offset, len, "sreg_dev %u ", fwd->sreg_dev);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		ret = snprintf(buf + offset, remain, "sreg_dev %u ",
+			       fwd->sreg_dev);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 
 	return offset;
diff --git a/src/expr/hash.c b/src/expr/hash.c
index d870510..fcc4fa5 100644
--- a/src/expr/hash.c
+++ b/src/expr/hash.c
@@ -229,29 +229,31 @@ nftnl_expr_hash_snprintf_default(char *buf, size_t size,
 				 const struct nftnl_expr *e)
 {
 	struct nftnl_expr_hash *hash = nftnl_expr_data(e);
-	int len = size, offset = 0, ret;
+	int remain = size, offset = 0, ret;
 
 	switch (hash->type) {
 	case NFT_HASH_SYM:
 		ret =
-		snprintf(buf, len, "reg %u = symhash() %% mod %u ", hash->dreg,
+		snprintf(buf, remain, "reg %u = symhash() %% mod %u ",
+			 hash->dreg,
 			 hash->modulus);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 		break;
 	case NFT_HASH_JENKINS:
 	default:
 		ret =
-		snprintf(buf, len,
+		snprintf(buf, remain,
 			 "reg %u = jhash(reg %u, %u, 0x%x) %% mod %u ",
 			 hash->dreg, hash->sreg, hash->len, hash->seed,
 			 hash->modulus);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 		break;
 	}
 
 	if (hash->offset) {
-		ret = snprintf(buf + offset, len, "offset %u ", hash->offset);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		ret = snprintf(buf + offset, remain, "offset %u ",
+			       hash->offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 
 	return offset;
diff --git a/src/expr/immediate.c b/src/expr/immediate.c
index 0b188cc..b0570bd 100644
--- a/src/expr/immediate.c
+++ b/src/expr/immediate.c
@@ -233,26 +233,26 @@ nftnl_expr_immediate_snprintf_default(char *buf, size_t len,
 				      const struct nftnl_expr *e,
 				      uint32_t flags)
 {
-	int size = len, offset = 0, ret;
+	int remain = len, offset = 0, ret;
 	struct nftnl_expr_immediate *imm = nftnl_expr_data(e);
 
-	ret = snprintf(buf, len, "reg %u ", imm->dreg);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	ret = snprintf(buf, remain, "reg %u ", imm->dreg);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	if (e->flags & (1 << NFTNL_EXPR_IMM_DATA)) {
-		ret = nftnl_data_reg_snprintf(buf+offset, len, &imm->data,
+		ret = nftnl_data_reg_snprintf(buf + offset, remain, &imm->data,
 					NFTNL_OUTPUT_DEFAULT, flags, DATA_VALUE);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	} else if (e->flags & (1 << NFTNL_EXPR_IMM_VERDICT)) {
-		ret = nftnl_data_reg_snprintf(buf+offset, len, &imm->data,
+		ret = nftnl_data_reg_snprintf(buf + offset, remain, &imm->data,
 				NFTNL_OUTPUT_DEFAULT, flags, DATA_VERDICT);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	} else if (e->flags & (1 << NFTNL_EXPR_IMM_CHAIN)) {
-		ret = nftnl_data_reg_snprintf(buf+offset, len, &imm->data,
+		ret = nftnl_data_reg_snprintf(buf + offset, remain, &imm->data,
 					NFTNL_OUTPUT_DEFAULT, flags, DATA_CHAIN);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 
 	return offset;
diff --git a/src/expr/log.c b/src/expr/log.c
index b642255..86d9651 100644
--- a/src/expr/log.c
+++ b/src/expr/log.c
@@ -229,44 +229,45 @@ static int nftnl_expr_log_snprintf_default(char *buf, size_t size,
 					   const struct nftnl_expr *e)
 {
 	struct nftnl_expr_log *log = nftnl_expr_data(e);
-	int ret, offset = 0, len = size;
+	int ret, offset = 0, remain = size;
 
 	if (e->flags & (1 << NFTNL_EXPR_LOG_PREFIX)) {
-		ret = snprintf(buf, len, "prefix %s ", log->prefix);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		ret = snprintf(buf, remain, "prefix %s ", log->prefix);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 
 	if (e->flags & (1 << NFTNL_EXPR_LOG_GROUP)) {
-		ret = snprintf(buf + offset, len,
+		ret = snprintf(buf + offset, remain,
 			       "group %u snaplen %u qthreshold %u ",
 			       log->group, log->snaplen, log->qthreshold);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	} else {
 		if (e->flags & (1 << NFTNL_EXPR_LOG_LEVEL)) {
-			ret = snprintf(buf + offset, len, "level %u ",
+			ret = snprintf(buf + offset, remain, "level %u ",
 				       log->level);
-			SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+			SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 		}
 		if (e->flags & (1 << NFTNL_EXPR_LOG_FLAGS)) {
 			if (log->flags & NF_LOG_TCPSEQ) {
-				ret = snprintf(buf + offset, len, "tcpseq ");
-				SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+				ret = snprintf(buf + offset, remain, "tcpseq ");
+				SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 			}
 			if (log->flags & NF_LOG_TCPOPT) {
-				ret = snprintf(buf + offset, len, "tcpopt ");
-				SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+				ret = snprintf(buf + offset, remain, "tcpopt ");
+				SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 			}
 			if (log->flags & NF_LOG_IPOPT) {
-				ret = snprintf(buf + offset, len, "ipopt ");
-				SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+				ret = snprintf(buf + offset, remain, "ipopt ");
+				SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 			}
 			if (log->flags & NF_LOG_UID) {
-				ret = snprintf(buf + offset, len, "uid ");
-				SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+				ret = snprintf(buf + offset, remain, "uid ");
+				SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 			}
 			if (log->flags & NF_LOG_MACDECODE) {
-				ret = snprintf(buf + offset, len, "macdecode ");
-				SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+				ret = snprintf(buf + offset, remain,
+					       "macdecode ");
+				SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 			}
 		}
 	}
diff --git a/src/expr/lookup.c b/src/expr/lookup.c
index 861815f..e4c05ec 100644
--- a/src/expr/lookup.c
+++ b/src/expr/lookup.c
@@ -219,20 +219,20 @@ static int
 nftnl_expr_lookup_snprintf_default(char *buf, size_t size,
 				   const struct nftnl_expr *e)
 {
-	int len = size, offset = 0, ret;
+	int remain = size, offset = 0, ret;
 	struct nftnl_expr_lookup *l = nftnl_expr_data(e);
 
-	ret = snprintf(buf, len, "reg %u set %s ", l->sreg, l->set_name);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	ret = snprintf(buf, remain, "reg %u set %s ", l->sreg, l->set_name);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	if (e->flags & (1 << NFTNL_EXPR_LOOKUP_DREG)) {
-		ret = snprintf(buf+offset, len, "dreg %u ", l->dreg);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		ret = snprintf(buf + offset, remain, "dreg %u ", l->dreg);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 
 	if (e->flags & (1 << NFTNL_EXPR_LOOKUP_FLAGS)) {
-		ret = snprintf(buf + offset, len, "0x%x ", l->flags);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		ret = snprintf(buf + offset, remain, "0x%x ", l->flags);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 
 	return offset;
diff --git a/src/expr/nat.c b/src/expr/nat.c
index 29bc3a2..9271303 100644
--- a/src/expr/nat.c
+++ b/src/expr/nat.c
@@ -304,31 +304,32 @@ nftnl_expr_nat_snprintf_default(char *buf, size_t size,
 				const struct nftnl_expr *e)
 {
 	struct nftnl_expr_nat *nat = nftnl_expr_data(e);
-	int len = size, offset = 0, ret = 0;
+	int remain = size, offset = 0, ret = 0;
 
-	ret = snprintf(buf, len, "%s ", nat2str(nat->type));
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	ret = snprintf(buf, remain, "%s ", nat2str(nat->type));
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
-	ret = snprintf(buf+offset, len, "%s ", nftnl_family2str(nat->family));
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	ret = snprintf(buf + offset, remain, "%s ",
+		       nftnl_family2str(nat->family));
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	if (e->flags & (1 << NFTNL_EXPR_NAT_REG_ADDR_MIN)) {
-		ret = snprintf(buf+offset, len,
+		ret = snprintf(buf + offset, remain,
 			       "addr_min reg %u addr_max reg %u ",
 			       nat->sreg_addr_min, nat->sreg_addr_max);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 
 	if (e->flags & (1 << NFTNL_EXPR_NAT_REG_PROTO_MIN)) {
-		ret = snprintf(buf+offset, len,
+		ret = snprintf(buf + offset, remain,
 			       "proto_min reg %u proto_max reg %u ",
 			       nat->sreg_proto_min, nat->sreg_proto_max);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 
 	if (e->flags & (1 << NFTNL_EXPR_NAT_FLAGS)) {
-		ret = snprintf(buf+offset, len, "flags %u", nat->flags);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		ret = snprintf(buf + offset, remain, "flags %u", nat->flags);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 
 	return offset;
diff --git a/src/expr/numgen.c b/src/expr/numgen.c
index a15f03a..1369b01 100644
--- a/src/expr/numgen.c
+++ b/src/expr/numgen.c
@@ -176,26 +176,26 @@ nftnl_expr_ng_snprintf_default(char *buf, size_t size,
 			       const struct nftnl_expr *e)
 {
 	struct nftnl_expr_ng *ng = nftnl_expr_data(e);
-	int len = size, offset = 0, ret;
+	int remain = size, offset = 0, ret;
 
 	switch (ng->type) {
 	case NFT_NG_INCREMENTAL:
-		ret = snprintf(buf, len, "reg %u = inc mod %u ",
+		ret = snprintf(buf, remain, "reg %u = inc mod %u ",
 			       ng->dreg, ng->modulus);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 		break;
 	case NFT_NG_RANDOM:
-		ret = snprintf(buf, len, "reg %u = random mod %u ",
+		ret = snprintf(buf, remain, "reg %u = random mod %u ",
 			       ng->dreg, ng->modulus);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 		break;
 	default:
 		return 0;
 	}
 
 	if (ng->offset) {
-		ret = snprintf(buf + offset, len, "offset %u ", ng->offset);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		ret = snprintf(buf + offset, remain, "offset %u ", ng->offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 
 	return offset;
diff --git a/src/expr/queue.c b/src/expr/queue.c
index 8a9deda..f62db9f 100644
--- a/src/expr/queue.c
+++ b/src/expr/queue.c
@@ -176,38 +176,38 @@ static int nftnl_expr_queue_snprintf_default(char *buf, size_t len,
 					     const struct nftnl_expr *e)
 {
 	struct nftnl_expr_queue *queue = nftnl_expr_data(e);
-	int ret, size = len, offset = 0;
+	int ret, remain = len, offset = 0;
 	uint16_t total_queues;
 
 	if (e->flags & (1 << NFTNL_EXPR_QUEUE_NUM)) {
 		total_queues = queue->queuenum + queue->queues_total - 1;
 
 		ret = snprintf(buf + offset, len, "num %u", queue->queuenum);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 		if (queue->queues_total && total_queues != queue->queuenum) {
 			ret = snprintf(buf + offset, len, "-%u", total_queues);
-			SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+			SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 		}
 
 		ret = snprintf(buf + offset, len, " ");
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 
 	if (e->flags & (1 << NFTNL_EXPR_QUEUE_SREG_QNUM)) {
 		ret = snprintf(buf + offset, len, "sreg_qnum %u ",
 			       queue->sreg_qnum);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 
 	if (e->flags & (1 << NFTNL_EXPR_QUEUE_FLAGS)) {
 		if (queue->flags & (NFT_QUEUE_FLAG_BYPASS)) {
 			ret = snprintf(buf + offset, len, "bypass ");
-			SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+			SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 		}
 		if (queue->flags & (NFT_QUEUE_FLAG_CPU_FANOUT)) {
 			ret = snprintf(buf + offset, len, "fanout ");
-			SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+			SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 		}
 	}
 	return offset;
diff --git a/src/expr/range.c b/src/expr/range.c
index 8c8ce12..b2789ff 100644
--- a/src/expr/range.c
+++ b/src/expr/range.c
@@ -243,19 +243,19 @@ static int nftnl_expr_range_snprintf_default(char *buf, size_t size,
 					   const struct nftnl_expr *e)
 {
 	struct nftnl_expr_range *range = nftnl_expr_data(e);
-	int len = size, offset = 0, ret;
+	int remain = size, offset = 0, ret;
 
-	ret = snprintf(buf, len, "%s reg %u ",
+	ret = snprintf(buf, remain, "%s reg %u ",
 		       expr_range_str[range->op], range->sreg);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
-	ret = nftnl_data_reg_snprintf(buf + offset, len, &range->data_from,
+	ret = nftnl_data_reg_snprintf(buf + offset, remain, &range->data_from,
 				      NFTNL_OUTPUT_DEFAULT, 0, DATA_VALUE);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
-	ret = nftnl_data_reg_snprintf(buf + offset, len, &range->data_to,
+	ret = nftnl_data_reg_snprintf(buf + offset, remain, &range->data_to,
 				      NFTNL_OUTPUT_DEFAULT, 0, DATA_VALUE);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	return offset;
 }
diff --git a/src/expr/redir.c b/src/expr/redir.c
index 43538d5..b2aa345 100644
--- a/src/expr/redir.c
+++ b/src/expr/redir.c
@@ -176,25 +176,25 @@ static int nftnl_expr_redir_export(char *buf, size_t size,
 static int nftnl_expr_redir_snprintf_default(char *buf, size_t len,
 					     const struct nftnl_expr *e)
 {
-	int ret, size = len, offset = 0;
+	int ret, remain = len, offset = 0;
 	struct nftnl_expr_redir *redir = nftnl_expr_data(e);
 
 	if (nftnl_expr_is_set(e, NFTNL_EXPR_REDIR_REG_PROTO_MIN)) {
 		ret = snprintf(buf + offset, len, "proto_min reg %u ",
 			       redir->sreg_proto_min);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 
 	if (nftnl_expr_is_set(e, NFTNL_EXPR_REDIR_REG_PROTO_MAX)) {
 		ret = snprintf(buf + offset, len, "proto_max reg %u ",
 			       redir->sreg_proto_max);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 
 	if (nftnl_expr_is_set(e, NFTNL_EXPR_REDIR_FLAGS)) {
-		ret = snprintf(buf + offset , len, "flags 0x%x ",
+		ret = snprintf(buf + offset, len, "flags 0x%x ",
 			       redir->flags);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 
 	return offset;