From 661d72987ee7bf554c5a24bf76105e84f68b1849 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Petr=20Men=C5=A1=C3=ADk?= Date: Tue, 9 Jan 2018 18:18:17 +0100 Subject: [PATCH] 4776. [bug] Improve portability of ht_test. [RT #46333] --- bind-9.11-kyua-ht_test.patch | 275 +++++++++++++++++++++++++++++++++++ bind.spec | 5 + 2 files changed, 280 insertions(+) create mode 100644 bind-9.11-kyua-ht_test.patch diff --git a/bind-9.11-kyua-ht_test.patch b/bind-9.11-kyua-ht_test.patch new file mode 100644 index 0000000..2184f7f --- /dev/null +++ b/bind-9.11-kyua-ht_test.patch @@ -0,0 +1,275 @@ +From cc6bf2f8a3a1986ae0ef74ad8baadc08145a6702 Mon Sep 17 00:00:00 2001 +From: Mark Andrews +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 + #include + #include ++#include + #include + ++#include ++ + 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 + diff --git a/bind.spec b/bind.spec index d89c772..002a2b5 100644 --- a/bind.spec +++ b/bind.spec @@ -95,6 +95,10 @@ Patch147:bind-9.11-kyua.patch Patch148:bind-9.11-kyua-unit.patch Patch149:bind-9.11-kyua-pkcs11.patch Patch150:bind-9.11-kyua-portfix.patch +# [ISC-Bugs #46107] commit 73074e954a1f751c561728d08176b6849e843a2e ISC 4740 +# [ISC-Bugs #46281] commit 583e355951c73f5cdae3a161be9753701abaf553 ISC 4775 +# [ISC-Bugs #46333] commit 66258ca349b7398062e684337b19c5ce76701037 ISC 4776 +Patch151:bind-9.11-kyua-ht_test.patch # SDB patches Patch11: bind-9.3.2b2-sdbsrc.patch @@ -403,6 +407,7 @@ This package provides a module which allows commands to be sent to rndc directly %patch147 -p1 -b .kyua %patch148 -p1 -b .kyua-unit %patch150 -p1 -b .kyua-portfix +%patch151 -p1 -b .kyua-ht_test %if %{PKCS11} cp -r bin/named{,-pkcs11}