From cc6bf2f8a3a1986ae0ef74ad8baadc08145a6702 Mon Sep 17 00:00:00 2001

From: Mark Andrews <marka@isc.org>

Date: Wed, 27 Sep 2017 16:02:02 +1000

Subject: [PATCH] 4740.   [cleanup]       Avoid triggering format-truncated

 warnings. [RT #46107]

(cherry picked from commit 73074e954a1f751c561728d08176b6849e843a2e)

use %u and cast to unsigned int

(cherry picked from commit 2495de04a50dc44968490168226199b9c80a2ab4)

4775.   [bug]           Address Coverity warnings in ht_test.c and mem_test.c

                        [RT #46281]

(cherry picked from commit 583e355951c73f5cdae3a161be9753701abaf553)

4776.   [bug]           Improve portability of ht_test. [RT #46333]

(cherry picked from commit 66258ca349b7398062e684337b19c5ce76701037)

(cherry picked from commit 5ff48dca189244295a0baded4970605156ca8529)

---

 lib/isc/tests/ht_test.c | 99 +++++++++++++++++++++++++++++++++----------------

 1 file changed, 67 insertions(+), 32 deletions(-)

diff --git a/lib/isc/tests/ht_test.c b/lib/isc/tests/ht_test.c

index 78dbc2d6a1..4a56ab86b5 100644

--- a/lib/isc/tests/ht_test.c

+++ b/lib/isc/tests/ht_test.c

@@ -20,8 +20,11 @@

 #include <isc/ht.h>

 #include <isc/mem.h>

 #include <isc/print.h>

+#include <isc/string.h>

 #include <isc/util.h>

+#include <inttypes.h>

+

 static void *

 default_memalloc(void *arg, size_t size) {

 	UNUSED(arg);

@@ -36,25 +39,28 @@ default_memfree(void *arg, void *ptr) {

 	free(ptr);

 }

-

-static void test_ht_full(int bits, int count) {

+static void test_ht_full(int bits, uintptr_t count) {

 	isc_ht_t *ht = NULL;

 	isc_result_t result;

 	isc_mem_t *mctx = NULL;

-	isc_int64_t i;

+	uintptr_t i;

 	result = isc_mem_createx2(0, 0, default_memalloc, default_memfree,

 				  NULL, &mctx, 0);

 	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);

-	isc_ht_init(&ht, mctx, bits);

+	result = isc_ht_init(&ht, mctx, bits);

+	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);

+	ATF_REQUIRE(ht != NULL);

+

 	for (i = 1; i < count; i++) {

 		/*

-		 * Note that the string we're snprintfing is always > 16 bytes

-		 * so we are always filling the key.

+		 * Note: snprintf() is followed with strlcat()

+		 * to ensure we are always filling the 16 byte key.

 		 */

 		unsigned char key[16];

-		snprintf((char *)key, 16, "%lld key of a raw hashtable!!", i);

+		snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);

+		strlcat((char *)key, " key of a raw hashtable!!", sizeof(key));

 		result = isc_ht_add(ht, key, 16, (void *) i);

 		ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);

 	}

@@ -62,22 +68,29 @@ static void test_ht_full(int bits, int count) {

 	for (i = 1; i < count; i++) {

 		unsigned char key[16];

 		void *f = NULL;

-		snprintf((char *)key, 16, "%lld key of a raw hashtable!!", i);

+		snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);

+		strlcat((char *)key, " key of a raw hashtable!!", sizeof(key));

 		result = isc_ht_find(ht, key, 16, &f);

 		ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);

-		ATF_REQUIRE_EQ(i, (isc_int64_t) f);

+		ATF_REQUIRE_EQ(i, (uintptr_t) f);

 	}

 	for (i = 1; i < count; i++) {

 		unsigned char key[16];

-		snprintf((char *)key, 16, "%lld key of a raw hashtable!!", i);

+		snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);

+		strlcat((char *)key, " key of a raw hashtable!!", sizeof(key));

 		result = isc_ht_add(ht, key, 16, (void *) i);

 		ATF_REQUIRE_EQ(result, ISC_R_EXISTS);

 	}

 	for (i = 1; i < count; i++) {

 		char key[64];

-		snprintf((char *)key, 64, "%lld key of a str hashtable!!", i);

+		/*

+		 * Note: the key size is now strlen(key) which is bigger

+		 * then the keys added above.

+		 */

+		snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);

+		strlcat((char *)key, " key of a raw hashtable!!", sizeof(key));

 		result = isc_ht_add(ht, (const unsigned char *) key,

 				    strlen(key), (void *) i);

 		ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);

@@ -86,7 +99,11 @@ static void test_ht_full(int bits, int count) {

 	for (i = 1; i < count; i++) {

 		unsigned char key[16];

 		void *f = NULL;

-		snprintf((char *)key, 16, "%lld KEY of a raw hashtable!!", i);

+		/*

+		 * Note: case of KEY is now in capitals,

+		 */

+		snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);

+		strlcat((char *)key, " KEY of a raw hashtable!!", sizeof(key));

 		result = isc_ht_find(ht, key, 16, &f);

 		ATF_REQUIRE_EQ(result, ISC_R_NOTFOUND);

 		ATF_REQUIRE_EQ(f, NULL);

@@ -95,7 +112,8 @@ static void test_ht_full(int bits, int count) {

 	for (i = 1; i < count; i++) {

 		char key[64];

 		void *f = NULL;

-		snprintf((char *)key, 64, "%lld key of a str hashtable!!", i);

+		snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);

+		strlcat((char *)key, " key of a raw hashtable!!", sizeof(key));

 		result = isc_ht_find(ht, (const unsigned char *) key,

 				     strlen(key), &f);

 		ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);

@@ -105,7 +123,8 @@ static void test_ht_full(int bits, int count) {

 	for (i = 1; i < count; i++) {

 		unsigned char key[16];

 		void *f = NULL;

-		snprintf((char *)key, 16, "%lld key of a raw hashtable!!", i);

+		snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);

+		strlcat((char *)key, " key of a raw hashtable!!", sizeof(key));

 		result = isc_ht_delete(ht, key, 16);

 		ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);

 		result = isc_ht_find(ht, key, 16, &f);

@@ -115,7 +134,11 @@ static void test_ht_full(int bits, int count) {

 	for (i = 1; i < count; i++) {

 		unsigned char key[16];

-		snprintf((char *)key, 16, "%lld KEY of a raw hashtable!!", i);

+		/*

+		 * Note: upper case KEY.

+		 */

+		snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);

+		strlcat((char *)key, " KEY of a raw hashtable!!", sizeof(key));

 		result = isc_ht_add(ht, key, 16, (void *) i);

 		ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);

 	}

@@ -123,7 +146,8 @@ static void test_ht_full(int bits, int count) {

 	for (i = 1; i < count; i++) {

 		char key[64];

 		void *f = NULL;

-		snprintf((char *)key, 64, "%lld key of a str hashtable!!", i);

+		snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);

+		strlcat((char *)key, " key of a raw hashtable!!", sizeof(key));

 		result = isc_ht_delete(ht, (const unsigned char *) key,

 				       strlen(key));

 		ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);

@@ -137,16 +161,21 @@ static void test_ht_full(int bits, int count) {

 	for (i = 1; i < count; i++) {

 		unsigned char key[16];

 		void *f = NULL;

-		snprintf((char *)key, 16, "%lld KEY of a raw hashtable!!", i);

+		/*

+		 * Note: case of KEY is now in capitals,

+		 */

+		snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);

+		strlcat((char *)key, " KEY of a raw hashtable!!", sizeof(key));

 		result = isc_ht_find(ht, key, 16, &f);

 		ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);

-		ATF_REQUIRE_EQ(i, (isc_int64_t) f);

+		ATF_REQUIRE_EQ(i, (uintptr_t) f);

 	}

 	for (i = 1; i < count; i++) {

 		unsigned char key[16];

 		void *f = NULL;

-		snprintf((char *)key, 16, "%lld key of a raw hashtable!!", i);

+		snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);

+		strlcat((char *)key, " key of a raw hashtable!!", sizeof(key));

 		result = isc_ht_find(ht, key, 16, &f);

 		ATF_REQUIRE_EQ(result, ISC_R_NOTFOUND);

 		ATF_REQUIRE_EQ(f, NULL);

@@ -161,9 +190,9 @@ static void test_ht_iterator() {

 	isc_result_t result;

 	isc_mem_t *mctx = NULL;

 	isc_ht_iter_t * iter = NULL;

-	isc_int64_t i;

-	isc_int64_t v;

-	isc_uint32_t count = 10000;

+	uintptr_t i;

+	void *v;

+	uintptr_t count = 10000;

 	isc_uint32_t walked;

 	unsigned char key[16];

 	unsigned char *tkey;

@@ -181,7 +210,8 @@ static void test_ht_iterator() {

 		 * Note that the string we're snprintfing is always > 16 bytes

 		 * so we are always filling the key.

 		 */

-		snprintf((char *)key, 16, "%lld key of a raw hashtable!!", i);

+		snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);

+		strlcat((char *)key, "key of a raw hashtable!!", sizeof(key));

 		result = isc_ht_add(ht, key, 16, (void *) i);

 		ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);

 	}

@@ -194,10 +224,12 @@ static void test_ht_iterator() {

 	     result == ISC_R_SUCCESS;

 	     result = isc_ht_iter_next(iter))

 	{

-		isc_ht_iter_current(iter, (void**) &v);

+		isc_ht_iter_current(iter, &v);

 		isc_ht_iter_currentkey(iter, &tkey, &tksize);

 		ATF_REQUIRE_EQ(tksize, 16);

-		snprintf((char *)key, 16, "%lld key of a raw hashtable!!", v);

+		i = (uintptr_t)v;

+		snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);

+		strlcat((char *)key, "key of a raw hashtable!!", sizeof(key));

 		ATF_REQUIRE_EQ(memcmp(key, tkey, 16), 0);

 		walked++;

 	}

@@ -208,12 +240,14 @@ static void test_ht_iterator() {

 	walked = 0;

 	result = isc_ht_iter_first(iter);

 	while (result == ISC_R_SUCCESS) {

-		isc_ht_iter_current(iter, (void**) &v);

+		isc_ht_iter_current(iter, &v);

 		isc_ht_iter_currentkey(iter, &tkey, &tksize);

 		ATF_REQUIRE_EQ(tksize, 16);

-		snprintf((char *)key, 16, "%lld key of a raw hashtable!!", v);

+		i = (uintptr_t)v;

+		snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);

+		strlcat((char *)key, "key of a raw hashtable!!", sizeof(key));

 		ATF_REQUIRE_EQ(memcmp(key, tkey, 16), 0);

-		if (v % 2 == 0) {

+		if ((uintptr_t)v % 2 == 0) {

 			result = isc_ht_iter_delcurrent_next(iter);

 		} else {

 			result = isc_ht_iter_next(iter);

@@ -227,12 +261,14 @@ static void test_ht_iterator() {

 	walked = 0;

 	result = isc_ht_iter_first(iter);

 	while (result == ISC_R_SUCCESS) {

-		isc_ht_iter_current(iter, (void**) &v);

+		isc_ht_iter_current(iter, &v);

 		isc_ht_iter_currentkey(iter, &tkey, &tksize);

 		ATF_REQUIRE_EQ(tksize, 16);

-		snprintf((char *)key, 16, "%lld key of a raw hashtable!!", v);

+		i = (uintptr_t)v;

+		snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);

+		strlcat((char *)key, "key of a raw hashtable!!", sizeof(key));

 		ATF_REQUIRE_EQ(memcmp(key, tkey, 16), 0);

-		if (v % 2 == 1) {

+		if ((uintptr_t)v % 2 == 1) {

 			result = isc_ht_iter_delcurrent_next(iter);

 		} else {

 			result = isc_ht_iter_next(iter);

@@ -322,4 +358,3 @@ ATF_TP_ADD_TCS(tp) {

 	ATF_TP_ADD_TC(tp, isc_ht_iterator);

 	return (atf_no_error());

 }

-

-- 

2.14.3