1
2/* pngerror.c - stub functions for i/o and memory allocation
3 *
4 * Last changed in libpng 1.2.45 [July 7, 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 error handling.  Users who
14 * need special error handling are expected to write replacement functions
15 * and use png_set_error_fn() to use those functions.  See the instructions
16 * at each function.
17 */
18
19#define PNG_INTERNAL
20#define PNG_NO_PEDANTIC_WARNINGS
21#include "png.h"
22#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
23
24static void /* PRIVATE */
25png_default_error PNGARG((png_structp png_ptr,
26  png_const_charp error_message)) PNG_NORETURN;
27#ifdef PNG_WARNINGS_SUPPORTED
28static void /* PRIVATE */
29png_default_warning PNGARG((png_structp png_ptr,
30  png_const_charp warning_message));
31#endif /* PNG_WARNINGS_SUPPORTED */
32
33/* This function is called whenever there is a fatal error.  This function
34 * should not be changed.  If there is a need to handle errors differently,
35 * you should supply a replacement error function and use png_set_error_fn()
36 * to replace the error function at run-time.
37 */
38#ifdef PNG_ERROR_TEXT_SUPPORTED
39void PNGAPI
40png_error(png_structp png_ptr, png_const_charp error_message)
41{
42#ifdef PNG_ERROR_NUMBERS_SUPPORTED
43   char msg[16];
44   if (png_ptr != NULL)
45   {
46     if (png_ptr->flags&
47       (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
48     {
49       if (*error_message == PNG_LITERAL_SHARP)
50       {
51           /* Strip "#nnnn " from beginning of error message. */
52           int offset;
53           for (offset = 1; offset<15; offset++)
54              if (error_message[offset] == ' ')
55                  break;
56           if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
57           {
58              int i;
59              for (i = 0; i < offset - 1; i++)
60                 msg[i] = error_message[i + 1];
61              msg[i - 1] = '\0';
62              error_message = msg;
63           }
64           else
65              error_message += offset;
66       }
67       else
68       {
69           if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
70           {
71              msg[0] = '0';
72              msg[1] = '\0';
73              error_message = msg;
74           }
75       }
76     }
77   }
78#endif
79   if (png_ptr != NULL && png_ptr->error_fn != NULL)
80      (*(png_ptr->error_fn))(png_ptr, error_message);
81
82   /* If the custom handler doesn't exist, or if it returns,
83      use the default handler, which will not return. */
84   png_default_error(png_ptr, error_message);
85}
86#else
87void PNGAPI
88png_err(png_structp png_ptr)
89{
90   /* Prior to 1.2.45 the error_fn received a NULL pointer, expressed
91    * erroneously as '\0', instead of the empty string "".  This was
92    * apparently an error, introduced in libpng-1.2.20, and png_default_error
93    * will crash in this case.
94    */
95   if (png_ptr != NULL && png_ptr->error_fn != NULL)
96      (*(png_ptr->error_fn))(png_ptr, "");
97
98   /* If the custom handler doesn't exist, or if it returns,
99      use the default handler, which will not return. */
100   png_default_error(png_ptr, "");
101}
102#endif /* PNG_ERROR_TEXT_SUPPORTED */
103
104#ifdef PNG_WARNINGS_SUPPORTED
105/* This function is called whenever there is a non-fatal error.  This function
106 * should not be changed.  If there is a need to handle warnings differently,
107 * you should supply a replacement warning function and use
108 * png_set_error_fn() to replace the warning function at run-time.
109 */
110void PNGAPI
111png_warning(png_structp png_ptr, png_const_charp warning_message)
112{
113   int offset = 0;
114   if (png_ptr != NULL)
115   {
116#ifdef PNG_ERROR_NUMBERS_SUPPORTED
117   if (png_ptr->flags&
118     (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
119#endif
120     {
121       if (*warning_message == PNG_LITERAL_SHARP)
122       {
123           for (offset = 1; offset < 15; offset++)
124              if (warning_message[offset] == ' ')
125                  break;
126       }
127     }
128   }
129   if (png_ptr != NULL && png_ptr->warning_fn != NULL)
130      (*(png_ptr->warning_fn))(png_ptr, warning_message + offset);
131   else
132      png_default_warning(png_ptr, warning_message + offset);
133}
134#endif /* PNG_WARNINGS_SUPPORTED */
135
136#ifdef PNG_BENIGN_ERRORS_SUPPORTED
137void PNGAPI
138png_benign_error(png_structp png_ptr, png_const_charp error_message)
139{
140  if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
141    png_warning(png_ptr, error_message);
142  else
143    png_error(png_ptr, error_message);
144}
145#endif
146
147/* These utilities are used internally to build an error message that relates
148 * to the current chunk.  The chunk name comes from png_ptr->chunk_name,
149 * this is used to prefix the message.  The message is limited in length
150 * to 63 bytes, the name characters are output as hex digits wrapped in []
151 * if the character is invalid.
152 */
153#define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))
154static PNG_CONST char png_digit[16] = {
155   '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
156   'A', 'B', 'C', 'D', 'E', 'F'
157};
158
159#define PNG_MAX_ERROR_TEXT 64
160#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED)
161static void /* PRIVATE */
162png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp
163   error_message)
164{
165   int iout = 0, iin = 0;
166
167   while (iin < 4)
168   {
169      int c = png_ptr->chunk_name[iin++];
170      if (isnonalpha(c))
171      {
172         buffer[iout++] = PNG_LITERAL_LEFT_SQUARE_BRACKET;
173         buffer[iout++] = png_digit[(c & 0xf0) >> 4];
174         buffer[iout++] = png_digit[c & 0x0f];
175         buffer[iout++] = PNG_LITERAL_RIGHT_SQUARE_BRACKET;
176      }
177      else
178      {
179         buffer[iout++] = (png_byte)c;
180      }
181   }
182
183   if (error_message == NULL)
184      buffer[iout] = '\0';
185   else
186   {
187      buffer[iout++] = ':';
188      buffer[iout++] = ' ';
189
190      iin = 0;
191      while (iin < PNG_MAX_ERROR_TEXT-1 && error_message[iin] != '\0')
192         buffer[iout++] = error_message[iin++];
193
194      /* iin < PNG_MAX_ERROR_TEXT, so the following is safe: */
195      buffer[iout] = '\0';
196   }
197}
198
199#ifdef PNG_READ_SUPPORTED
200void PNGAPI
201png_chunk_error(png_structp png_ptr, png_const_charp error_message)
202{
203   char msg[18+PNG_MAX_ERROR_TEXT];
204   if (png_ptr == NULL)
205     png_error(png_ptr, error_message);
206   else
207   {
208     png_format_buffer(png_ptr, msg, error_message);
209     png_error(png_ptr, msg);
210   }
211}
212#endif /* PNG_READ_SUPPORTED */
213#endif /* PNG_WARNINGS_SUPPORTED || PNG_ERROR_TEXT_SUPPORTED */
214
215#ifdef PNG_WARNINGS_SUPPORTED
216void PNGAPI
217png_chunk_warning(png_structp png_ptr, png_const_charp warning_message)
218{
219   char msg[18+PNG_MAX_ERROR_TEXT];
220   if (png_ptr == NULL)
221     png_warning(png_ptr, warning_message);
222   else
223   {
224     png_format_buffer(png_ptr, msg, warning_message);
225     png_warning(png_ptr, msg);
226   }
227}
228#endif /* PNG_WARNINGS_SUPPORTED */
229
230#ifdef PNG_READ_SUPPORTED
231#ifdef PNG_BENIGN_ERRORS_SUPPORTED
232void PNGAPI
233png_chunk_benign_error(png_structp png_ptr, png_const_charp error_message)
234{
235  if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
236    png_chunk_warning(png_ptr, error_message);
237  else
238    png_chunk_error(png_ptr, error_message);
239}
240#endif
241#endif /* PNG_READ_SUPPORTED */
242
243/* This is the default error handling function.  Note that replacements for
244 * this function MUST NOT RETURN, or the program will likely crash.  This
245 * function is used by default, or if the program supplies NULL for the
246 * error function pointer in png_set_error_fn().
247 */
248static void /* PRIVATE */
249png_default_error(png_structp png_ptr, png_const_charp error_message)
250{
251#ifdef PNG_CONSOLE_IO_SUPPORTED
252#ifdef PNG_ERROR_NUMBERS_SUPPORTED
253   if (*error_message == PNG_LITERAL_SHARP)
254   {
255     /* Strip "#nnnn " from beginning of error message. */
256     int offset;
257     char error_number[16];
258     for (offset = 0; offset<15; offset++)
259     {
260         error_number[offset] = error_message[offset + 1];
261         if (error_message[offset] == ' ')
262             break;
263     }
264     if ((offset > 1) && (offset < 15))
265     {
266       error_number[offset - 1] = '\0';
267       fprintf(stderr, "libpng error no. %s: %s",
268          error_number, error_message + offset + 1);
269       fprintf(stderr, PNG_STRING_NEWLINE);
270     }
271     else
272     {
273       fprintf(stderr, "libpng error: %s, offset=%d",
274          error_message, offset);
275       fprintf(stderr, PNG_STRING_NEWLINE);
276     }
277   }
278   else
279#endif
280   {
281      fprintf(stderr, "libpng error: %s", error_message);
282      fprintf(stderr, PNG_STRING_NEWLINE);
283   }
284#endif
285
286#ifdef PNG_SETJMP_SUPPORTED
287   if (png_ptr)
288   {
289#  ifdef USE_FAR_KEYWORD
290   {
291      jmp_buf jmpbuf;
292      png_memcpy(jmpbuf, png_ptr->jmpbuf, png_sizeof(jmp_buf));
293     longjmp(jmpbuf,1);
294   }
295#  else
296   longjmp(png_ptr->jmpbuf, 1);
297#  endif
298   }
299#endif
300   /* Here if not setjmp support or if png_ptr is null. */
301   PNG_ABORT();
302#ifndef PNG_CONSOLE_IO_SUPPORTED
303   error_message = error_message; /* Make compiler happy */
304#endif
305}
306
307#ifdef PNG_WARNINGS_SUPPORTED
308/* This function is called when there is a warning, but the library thinks
309 * it can continue anyway.  Replacement functions don't have to do anything
310 * here if you don't want them to.  In the default configuration, png_ptr is
311 * not used, but it is passed in case it may be useful.
312 */
313static void /* PRIVATE */
314png_default_warning(png_structp png_ptr, png_const_charp warning_message)
315{
316#ifdef PNG_CONSOLE_IO_SUPPORTED
317#  ifdef PNG_ERROR_NUMBERS_SUPPORTED
318   if (*warning_message == PNG_LITERAL_SHARP)
319   {
320     int offset;
321     char warning_number[16];
322     for (offset = 0; offset < 15; offset++)
323     {
324        warning_number[offset] = warning_message[offset + 1];
325        if (warning_message[offset] == ' ')
326            break;
327     }
328     if ((offset > 1) && (offset < 15))
329     {
330       warning_number[offset + 1] = '\0';
331       fprintf(stderr, "libpng warning no. %s: %s",
332          warning_number, warning_message + offset);
333       fprintf(stderr, PNG_STRING_NEWLINE);
334     }
335     else
336     {
337       fprintf(stderr, "libpng warning: %s",
338          warning_message);
339       fprintf(stderr, PNG_STRING_NEWLINE);
340     }
341   }
342   else
343#  endif
344   {
345     fprintf(stderr, "libpng warning: %s", warning_message);
346     fprintf(stderr, PNG_STRING_NEWLINE);
347   }
348#else
349   warning_message = warning_message; /* Make compiler happy */
350#endif
351   png_ptr = png_ptr; /* Make compiler happy */
352}
353#endif /* PNG_WARNINGS_SUPPORTED */
354
355/* This function is called when the application wants to use another method
356 * of handling errors and warnings.  Note that the error function MUST NOT
357 * return to the calling routine or serious problems will occur.  The return
358 * method used in the default routine calls longjmp(png_ptr->jmpbuf, 1)
359 */
360void PNGAPI
361png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,
362   png_error_ptr error_fn, png_error_ptr warning_fn)
363{
364   if (png_ptr == NULL)
365      return;
366   png_ptr->error_ptr = error_ptr;
367   png_ptr->error_fn = error_fn;
368   png_ptr->warning_fn = warning_fn;
369}
370
371
372/* This function returns a pointer to the error_ptr associated with the user
373 * functions.  The application should free any memory associated with this
374 * pointer before png_write_destroy and png_read_destroy are called.
375 */
376png_voidp PNGAPI
377png_get_error_ptr(png_structp png_ptr)
378{
379   if (png_ptr == NULL)
380      return NULL;
381   return ((png_voidp)png_ptr->error_ptr);
382}
383
384
385#ifdef PNG_ERROR_NUMBERS_SUPPORTED
386void PNGAPI
387png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode)
388{
389   if (png_ptr != NULL)
390   {
391     png_ptr->flags &=
392       ((~(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode);
393   }
394}
395#endif
396#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
397