test: Make sure memset_explicit works before free or realloc

Check to make sure the heap is actually cleared. If
_NANO_MALLOC_CLEAR_FREED is set, skip the clears as that will have
done them.

Signed-off-by: Keith Packard <[email protected]>

Author: keith-packard

test/malloc.c

@@ -33,7 +33,7 @@
  * OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#define _DEFAULT_SOURCE
+#define _GNU_SOURCE
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
@@ -42,9 +42,15 @@
 #include <stdlib.h>
 #include <stdint.h>
 
-#ifndef __clang__
+#ifdef __GNUC__
+#pragma GCC diagnostic ignored "-Wpragmas"
+#pragma GCC diagnostic ignored "-Wunknown-warning-option"
 #pragma GCC diagnostic ignored "-Walloc-size-larger-than="
 #pragma GCC diagnostic ignored "-Wanalyzer-use-of-uninitialized-value"
+#pragma GCC diagnostic ignored "-Wanalyzer-use-after-free"
+#pragma GCC diagnostic ignored "-Wanalyzer-out-of-bounds"
+#pragma GCC diagnostic ignored "-Wuse-after-free"
+#pragma GCC diagnostic ignored "-Warray-bounds"
 #endif
 
 int
@@ -56,24 +62,24 @@ main(void)
 
 	errno = 0;
 	r = malloc(0);
-        printf("malloc(0): %p\n", r);
+//        printf("malloc(0): %p\n", r);
 	if (errno != 0) {
 		printf("malloc(0) failed: %s. got %p\n", strerror(errno), r);
-		result++;
+		result = 1;
 	}
 	free(r);
 
 	r = memalign(128, 237);
-        printf("memalign(128, 237): %p\n", r);
+//        printf("memalign(128, 237): %p\n", r);
 	if ((uintptr_t) r & 127) {
 		printf("memalign(128, 237) unaligned (%p)\n", r);
-		result++;
+		result = 1;
 	}
 	free(r);
 
 	r = NULL;
 	err = posix_memalign(&r, 128, 237);
-	printf("posix_memalign(128, 237): %p, err=%d\n", r, err);
+//	printf("posix_memalign(128, 237): %p, err=%d\n", r, err);
 	if ((uintptr_t) r & 127) {
 		printf("posix_memalign(128, 237) unaligned (%p)\n", r);
 		err++;
@@ -82,7 +88,7 @@ main(void)
 
 	r = NULL;
 	err = posix_memalign(&r, 0, 237);
-	printf("posix_memalign(0, 237): %p, err=%d\n", r, err);
+//	printf("posix_memalign(0, 237): %p, err=%d\n", r, err);
 	if (err != EINVAL) {
 		printf("posix_memalign(0, 237) should return EINVAL\n");
 		err++;
@@ -91,7 +97,7 @@ main(void)
 
 	r = NULL;
 	err = posix_memalign(&r, 129, 237);
-	printf("posix_memalign(129, 237): %p, err=%d\n", r, err);
+//	printf("posix_memalign(129, 237): %p, err=%d\n", r, err);
 	if (err != EINVAL) {
 		printf("posix_memalign(129, 237) should return EINVAL\n");
 		err++;
@@ -100,7 +106,7 @@ main(void)
 
 	r = NULL;
 	err = posix_memalign(&r, 128, PTRDIFF_MAX);
-	printf("posix_memalign(128, PTRDIFF_MAX): %p, err=%d\n", r, err);
+//	printf("posix_memalign(128, PTRDIFF_MAX): %p, err=%d\n", r, err);
 	if (err != ENOMEM) {
 		printf("posix_memalign(128, PTRDIFF_MAX) should return ENOMEM\n");
 		err++;
@@ -112,71 +118,120 @@ main(void)
         q = NULL;
         if (r)
                 q = malloc(PTRDIFF_MAX);
-        printf("malloc(PTRDIFF_MAX: %p %p\n", r, q);
+//        printf("malloc(PTRDIFF_MAX: %p %p\n", r, q);
 	if ((r && q) || errno != ENOMEM) {
                 printf("2*malloc(PTRDIFF_MAX) should have failed. got %p,%p error %s\n", r, q, strerror(errno));
-		result++;
+		result = 1;
 	}
         free(r);
         free(q);
 
 	errno = 0;
 	r = malloc(SIZE_MAX);
-        printf("malloc(SIZE_MAX): %p\n", r);
+//        printf("malloc(SIZE_MAX): %p\n", r);
 	if (r || errno != ENOMEM) {
 		printf("malloc(SIZE_MAX) should have failed. got %p error %s\n", r, strerror(errno));
-		result++;
+		result = 1;
 	}
 
 	errno = 0;
 	r = calloc(1, SIZE_MAX);
-        printf("calloc(1, SIZE_MAX): %p\n", r);
+//        printf("calloc(1, SIZE_MAX): %p\n", r);
 	if (r || errno != ENOMEM) {
 		printf("calloc(1, SIZE_MAX) should have failed. got %p error %s\n", r, strerror(errno));
-		result++;
+		result = 1;
 	}
 
 	errno = 0;
 	r = reallocarray(NULL, 1, SIZE_MAX);
-        printf("reallocarray(NULL, 1, SIZE_MAX): %p\n", r);
+//        printf("reallocarray(NULL, 1, SIZE_MAX): %p\n", r);
 	if (r || errno != ENOMEM) {
 		printf("reallocarray(NULL, 1, SIZE_MAX) should have failed. got %p error %s\n", r, strerror(errno));
-		result++;
+		result = 1;
 	}
 
 	for (pow = 0; pow < 4; pow++) {
 		errno = 0;
 		r = calloc(SIZE_MAX >> pow, SIZE_MAX >> pow);
-                printf("calloc(SIZE_MAX >> %d, SIZE_MAX >> %d): %p\n", pow, pow, r);
+//                printf("calloc(SIZE_MAX >> %d, SIZE_MAX >> %d): %p\n", pow, pow, r);
 		if (r || errno != ENOMEM) {
 			printf("calloc(SIZE_MAX >> %d, SIZE_MAX >> %d) should have failed. got %p error %s\n", pow, pow, r, strerror(errno));
-			result++;
+			result = 1;
 		}
                 free(r);
 		r = reallocarray(NULL, SIZE_MAX >> pow, SIZE_MAX >> pow);
-                printf("reallocarray(SIZE_MAX >> %d, SIZE_MAX >> %d): %p\n", pow, pow, r);
+//                printf("reallocarray(SIZE_MAX >> %d, SIZE_MAX >> %d): %p\n", pow, pow, r);
 		if (r || errno != ENOMEM) {
 			printf("reallocarray(NULL, SIZE_MAX >> %d, SIZE_MAX >> %d) should have failed. got %p error %s\n", pow, pow, r, strerror(errno));
-			result++;
+			result = 1;
 		}
                 free(r);
 	}
 
+        char *fzero = malloc(128);
+        int wrong = 0;
+        if (fzero) {
+            for (pow = 0; pow < 128; pow++)
+                fzero[pow] = pow + 2;
+#ifndef _NANO_MALLOC_CLEAR_FREED
+#ifdef __GLIBC__
+            explicit_bzero(fzero, 128);
+#else
+            memset_explicit(fzero, 0, 128);
+#endif
+#endif
+            free(fzero);
+            for (pow = 0; pow < 128; pow++)
+                if (fzero[pow] == pow + 2) {
+                    wrong++;
+                    break;
+                }
+        }
+        if (wrong > 3)  {
+            printf("free: %d bytes of memory not cleared\n", wrong);
+            result = 1;
+        }
+        wrong = 0;
+        char *rzero = malloc(128);
+        if (rzero) {
+            for (pow = 0; pow < 128; pow++)
+                rzero[pow] = pow + 2;
+#ifndef _NANO_MALLOC_CLEAR_FREED
+#ifdef __GLIBC__
+            explicit_bzero(rzero + 16, 128 - 16);
+#else
+            memset_explicit(rzero + 16, 0, 128-16);
+#endif
+#endif
+            rzero = realloc(rzero, 16);
+            for (pow = 16; pow < 128; pow++) {
+                if (rzero[pow] == pow + 2) {
+                    wrong++;
+                    break;
+                }
+            }
+            free(rzero);
+        }
+        if (wrong > 3)  {
+            printf("realloc: %d bytes of memory not cleared\n", wrong);
+            result = 1;
+        }
+
 	/* make sure realloc doesn't read past the source */
 
 	void *big = malloc(1024);
-        printf("big %p\n", big);
+//        printf("big %p\n", big);
 	if (big) {
                 memset(big, '1', 1024);
 		void *small = malloc(128);
-                printf("small %p\n", small);
+//                printf("small %p\n", small);
 		if (small) {
                         memset(small, '2', 128);
                         (void) atoi(small);
 			free(big);
 			char *med = realloc(small, 1024);
 			if (med) {
-                                printf("med %p\n", med);
+//                                printf("med %p\n", med);
 #ifdef _NANO_MALLOC
 				int i;
 				for (i = 128; i < 1024; i++)