workbench/libs/png/pngmem.c

   1
   2 /* pngmem.c - stub functions for memory allocation
   3  *
   4  * Last changed in libpng 1.6.0 [February 14, 2013]
   5  * Copyright (c) 1998-2013 Glenn Randers-Pehrson
   6  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
   7  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
   8  *
   9  * This code is released under the libpng license.
  10  * For conditions of distribution and use, see the disclaimer
  11  * and license in png.h
  12  *
  13  * This file provides a location for all memory allocation.  Users who
  14  * need special memory handling are expected to supply replacement
  15  * functions for png_malloc() and png_free(), and to use
  16  * png_create_read_struct_2() and png_create_write_struct_2() to
  17  * identify the replacement functions.
  18  */
  19
  20 #include "pngpriv.h"
  21
  22 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
  23 /* Free a png_struct */
  24 void /* PRIVATE */
  25 png_destroy_png_struct(png_structrp png_ptr)
  26 {
  27    if (png_ptr != NULL)
  28    {
  29       /* png_free might call png_error and may certainly call
  30        * png_get_mem_ptr, so fake a temporary png_struct to support this.
  31        */
  32       png_struct dummy_struct = *png_ptr;
  33       memset(png_ptr, 0, (sizeof *png_ptr));
  34       png_free(&dummy_struct, png_ptr);
  35
  36 #     ifdef PNG_SETJMP_SUPPORTED
  37          /* We may have a jmp_buf left to deallocate. */
  38          png_free_jmpbuf(&dummy_struct);
  39 #     endif
  40    }
  41 }
  42
  43 /* Allocate memory.  For reasonable files, size should never exceed
  44  * 64K.  However, zlib may allocate more then 64K if you don't tell
  45  * it not to.  See zconf.h and png.h for more information.  zlib does
  46  * need to allocate exactly 64K, so whatever you call here must
  47  * have the ability to do that.
  48  */
  49 PNG_FUNCTION(png_voidp,PNGAPI
  50 png_calloc,(png_const_structrp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
  51 {
  52    png_voidp ret;
  53
  54    ret = png_malloc(png_ptr, size);
  55
  56    if (ret != NULL)
  57       memset(ret, 0, size);
  58
  59    return ret;
  60 }
  61
  62 /* png_malloc_base, an internal function added at libpng 1.6.0, does the work of
  63  * allocating memory, taking into account limits and PNG_USER_MEM_SUPPORTED.
  64  * Checking and error handling must happen outside this routine; it returns NULL
  65  * if the allocation cannot be done (for any reason.)
  66  */
  67 PNG_FUNCTION(png_voidp /* PRIVATE */,
  68 png_malloc_base,(png_const_structrp png_ptr, png_alloc_size_t size),
  69    PNG_ALLOCATED)
  70 {
  71    /* Moved to png_malloc_base from png_malloc_default in 1.6.0; the DOS
  72     * allocators have also been removed in 1.6.0, so any 16-bit system now has
  73     * to implement a user memory handler.  This checks to be sure it isn't
  74     * called with big numbers.
  75     */
  76 #ifdef PNG_USER_MEM_SUPPORTED
  77    PNG_UNUSED(png_ptr)
  78 #endif
  79    if (size > 0 && size <= PNG_SIZE_MAX
  80 #     ifdef PNG_MAX_MALLOC_64K
  81          && size <= 65536U
  82 #     endif
  83       )
  84    {
  85 #ifdef PNG_USER_MEM_SUPPORTED
  86       if (png_ptr != NULL && png_ptr->malloc_fn != NULL)
  87          return png_ptr->malloc_fn(png_constcast(png_structrp,png_ptr), size);
  88
  89       else
  90 #endif
  91          return malloc((size_t)size); /* checked for truncation above */
  92    }
  93
  94    else
  95       return NULL;
  96 }
  97
  98 /* This is really here only to work round a spurious warning in GCC 4.6 and 4.7
  99  * that arises because of the checks in png_realloc_array that are repeated in
 100  * png_malloc_array.
 101  */
 102 static png_voidp
 103 png_malloc_array_checked(png_const_structrp png_ptr, int nelements,
 104    size_t element_size)
 105 {
 106    png_alloc_size_t req = nelements; /* known to be > 0 */
 107
 108    if (req <= PNG_SIZE_MAX/element_size)
 109       return png_malloc_base(png_ptr, req * element_size);
 110
 111    /* The failure case when the request is too large */
 112    return NULL;
 113 }
 114
 115 PNG_FUNCTION(png_voidp /* PRIVATE */,
 116 png_malloc_array,(png_const_structrp png_ptr, int nelements,
 117    size_t element_size),PNG_ALLOCATED)
 118 {
 119    if (nelements <= 0 || element_size == 0)
 120       png_error(png_ptr, "internal error: array alloc");
 121
 122    return png_malloc_array_checked(png_ptr, nelements, element_size);
 123 }
 124
 125 PNG_FUNCTION(png_voidp /* PRIVATE */,
 126 png_realloc_array,(png_const_structrp png_ptr, png_const_voidp old_array,
 127    int old_elements, int add_elements, size_t element_size),PNG_ALLOCATED)
 128 {
 129    /* These are internal errors: */
 130    if (add_elements <= 0 || element_size == 0 || old_elements < 0 ||
 131       (old_array == NULL && old_elements > 0))
 132       png_error(png_ptr, "internal error: array realloc");
 133
 134    /* Check for overflow on the elements count (so the caller does not have to
 135     * check.)
 136     */
 137    if (add_elements <= INT_MAX - old_elements)
 138    {
 139       png_voidp new_array = png_malloc_array_checked(png_ptr,
 140          old_elements+add_elements, element_size);
 141
 142       if (new_array != NULL)
 143       {
 144          /* Because png_malloc_array worked the size calculations below cannot
 145           * overflow.
 146           */
 147          if (old_elements > 0)
 148             memcpy(new_array, old_array, element_size*(unsigned)old_elements);
 149
 150          memset((char*)new_array + element_size*(unsigned)old_elements, 0,
 151             element_size*(unsigned)add_elements);
 152
 153          return new_array;
 154       }
 155    }
 156
 157    return NULL; /* error */
 158 }
 159
 160 /* Various functions that have different error handling are derived from this.
 161  * png_malloc always exists, but if PNG_USER_MEM_SUPPORTED is defined a separate
 162  * function png_malloc_default is also provided.
 163  */
 164 PNG_FUNCTION(png_voidp,PNGAPI
 165 png_malloc,(png_const_structrp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
 166 {
 167    png_voidp ret;
 168
 169    if (png_ptr == NULL)
 170       return NULL;
 171
 172    ret = png_malloc_base(png_ptr, size);
 173
 174    if (ret == NULL)
 175        png_error(png_ptr, "Out of memory"); /* 'm' means png_malloc */
 176
 177    return ret;
 178 }
 179
 180 #ifdef PNG_USER_MEM_SUPPORTED
 181 PNG_FUNCTION(png_voidp,PNGAPI
 182 png_malloc_default,(png_const_structrp png_ptr, png_alloc_size_t size),
 183    PNG_ALLOCATED PNG_DEPRECATED)
 184 {
 185    png_voidp ret;
 186
 187    if (png_ptr == NULL)
 188       return NULL;
 189
 190    /* Passing 'NULL' here bypasses the application provided memory handler. */
 191    ret = png_malloc_base(NULL/*use malloc*/, size);
 192
 193    if (ret == NULL)
 194       png_error(png_ptr, "Out of Memory"); /* 'M' means png_malloc_default */
 195
 196    return ret;
 197 }
 198 #endif /* PNG_USER_MEM_SUPPORTED */
 199
 200 /* This function was added at libpng version 1.2.3.  The png_malloc_warn()
 201  * function will issue a png_warning and return NULL instead of issuing a
 202  * png_error, if it fails to allocate the requested memory.
 203  */
 204 PNG_FUNCTION(png_voidp,PNGAPI
 205 png_malloc_warn,(png_const_structrp png_ptr, png_alloc_size_t size),
 206    PNG_ALLOCATED)
 207 {
 208    if (png_ptr != NULL)
 209    {
 210       png_voidp ret = png_malloc_base(png_ptr, size);
 211
 212       if (ret != NULL)
 213          return ret;
 214
 215       png_warning(png_ptr, "Out of memory");
 216    }
 217
 218    return NULL;
 219 }
 220
 221 /* Free a pointer allocated by png_malloc().  If ptr is NULL, return
 222  * without taking any action.
 223  */
 224 void PNGAPI
 225 png_free(png_const_structrp png_ptr, png_voidp ptr)
 226 {
 227    if (png_ptr == NULL || ptr == NULL)
 228       return;
 229
 230 #ifdef PNG_USER_MEM_SUPPORTED
 231    if (png_ptr->free_fn != NULL)
 232       png_ptr->free_fn(png_constcast(png_structrp,png_ptr), ptr);
 233
 234    else
 235       png_free_default(png_ptr, ptr);
 236 }
 237
 238 PNG_FUNCTION(void,PNGAPI
 239 png_free_default,(png_const_structrp png_ptr, png_voidp ptr),PNG_DEPRECATED)
 240 {
 241    if (png_ptr == NULL || ptr == NULL)
 242       return;
 243 #endif /* PNG_USER_MEM_SUPPORTED */
 244
 245    free(ptr);
 246 }
 247
 248 #ifdef __AROS__
 249 png_voidp PNGAPI
 250 png_memcpy_check (png_structp png_ptr, png_voidp s1, png_voidp s2,
 251    png_uint_32 length)
 252 {
 253    png_size_t size;
 254
 255    size = (png_size_t)length;
 256    if ((png_uint_32)size != length)
 257       png_error(png_ptr, "Overflow in png_memcpy_check.");
 258
 259    return(memcpy (s1, s2, size));
 260 }
 261
 262 png_voidp PNGAPI
 263 png_memset_check (png_structp png_ptr, png_voidp s1, int value,
 264    png_uint_32 length)
 265 {
 266    png_size_t size;
 267
 268    size = (png_size_t)length;
 269    if ((png_uint_32)size != length)
 270       png_error(png_ptr, "Overflow in png_memset_check.");
 271
 272    return (memset (s1, value, size));
 273
 274 }
 275 #endif /* __AROS__ */
 276
 277 #ifdef PNG_USER_MEM_SUPPORTED
 278 /* This function is called when the application wants to use another method
 279  * of allocating and freeing memory.
 280  */
 281 void PNGAPI
 282 png_set_mem_fn(png_structrp png_ptr, png_voidp mem_ptr, png_malloc_ptr
 283   malloc_fn, png_free_ptr free_fn)
 284 {
 285    if (png_ptr != NULL)
 286    {
 287       png_ptr->mem_ptr = mem_ptr;
 288       png_ptr->malloc_fn = malloc_fn;
 289       png_ptr->free_fn = free_fn;
 290    }
 291 }
 292
 293 /* This function returns a pointer to the mem_ptr associated with the user
 294  * functions.  The application should free any memory associated with this
 295  * pointer before png_write_destroy and png_read_destroy are called.
 296  */
 297 png_voidp PNGAPI
 298 png_get_mem_ptr(png_const_structrp png_ptr)
 299 {
 300    if (png_ptr == NULL)
 301       return NULL;
 302
 303    return png_ptr->mem_ptr;
 304 }
 305 #endif /* PNG_USER_MEM_SUPPORTED */
 306 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */