]> git.cworth.org Git - apitrace/blob - thirdparty/libpng/pngerror.c
directxtex: Don't redefine NOMINMAX.
[apitrace] / thirdparty / libpng / pngerror.c
1
2 /* pngerror.c - stub functions for i/o and memory allocation
3  *
4  * Last changed in libpng 1.5.8 [February 1, 2011]
5  * Copyright (c) 1998-2012 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 #include "pngpriv.h"
20
21 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
22
23 static PNG_FUNCTION(void, png_default_error,PNGARG((png_structp png_ptr,
24     png_const_charp error_message)),PNG_NORETURN);
25
26 #ifdef PNG_WARNINGS_SUPPORTED
27 static void /* PRIVATE */
28 png_default_warning PNGARG((png_structp png_ptr,
29    png_const_charp warning_message));
30 #endif /* PNG_WARNINGS_SUPPORTED */
31
32 /* This function is called whenever there is a fatal error.  This function
33  * should not be changed.  If there is a need to handle errors differently,
34  * you should supply a replacement error function and use png_set_error_fn()
35  * to replace the error function at run-time.
36  */
37 #ifdef PNG_ERROR_TEXT_SUPPORTED
38 PNG_FUNCTION(void,PNGAPI
39 png_error,(png_structp png_ptr, png_const_charp error_message),PNG_NORETURN)
40 {
41 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
42    char msg[16];
43    if (png_ptr != NULL)
44    {
45       if (png_ptr->flags&
46          (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
47       {
48          if (*error_message == PNG_LITERAL_SHARP)
49          {
50             /* Strip "#nnnn " from beginning of error message. */
51             int offset;
52             for (offset = 1; offset<15; offset++)
53                if (error_message[offset] == ' ')
54                   break;
55
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
65             else
66                error_message += offset;
67       }
68
69       else
70       {
71          if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
72          {
73             msg[0] = '0';
74             msg[1] = '\0';
75             error_message = msg;
76          }
77        }
78      }
79    }
80 #endif
81    if (png_ptr != NULL && png_ptr->error_fn != NULL)
82       (*(png_ptr->error_fn))(png_ptr, error_message);
83
84    /* If the custom handler doesn't exist, or if it returns,
85       use the default handler, which will not return. */
86    png_default_error(png_ptr, error_message);
87 }
88 #else
89 PNG_FUNCTION(void,PNGAPI
90 png_err,(png_structp png_ptr),PNG_NORETURN)
91 {
92    /* Prior to 1.5.2 the error_fn received a NULL pointer, expressed
93     * erroneously as '\0', instead of the empty string "".  This was
94     * apparently an error, introduced in libpng-1.2.20, and png_default_error
95     * will crash in this case.
96     */
97    if (png_ptr != NULL && png_ptr->error_fn != NULL)
98       (*(png_ptr->error_fn))(png_ptr, "");
99
100    /* If the custom handler doesn't exist, or if it returns,
101       use the default handler, which will not return. */
102    png_default_error(png_ptr, "");
103 }
104 #endif /* PNG_ERROR_TEXT_SUPPORTED */
105
106 /* Utility to safely appends strings to a buffer.  This never errors out so
107  * error checking is not required in the caller.
108  */
109 size_t
110 png_safecat(png_charp buffer, size_t bufsize, size_t pos,
111    png_const_charp string)
112 {
113    if (buffer != NULL && pos < bufsize)
114    {
115       if (string != NULL)
116          while (*string != '\0' && pos < bufsize-1)
117            buffer[pos++] = *string++;
118
119       buffer[pos] = '\0';
120    }
121
122    return pos;
123 }
124
125 #if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_TIME_RFC1123_SUPPORTED)
126 /* Utility to dump an unsigned value into a buffer, given a start pointer and
127  * and end pointer (which should point just *beyond* the end of the buffer!)
128  * Returns the pointer to the start of the formatted string.
129  */
130 png_charp
131 png_format_number(png_const_charp start, png_charp end, int format,
132    png_alloc_size_t number)
133 {
134    int count = 0;    /* number of digits output */
135    int mincount = 1; /* minimum number required */
136    int output = 0;   /* digit output (for the fixed point format) */
137
138    *--end = '\0';
139
140    /* This is written so that the loop always runs at least once, even with
141     * number zero.
142     */
143    while (end > start && (number != 0 || count < mincount))
144    {
145
146       static const char digits[] = "0123456789ABCDEF";
147
148       switch (format)
149       {
150          case PNG_NUMBER_FORMAT_fixed:
151             /* Needs five digits (the fraction) */
152             mincount = 5;
153             if (output || number % 10 != 0)
154             {
155                *--end = digits[number % 10];
156                output = 1;
157             }
158             number /= 10;
159             break;
160
161          case PNG_NUMBER_FORMAT_02u:
162             /* Expects at least 2 digits. */
163             mincount = 2;
164             /* fall through */
165
166          case PNG_NUMBER_FORMAT_u:
167             *--end = digits[number % 10];
168             number /= 10;
169             break;
170
171          case PNG_NUMBER_FORMAT_02x:
172             /* This format expects at least two digits */
173             mincount = 2;
174             /* fall through */
175
176          case PNG_NUMBER_FORMAT_x:
177             *--end = digits[number & 0xf];
178             number >>= 4;
179             break;
180
181          default: /* an error */
182             number = 0;
183             break;
184       }
185
186       /* Keep track of the number of digits added */
187       ++count;
188
189       /* Float a fixed number here: */
190       if (format == PNG_NUMBER_FORMAT_fixed) if (count == 5) if (end > start)
191       {
192          /* End of the fraction, but maybe nothing was output?  In that case
193           * drop the decimal point.  If the number is a true zero handle that
194           * here.
195           */
196          if (output)
197             *--end = '.';
198          else if (number == 0) /* and !output */
199             *--end = '0';
200       }
201    }
202
203    return end;
204 }
205 #endif
206
207 #ifdef PNG_WARNINGS_SUPPORTED
208 /* This function is called whenever there is a non-fatal error.  This function
209  * should not be changed.  If there is a need to handle warnings differently,
210  * you should supply a replacement warning function and use
211  * png_set_error_fn() to replace the warning function at run-time.
212  */
213 void PNGAPI
214 png_warning(png_structp png_ptr, png_const_charp warning_message)
215 {
216    int offset = 0;
217    if (png_ptr != NULL)
218    {
219 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
220    if (png_ptr->flags&
221        (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
222 #endif
223       {
224          if (*warning_message == PNG_LITERAL_SHARP)
225          {
226             for (offset = 1; offset < 15; offset++)
227                if (warning_message[offset] == ' ')
228                   break;
229          }
230       }
231    }
232    if (png_ptr != NULL && png_ptr->warning_fn != NULL)
233       (*(png_ptr->warning_fn))(png_ptr, warning_message + offset);
234    else
235       png_default_warning(png_ptr, warning_message + offset);
236 }
237
238 /* These functions support 'formatted' warning messages with up to
239  * PNG_WARNING_PARAMETER_COUNT parameters.  In the format string the parameter
240  * is introduced by @<number>, where 'number' starts at 1.  This follows the
241  * standard established by X/Open for internationalizable error messages.
242  */
243 void
244 png_warning_parameter(png_warning_parameters p, int number,
245    png_const_charp string)
246 {
247    if (number > 0 && number <= PNG_WARNING_PARAMETER_COUNT)
248       (void)png_safecat(p[number-1], (sizeof p[number-1]), 0, string);
249 }
250
251 void
252 png_warning_parameter_unsigned(png_warning_parameters p, int number, int format,
253    png_alloc_size_t value)
254 {
255    char buffer[PNG_NUMBER_BUFFER_SIZE];
256    png_warning_parameter(p, number, PNG_FORMAT_NUMBER(buffer, format, value));
257 }
258
259 void
260 png_warning_parameter_signed(png_warning_parameters p, int number, int format,
261    png_int_32 value)
262 {
263    png_alloc_size_t u;
264    png_charp str;
265    char buffer[PNG_NUMBER_BUFFER_SIZE];
266
267    /* Avoid overflow by doing the negate in a png_alloc_size_t: */
268    u = (png_alloc_size_t)value;
269    if (value < 0)
270       u = ~u + 1;
271
272    str = PNG_FORMAT_NUMBER(buffer, format, u);
273
274    if (value < 0 && str > buffer)
275       *--str = '-';
276
277    png_warning_parameter(p, number, str);
278 }
279
280 void
281 png_formatted_warning(png_structp png_ptr, png_warning_parameters p,
282    png_const_charp message)
283 {
284    /* The internal buffer is just 192 bytes - enough for all our messages,
285     * overflow doesn't happen because this code checks!  If someone figures
286     * out how to send us a message longer than 192 bytes, all that will
287     * happen is that the message will be truncated appropriately.
288     */
289    size_t i = 0; /* Index in the msg[] buffer: */
290    char msg[192];
291
292    /* Each iteration through the following loop writes at most one character
293     * to msg[i++] then returns here to validate that there is still space for
294     * the trailing '\0'.  It may (in the case of a parameter) read more than
295     * one character from message[]; it must check for '\0' and continue to the
296     * test if it finds the end of string.
297     */
298    while (i<(sizeof msg)-1 && *message != '\0')
299    {
300       /* '@' at end of string is now just printed (previously it was skipped);
301        * it is an error in the calling code to terminate the string with @.
302        */
303       if (p != NULL && *message == '@' && message[1] != '\0')
304       {
305          int parameter_char = *++message; /* Consume the '@' */
306          static const char valid_parameters[] = "123456789";
307          int parameter = 0;
308
309          /* Search for the parameter digit, the index in the string is the
310           * parameter to use.
311           */
312          while (valid_parameters[parameter] != parameter_char &&
313             valid_parameters[parameter] != '\0')
314             ++parameter;
315
316          /* If the parameter digit is out of range it will just get printed. */
317          if (parameter < PNG_WARNING_PARAMETER_COUNT)
318          {
319             /* Append this parameter */
320             png_const_charp parm = p[parameter];
321             png_const_charp pend = p[parameter] + (sizeof p[parameter]);
322
323             /* No need to copy the trailing '\0' here, but there is no guarantee
324              * that parm[] has been initialized, so there is no guarantee of a
325              * trailing '\0':
326              */
327             while (i<(sizeof msg)-1 && *parm != '\0' && parm < pend)
328                msg[i++] = *parm++;
329
330             /* Consume the parameter digit too: */
331             ++message;
332             continue;
333          }
334
335          /* else not a parameter and there is a character after the @ sign; just
336           * copy that.  This is known not to be '\0' because of the test above.
337           */
338       }
339
340       /* At this point *message can't be '\0', even in the bad parameter case
341        * above where there is a lone '@' at the end of the message string.
342        */
343       msg[i++] = *message++;
344    }
345
346    /* i is always less than (sizeof msg), so: */
347    msg[i] = '\0';
348
349    /* And this is the formatted message, it may be larger than
350     * PNG_MAX_ERROR_TEXT, but that is only used for 'chunk' errors and these are
351     * not (currently) formatted.
352     */
353    png_warning(png_ptr, msg);
354 }
355 #endif /* PNG_WARNINGS_SUPPORTED */
356
357 #ifdef PNG_BENIGN_ERRORS_SUPPORTED
358 void PNGAPI
359 png_benign_error(png_structp png_ptr, png_const_charp error_message)
360 {
361   if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
362      png_warning(png_ptr, error_message);
363   else
364      png_error(png_ptr, error_message);
365 }
366 #endif
367
368 /* These utilities are used internally to build an error message that relates
369  * to the current chunk.  The chunk name comes from png_ptr->chunk_name,
370  * this is used to prefix the message.  The message is limited in length
371  * to 63 bytes, the name characters are output as hex digits wrapped in []
372  * if the character is invalid.
373  */
374 #define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))
375 static PNG_CONST char png_digit[16] = {
376    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
377    'A', 'B', 'C', 'D', 'E', 'F'
378 };
379
380 #define PNG_MAX_ERROR_TEXT 64
381 #if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED)
382 static void /* PRIVATE */
383 png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp
384     error_message)
385 {
386    png_uint_32 chunk_name = png_ptr->chunk_name;
387    int iout = 0, ishift = 24;
388
389    while (ishift >= 0)
390    {
391       int c = (int)(chunk_name >> ishift) & 0xff;
392
393       ishift -= 8;
394       if (isnonalpha(c))
395       {
396          buffer[iout++] = PNG_LITERAL_LEFT_SQUARE_BRACKET;
397          buffer[iout++] = png_digit[(c & 0xf0) >> 4];
398          buffer[iout++] = png_digit[c & 0x0f];
399          buffer[iout++] = PNG_LITERAL_RIGHT_SQUARE_BRACKET;
400       }
401
402       else
403       {
404          buffer[iout++] = (char)c;
405       }
406    }
407
408    if (error_message == NULL)
409       buffer[iout] = '\0';
410
411    else
412    {
413       int iin = 0;
414
415       buffer[iout++] = ':';
416       buffer[iout++] = ' ';
417
418       while (iin < PNG_MAX_ERROR_TEXT-1 && error_message[iin] != '\0')
419          buffer[iout++] = error_message[iin++];
420
421       /* iin < PNG_MAX_ERROR_TEXT, so the following is safe: */
422       buffer[iout] = '\0';
423    }
424 }
425 #endif /* PNG_WARNINGS_SUPPORTED || PNG_ERROR_TEXT_SUPPORTED */
426
427 #if defined(PNG_READ_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED)
428 PNG_FUNCTION(void,PNGAPI
429 png_chunk_error,(png_structp png_ptr, png_const_charp error_message),
430    PNG_NORETURN)
431 {
432    char msg[18+PNG_MAX_ERROR_TEXT];
433    if (png_ptr == NULL)
434       png_error(png_ptr, error_message);
435
436    else
437    {
438       png_format_buffer(png_ptr, msg, error_message);
439       png_error(png_ptr, msg);
440    }
441 }
442 #endif /* PNG_READ_SUPPORTED && PNG_ERROR_TEXT_SUPPORTED */
443
444 #ifdef PNG_WARNINGS_SUPPORTED
445 void PNGAPI
446 png_chunk_warning(png_structp png_ptr, png_const_charp warning_message)
447 {
448    char msg[18+PNG_MAX_ERROR_TEXT];
449    if (png_ptr == NULL)
450       png_warning(png_ptr, warning_message);
451
452    else
453    {
454       png_format_buffer(png_ptr, msg, warning_message);
455       png_warning(png_ptr, msg);
456    }
457 }
458 #endif /* PNG_WARNINGS_SUPPORTED */
459
460 #ifdef PNG_READ_SUPPORTED
461 #ifdef PNG_BENIGN_ERRORS_SUPPORTED
462 void PNGAPI
463 png_chunk_benign_error(png_structp png_ptr, png_const_charp error_message)
464 {
465    if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
466       png_chunk_warning(png_ptr, error_message);
467
468    else
469       png_chunk_error(png_ptr, error_message);
470 }
471 #endif
472 #endif /* PNG_READ_SUPPORTED */
473
474 #ifdef PNG_ERROR_TEXT_SUPPORTED
475 #ifdef PNG_FLOATING_POINT_SUPPORTED
476 PNG_FUNCTION(void,
477 png_fixed_error,(png_structp png_ptr, png_const_charp name),PNG_NORETURN)
478 {
479 #  define fixed_message "fixed point overflow in "
480 #  define fixed_message_ln ((sizeof fixed_message)-1)
481    int  iin;
482    char msg[fixed_message_ln+PNG_MAX_ERROR_TEXT];
483    png_memcpy(msg, fixed_message, fixed_message_ln);
484    iin = 0;
485    if (name != NULL) while (iin < (PNG_MAX_ERROR_TEXT-1) && name[iin] != 0)
486    {
487       msg[fixed_message_ln + iin] = name[iin];
488       ++iin;
489    }
490    msg[fixed_message_ln + iin] = 0;
491    png_error(png_ptr, msg);
492 }
493 #endif
494 #endif
495
496 #ifdef PNG_SETJMP_SUPPORTED
497 /* This API only exists if ANSI-C style error handling is used,
498  * otherwise it is necessary for png_default_error to be overridden.
499  */
500 jmp_buf* PNGAPI
501 png_set_longjmp_fn(png_structp png_ptr, png_longjmp_ptr longjmp_fn,
502     size_t jmp_buf_size)
503 {
504    if (png_ptr == NULL || jmp_buf_size != png_sizeof(jmp_buf))
505       return NULL;
506
507    png_ptr->longjmp_fn = longjmp_fn;
508    return &png_ptr->longjmp_buffer;
509 }
510 #endif
511
512 /* This is the default error handling function.  Note that replacements for
513  * this function MUST NOT RETURN, or the program will likely crash.  This
514  * function is used by default, or if the program supplies NULL for the
515  * error function pointer in png_set_error_fn().
516  */
517 static PNG_FUNCTION(void /* PRIVATE */,
518 png_default_error,(png_structp png_ptr, png_const_charp error_message),
519    PNG_NORETURN)
520 {
521 #ifdef PNG_CONSOLE_IO_SUPPORTED
522 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
523    /* Check on NULL only added in 1.5.4 */
524    if (error_message != NULL && *error_message == PNG_LITERAL_SHARP)
525    {
526       /* Strip "#nnnn " from beginning of error message. */
527       int offset;
528       char error_number[16];
529       for (offset = 0; offset<15; offset++)
530       {
531          error_number[offset] = error_message[offset + 1];
532          if (error_message[offset] == ' ')
533             break;
534       }
535
536       if ((offset > 1) && (offset < 15))
537       {
538          error_number[offset - 1] = '\0';
539          fprintf(stderr, "libpng error no. %s: %s",
540              error_number, error_message + offset + 1);
541          fprintf(stderr, PNG_STRING_NEWLINE);
542       }
543
544       else
545       {
546          fprintf(stderr, "libpng error: %s, offset=%d",
547              error_message, offset);
548          fprintf(stderr, PNG_STRING_NEWLINE);
549       }
550    }
551    else
552 #endif
553    {
554       fprintf(stderr, "libpng error: %s", error_message ? error_message :
555          "undefined");
556       fprintf(stderr, PNG_STRING_NEWLINE);
557    }
558 #else
559    PNG_UNUSED(error_message) /* Make compiler happy */
560 #endif
561    png_longjmp(png_ptr, 1);
562 }
563
564 PNG_FUNCTION(void,PNGAPI
565 png_longjmp,(png_structp png_ptr, int val),PNG_NORETURN)
566 {
567 #ifdef PNG_SETJMP_SUPPORTED
568    if (png_ptr && png_ptr->longjmp_fn)
569    {
570 #  ifdef USE_FAR_KEYWORD
571       {
572          jmp_buf tmp_jmpbuf;
573          png_memcpy(tmp_jmpbuf, png_ptr->longjmp_buffer, png_sizeof(jmp_buf));
574          png_ptr->longjmp_fn(tmp_jmpbuf, val);
575       }
576
577 #  else
578    png_ptr->longjmp_fn(png_ptr->longjmp_buffer, val);
579 #  endif
580    }
581 #endif
582    /* Here if not setjmp support or if png_ptr is null. */
583    PNG_ABORT();
584 }
585
586 #ifdef PNG_WARNINGS_SUPPORTED
587 /* This function is called when there is a warning, but the library thinks
588  * it can continue anyway.  Replacement functions don't have to do anything
589  * here if you don't want them to.  In the default configuration, png_ptr is
590  * not used, but it is passed in case it may be useful.
591  */
592 static void /* PRIVATE */
593 png_default_warning(png_structp png_ptr, png_const_charp warning_message)
594 {
595 #ifdef PNG_CONSOLE_IO_SUPPORTED
596 #  ifdef PNG_ERROR_NUMBERS_SUPPORTED
597    if (*warning_message == PNG_LITERAL_SHARP)
598    {
599       int offset;
600       char warning_number[16];
601       for (offset = 0; offset < 15; offset++)
602       {
603          warning_number[offset] = warning_message[offset + 1];
604          if (warning_message[offset] == ' ')
605             break;
606       }
607
608       if ((offset > 1) && (offset < 15))
609       {
610          warning_number[offset + 1] = '\0';
611          fprintf(stderr, "libpng warning no. %s: %s",
612              warning_number, warning_message + offset);
613          fprintf(stderr, PNG_STRING_NEWLINE);
614       }
615
616       else
617       {
618          fprintf(stderr, "libpng warning: %s",
619              warning_message);
620          fprintf(stderr, PNG_STRING_NEWLINE);
621       }
622    }
623    else
624 #  endif
625
626    {
627       fprintf(stderr, "libpng warning: %s", warning_message);
628       fprintf(stderr, PNG_STRING_NEWLINE);
629    }
630 #else
631    PNG_UNUSED(warning_message) /* Make compiler happy */
632 #endif
633    PNG_UNUSED(png_ptr) /* Make compiler happy */
634 }
635 #endif /* PNG_WARNINGS_SUPPORTED */
636
637 /* This function is called when the application wants to use another method
638  * of handling errors and warnings.  Note that the error function MUST NOT
639  * return to the calling routine or serious problems will occur.  The return
640  * method used in the default routine calls longjmp(png_ptr->longjmp_buffer, 1)
641  */
642 void PNGAPI
643 png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,
644     png_error_ptr error_fn, png_error_ptr warning_fn)
645 {
646    if (png_ptr == NULL)
647       return;
648
649    png_ptr->error_ptr = error_ptr;
650    png_ptr->error_fn = error_fn;
651 #ifdef PNG_WARNINGS_SUPPORTED
652    png_ptr->warning_fn = warning_fn;
653 #else
654    PNG_UNUSED(warning_fn)
655 #endif
656 }
657
658
659 /* This function returns a pointer to the error_ptr associated with the user
660  * functions.  The application should free any memory associated with this
661  * pointer before png_write_destroy and png_read_destroy are called.
662  */
663 png_voidp PNGAPI
664 png_get_error_ptr(png_const_structp png_ptr)
665 {
666    if (png_ptr == NULL)
667       return NULL;
668
669    return ((png_voidp)png_ptr->error_ptr);
670 }
671
672
673 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
674 void PNGAPI
675 png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode)
676 {
677    if (png_ptr != NULL)
678    {
679       png_ptr->flags &=
680          ((~(PNG_FLAG_STRIP_ERROR_NUMBERS |
681          PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode);
682    }
683 }
684 #endif
685 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */