src: Change parameters of SNPRINTF_BUFFER_SIZE macro.

index 2f5cf34..e1c2efe 100644
@@ -50,14 +50,13 @@ void __nftnl_assert_attr_exists(uint16_t attr, uint16_t attr_max,
 		__nftnl_assert_attr_exists(_attr, _attr_max, __FILE__, __LINE__);	\
 })
 
-#define SNPRINTF_BUFFER_SIZE(ret, size, len, offset)	\
+#define SNPRINTF_BUFFER_SIZE(ret, remain, offset)	\
 	if (ret < 0)					\
 		ret = 0;				\
 	offset += ret;					\
-	if (ret > len)					\
-		ret = len;				\
-	size += ret;					\
-	len -= ret;
+	if (ret > remain)				\
+		ret = remain;				\
+	remain -= ret;					\
 
 const char *nftnl_family2str(uint32_t family);
 int nftnl_str2family(const char *family);

index e5b9fe3..44c2613 100644
@@ -788,32 +788,33 @@ static int nftnl_chain_export(char *buf, size_t size,
 static int nftnl_chain_snprintf_default(char *buf, size_t size,
 					const struct nftnl_chain *c)
 {
-	int ret, len = size, offset = 0;
+	int ret, remain = size, offset = 0;
 
-	ret = snprintf(buf, len, "%s %s %s use %u",
+	ret = snprintf(buf, remain, "%s %s %s use %u",
 		       nftnl_family2str(c->family), c->table, c->name, c->use);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	if (c->flags & (1 << NFTNL_CHAIN_HOOKNUM)) {
-		ret = snprintf(buf + offset, len, " type %s hook %s prio %d",
+		ret = snprintf(buf + offset, remain, " type %s hook %s prio %d",
 			       c->type, nftnl_hooknum2str(c->family, c->hooknum),
 			       c->prio);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 		if (c->flags & (1 << NFTNL_CHAIN_POLICY)) {
-			ret = snprintf(buf + offset, len, " policy %s",
+			ret = snprintf(buf + offset, remain, " policy %s",
 				       nftnl_verdict2str(c->policy));
-			SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+			SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 		}
 
-		ret = snprintf(buf + offset, len,
+		ret = snprintf(buf + offset, remain,
 			       " packets %"PRIu64" bytes %"PRIu64"",
 			       c->packets, c->bytes);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 		if (c->flags & (1 << NFTNL_CHAIN_DEV)) {
-			ret = snprintf(buf + offset, len, " dev %s ", c->dev);
-			SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+			ret = snprintf(buf + offset, remain, " dev %s ",
+				       c->dev);
+			SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 		}
 	}
 

@@ -824,27 +825,27 @@ static int nftnl_chain_cmd_snprintf(char *buf, size_t size,
 				    const struct nftnl_chain *c, uint32_t cmd,
 				    uint32_t type, uint32_t flags)
 {
-	int ret, len = size, offset = 0;
+	int ret, remain = size, offset = 0;
 
-	ret = nftnl_cmd_header_snprintf(buf + offset, len, cmd, type, flags);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	ret = nftnl_cmd_header_snprintf(buf + offset, remain, cmd, type, flags);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
-		ret = nftnl_chain_snprintf_default(buf+offset, len, c);
+		ret = nftnl_chain_snprintf_default(buf+offset, remain, c);
 		break;
 	case NFTNL_OUTPUT_XML:
 	case NFTNL_OUTPUT_JSON:
-		ret = nftnl_chain_export(buf+offset, len, c, type);
+		ret = nftnl_chain_export(buf+offset, remain, c, type);
 		break;
 	default:
 		return -1;
 	}
 
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
-	ret = nftnl_cmd_footer_snprintf(buf + offset, len, cmd, type, flags);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	ret = nftnl_cmd_footer_snprintf(buf + offset, remain, cmd, type, flags);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	return offset;
 }

index 10ba2c4..475ef6b 100644
@@ -279,13 +279,13 @@ int nftnl_expr_snprintf(char *buf, size_t size, const struct nftnl_expr *expr,
 			uint32_t type, uint32_t flags)
 {
 	int ret;
-	unsigned int offset = 0, len = size;
+	unsigned int offset = 0, remain = size;
 
 	if (!expr->ops->snprintf)
 		return 0;
 
-	ret = expr->ops->snprintf(buf+offset, len, type, flags, expr);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	ret = expr->ops->snprintf(buf+offset, remain, type, flags, expr);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	return offset;
 }

index 0febc9d..865aaf0 100644
@@ -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;
 }

index 3805307..47c04cf 100644
@@ -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;
 }

index 353e907..8156d69 100644
@@ -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;
 }

index 676dfb6..82aad58 100644
@@ -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;

105 lines not on this page · raw message

index 9aa332b..ed8e620 100644
@@ -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;

index f7b99ea..68fa14e 100644
@@ -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;

index f3be081..b922b26 100644
@@ -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;
 }

index c30d494..1312ea1 100644
@@ -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;

index d870510..fcc4fa5 100644
@@ -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;

index 0b188cc..8a858da 100644
@@ -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;

index b642255..86d9651 100644
@@ -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);
 			}
 		}
 	}

index 861815f..e5adfd4 100644
@@ -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;

index 29bc3a2..ac189e6 100644
@@ -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;

index a15f03a..1369b01 100644
@@ -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;

index 8a9deda..f62db9f 100644
@@ -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;

index 8c8ce12..b2789ff 100644
@@ -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;
 }

index 43538d5..b2aa345 100644
@@ -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;

index 213562e..e1d5280 100644
@@ -166,22 +166,22 @@ static int nftnl_gen_cmd_snprintf(char *buf, size_t size,
 				  const struct nftnl_gen *gen, uint32_t cmd,
 				  uint32_t type, uint32_t flags)
 {
-	int ret, len = size, offset = 0;
+	int ret, remain = size, offset = 0;
 
-	ret = nftnl_cmd_header_snprintf(buf + offset, len, cmd, type, flags);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	ret = nftnl_cmd_header_snprintf(buf + offset, remain, cmd, type, flags);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	switch(type) {
 	case NFTNL_OUTPUT_DEFAULT:
-		ret = nftnl_gen_snprintf_default(buf + offset, len, gen);
+		ret = nftnl_gen_snprintf_default(buf + offset, remain, gen);
 		break;
 	default:
 		return -1;
 	}
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
-	ret = nftnl_cmd_footer_snprintf(buf + offset, len, cmd, type, flags);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	ret = nftnl_cmd_footer_snprintf(buf + offset, remain, cmd, type, flags);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	return offset;
 }

index 9dc5b41..d15ec10 100644
@@ -425,18 +425,19 @@ static int nftnl_obj_snprintf_dflt(char *buf, size_t size,
 				   uint32_t type, uint32_t flags)
 {
 	const char *name = obj->ops ? obj->ops->name : "(unknown)";
-	int ret, len = size, offset = 0;
+	int ret, remain = size, offset = 0;
 
 	ret = snprintf(buf, size, "table %s name %s use %u [ %s ",
 		       obj->table, obj->name, obj->use, name);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	if (obj->ops) {
-		ret = obj->ops->snprintf(buf + offset, offset, type, flags, obj);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+		ret = obj->ops->snprintf(buf + offset, offset, type, flags,
+					 obj);
+		SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 	}
 	ret = snprintf(buf + offset, offset, "]");
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	return offset;
 }

@@ -445,27 +446,27 @@ static int nftnl_obj_cmd_snprintf(char *buf, size_t size,
 				    const struct nftnl_obj *obj, uint32_t cmd,
 				    uint32_t type, uint32_t flags)
 {
-	int ret, len = size, offset = 0;
+	int ret, remain = size, offset = 0;
 
-	ret = nftnl_cmd_header_snprintf(buf + offset, len, cmd, type, flags);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	ret = nftnl_cmd_header_snprintf(buf + offset, remain, cmd, type, flags);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
-		ret = nftnl_obj_snprintf_dflt(buf + offset, len, obj, type,
+		ret = nftnl_obj_snprintf_dflt(buf + offset, remain, obj, type,
 					      flags);
 		break;
 	case NFTNL_OUTPUT_JSON:
-		ret = nftnl_obj_export(buf + offset, len, obj, type, flags);
+		ret = nftnl_obj_export(buf + offset, remain, obj, type, flags);
 		break;
 	case NFTNL_OUTPUT_XML:
 	default:
 		return -1;
 	}
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
-	ret = nftnl_cmd_footer_snprintf(buf + offset, len, cmd, type, flags);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	ret = nftnl_cmd_footer_snprintf(buf + offset, remain, cmd, type, flags);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	return offset;
 }

137 lines not on this page · raw message

199 lines not on this page · raw message

240 lines not on this page · raw message

148 lines not on this page · raw message

index a7d5a8f..d426bcb 100644
@@ -376,26 +376,26 @@ static int nftnl_table_cmd_snprintf(char *buf, size_t size,
 				    const struct nftnl_table *t, uint32_t cmd,
 				    uint32_t type, uint32_t flags)
 {
-	int ret, len = size, offset = 0;
+	int ret, remain = size, offset = 0;
 
-	ret = nftnl_cmd_header_snprintf(buf + offset, len, cmd, type, flags);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	ret = nftnl_cmd_header_snprintf(buf + offset, remain, cmd, type, flags);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
-		ret = nftnl_table_snprintf_default(buf+offset, len, t);
+		ret = nftnl_table_snprintf_default(buf+offset, remain, t);
 		break;
 	case NFTNL_OUTPUT_XML:
 	case NFTNL_OUTPUT_JSON:
-		ret = nftnl_table_export(buf+offset, len, t, type);
+		ret = nftnl_table_export(buf+offset, remain, t, type);
 		break;
 	default:
 		return -1;
 	}
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
-	ret = nftnl_cmd_footer_snprintf(buf + offset, len, cmd, type, flags);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
+	ret = nftnl_cmd_footer_snprintf(buf + offset, remain, cmd, type, flags);
+	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 
 	return offset;
 }

index 44c2613..46189ef 100644
@@ -827,6 +827,9 @@ static int nftnl_chain_cmd_snprintf(char *buf, size_t size,
 {
 	int ret, remain = size, offset = 0;
 
+	if (size)
+		buf[0] = '\0';
+
 	ret = nftnl_cmd_header_snprintf(buf + offset, remain, cmd, type, flags);
 	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 

@@ -853,14 +856,20 @@ static int nftnl_chain_cmd_snprintf(char *buf, size_t size,
 int nftnl_chain_snprintf(char *buf, size_t size, const struct nftnl_chain *c,
 			 uint32_t type, uint32_t flags)
 {
-	return nftnl_chain_cmd_snprintf(buf, size, c, nftnl_flag2cmd(flags), type,
-				      flags);
+	if (size)
+		buf[0] = '\0';
+
+	return nftnl_chain_cmd_snprintf(buf, size, c, nftnl_flag2cmd(flags),
+					type, flags);
 }
 EXPORT_SYMBOL(nftnl_chain_snprintf);
 
 static int nftnl_chain_do_snprintf(char *buf, size_t size, const void *c,
 				   uint32_t cmd, uint32_t type, uint32_t flags)
 {
+	if (size)
+		buf[0] = '\0';
+
 	return nftnl_chain_snprintf(buf, size, c, type, flags);
 }
 

index a95883c..ba5a49f 100644
@@ -94,6 +94,9 @@ EXPORT_SYMBOL(nftnl_parse_perror);
 int nftnl_cmd_header_snprintf(char *buf, size_t size, uint32_t cmd, uint32_t type,
 			    uint32_t flags)
 {
+	if (size)
+		buf[0] = '\0';
+
 	NFTNL_BUF_INIT(b, buf, size);
 
 	if (cmd == NFTNL_CMD_UNSPEC)

@@ -135,6 +138,9 @@ int nftnl_cmd_header_fprintf(FILE *fp, uint32_t cmd, uint32_t type,
 int nftnl_cmd_footer_snprintf(char *buf, size_t size, uint32_t cmd, uint32_t type,
 			    uint32_t flags)
 {
+	if (size)
+		buf[0] = '\0';
+
 	NFTNL_BUF_INIT(b, buf, size);
 
 	if (cmd == NFTNL_CMD_UNSPEC)

index 475ef6b..7438dc1 100644
@@ -281,6 +281,9 @@ int nftnl_expr_snprintf(char *buf, size_t size, const struct nftnl_expr *expr,
 	int ret;
 	unsigned int offset = 0, remain = size;
 
+	if (size)
+		buf[0] = '\0';
+
 	if (!expr->ops->snprintf)
 		return 0;
 

index 865aaf0..2797d33 100644
@@ -257,6 +257,9 @@ static int
 nftnl_expr_bitwise_snprintf(char *buf, size_t size, uint32_t type,
 			    uint32_t flags, const struct nftnl_expr *e)
 {
+	if (size)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_expr_bitwise_snprintf_default(buf, size, e);

index 47c04cf..4bb95b4 100644
@@ -272,6 +272,9 @@ static int
 nftnl_expr_byteorder_snprintf(char *buf, size_t size, uint32_t type,
 			      uint32_t flags, const struct nftnl_expr *e)
 {
+	if (size)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_expr_byteorder_snprintf_default(buf, size, e);

index 8156d69..1276a0c 100644
@@ -246,6 +246,9 @@ static int
 nftnl_expr_cmp_snprintf(char *buf, size_t size, uint32_t type,
 			uint32_t flags, const struct nftnl_expr *e)
 {
+	if (size)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_expr_cmp_snprintf_default(buf, size, e);

index 21901e8..5c196d4 100644
@@ -164,6 +164,9 @@ static int nftnl_expr_counter_snprintf(char *buf, size_t len, uint32_t type,
 				       uint32_t flags,
 				       const struct nftnl_expr *e)
 {
+	if (len)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_expr_counter_snprintf_default(buf, len, e);

index 82aad58..8ed3cf4 100644
@@ -317,6 +317,9 @@ static int
 nftnl_expr_ct_snprintf(char *buf, size_t len, uint32_t type,
 		       uint32_t flags, const struct nftnl_expr *e)
 {
+	if (len)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_expr_ct_snprintf_default(buf, len, e);

index 3abe0df..85b356e 100644
@@ -194,6 +194,9 @@ int nftnl_data_reg_snprintf(char *buf, size_t size,
 			    uint32_t output_format, uint32_t flags,
 			    int reg_type)
 {
+	if (size)
+		buf[0] = '\0';
+
 	switch(reg_type) {
 	case DATA_VALUE:
 		switch(output_format) {

index ed8e620..e2171f4 100644
@@ -170,6 +170,9 @@ static int nftnl_expr_dup_snprintf_default(char *buf, size_t len,
 static int nftnl_expr_dup_snprintf(char *buf, size_t len, uint32_t type,
 				   uint32_t flags, const struct nftnl_expr *e)
 {
+	if (len)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_expr_dup_snprintf_default(buf, len, e, flags);

index 68fa14e..2d14238 100644
@@ -314,6 +314,8 @@ static int
 nftnl_expr_dynset_snprintf(char *buf, size_t size, uint32_t type,
 			   uint32_t flags, const struct nftnl_expr *e)
 {
+	if (size)
+		buf[0] = '\0';
 
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:

index 75cafbc..11766fa 100644
@@ -339,6 +339,9 @@ static int
 nftnl_expr_exthdr_snprintf(char *buf, size_t len, uint32_t type,
 			   uint32_t flags, const struct nftnl_expr *e)
 {
+	if (len)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_expr_exthdr_snprintf_default(buf, len, e);

index b922b26..cbadeef 100644
@@ -236,6 +236,9 @@ static int
 nftnl_expr_fib_snprintf(char *buf, size_t len, uint32_t type,
 			 uint32_t flags, const struct nftnl_expr *e)
 {
+	if (len)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_expr_fib_snprintf_default(buf, len, e);

index 1312ea1..38923df 100644
@@ -147,6 +147,9 @@ static int nftnl_expr_fwd_snprintf_default(char *buf, size_t len,
 static int nftnl_expr_fwd_snprintf(char *buf, size_t len, uint32_t type,
 				   uint32_t flags, const struct nftnl_expr *e)
 {
+	if (len)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_expr_fwd_snprintf_default(buf, len, e, flags);

index fcc4fa5..066c790 100644
@@ -288,6 +288,9 @@ static int
 nftnl_expr_hash_snprintf(char *buf, size_t len, uint32_t type,
 			 uint32_t flags, const struct nftnl_expr *e)
 {
+	if (len)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_expr_hash_snprintf_default(buf, len, e);

index 8a858da..9eb6508 100644
@@ -262,6 +262,9 @@ static int
 nftnl_expr_immediate_snprintf(char *buf, size_t len, uint32_t type,
 			      uint32_t flags, const struct nftnl_expr *e)
 {
+	if (len)
+		buf[0] = '\0';
+
 	switch(type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_expr_immediate_snprintf_default(buf, len, e, flags);

index 856ab18..8e1f02a 100644
@@ -243,6 +243,9 @@ static int
 nftnl_expr_limit_snprintf(char *buf, size_t len, uint32_t type,
 			  uint32_t flags, const struct nftnl_expr *e)
 {
+	if (len)
+		buf[0] = '\0';
+
 	switch(type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_expr_limit_snprintf_default(buf, len, e);

index 86d9651..161327b 100644
@@ -301,6 +301,9 @@ static int
 nftnl_expr_log_snprintf(char *buf, size_t len, uint32_t type,
 			uint32_t flags, const struct nftnl_expr *e)
 {
+	if (len)
+		buf[0] = '\0';
+
 	switch(type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_expr_log_snprintf_default(buf, len, e);

index e5adfd4..5840b47 100644
@@ -242,6 +242,8 @@ static int
 nftnl_expr_lookup_snprintf(char *buf, size_t size, uint32_t type,
 			   uint32_t flags, const struct nftnl_expr *e)
 {
+	if (size)
+		buf[0] = '\0';
 
 	switch(type) {
 	case NFTNL_OUTPUT_DEFAULT:

index 7c235d3..1c75ee9 100644
@@ -190,6 +190,9 @@ static int nftnl_expr_masq_snprintf_default(char *buf, size_t len,
 static int nftnl_expr_masq_snprintf(char *buf, size_t len, uint32_t type,
 				    uint32_t flags, const struct nftnl_expr *e)
 {
+	if (len)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_expr_masq_snprintf_default(buf, len, e);

index dd09e1e..af659b3 100644
@@ -200,6 +200,9 @@ nftnl_expr_match_snprintf(char *buf, size_t len, uint32_t type,
 {
 	struct nftnl_expr_match *match = nftnl_expr_data(e);
 
+	if (len)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return snprintf(buf, len, "name %s rev %u ",

index 2c75841..b5c27e6 100644
@@ -252,6 +252,9 @@ static int
 nftnl_expr_meta_snprintf(char *buf, size_t len, uint32_t type,
 			 uint32_t flags, const struct nftnl_expr *e)
 {
+	if (len)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_expr_meta_snprintf_default(buf, len, e);

index ac189e6..55e6de8 100644
@@ -339,6 +339,9 @@ static int
 nftnl_expr_nat_snprintf(char *buf, size_t size, uint32_t type,
 			uint32_t flags, const struct nftnl_expr *e)
 {
+	if (size)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_expr_nat_snprintf_default(buf, size, e);

index 1369b01..9b5b1b7 100644
@@ -224,6 +224,9 @@ static int
 nftnl_expr_ng_snprintf(char *buf, size_t len, uint32_t type,
 		       uint32_t flags, const struct nftnl_expr *e)
 {
+	if (len)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_expr_ng_snprintf_default(buf, len, e);

index 4cfa3cb..b4b3383 100644
@@ -236,6 +236,9 @@ static int nftnl_expr_objref_snprintf(char *buf, size_t len, uint32_t type,
 				      uint32_t flags,
 				      const struct nftnl_expr *e)
 {
+	if (len)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_expr_objref_snprintf_default(buf, len, e);

index 91e1587..897fc77 100644
@@ -290,6 +290,9 @@ nftnl_expr_payload_snprintf(char *buf, size_t len, uint32_t type,
 {
 	struct nftnl_expr_payload *payload = nftnl_expr_data(e);
 
+	if (len)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		if (payload->sreg)

index f62db9f..e0fb785 100644
@@ -235,6 +235,8 @@ static int
 nftnl_expr_queue_snprintf(char *buf, size_t len, uint32_t type,
 			  uint32_t flags, const struct nftnl_expr *e)
 {
+	if (len)
+		buf[0] = '\0';
 
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:

index 667e6e1..c247b0a 100644
@@ -183,6 +183,9 @@ static int nftnl_expr_quota_snprintf(char *buf, size_t len, uint32_t type,
 				       uint32_t flags,
 				       const struct nftnl_expr *e)
 {
+	if (len)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_expr_quota_snprintf_default(buf, len, e);

index b2789ff..c7bb7c7 100644
@@ -263,6 +263,9 @@ static int nftnl_expr_range_snprintf_default(char *buf, size_t size,
 static int nftnl_expr_range_snprintf(char *buf, size_t size, uint32_t type,
 				     uint32_t flags, const struct nftnl_expr *e)
 {
+	if (size)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_expr_range_snprintf_default(buf, size, e);

index b2aa345..9fb634a 100644
@@ -204,6 +204,9 @@ static int
 nftnl_expr_redir_snprintf(char *buf, size_t len, uint32_t type,
 			  uint32_t flags, const struct nftnl_expr *e)
 {
+	if (len)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_expr_redir_snprintf_default(buf, len, e);

index 11d8b20..1e6fdf5 100644
@@ -164,6 +164,9 @@ static int
 nftnl_expr_reject_snprintf(char *buf, size_t len, uint32_t type,
 			   uint32_t flags, const struct nftnl_expr *e)
 {
+	if (len)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_expr_reject_snprintf_default(buf, len, e);

index 62c01a0..10cb1e2 100644
@@ -203,6 +203,9 @@ static int
 nftnl_expr_rt_snprintf(char *buf, size_t len, uint32_t type,
 		       uint32_t flags, const struct nftnl_expr *e)
 {
+	if (len)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_expr_rt_snprintf_default(buf, len, e);

index ed4bf7d..3c58b03 100644
@@ -200,6 +200,9 @@ nftnl_expr_target_snprintf(char *buf, size_t len, uint32_t type,
 {
 	struct nftnl_expr_target *target = nftnl_expr_data(e);
 
+	if (len)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return snprintf(buf, len, "name %s rev %u ",

index e1d5280..a03648b 100644
@@ -168,6 +168,9 @@ static int nftnl_gen_cmd_snprintf(char *buf, size_t size,
 {
 	int ret, remain = size, offset = 0;
 
+	if (size)
+		buf[0] = '\0';
+
 	ret = nftnl_cmd_header_snprintf(buf + offset, remain, cmd, type, flags);
 	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 

@@ -188,7 +191,10 @@ static int nftnl_gen_cmd_snprintf(char *buf, size_t size,
 
 int nftnl_gen_snprintf(char *buf, size_t size, const struct nftnl_gen *gen,
 		       uint32_t type, uint32_t flags)
-{;
+{
+	if (size)
+		buf[0] = '\0';
+
 	return nftnl_gen_cmd_snprintf(buf, size, gen, nftnl_flag2cmd(flags), type,
 				    flags);
 }

@@ -197,6 +203,9 @@ EXPORT_SYMBOL(nftnl_gen_snprintf);
 static int nftnl_gen_do_snprintf(char *buf, size_t size, const void *gen,
 				 uint32_t cmd, uint32_t type, uint32_t flags)
 {
+	if (size)
+		buf = '\0';
+
 	return nftnl_gen_snprintf(buf, size, gen, type, flags);
 }
 

index beadc93..332bb2b 100644
@@ -158,6 +158,9 @@ static int nftnl_obj_counter_snprintf(char *buf, size_t len, uint32_t type,
 				       uint32_t flags,
 				       const struct nftnl_obj *e)
 {
+	if (len)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_obj_counter_snprintf_default(buf, len, e);

index d6d3111..62569fe 100644
@@ -185,6 +185,9 @@ static int nftnl_obj_ct_helper_snprintf(char *buf, size_t len, uint32_t type,
 				       uint32_t flags,
 				       const struct nftnl_obj *e)
 {
+	if (len)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_obj_ct_helper_snprintf_default(buf, len, e);

index 8cf0faa..7f8bcf7 100644
@@ -212,6 +212,9 @@ static int nftnl_obj_limit_snprintf(char *buf, size_t len, uint32_t type,
 				    uint32_t flags,
 				    const struct nftnl_obj *e)
 {
+	if (len)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_obj_limit_snprintf_default(buf, len, e);

index d5757b2..6d36784 100644
@@ -179,6 +179,9 @@ static int nftnl_obj_quota_snprintf(char *buf, size_t len, uint32_t type,
 				       uint32_t flags,
 				       const struct nftnl_obj *e)
 {
+	if (len)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 		return nftnl_obj_quota_snprintf_default(buf, len, e);

index d15ec10..8dc83b3 100644
@@ -448,6 +448,9 @@ static int nftnl_obj_cmd_snprintf(char *buf, size_t size,
 {
 	int ret, remain = size, offset = 0;
 
+	if (size)
+		buf[0] = '\0';
+
 	ret = nftnl_cmd_header_snprintf(buf + offset, remain, cmd, type, flags);
 	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 

@@ -474,6 +477,9 @@ static int nftnl_obj_cmd_snprintf(char *buf, size_t size,
 int nftnl_obj_snprintf(char *buf, size_t size, const struct nftnl_obj *obj,
 		       uint32_t type, uint32_t flags)
 {
+	if (size)
+		buf[0] = '\0';
+
 	return nftnl_obj_cmd_snprintf(buf, size, obj, nftnl_flag2cmd(flags),
 				      type, flags);
 }

@@ -482,6 +488,9 @@ EXPORT_SYMBOL(nftnl_obj_snprintf);
 static int nftnl_obj_do_snprintf(char *buf, size_t size, const void *obj,
 				 uint32_t cmd, uint32_t type, uint32_t flags)
 {
+	if (size)
+		buf[0] = '\0';
+
 	return nftnl_obj_snprintf(buf, size, obj, type, flags);
 }
 

index 5df8216..04788f4 100644
@@ -792,6 +792,9 @@ static int nftnl_rule_cmd_snprintf(char *buf, size_t size,
 	int ret, remain = size, offset = 0;
 	uint32_t inner_flags = flags;
 
+	if (size)
+		buf[0] = '\0';
+
 	inner_flags &= ~NFTNL_OF_EVENT_ANY;
 
 	ret = nftnl_cmd_header_snprintf(buf + offset, remain, cmd, type, flags);

@@ -822,6 +825,9 @@ static int nftnl_rule_cmd_snprintf(char *buf, size_t size,
 int nftnl_rule_snprintf(char *buf, size_t size, const struct nftnl_rule *r,
 			uint32_t type, uint32_t flags)
 {
+	if (size)
+		buf[0] = '\0';
+
 	return nftnl_rule_cmd_snprintf(buf, size, r, nftnl_flag2cmd(flags), type,
 				     flags);
 }

@@ -830,6 +836,9 @@ EXPORT_SYMBOL(nftnl_rule_snprintf);
 static int nftnl_rule_do_snprintf(char *buf, size_t size, const void *r,
 				  uint32_t cmd, uint32_t type, uint32_t flags)
 {
+	if (size)
+		buf[0] = '\0';
+
 	return nftnl_rule_snprintf(buf, size, r, type, flags);
 }
 

index aa23395..443388f 100644
@@ -846,6 +846,9 @@ nftnl_ruleset_do_snprintf(char *buf, size_t size, const struct nftnl_ruleset *rs
 	void *prev = NULL;
 	uint32_t inner_flags = flags;
 
+	if (size)
+		buf[0] = '\0';
+
 	/* dont pass events flags to child calls of _snprintf() */
 	inner_flags &= ~NFTNL_OF_EVENT_ANY;
 

@@ -919,6 +922,9 @@ static int nftnl_ruleset_cmd_snprintf(char *buf, size_t size,
 				    const struct nftnl_ruleset *r, uint32_t cmd,
 				    uint32_t type, uint32_t flags)
 {
+	if (size)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 	case NFTNL_OUTPUT_JSON:

@@ -933,6 +939,9 @@ static int nftnl_ruleset_cmd_snprintf(char *buf, size_t size,
 int nftnl_ruleset_snprintf(char *buf, size_t size, const struct nftnl_ruleset *r,
 			 uint32_t type, uint32_t flags)
 {
+	if (size)
+		buf[0] = '\0';
+
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
 	case NFTNL_OUTPUT_JSON:

index 720177b..3147bf2 100644
@@ -895,6 +895,9 @@ static int nftnl_set_cmd_snprintf(char *buf, size_t size,
 	if (type == NFTNL_OUTPUT_XML)
 		return 0;
 
+	if (size)
+		buf[0] = '\0';
+
 	/* prevent set_elems to print as events */
 	inner_flags &= ~NFTNL_OF_EVENT_ANY;
 

@@ -925,6 +928,9 @@ static int nftnl_set_cmd_snprintf(char *buf, size_t size,
 int nftnl_set_snprintf(char *buf, size_t size, const struct nftnl_set *s,
 		       uint32_t type, uint32_t flags)
 {
+	if (size)
+		buf[0] = '\0';
+
 	return nftnl_set_cmd_snprintf(buf, size, s, nftnl_flag2cmd(flags), type,
 				    flags);
 }

@@ -933,6 +939,9 @@ EXPORT_SYMBOL(nftnl_set_snprintf);
 static int nftnl_set_do_snprintf(char *buf, size_t size, const void *s,
 				 uint32_t cmd, uint32_t type, uint32_t flags)
 {
+	if (size)
+		buf[0] = '\0';
+
 	return nftnl_set_snprintf(buf, size, s, type, flags);
 }
 

index 40fbf33..9b59744 100644
@@ -696,6 +696,8 @@ static int nftnl_set_elem_cmd_snprintf(char *buf, size_t size,
 
 	if (type == NFTNL_OUTPUT_XML)
 		return 0;
+	if (size)
+		buf[0] = '\0';
 
 	ret = nftnl_cmd_header_snprintf(buf + offset, remain, cmd, type, flags);
 	SNPRINTF_BUFFER_SIZE(ret, remain, offset);

@@ -724,6 +726,9 @@ int nftnl_set_elem_snprintf(char *buf, size_t size,
 			    const struct nftnl_set_elem *e,
 			    uint32_t type, uint32_t flags)
 {
+	if (size)
+		buf[0] = '\0';
+
 	return nftnl_set_elem_cmd_snprintf(buf, size, e, nftnl_flag2cmd(flags),
 					 type, flags);
 }

@@ -733,6 +738,9 @@ static int nftnl_set_elem_do_snprintf(char *buf, size_t size, const void *e,
 				      uint32_t cmd, uint32_t type,
 				      uint32_t flags)
 {
+	if (size)
+		buf[0] = '\0';
+
 	return nftnl_set_elem_snprintf(buf, size, e, type, flags);
 }
 

index d426bcb..4a0a896 100644
@@ -378,6 +378,9 @@ static int nftnl_table_cmd_snprintf(char *buf, size_t size,
 {
 	int ret, remain = size, offset = 0;
 
+	if (size)
+		buf[0] = '\0';
+
 	ret = nftnl_cmd_header_snprintf(buf + offset, remain, cmd, type, flags);
 	SNPRINTF_BUFFER_SIZE(ret, remain, offset);
 

@@ -403,6 +406,9 @@ static int nftnl_table_cmd_snprintf(char *buf, size_t size,
 int nftnl_table_snprintf(char *buf, size_t size, const struct nftnl_table *t,
 			 uint32_t type, uint32_t flags)
 {
+	if (size)
+		buf[0] = '\0';
+
 	return nftnl_table_cmd_snprintf(buf, size, t, nftnl_flag2cmd(flags), type,
 				      flags);
 }

@@ -411,6 +417,9 @@ EXPORT_SYMBOL(nftnl_table_snprintf);
 static int nftnl_table_do_snprintf(char *buf, size_t size, const void *t,
 				   uint32_t cmd, uint32_t type, uint32_t flags)
 {
+	if (size)
+		buf[0] = '\0';
+
 	return nftnl_table_snprintf(buf, size, t, type, flags);
 }