| /* BEGIN_HEADER */ |
| #include "mbedtls/memory_buffer_alloc.h" |
| #define TEST_SUITE_MEMORY_BUFFER_ALLOC |
| |
| /* END_HEADER */ |
| |
| /* BEGIN_DEPENDENCIES |
| * depends_on:MBEDTLS_MEMORY_BUFFER_ALLOC_C |
| * END_DEPENDENCIES |
| */ |
| |
| /* BEGIN_SUITE_HELPERS */ |
| static int check_pointer(void *p) |
| { |
| if (p == NULL) { |
| return -1; |
| } |
| |
| if ((size_t) p % MBEDTLS_MEMORY_ALIGN_MULTIPLE != 0) { |
| return -1; |
| } |
| |
| return 0; |
| } |
| /* END_SUITE_HELPERS */ |
| |
| /* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */ |
| void mbedtls_memory_buffer_alloc_self_test() |
| { |
| TEST_ASSERT(mbedtls_memory_buffer_alloc_self_test(1) == 0); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE */ |
| void memory_buffer_alloc_free_alloc(int a_bytes, int b_bytes, int c_bytes, |
| int d_bytes, int free_a, int free_b, |
| int free_c, int free_d, int e_bytes, |
| int f_bytes) |
| { |
| unsigned char buf[1024]; |
| unsigned char *ptr_a = NULL, *ptr_b = NULL, *ptr_c = NULL, *ptr_d = NULL, |
| *ptr_e = NULL, *ptr_f = NULL; |
| |
| #if defined(MBEDTLS_MEMORY_DEBUG) |
| size_t reported_blocks; |
| size_t reported_bytes; |
| #endif |
| size_t allocated_bytes = 0; |
| |
| mbedtls_memory_buffer_alloc_init(buf, sizeof(buf)); |
| |
| mbedtls_memory_buffer_set_verify(MBEDTLS_MEMORY_VERIFY_ALWAYS); |
| |
| if (a_bytes > 0) { |
| ptr_a = mbedtls_calloc(a_bytes, sizeof(char)); |
| TEST_ASSERT(check_pointer(ptr_a) == 0); |
| |
| allocated_bytes += a_bytes * sizeof(char); |
| } |
| |
| if (b_bytes > 0) { |
| ptr_b = mbedtls_calloc(b_bytes, sizeof(char)); |
| TEST_ASSERT(check_pointer(ptr_b) == 0); |
| |
| allocated_bytes += b_bytes * sizeof(char); |
| } |
| |
| if (c_bytes > 0) { |
| ptr_c = mbedtls_calloc(c_bytes, sizeof(char)); |
| TEST_ASSERT(check_pointer(ptr_c) == 0); |
| |
| allocated_bytes += c_bytes * sizeof(char); |
| } |
| |
| if (d_bytes > 0) { |
| ptr_d = mbedtls_calloc(d_bytes, sizeof(char)); |
| TEST_ASSERT(check_pointer(ptr_d) == 0); |
| |
| allocated_bytes += d_bytes * sizeof(char); |
| } |
| |
| #if defined(MBEDTLS_MEMORY_DEBUG) |
| mbedtls_memory_buffer_alloc_cur_get(&reported_bytes, &reported_blocks); |
| TEST_ASSERT(reported_bytes == allocated_bytes); |
| #endif |
| |
| if (free_a) { |
| mbedtls_free(ptr_a); |
| ptr_a = NULL; |
| TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0); |
| |
| allocated_bytes -= a_bytes * sizeof(char); |
| } |
| |
| if (free_b) { |
| mbedtls_free(ptr_b); |
| ptr_b = NULL; |
| TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0); |
| |
| allocated_bytes -= b_bytes * sizeof(char); |
| } |
| |
| if (free_c) { |
| mbedtls_free(ptr_c); |
| ptr_c = NULL; |
| TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0); |
| |
| allocated_bytes -= c_bytes * sizeof(char); |
| } |
| |
| if (free_d) { |
| mbedtls_free(ptr_d); |
| ptr_d = NULL; |
| TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0); |
| |
| allocated_bytes -= d_bytes * sizeof(char); |
| } |
| |
| #if defined(MBEDTLS_MEMORY_DEBUG) |
| mbedtls_memory_buffer_alloc_cur_get(&reported_bytes, &reported_blocks); |
| TEST_ASSERT(reported_bytes == allocated_bytes); |
| #endif |
| |
| if (e_bytes > 0) { |
| ptr_e = mbedtls_calloc(e_bytes, sizeof(char)); |
| TEST_ASSERT(check_pointer(ptr_e) == 0); |
| } |
| |
| if (f_bytes > 0) { |
| ptr_f = mbedtls_calloc(f_bytes, sizeof(char)); |
| TEST_ASSERT(check_pointer(ptr_f) == 0); |
| } |
| |
| /* Once blocks are reallocated, the block allocated to the memory request |
| * may be bigger than the request itself, which is indicated by the reported |
| * bytes, and makes it hard to know what the reported size will be, so |
| * we don't check the size after blocks have been reallocated. */ |
| |
| if (ptr_a != NULL) { |
| mbedtls_free(ptr_a); |
| ptr_a = NULL; |
| TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0); |
| } |
| |
| if (ptr_b != NULL) { |
| mbedtls_free(ptr_b); |
| ptr_b = NULL; |
| TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0); |
| } |
| |
| if (ptr_c != NULL) { |
| mbedtls_free(ptr_c); |
| ptr_c = NULL; |
| TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0); |
| } |
| |
| if (ptr_d != NULL) { |
| mbedtls_free(ptr_d); |
| ptr_d = NULL; |
| TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0); |
| } |
| |
| if (ptr_e != NULL) { |
| mbedtls_free(ptr_e); |
| ptr_e = NULL; |
| TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0); |
| } |
| |
| if (ptr_f != NULL) { |
| mbedtls_free(ptr_f); |
| ptr_f = NULL; |
| } |
| |
| #if defined(MBEDTLS_MEMORY_DEBUG) |
| mbedtls_memory_buffer_alloc_cur_get(&reported_bytes, &reported_blocks); |
| TEST_ASSERT(reported_bytes == 0); |
| #endif |
| |
| TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0); |
| |
| exit: |
| mbedtls_memory_buffer_alloc_free(); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE */ |
| void memory_buffer_alloc_oom_test() |
| { |
| unsigned char buf[1024]; |
| unsigned char *ptr_a = NULL, *ptr_b = NULL, *ptr_c = NULL; |
| #if defined(MBEDTLS_MEMORY_DEBUG) |
| size_t reported_blocks, reported_bytes; |
| #endif |
| |
| (void) ptr_c; |
| |
| mbedtls_memory_buffer_alloc_init(buf, sizeof(buf)); |
| |
| mbedtls_memory_buffer_set_verify(MBEDTLS_MEMORY_VERIFY_ALWAYS); |
| |
| ptr_a = mbedtls_calloc(432, sizeof(char)); |
| TEST_ASSERT(check_pointer(ptr_a) == 0); |
| |
| ptr_b = mbedtls_calloc(432, sizeof(char)); |
| TEST_ASSERT(check_pointer(ptr_b) == 0); |
| |
| ptr_c = mbedtls_calloc(431, sizeof(char)); |
| TEST_ASSERT(ptr_c == NULL); |
| |
| #if defined(MBEDTLS_MEMORY_DEBUG) |
| mbedtls_memory_buffer_alloc_cur_get(&reported_bytes, &reported_blocks); |
| TEST_ASSERT(reported_bytes >= 864 && reported_bytes <= sizeof(buf)); |
| #endif |
| |
| mbedtls_free(ptr_a); |
| ptr_a = NULL; |
| TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0); |
| |
| mbedtls_free(ptr_b); |
| ptr_b = NULL; |
| TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0); |
| |
| #if defined(MBEDTLS_MEMORY_DEBUG) |
| mbedtls_memory_buffer_alloc_cur_get(&reported_bytes, &reported_blocks); |
| TEST_ASSERT(reported_bytes == 0); |
| #endif |
| |
| TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0); |
| |
| exit: |
| mbedtls_memory_buffer_alloc_free(); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE */ |
| void memory_buffer_heap_too_small() |
| { |
| unsigned char buf[1]; |
| |
| mbedtls_memory_buffer_alloc_init(buf, sizeof(buf)); |
| /* With MBEDTLS_MEMORY_DEBUG enabled, this prints a message |
| * "FATAL: verification of first header failed". |
| */ |
| TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() != 0); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE */ |
| void memory_buffer_underalloc() |
| { |
| unsigned char buf[100]; |
| size_t i; |
| |
| mbedtls_memory_buffer_alloc_init(buf, sizeof(buf)); |
| for (i = 1; i < MBEDTLS_MEMORY_ALIGN_MULTIPLE; i++) { |
| TEST_ASSERT(mbedtls_calloc(1, |
| (size_t) -(MBEDTLS_MEMORY_ALIGN_MULTIPLE - i)) == NULL); |
| TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0); |
| } |
| |
| exit: |
| mbedtls_memory_buffer_alloc_free(); |
| } |
| /* END_CASE */ |