nfct_snprintf now returns the number of bytes that would have been written, not just the number of bytes written. Emulate snprintf behaviour as in specified in C99

3 files changed, 112 insertions, 111 deletions

diff --git a/include/internal.h b/include/internal.h
index c512a85..5a13c11 100644
--- a/include/internal.h
+++ b/include/internal.h
@@ -158,10 +158,11 @@ static inline int test_bit(int nr, const u_int32_t *addr)
 	return ((1UL << (nr & 31)) & (addr[nr >> 5])) != 0;
 }
 
-#define BUFFER_SIZE(ret, size, len)			\
+#define BUFFER_SIZE(ret, size, len, offset)		\
+	size += ret;					\
 	if (ret > len)					\
 		ret = len;				\
-	size += ret;					\
+	offset += ret;					\
 	len -= ret;
 
 int __build_conntrack(struct nfnl_subsys_handle *ssh, struct nfnlhdr *req, size_t size, u_int16_t type, u_int16_t flags, const struct nf_conntrack *ct);
diff --git a/src/conntrack/snprintf_default.c b/src/conntrack/snprintf_default.c
index 78c0c64..5674963 100644
--- a/src/conntrack/snprintf_default.c
+++ b/src/conntrack/snprintf_default.c
@@ -70,15 +70,15 @@ int __snprintf_address_ipv4(char *buf,
 			    unsigned int len,
 			    const struct __nfct_tuple *tuple)
 {
-	int ret, size = 0;
+	int ret, size = 0, offset = 0;
 	struct in_addr src = { .s_addr = tuple->src.v4 };
 	struct in_addr dst = { .s_addr = tuple->dst.v4 };
 
 	ret = snprintf(buf, len, "src=%s ", inet_ntoa(src));
-	BUFFER_SIZE(ret, size, len);
+	BUFFER_SIZE(ret, size, len, offset);
 
-	ret = snprintf(buf+size, len, "dst=%s ", inet_ntoa(dst));
-	BUFFER_SIZE(ret, size, len);
+	ret = snprintf(buf+offset, len, "dst=%s ", inet_ntoa(dst));
+	BUFFER_SIZE(ret, size, len, offset);
 
 	return size;
 }
@@ -87,7 +87,7 @@ int __snprintf_address_ipv6(char *buf,
 			    unsigned int len,
 			    const struct __nfct_tuple *tuple)
 {
-	int ret, size = 0;
+	int ret, size = 0, offset = 0;
 	struct in6_addr src;
 	struct in6_addr dst;
 	char tmp[INET6_ADDRSTRLEN];
@@ -99,13 +99,13 @@ int __snprintf_address_ipv6(char *buf,
 		return -1;
 
 	ret = snprintf(buf, len, "src=%s ", tmp);
-	BUFFER_SIZE(ret, size, len);
+	BUFFER_SIZE(ret, size, len, offset);
 
 	if (!inet_ntop(AF_INET6, &dst, tmp, sizeof(tmp)))
 		return -1;
 
-	ret = snprintf(buf+size, len-size, "dst=%s ", tmp);
-	BUFFER_SIZE(ret, size, len);
+	ret = snprintf(buf+offset, len-size, "dst=%s ", tmp);
+	BUFFER_SIZE(ret, size, len, offset);
 
 	return size;
 }
@@ -205,89 +205,89 @@ int __snprintf_id(char *buf, unsigned int len, u_int32_t id)
 }
 
 int __snprintf_conntrack_default(char *buf, 
-				 unsigned int remain,
+				 unsigned int len,
 				 const struct nf_conntrack *ct,
 				 unsigned int msg_type,
 				 unsigned int flags) 
 {
-	int ret = 0, size = 0;
+	int ret = 0, size = 0, offset = 0;
 
 	switch(msg_type) {
 		case NFCT_T_NEW:
-			ret = snprintf(buf, remain, "%9s ", "[NEW]");
+			ret = snprintf(buf, len, "%9s ", "[NEW]");
 			break;
 		case NFCT_T_UPDATE:
-			ret = snprintf(buf, remain, "%9s ", "[UPDATE]");
+			ret = snprintf(buf, len, "%9s ", "[UPDATE]");
 			break;
 		case NFCT_T_DESTROY:
-			ret = snprintf(buf, remain, "%9s ", "[DESTROY]");
+			ret = snprintf(buf, len, "%9s ", "[DESTROY]");
 			break;
 		default:
 			break;
 	}
 
-	BUFFER_SIZE(ret, size, remain);
+	BUFFER_SIZE(ret, size, len, offset);
 
 	if (flags & NFCT_OF_SHOW_LAYER3) {
-		ret = __snprintf_l3protocol(buf+size, remain, ct);
-		BUFFER_SIZE(ret, size, remain);
+		ret = __snprintf_l3protocol(buf+offset, len, ct);
+		BUFFER_SIZE(ret, size, len, offset);
 	}
 
-	ret = __snprintf_protocol(buf+size, remain, ct);
-	BUFFER_SIZE(ret, size, remain);
+	ret = __snprintf_protocol(buf+offset, len, ct);
+	BUFFER_SIZE(ret, size, len, offset);
 
 	if (test_bit(ATTR_TIMEOUT, ct->set)) {
-		ret = __snprintf_timeout(buf+size, remain, ct);
-		BUFFER_SIZE(ret, size, remain);
+		ret = __snprintf_timeout(buf+offset, len, ct);
+		BUFFER_SIZE(ret, size, len, offset);
 	}
 
         if (test_bit(ATTR_TCP_STATE, ct->set)) {
-		ret = __snprintf_protoinfo(buf+size, remain, ct);
-		BUFFER_SIZE(ret, size, remain);
+		ret = __snprintf_protoinfo(buf+offset, len, ct);
+		BUFFER_SIZE(ret, size, len, offset);
 	}
 
-	ret = __snprintf_address(buf+size, remain, &ct->tuple[__DIR_ORIG]);
-	BUFFER_SIZE(ret, size, remain);
+	ret = __snprintf_address(buf+offset, len, &ct->tuple[__DIR_ORIG]);
+	BUFFER_SIZE(ret, size, len, offset);
 
-	ret = __snprintf_proto(buf+size, remain, &ct->tuple[__DIR_ORIG]);
-	BUFFER_SIZE(ret, size, remain);
+	ret = __snprintf_proto(buf+offset, len, &ct->tuple[__DIR_ORIG]);
+	BUFFER_SIZE(ret, size, len, offset);
 
 	if (test_bit(ATTR_ORIG_COUNTER_PACKETS, ct->set) &&
 	    test_bit(ATTR_ORIG_COUNTER_BYTES, ct->set)) {
-		ret = __snprintf_counters(buf+size, remain, ct, __DIR_ORIG);
-		BUFFER_SIZE(ret, size, remain);
+		ret = __snprintf_counters(buf+offset, len, ct, __DIR_ORIG);
+		BUFFER_SIZE(ret, size, len, offset);
 	}
 
 	if (test_bit(ATTR_STATUS, ct->set)) {
-		ret = __snprintf_status_not_seen_reply(buf+size, remain, ct);
-		BUFFER_SIZE(ret, size, remain);
+		ret = __snprintf_status_not_seen_reply(buf+offset, len, ct);
+		BUFFER_SIZE(ret, size, len, offset);
 	}
 
-	ret = __snprintf_address(buf+size, remain, &ct->tuple[__DIR_REPL]);
-	BUFFER_SIZE(ret, size, remain);
+	ret = __snprintf_address(buf+offset, len, &ct->tuple[__DIR_REPL]);
+	BUFFER_SIZE(ret, size, len, offset);
 
-	ret = __snprintf_proto(buf+size, remain, &ct->tuple[__DIR_REPL]);
-	BUFFER_SIZE(ret, size, remain);
+	ret = __snprintf_proto(buf+offset, len, &ct->tuple[__DIR_REPL]);
+	BUFFER_SIZE(ret, size, len, offset);
 
 	if (test_bit(ATTR_REPL_COUNTER_PACKETS, ct->set) &&
 	    test_bit(ATTR_REPL_COUNTER_BYTES, ct->set)) {
-		ret = __snprintf_counters(buf+size, remain, ct, __DIR_REPL);
-		BUFFER_SIZE(ret, size, remain);
+		ret = __snprintf_counters(buf+offset, len, ct, __DIR_REPL);
+		BUFFER_SIZE(ret, size, len, offset);
 	}
 
 	if (test_bit(ATTR_STATUS, ct->set)) {
-		ret = __snprintf_status_assured(buf+size, remain, ct);
-		BUFFER_SIZE(ret, size, remain);
+		ret = __snprintf_status_assured(buf+offset, len, ct);
+		BUFFER_SIZE(ret, size, len, offset);
 	}
 
 	if (test_bit(ATTR_MARK, ct->set)) {
-		ret = __snprintf_mark(buf+size, remain, ct);
-		BUFFER_SIZE(ret, size, remain);
+		ret = __snprintf_mark(buf+offset, len, ct);
+		BUFFER_SIZE(ret, size, len, offset);
 	}
 
 	if (test_bit(ATTR_USE, ct->set)) {
-		ret = __snprintf_use(buf+size, remain, ct);
-		BUFFER_SIZE(ret, size, remain);
+		ret = __snprintf_use(buf+offset, len, ct);
+		BUFFER_SIZE(ret, size, len, offset);
 	}
 
 	/* Delete the last blank space */
diff --git a/src/conntrack/snprintf_xml.c b/src/conntrack/snprintf_xml.c
index 892c85b..56b2016 100644
--- a/src/conntrack/snprintf_xml.c
+++ b/src/conntrack/snprintf_xml.c
@@ -112,38 +112,38 @@ static int __snprintf_addr_xml(char *buf,
 			       unsigned int type)
 {
 	int ret;
-	unsigned int size = 0;
+	unsigned int size = 0, offset = 0;
 
 	switch(type) {
 	case __ADDR_SRC:
 		ret = snprintf(buf, len, "<src>");
-		BUFFER_SIZE(ret, size, len);
+		BUFFER_SIZE(ret, size, len, offset);
 		break;
 	case __ADDR_DST:
-		ret = snprintf(buf+size, len, "<dst>");
-		BUFFER_SIZE(ret, size, len);
+		ret = snprintf(buf+offset, len, "<dst>");
+		BUFFER_SIZE(ret, size, len, offset);
 		break;
 	}
 
 	switch (tuple->l3protonum) {
 	case AF_INET:
-		ret = __snprintf_ipv4_xml(buf+size, len, tuple, type);
-		BUFFER_SIZE(ret, size, len);
+		ret = __snprintf_ipv4_xml(buf+offset, len, tuple, type);
+		BUFFER_SIZE(ret, size, len, offset);
 		break;
 	case AF_INET6:
-		ret = __snprintf_ipv6_xml(buf+size, len, tuple, type);
-		BUFFER_SIZE(ret, size, len);
+		ret = __snprintf_ipv6_xml(buf+offset, len, tuple, type);
+		BUFFER_SIZE(ret, size, len, offset);
 		break;
 	}
 
 	switch(type) {
 	case __ADDR_SRC:
-		ret = snprintf(buf+size, len, "</src>");
-		BUFFER_SIZE(ret, size, len);
+		ret = snprintf(buf+offset, len, "</src>");
+		BUFFER_SIZE(ret, size, len, offset);
 		break;
 	case __ADDR_DST:
-		ret = snprintf(buf+size, len, "</dst>");
-		BUFFER_SIZE(ret, size, len);
+		ret = snprintf(buf+offset, len, "</dst>");
+		BUFFER_SIZE(ret, size, len, offset);
 		break;
 	}
 
@@ -156,7 +156,7 @@ static int __snprintf_proto_xml(char *buf,
 				unsigned int type)
 {
 	int ret = 0;
-	unsigned int size = 0;
+	unsigned int size = 0, offset = 0;
 
 	switch(tuple->protonum) {
 	case IPPROTO_TCP:
@@ -165,11 +165,11 @@ static int __snprintf_proto_xml(char *buf,
 		if (type == __ADDR_SRC) {
 			ret = snprintf(buf, len, "<sport>%u</sport>", 
 				       ntohs(tuple->l4src.tcp.port));
-			BUFFER_SIZE(ret, size, len);
+			BUFFER_SIZE(ret, size, len, offset);
 		} else {
 			ret = snprintf(buf, len, "<dport>%u</dport>",
 				       ntohs(tuple->l4dst.tcp.port));
-			BUFFER_SIZE(ret, size, len);
+			BUFFER_SIZE(ret, size, len, offset);
 		}
 		break;
 	}
@@ -183,15 +183,15 @@ static int __snprintf_counters_xml(char *buf,
 				   unsigned int type)
 {
 	int ret;
-	unsigned int size = 0;
+	unsigned int size = 0, offset = 0;
 
 	ret = snprintf(buf, len, "<packets>%llu</packets>",
 		       ct->counters[type].packets);
-	BUFFER_SIZE(ret, size, len);
+	BUFFER_SIZE(ret, size, len, offset);
 
-	ret = snprintf(buf+size, len, "<bytes>%llu</bytes>",
+	ret = snprintf(buf+offset, len, "<bytes>%llu</bytes>",
 		       ct->counters[type].bytes);
-	BUFFER_SIZE(ret, size, len);
+	BUFFER_SIZE(ret, size, len, offset);
 
 	return size;
 }
@@ -202,55 +202,55 @@ static int __snprintf_tuple_xml(char *buf,
 				unsigned int dir)
 {
 	int ret;
-	unsigned int size = 0;
+	unsigned int size = 0, offset = 0;
 	const struct __nfct_tuple *tuple = &ct->tuple[dir];
 
 	ret = snprintf(buf, len, "<meta direction=\"%s\">",
 		       dir == __DIR_ORIG ? "original" : "reply");
-	BUFFER_SIZE(ret, size, len);
+	BUFFER_SIZE(ret, size, len, offset);
 
-	ret = snprintf(buf+size, len, 
+	ret = snprintf(buf+offset, len, 
 		       "<layer3 protonum=\"%d\" protoname=\"%s\">",
 		       tuple->l3protonum, __l3proto2str(tuple->l3protonum));
-	BUFFER_SIZE(ret, size, len);
+	BUFFER_SIZE(ret, size, len, offset);
 
-	ret = __snprintf_addr_xml(buf+size, len, tuple, __DIR_ORIG);
-	BUFFER_SIZE(ret, size, len);
+	ret = __snprintf_addr_xml(buf+offset, len, tuple, __DIR_ORIG);
+	BUFFER_SIZE(ret, size, len, offset);
 
-	ret = __snprintf_addr_xml(buf+size, len, tuple, __DIR_REPL);
-	BUFFER_SIZE(ret, size, len);
+	ret = __snprintf_addr_xml(buf+offset, len, tuple, __DIR_REPL);
+	BUFFER_SIZE(ret, size, len, offset);
 
-	ret = snprintf(buf+size, len, "</layer3>");
-	BUFFER_SIZE(ret, size, len);
+	ret = snprintf(buf+offset, len, "</layer3>");
+	BUFFER_SIZE(ret, size, len, offset);
 
-	ret = snprintf(buf+size, len, 
+	ret = snprintf(buf+offset, len, 
 		       "<layer4 protonum=\"%d\" protoname=\"%s\">",
 		       tuple->protonum, __proto2str(tuple->protonum));
-	BUFFER_SIZE(ret, size, len);
+	BUFFER_SIZE(ret, size, len, offset);
 
-	ret = __snprintf_proto_xml(buf+size, len, tuple, __DIR_ORIG);
-	BUFFER_SIZE(ret, size, len);
+	ret = __snprintf_proto_xml(buf+offset, len, tuple, __DIR_ORIG);
+	BUFFER_SIZE(ret, size, len, offset);
 
-	ret = __snprintf_proto_xml(buf+size, len, tuple, __DIR_REPL);
-	BUFFER_SIZE(ret, size, len);
+	ret = __snprintf_proto_xml(buf+offset, len, tuple, __DIR_REPL);
+	BUFFER_SIZE(ret, size, len, offset);
 
-	ret = snprintf(buf+size, len, "</layer4>");
-	BUFFER_SIZE(ret, size, len);
+	ret = snprintf(buf+offset, len, "</layer4>");
+	BUFFER_SIZE(ret, size, len, offset);
 
 	if (test_bit(ATTR_ORIG_COUNTER_PACKETS, ct->set) &&
 	    test_bit(ATTR_ORIG_COUNTER_BYTES, ct->set)) {
-		ret = snprintf(buf+size, len, "<counters>");
-		BUFFER_SIZE(ret, size, len);
+		ret = snprintf(buf+offset, len, "<counters>");
+		BUFFER_SIZE(ret, size, len, offset);
 
-		ret = __snprintf_counters_xml(buf+size, len, ct, dir);
-		BUFFER_SIZE(ret, size, len);
+		ret = __snprintf_counters_xml(buf+offset, len, ct, dir);
+		BUFFER_SIZE(ret, size, len, offset);
 
-		ret = snprintf(buf+size, len, "</counters>");
-		BUFFER_SIZE(ret, size, len);
+		ret = snprintf(buf+offset, len, "</counters>");
+		BUFFER_SIZE(ret, size, len, offset);
 	}
 
-	ret = snprintf(buf+size, len, "</meta>");
-	BUFFER_SIZE(ret, size, len);
+	ret = snprintf(buf+offset, len, "</meta>");
+	BUFFER_SIZE(ret, size, len, offset);
 
 	return size;
 }
@@ -262,7 +262,7 @@ int __snprintf_conntrack_xml(char *buf,
 			     const unsigned int flags) 
 {
 	int ret = 0;
-	unsigned int size = 0;
+	unsigned int size = 0, offset = 0;
 
 	switch(msg_type) {
 		case NFCT_T_NEW:
@@ -279,61 +279,61 @@ int __snprintf_conntrack_xml(char *buf,
 			break;
 	}
 
-	BUFFER_SIZE(ret, size, len);
+	BUFFER_SIZE(ret, size, len, offset);
 
-	ret = __snprintf_tuple_xml(buf+size, len, ct, __DIR_ORIG);
-	BUFFER_SIZE(ret, size, len);
+	ret = __snprintf_tuple_xml(buf+offset, len, ct, __DIR_ORIG);
+	BUFFER_SIZE(ret, size, len, offset);
 
-	ret = __snprintf_tuple_xml(buf+size, len, ct, __DIR_REPL);
-	BUFFER_SIZE(ret, size, len);
+	ret = __snprintf_tuple_xml(buf+offset, len, ct, __DIR_REPL);
+	BUFFER_SIZE(ret, size, len, offset);
 
 	if (test_bit(ATTR_TIMEOUT, ct->set) ||
 	    test_bit(ATTR_MARK, ct->set) ||
 	    test_bit(ATTR_USE, ct->set) ||
 	    test_bit(ATTR_STATUS, ct->set)) {
-		ret = snprintf(buf+size, len, 
+		ret = snprintf(buf+offset, len, 
 			       "<meta direction=\"independent\">");
-		BUFFER_SIZE(ret, size, len);
+		BUFFER_SIZE(ret, size, len, offset);
 	}
 
 	if (test_bit(ATTR_TIMEOUT, ct->set)) {
-		ret = snprintf(buf+size, len,
+		ret = snprintf(buf+offset, len,
 				"<timeout>%u</timeout>", ct->timeout);
-		BUFFER_SIZE(ret, size, len);
+		BUFFER_SIZE(ret, size, len, offset);
 	}
 
 	if (test_bit(ATTR_MARK, ct->set)) {
-		ret = snprintf(buf+size, len, "<mark>%u</mark>", ct->mark);
-		BUFFER_SIZE(ret, size, len);
+		ret = snprintf(buf+offset, len, "<mark>%u</mark>", ct->mark);
+		BUFFER_SIZE(ret, size, len, offset);
 	}
 
 	if (test_bit(ATTR_USE, ct->set)) {
-		ret = snprintf(buf+size, len, "<use>%u</use>", ct->use);
-		BUFFER_SIZE(ret, size, len);
+		ret = snprintf(buf+offset, len, "<use>%u</use>", ct->use);
+		BUFFER_SIZE(ret, size, len, offset);
 	}
 
 	if (test_bit(ATTR_STATUS, ct->set)
 	    && ct->status & IPS_ASSURED) {
-		ret = snprintf(buf+size, len, "<assured/>");
-		BUFFER_SIZE(ret, size, len);
+		ret = snprintf(buf+offset, len, "<assured/>");
+		BUFFER_SIZE(ret, size, len, offset);
 	}
 
 	if (test_bit(ATTR_STATUS, ct->set) 
 	    && !(ct->status & IPS_SEEN_REPLY)) {
-		ret = snprintf(buf+size, len, "<unreplied/>");
-		BUFFER_SIZE(ret, size, len);
+		ret = snprintf(buf+offset, len, "<unreplied/>");
+		BUFFER_SIZE(ret, size, len, offset);
 	}
 
 	if (test_bit(ATTR_TIMEOUT, ct->set) ||
 	    test_bit(ATTR_MARK, ct->set) ||
 	    test_bit(ATTR_USE, ct->set) ||
 	    test_bit(ATTR_STATUS, ct->set)) {
-	    	ret = snprintf(buf+size, len, "</meta>");
-		BUFFER_SIZE(ret, size, len);
+	    	ret = snprintf(buf+offset, len, "</meta>");
+		BUFFER_SIZE(ret, size, len, offset);
 	}
 
-	ret = snprintf(buf+size, len, "</flow>");
-	BUFFER_SIZE(ret, size, len);
+	ret = snprintf(buf+offset, len, "</flow>");
+	BUFFER_SIZE(ret, size, len, offset);
 
 	return size;
 }