From 8034ffde8b108957aeff801c30b1a4c31e147e55 Mon Sep 17 00:00:00 2001 From: mayeut Date: Sat, 17 Oct 2015 02:55:09 +0200 Subject: [PATCH] Fix inconsistent behavior of malloc(0) Update #635 Update #625 --- src/lib/openjp2/dwt.c | 8 ++++--- src/lib/openjp2/opj_malloc.c | 44 +++++++++++++++++++++++++----------- src/lib/openjp2/tcd.c | 4 ++-- 3 files changed, 38 insertions(+), 18 deletions(-) diff --git a/src/lib/openjp2/dwt.c b/src/lib/openjp2/dwt.c index 4ad99ed9..41dca2fe 100644 --- a/src/lib/openjp2/dwt.c +++ b/src/lib/openjp2/dwt.c @@ -567,9 +567,11 @@ static OPJ_BOOL opj_dwt_decode_tile(opj_tcd_tilecomp_t* tilec, OPJ_UINT32 numres OPJ_UINT32 rh = (OPJ_UINT32)(tr->y1 - tr->y0); /* height of the resolution level computed */ OPJ_UINT32 w = (OPJ_UINT32)(tilec->x1 - tilec->x0); - - h.mem = (OPJ_INT32*) - opj_aligned_malloc(opj_dwt_max_resolution(tr, numres) * sizeof(OPJ_INT32)); + + if (numres == 1U) { + return OPJ_TRUE; + } + h.mem = (OPJ_INT32*)opj_aligned_malloc(opj_dwt_max_resolution(tr, numres) * sizeof(OPJ_INT32)); if (! h.mem){ /* FIXME event manager error callback */ return OPJ_FALSE; diff --git a/src/lib/openjp2/opj_malloc.c b/src/lib/openjp2/opj_malloc.c index 66ce0316..beb887bc 100644 --- a/src/lib/openjp2/opj_malloc.c +++ b/src/lib/openjp2/opj_malloc.c @@ -44,6 +44,10 @@ static inline void *opj_aligned_alloc_n(size_t alignment, size_t size) /* alignment shall be power of 2 */ assert( (alignment != 0U) && ((alignment & (alignment - 1U)) == 0U)); + if (size == 0U) { /* prevent implementation defined behavior of realloc */ + return NULL; + } + #if defined(HAVE_POSIX_MEMALIGN) /* aligned_alloc requires c11, restrict to posix_memalign for now. Quote: * This function was introduced in POSIX 1003.1d. Although this function is @@ -65,17 +69,21 @@ static inline void *opj_aligned_alloc_n(size_t alignment, size_t size) #endif return ptr; } -static inline void *opj_aligned_realloc_n(void *ptr, size_t alignment, size_t size) +static inline void *opj_aligned_realloc_n(void *ptr, size_t alignment, size_t new_size) { void *r_ptr; /* alignment shall be power of 2 */ assert( (alignment != 0U) && ((alignment & (alignment - 1U)) == 0U)); + if (new_size == 0U) { /* prevent implementation defined behavior of realloc */ + return NULL; + } + /* no portable aligned realloc */ #if defined(HAVE_POSIX_MEMALIGN) || defined(HAVE_MEMALIGN) /* glibc doc states one can mixed aligned malloc with realloc */ - r_ptr = realloc( ptr, size ); /* fast path */ + r_ptr = realloc( ptr, new_size ); /* fast path */ /* we simply use `size_t` to cast, since we are only interest in binary AND * operator */ if( ((size_t)r_ptr & (alignment - 1U)) != 0U ) { @@ -83,16 +91,16 @@ static inline void *opj_aligned_realloc_n(void *ptr, size_t alignment, size_t si * simple approach where we do not need a function that return the size of an * allocated array (eg. _msize on Windows, malloc_size on MacOS, * malloc_usable_size on systems with glibc) */ - void *a_ptr = opj_aligned_alloc_n(alignment, size); + void *a_ptr = opj_aligned_alloc_n(alignment, new_size); if (a_ptr != NULL) { - memcpy(a_ptr, r_ptr, size); + memcpy(a_ptr, r_ptr, new_size); } free( r_ptr ); r_ptr = a_ptr; } /* _MSC_VER */ #elif defined(HAVE__ALIGNED_MALLOC) - r_ptr = _aligned_realloc( ptr, size, alignment ); + r_ptr = _aligned_realloc( ptr, new_size, alignment ); #else /* TODO: _mm_malloc(x,y) */ #error missing aligned realloc function @@ -101,20 +109,27 @@ static inline void *opj_aligned_realloc_n(void *ptr, size_t alignment, size_t si } void * opj_malloc(size_t size) { + if (size == 0U) { /* prevent implementation defined behavior of realloc */ + return NULL; + } return malloc(size); } -void * opj_calloc(size_t numOfElements, size_t sizeOfElements) +void * opj_calloc(size_t num, size_t size) { - return calloc(numOfElements, sizeOfElements); + if (size == 0U) { /* prevent implementation defined behavior of realloc */ + return NULL; + } + /* according to C89 standard, num == 0 shall return a valid pointer */ + return calloc(num, size); } void *opj_aligned_malloc(size_t size) { - return opj_aligned_alloc_n(16u,size); + return opj_aligned_alloc_n(16U, size); } void * opj_aligned_realloc(void *ptr, size_t size) { - return opj_aligned_realloc_n(ptr,16u,size); + return opj_aligned_realloc_n(ptr, 16U, size); } void opj_aligned_free(void* ptr) @@ -126,11 +141,14 @@ void opj_aligned_free(void* ptr) #endif } -void * opj_realloc(void * m, size_t s) +void * opj_realloc(void *ptr, size_t new_size) { - return realloc(m,s); + if (new_size == 0U) { /* prevent implementation defined behavior of realloc */ + return NULL; + } + return realloc(ptr, new_size); } -void opj_free(void * m) +void opj_free(void *ptr) { - free(m); + free(ptr); } diff --git a/src/lib/openjp2/tcd.c b/src/lib/openjp2/tcd.c index 5e20a7a0..6eeb211e 100644 --- a/src/lib/openjp2/tcd.c +++ b/src/lib/openjp2/tcd.c @@ -871,7 +871,7 @@ static INLINE OPJ_BOOL opj_tcd_init_tile(opj_tcd_t *p_tcd, OPJ_UINT32 p_tile_no, l_band->stepsize = (OPJ_FLOAT32)(((1.0 + l_step_size->mant / 2048.0) * pow(2.0, (OPJ_INT32) (numbps - l_step_size->expn)))) * fraction; l_band->numbps = l_step_size->expn + (OPJ_INT32)l_tccp->numgbits - 1; /* WHY -1 ? */ - if (! l_band->precincts) { + if (!l_band->precincts && (l_nb_precincts > 0U)) { l_band->precincts = (opj_tcd_precinct_t *) opj_malloc( /*3 * */ l_nb_precinct_size); if (! l_band->precincts) { return OPJ_FALSE; @@ -930,7 +930,7 @@ static INLINE OPJ_BOOL opj_tcd_init_tile(opj_tcd_t *p_tcd, OPJ_UINT32 p_tile_no, /*fprintf(stderr, "\t\t\t\t precinct_cw = %d x recinct_ch = %d\n",l_current_precinct->cw, l_current_precinct->ch); */ l_nb_code_blocks_size = l_nb_code_blocks * (OPJ_UINT32)sizeof_block; - if (! l_current_precinct->cblks.blocks) { + if (!l_current_precinct->cblks.blocks && (l_nb_code_blocks > 0U)) { l_current_precinct->cblks.blocks = opj_malloc(l_nb_code_blocks_size); if (! l_current_precinct->cblks.blocks ) { return OPJ_FALSE; -- 2.30.2