src/png/pngmem.c

   1
   2 /* pngmem.c - stub functions for memory allocation
   3  *
   4  * Last changed in libpng 1.2.13 November 13, 2006
   5  * For conditions of distribution and use, see copyright notice in png.h
   6  * Copyright (c) 1998-2006 Glenn Randers-Pehrson
   7  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
   8  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
   9  *
  10  * This file provides a location for all memory allocation.  Users who
  11  * need special memory handling are expected to supply replacement
  12  * functions for png_malloc() and png_free(), and to use
  13  * png_create_read_struct_2() and png_create_write_struct_2() to
  14  * identify the replacement functions.
  15  */
  16
  17 #define PNG_INTERNAL
  18 #include "png.h"
  19
  20 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
  21
  22 /* Borland DOS special memory handler */
  23 #if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
  24 /* if you change this, be sure to change the one in png.h also */
  25
  26 /* Allocate memory for a png_struct.  The malloc and memset can be replaced
  27    by a single call to calloc() if this is thought to improve performance. */
  28 png_voidp /* PRIVATE */
  29 png_create_struct(int type)
  30 {
  31 #ifdef PNG_USER_MEM_SUPPORTED
  32    return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL));
  33 }
  34
  35 /* Alternate version of png_create_struct, for use with user-defined malloc. */
  36 png_voidp /* PRIVATE */
  37 png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)
  38 {
  39 #endif /* PNG_USER_MEM_SUPPORTED */
  40    png_size_t size;
  41    png_voidp struct_ptr;
  42
  43    if (type == PNG_STRUCT_INFO)
  44      size = png_sizeof(png_info);
  45    else if (type == PNG_STRUCT_PNG)
  46      size = png_sizeof(png_struct);
  47    else
  48      return (png_get_copyright(NULL));
  49
  50 #ifdef PNG_USER_MEM_SUPPORTED
  51    if(malloc_fn != NULL)
  52    {
  53       png_struct dummy_struct;
  54       png_structp png_ptr = &dummy_struct;
  55       png_ptr->mem_ptr=mem_ptr;
  56       struct_ptr = (*(malloc_fn))(png_ptr, (png_uint_32)size);
  57    }
  58    else
  59 #endif /* PNG_USER_MEM_SUPPORTED */
  60       struct_ptr = (png_voidp)farmalloc(size);
  61    if (struct_ptr != NULL)
  62       png_memset(struct_ptr, 0, size);
  63    return (struct_ptr);
  64 }
  65
  66 /* Free memory allocated by a png_create_struct() call */
  67 void /* PRIVATE */
  68 png_destroy_struct(png_voidp struct_ptr)
  69 {
  70 #ifdef PNG_USER_MEM_SUPPORTED
  71    png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL);
  72 }
  73
  74 /* Free memory allocated by a png_create_struct() call */
  75 void /* PRIVATE */
  76 png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
  77     png_voidp mem_ptr)
  78 {
  79 #endif
  80    if (struct_ptr != NULL)
  81    {
  82 #ifdef PNG_USER_MEM_SUPPORTED
  83       if(free_fn != NULL)
  84       {
  85          png_struct dummy_struct;
  86          png_structp png_ptr = &dummy_struct;
  87          png_ptr->mem_ptr=mem_ptr;
  88          (*(free_fn))(png_ptr, struct_ptr);
  89          return;
  90       }
  91 #endif /* PNG_USER_MEM_SUPPORTED */
  92       farfree (struct_ptr);
  93    }
  94 }
  95
  96 /* Allocate memory.  For reasonable files, size should never exceed
  97  * 64K.  However, zlib may allocate more then 64K if you don't tell
  98  * it not to.  See zconf.h and png.h for more information. zlib does
  99  * need to allocate exactly 64K, so whatever you call here must
 100  * have the ability to do that.
 101  *
 102  * Borland seems to have a problem in DOS mode for exactly 64K.
 103  * It gives you a segment with an offset of 8 (perhaps to store its
 104  * memory stuff).  zlib doesn't like this at all, so we have to
 105  * detect and deal with it.  This code should not be needed in
 106  * Windows or OS/2 modes, and only in 16 bit mode.  This code has
 107  * been updated by Alexander Lehmann for version 0.89 to waste less
 108  * memory.
 109  *
 110  * Note that we can't use png_size_t for the "size" declaration,
 111  * since on some systems a png_size_t is a 16-bit quantity, and as a
 112  * result, we would be truncating potentially larger memory requests
 113  * (which should cause a fatal error) and introducing major problems.
 114  */
 115
 116 png_voidp PNGAPI
 117 png_malloc(png_structp png_ptr, png_uint_32 size)
 118 {
 119    png_voidp ret;
 120
 121    if (png_ptr == NULL || size == 0)
 122       return (NULL);
 123
 124 #ifdef PNG_USER_MEM_SUPPORTED
 125    if(png_ptr->malloc_fn != NULL)
 126        ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
 127    else
 128        ret = (png_malloc_default(png_ptr, size));
 129    if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 130        png_error(png_ptr, "Out of memory!");
 131    return (ret);
 132 }
 133
 134 png_voidp PNGAPI
 135 png_malloc_default(png_structp png_ptr, png_uint_32 size)
 136 {
 137    png_voidp ret;
 138 #endif /* PNG_USER_MEM_SUPPORTED */
 139
 140    if (png_ptr == NULL || size == 0)
 141       return (NULL);
 142
 143 #ifdef PNG_MAX_MALLOC_64K
 144    if (size > (png_uint_32)65536L)
 145    {
 146       png_warning(png_ptr, "Cannot Allocate > 64K");
 147       ret = NULL;
 148    }
 149    else
 150 #endif
 151
 152    if (size != (size_t)size)
 153      ret = NULL;
 154    else if (size == (png_uint_32)65536L)
 155    {
 156       if (png_ptr->offset_table == NULL)
 157       {
 158          /* try to see if we need to do any of this fancy stuff */
 159          ret = farmalloc(size);
 160          if (ret == NULL || ((png_size_t)ret & 0xffff))
 161          {
 162             int num_blocks;
 163             png_uint_32 total_size;
 164             png_bytep table;
 165             int i;
 166             png_byte huge * hptr;
 167
 168             if (ret != NULL)
 169             {
 170                farfree(ret);
 171                ret = NULL;
 172             }
 173
 174             if(png_ptr->zlib_window_bits > 14)
 175                num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14));
 176             else
 177                num_blocks = 1;
 178             if (png_ptr->zlib_mem_level >= 7)
 179                num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7));
 180             else
 181                num_blocks++;
 182
 183             total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16;
 184
 185             table = farmalloc(total_size);
 186
 187             if (table == NULL)
 188             {
 189 #ifndef PNG_USER_MEM_SUPPORTED
 190                if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 191                   png_error(png_ptr, "Out Of Memory."); /* Note "O" and "M" */
 192                else
 193                   png_warning(png_ptr, "Out Of Memory.");
 194 #endif
 195                return (NULL);
 196             }
 197
 198             if ((png_size_t)table & 0xfff0)
 199             {
 200 #ifndef PNG_USER_MEM_SUPPORTED
 201                if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 202                   png_error(png_ptr,
 203                     "Farmalloc didn't return normalized pointer");
 204                else
 205                   png_warning(png_ptr,
 206                     "Farmalloc didn't return normalized pointer");
 207 #endif
 208                return (NULL);
 209             }
 210
 211             png_ptr->offset_table = table;
 212             png_ptr->offset_table_ptr = farmalloc(num_blocks *
 213                png_sizeof (png_bytep));
 214
 215             if (png_ptr->offset_table_ptr == NULL)
 216             {
 217 #ifndef PNG_USER_MEM_SUPPORTED
 218                if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 219                   png_error(png_ptr, "Out Of memory."); /* Note "O" and "M" */
 220                else
 221                   png_warning(png_ptr, "Out Of memory.");
 222 #endif
 223                return (NULL);
 224             }
 225
 226             hptr = (png_byte huge *)table;
 227             if ((png_size_t)hptr & 0xf)
 228             {
 229                hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);
 230                hptr = hptr + 16L;  /* "hptr += 16L" fails on Turbo C++ 3.0 */
 231             }
 232             for (i = 0; i < num_blocks; i++)
 233             {
 234                png_ptr->offset_table_ptr[i] = (png_bytep)hptr;
 235                hptr = hptr + (png_uint_32)65536L;  /* "+=" fails on TC++3.0 */
 236             }
 237
 238             png_ptr->offset_table_number = num_blocks;
 239             png_ptr->offset_table_count = 0;
 240             png_ptr->offset_table_count_free = 0;
 241          }
 242       }
 243
 244       if (png_ptr->offset_table_count >= png_ptr->offset_table_number)
 245       {
 246 #ifndef PNG_USER_MEM_SUPPORTED
 247          if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 248             png_error(png_ptr, "Out of Memory."); /* Note "o" and "M" */
 249          else
 250             png_warning(png_ptr, "Out of Memory.");
 251 #endif
 252          return (NULL);
 253       }
 254
 255       ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];
 256    }
 257    else
 258       ret = farmalloc(size);
 259
 260 #ifndef PNG_USER_MEM_SUPPORTED
 261    if (ret == NULL)
 262    {
 263       if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 264          png_error(png_ptr, "Out of memory."); /* Note "o" and "m" */
 265       else
 266          png_warning(png_ptr, "Out of memory."); /* Note "o" and "m" */
 267    }
 268 #endif
 269
 270    return (ret);
 271 }
 272
 273 /* free a pointer allocated by png_malloc().  In the default
 274    configuration, png_ptr is not used, but is passed in case it
 275    is needed.  If ptr is NULL, return without taking any action. */
 276 void PNGAPI
 277 png_free(png_structp png_ptr, png_voidp ptr)
 278 {
 279    if (png_ptr == NULL || ptr == NULL)
 280       return;
 281
 282 #ifdef PNG_USER_MEM_SUPPORTED
 283    if (png_ptr->free_fn != NULL)
 284    {
 285       (*(png_ptr->free_fn))(png_ptr, ptr);
 286       return;
 287    }
 288    else png_free_default(png_ptr, ptr);
 289 }
 290
 291 void PNGAPI
 292 png_free_default(png_structp png_ptr, png_voidp ptr)
 293 {
 294 #endif /* PNG_USER_MEM_SUPPORTED */
 295
 296    if(png_ptr == NULL) return;
 297
 298    if (png_ptr->offset_table != NULL)
 299    {
 300       int i;
 301
 302       for (i = 0; i < png_ptr->offset_table_count; i++)
 303       {
 304          if (ptr == png_ptr->offset_table_ptr[i])
 305          {
 306             ptr = NULL;
 307             png_ptr->offset_table_count_free++;
 308             break;
 309          }
 310       }
 311       if (png_ptr->offset_table_count_free == png_ptr->offset_table_count)
 312       {
 313          farfree(png_ptr->offset_table);
 314          farfree(png_ptr->offset_table_ptr);
 315          png_ptr->offset_table = NULL;
 316          png_ptr->offset_table_ptr = NULL;
 317       }
 318    }
 319
 320    if (ptr != NULL)
 321    {
 322       farfree(ptr);
 323    }
 324 }
 325
 326 #else /* Not the Borland DOS special memory handler */
 327
 328 /* Allocate memory for a png_struct or a png_info.  The malloc and
 329    memset can be replaced by a single call to calloc() if this is thought
 330    to improve performance noticably. */
 331 png_voidp /* PRIVATE */
 332 png_create_struct(int type)
 333 {
 334 #ifdef PNG_USER_MEM_SUPPORTED
 335    return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL));
 336 }
 337
 338 /* Allocate memory for a png_struct or a png_info.  The malloc and
 339    memset can be replaced by a single call to calloc() if this is thought
 340    to improve performance noticably. */
 341 png_voidp /* PRIVATE */
 342 png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)
 343 {
 344 #endif /* PNG_USER_MEM_SUPPORTED */
 345    png_size_t size;
 346    png_voidp struct_ptr;
 347
 348    if (type == PNG_STRUCT_INFO)
 349       size = png_sizeof(png_info);
 350    else if (type == PNG_STRUCT_PNG)
 351       size = png_sizeof(png_struct);
 352    else
 353       return (NULL);
 354
 355 #ifdef PNG_USER_MEM_SUPPORTED
 356    if(malloc_fn != NULL)
 357    {
 358       png_struct dummy_struct;
 359       png_structp png_ptr = &dummy_struct;
 360       png_ptr->mem_ptr=mem_ptr;
 361       struct_ptr = (*(malloc_fn))(png_ptr, size);
 362       if (struct_ptr != NULL)
 363          png_memset(struct_ptr, 0, size);
 364       return (struct_ptr);
 365    }
 366 #endif /* PNG_USER_MEM_SUPPORTED */
 367
 368 #if defined(__TURBOC__) && !defined(__FLAT__)
 369    struct_ptr = (png_voidp)farmalloc(size);
 370 #else
 371 # if defined(_MSC_VER) && defined(MAXSEG_64K)
 372    struct_ptr = (png_voidp)halloc(size,1);
 373 # else
 374    struct_ptr = (png_voidp)malloc(size);
 375 # endif
 376 #endif
 377    if (struct_ptr != NULL)
 378       png_memset(struct_ptr, 0, size);
 379
 380    return (struct_ptr);
 381 }
 382
 383
 384 /* Free memory allocated by a png_create_struct() call */
 385 void /* PRIVATE */
 386 png_destroy_struct(png_voidp struct_ptr)
 387 {
 388 #ifdef PNG_USER_MEM_SUPPORTED
 389    png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL);
 390 }
 391
 392 /* Free memory allocated by a png_create_struct() call */
 393 void /* PRIVATE */
 394 png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
 395     png_voidp mem_ptr)
 396 {
 397 #endif /* PNG_USER_MEM_SUPPORTED */
 398    if (struct_ptr != NULL)
 399    {
 400 #ifdef PNG_USER_MEM_SUPPORTED
 401       if(free_fn != NULL)
 402       {
 403          png_struct dummy_struct;
 404          png_structp png_ptr = &dummy_struct;
 405          png_ptr->mem_ptr=mem_ptr;
 406          (*(free_fn))(png_ptr, struct_ptr);
 407          return;
 408       }
 409 #endif /* PNG_USER_MEM_SUPPORTED */
 410 #if defined(__TURBOC__) && !defined(__FLAT__)
 411       farfree(struct_ptr);
 412 #else
 413 # if defined(_MSC_VER) && defined(MAXSEG_64K)
 414       hfree(struct_ptr);
 415 # else
 416       free(struct_ptr);
 417 # endif
 418 #endif
 419    }
 420 }
 421
 422 /* Allocate memory.  For reasonable files, size should never exceed
 423    64K.  However, zlib may allocate more then 64K if you don't tell
 424    it not to.  See zconf.h and png.h for more information.  zlib does
 425    need to allocate exactly 64K, so whatever you call here must
 426    have the ability to do that. */
 427
 428 png_voidp PNGAPI
 429 png_malloc(png_structp png_ptr, png_uint_32 size)
 430 {
 431    png_voidp ret;
 432
 433 #ifdef PNG_USER_MEM_SUPPORTED
 434    if (png_ptr == NULL || size == 0)
 435       return (NULL);
 436
 437    if(png_ptr->malloc_fn != NULL)
 438        ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
 439    else
 440        ret = (png_malloc_default(png_ptr, size));
 441    if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 442        png_error(png_ptr, "Out of Memory!");
 443    return (ret);
 444 }
 445
 446 png_voidp PNGAPI
 447 png_malloc_default(png_structp png_ptr, png_uint_32 size)
 448 {
 449    png_voidp ret;
 450 #endif /* PNG_USER_MEM_SUPPORTED */
 451
 452    if (png_ptr == NULL || size == 0)
 453       return (NULL);
 454
 455 #ifdef PNG_MAX_MALLOC_64K
 456    if (size > (png_uint_32)65536L)
 457    {
 458 #ifndef PNG_USER_MEM_SUPPORTED
 459       if(png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 460          png_error(png_ptr, "Cannot Allocate > 64K");
 461       else
 462 #endif
 463          return NULL;
 464    }
 465 #endif
 466
 467  /* Check for overflow */
 468 #if defined(__TURBOC__) && !defined(__FLAT__)
 469  if (size != (unsigned long)size)
 470    ret = NULL;
 471  else
 472    ret = farmalloc(size);
 473 #else
 474 # if defined(_MSC_VER) && defined(MAXSEG_64K)
 475  if (size != (unsigned long)size)
 476    ret = NULL;
 477  else
 478    ret = halloc(size, 1);
 479 # else
 480  if (size != (size_t)size)
 481    ret = NULL;
 482  else
 483    ret = malloc((size_t)size);
 484 # endif
 485 #endif
 486
 487 #ifndef PNG_USER_MEM_SUPPORTED
 488    if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 489       png_error(png_ptr, "Out of Memory");
 490 #endif
 491
 492    return (ret);
 493 }
 494
 495 /* Free a pointer allocated by png_malloc().  If ptr is NULL, return
 496    without taking any action. */
 497 void PNGAPI
 498 png_free(png_structp png_ptr, png_voidp ptr)
 499 {
 500    if (png_ptr == NULL || ptr == NULL)
 501       return;
 502
 503 #ifdef PNG_USER_MEM_SUPPORTED
 504    if (png_ptr->free_fn != NULL)
 505    {
 506       (*(png_ptr->free_fn))(png_ptr, ptr);
 507       return;
 508    }
 509    else png_free_default(png_ptr, ptr);
 510 }
 511 void PNGAPI
 512 png_free_default(png_structp png_ptr, png_voidp ptr)
 513 {
 514    if (png_ptr == NULL || ptr == NULL)
 515       return;
 516
 517 #endif /* PNG_USER_MEM_SUPPORTED */
 518
 519 #if defined(__TURBOC__) && !defined(__FLAT__)
 520    farfree(ptr);
 521 #else
 522 # if defined(_MSC_VER) && defined(MAXSEG_64K)
 523    hfree(ptr);
 524 # else
 525    free(ptr);
 526 # endif
 527 #endif
 528 }
 529
 530 #endif /* Not Borland DOS special memory handler */
 531
 532 #if defined(PNG_1_0_X)
 533 #  define png_malloc_warn png_malloc
 534 #else
 535 /* This function was added at libpng version 1.2.3.  The png_malloc_warn()
 536  * function will set up png_malloc() to issue a png_warning and return NULL
 537  * instead of issuing a png_error, if it fails to allocate the requested
 538  * memory.
 539  */
 540 png_voidp PNGAPI
 541 png_malloc_warn(png_structp png_ptr, png_uint_32 size)
 542 {
 543    png_voidp ptr;
 544    png_uint_32 save_flags;
 545    if(png_ptr == NULL) return (NULL);
 546
 547    save_flags=png_ptr->flags;
 548    png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
 549    ptr = (png_voidp)png_malloc((png_structp)png_ptr, size);
 550    png_ptr->flags=save_flags;
 551    return(ptr);
 552 }
 553 #endif
 554
 555 png_voidp PNGAPI
 556 png_memcpy_check (png_structp png_ptr, png_voidp s1, png_voidp s2,
 557    png_uint_32 length)
 558 {
 559    png_size_t size;
 560
 561    size = (png_size_t)length;
 562    if ((png_uint_32)size != length)
 563       png_error(png_ptr,"Overflow in png_memcpy_check.");
 564
 565    return(png_memcpy (s1, s2, size));
 566 }
 567
 568 png_voidp PNGAPI
 569 png_memset_check (png_structp png_ptr, png_voidp s1, int value,
 570    png_uint_32 length)
 571 {
 572    png_size_t size;
 573
 574    size = (png_size_t)length;
 575    if ((png_uint_32)size != length)
 576       png_error(png_ptr,"Overflow in png_memset_check.");
 577
 578    return (png_memset (s1, value, size));
 579
 580 }
 581
 582 #ifdef PNG_USER_MEM_SUPPORTED
 583 /* This function is called when the application wants to use another method
 584  * of allocating and freeing memory.
 585  */
 586 void PNGAPI
 587 png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr
 588   malloc_fn, png_free_ptr free_fn)
 589 {
 590    if(png_ptr != NULL) {
 591    png_ptr->mem_ptr = mem_ptr;
 592    png_ptr->malloc_fn = malloc_fn;
 593    png_ptr->free_fn = free_fn;
 594    }
 595 }
 596
 597 /* This function returns a pointer to the mem_ptr associated with the user
 598  * functions.  The application should free any memory associated with this
 599  * pointer before png_write_destroy and png_read_destroy are called.
 600  */
 601 png_voidp PNGAPI
 602 png_get_mem_ptr(png_structp png_ptr)
 603 {
 604    if(png_ptr == NULL) return (NULL);
 605    return ((png_voidp)png_ptr->mem_ptr);
 606 }
 607 #endif /* PNG_USER_MEM_SUPPORTED */
 608 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */