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