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