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. */
28png_voidp /* PRIVATE */
29png_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. */
36png_voidp /* PRIVATE */
37png_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 */
67void /* PRIVATE */
68png_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 */
75void /* PRIVATE */
76png_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
116png_voidp PNGAPI
117png_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
134png_voidp PNGAPI
135png_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. */
276void PNGAPI
277png_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
291void PNGAPI
292png_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. */
331png_voidp /* PRIVATE */
332png_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. */
341png_voidp /* PRIVATE */
342png_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 */
385void /* PRIVATE */
386png_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 */
393void /* PRIVATE */
394png_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
428png_voidp PNGAPI
429png_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
446png_voidp PNGAPI
447png_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. */
497void PNGAPI
498png_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}
511void PNGAPI
512png_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 */
540png_voidp PNGAPI
541png_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
555png_voidp PNGAPI
556png_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
568png_voidp PNGAPI
569png_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 */
586void PNGAPI
587png_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 */
601png_voidp PNGAPI
602png_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 */
609