ReactOS 0.4.15-dev-8419-g7f0e8a3
pngerror.c
Go to the documentation of this file.
1
2/* pngerror.c - stub functions for i/o and memory allocation
3 *
4 * Copyright (c) 2018 Cosmin Truta
5 * Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson
6 * Copyright (c) 1996-1997 Andreas Dilger
7 * 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
23static PNG_FUNCTION(void, png_default_error,PNGARG((png_const_structrp png_ptr,
25
26#ifdef PNG_WARNINGS_SUPPORTED
27static void /* PRIVATE */
28png_default_warning PNGARG((png_const_structrp png_ptr,
29 png_const_charp warning_message));
30#endif /* WARNINGS */
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
41{
42#ifdef PNG_ERROR_NUMBERS_SUPPORTED
43 char msg[16];
44 if (png_ptr != NULL)
45 {
46 if ((png_ptr->flags &
48 {
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
57 if ((png_ptr->flags & PNG_FLAG_STRIP_ERROR_TEXT) != 0)
58 {
59 int i;
60 for (i = 0; i < offset - 1; i++)
61 msg[i] = error_message[i + 1];
62 msg[i - 1] = '\0';
64 }
65
66 else
68 }
69
70 else
71 {
72 if ((png_ptr->flags & PNG_FLAG_STRIP_ERROR_TEXT) != 0)
73 {
74 msg[0] = '0';
75 msg[1] = '\0';
77 }
78 }
79 }
80 }
81#endif
82 if (png_ptr != NULL && png_ptr->error_fn != NULL)
85
86 /* If the custom handler doesn't exist, or if it returns,
87 use the default handler, which will not return. */
88 png_default_error(png_ptr, error_message);
89}
90#else
93{
94 /* Prior to 1.5.2 the error_fn received a NULL pointer, expressed
95 * erroneously as '\0', instead of the empty string "". This was
96 * apparently an error, introduced in libpng-1.2.20, and png_default_error
97 * will crash in this case.
98 */
99 if (png_ptr != NULL && png_ptr->error_fn != NULL)
100 (*(png_ptr->error_fn))(png_constcast(png_structrp,png_ptr), "");
101
102 /* If the custom handler doesn't exist, or if it returns,
103 use the default handler, which will not return. */
104 png_default_error(png_ptr, "");
105}
106#endif /* ERROR_TEXT */
107
108/* Utility to safely appends strings to a buffer. This never errors out so
109 * error checking is not required in the caller.
110 */
111size_t
112png_safecat(png_charp buffer, size_t bufsize, size_t pos,
113 png_const_charp string)
114{
115 if (buffer != NULL && pos < bufsize)
116 {
117 if (string != NULL)
118 while (*string != '\0' && pos < bufsize-1)
119 buffer[pos++] = *string++;
120
121 buffer[pos] = '\0';
122 }
123
124 return pos;
125}
126
127#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_TIME_RFC1123_SUPPORTED)
128/* Utility to dump an unsigned value into a buffer, given a start pointer and
129 * and end pointer (which should point just *beyond* the end of the buffer!)
130 * Returns the pointer to the start of the formatted string.
131 */
133png_format_number(png_const_charp start, png_charp end, int format,
135{
136 int count = 0; /* number of digits output */
137 int mincount = 1; /* minimum number required */
138 int output = 0; /* digit output (for the fixed point format) */
139
140 *--end = '\0';
141
142 /* This is written so that the loop always runs at least once, even with
143 * number zero.
144 */
145 while (end > start && (number != 0 || count < mincount))
146 {
147
148 static const char digits[] = "0123456789ABCDEF";
149
150 switch (format)
151 {
152 case PNG_NUMBER_FORMAT_fixed:
153 /* Needs five digits (the fraction) */
154 mincount = 5;
155 if (output != 0 || number % 10 != 0)
156 {
157 *--end = digits[number % 10];
158 output = 1;
159 }
160 number /= 10;
161 break;
162
163 case PNG_NUMBER_FORMAT_02u:
164 /* Expects at least 2 digits. */
165 mincount = 2;
166 /* FALLTHROUGH */
167
168 case PNG_NUMBER_FORMAT_u:
169 *--end = digits[number % 10];
170 number /= 10;
171 break;
172
173 case PNG_NUMBER_FORMAT_02x:
174 /* This format expects at least two digits */
175 mincount = 2;
176 /* FALLTHROUGH */
177
178 case PNG_NUMBER_FORMAT_x:
179 *--end = digits[number & 0xf];
180 number >>= 4;
181 break;
182
183 default: /* an error */
184 number = 0;
185 break;
186 }
187
188 /* Keep track of the number of digits added */
189 ++count;
190
191 /* Float a fixed number here: */
192 if ((format == PNG_NUMBER_FORMAT_fixed) && (count == 5) && (end > start))
193 {
194 /* End of the fraction, but maybe nothing was output? In that case
195 * drop the decimal point. If the number is a true zero handle that
196 * here.
197 */
198 if (output != 0)
199 *--end = '.';
200 else if (number == 0) /* and !output */
201 *--end = '0';
202 }
203 }
204
205 return end;
206}
207#endif
208
209#ifdef PNG_WARNINGS_SUPPORTED
210/* This function is called whenever there is a non-fatal error. This function
211 * should not be changed. If there is a need to handle warnings differently,
212 * you should supply a replacement warning function and use
213 * png_set_error_fn() to replace the warning function at run-time.
214 */
215void PNGAPI
216png_warning(png_const_structrp png_ptr, png_const_charp warning_message)
217{
218 int offset = 0;
219 if (png_ptr != NULL)
220 {
221#ifdef PNG_ERROR_NUMBERS_SUPPORTED
222 if ((png_ptr->flags &
224#endif
225 {
226 if (*warning_message == PNG_LITERAL_SHARP)
227 {
228 for (offset = 1; offset < 15; offset++)
229 if (warning_message[offset] == ' ')
230 break;
231 }
232 }
233 }
234 if (png_ptr != NULL && png_ptr->warning_fn != NULL)
235 (*(png_ptr->warning_fn))(png_constcast(png_structrp,png_ptr),
236 warning_message + offset);
237 else
238 png_default_warning(png_ptr, warning_message + offset);
239}
240
241/* These functions support 'formatted' warning messages with up to
242 * PNG_WARNING_PARAMETER_COUNT parameters. In the format string the parameter
243 * is introduced by @<number>, where 'number' starts at 1. This follows the
244 * standard established by X/Open for internationalizable error messages.
245 */
246void
247png_warning_parameter(png_warning_parameters p, int number,
248 png_const_charp string)
249{
250 if (number > 0 && number <= PNG_WARNING_PARAMETER_COUNT)
251 (void)png_safecat(p[number-1], (sizeof p[number-1]), 0, string);
252}
253
254void
255png_warning_parameter_unsigned(png_warning_parameters p, int number, int format,
257{
258 char buffer[PNG_NUMBER_BUFFER_SIZE];
259 png_warning_parameter(p, number, PNG_FORMAT_NUMBER(buffer, format, value));
260}
261
262void
263png_warning_parameter_signed(png_warning_parameters p, int number, int format,
264 png_int_32 value)
265{
268 char buffer[PNG_NUMBER_BUFFER_SIZE];
269
270 /* Avoid overflow by doing the negate in a png_alloc_size_t: */
272 if (value < 0)
273 u = ~u + 1;
274
275 str = PNG_FORMAT_NUMBER(buffer, format, u);
276
277 if (value < 0 && str > buffer)
278 *--str = '-';
279
281}
282
283void
284png_formatted_warning(png_const_structrp png_ptr, png_warning_parameters p,
286{
287 /* The internal buffer is just 192 bytes - enough for all our messages,
288 * overflow doesn't happen because this code checks! If someone figures
289 * out how to send us a message longer than 192 bytes, all that will
290 * happen is that the message will be truncated appropriately.
291 */
292 size_t i = 0; /* Index in the msg[] buffer: */
293 char msg[192];
294
295 /* Each iteration through the following loop writes at most one character
296 * to msg[i++] then returns here to validate that there is still space for
297 * the trailing '\0'. It may (in the case of a parameter) read more than
298 * one character from message[]; it must check for '\0' and continue to the
299 * test if it finds the end of string.
300 */
301 while (i<(sizeof msg)-1 && *message != '\0')
302 {
303 /* '@' at end of string is now just printed (previously it was skipped);
304 * it is an error in the calling code to terminate the string with @.
305 */
306 if (p != NULL && *message == '@' && message[1] != '\0')
307 {
308 int parameter_char = *++message; /* Consume the '@' */
309 static const char valid_parameters[] = "123456789";
310 int parameter = 0;
311
312 /* Search for the parameter digit, the index in the string is the
313 * parameter to use.
314 */
315 while (valid_parameters[parameter] != parameter_char &&
316 valid_parameters[parameter] != '\0')
317 ++parameter;
318
319 /* If the parameter digit is out of range it will just get printed. */
320 if (parameter < PNG_WARNING_PARAMETER_COUNT)
321 {
322 /* Append this parameter */
323 png_const_charp parm = p[parameter];
324 png_const_charp pend = p[parameter] + (sizeof p[parameter]);
325
326 /* No need to copy the trailing '\0' here, but there is no guarantee
327 * that parm[] has been initialized, so there is no guarantee of a
328 * trailing '\0':
329 */
330 while (i<(sizeof msg)-1 && *parm != '\0' && parm < pend)
331 msg[i++] = *parm++;
332
333 /* Consume the parameter digit too: */
334 ++message;
335 continue;
336 }
337
338 /* else not a parameter and there is a character after the @ sign; just
339 * copy that. This is known not to be '\0' because of the test above.
340 */
341 }
342
343 /* At this point *message can't be '\0', even in the bad parameter case
344 * above where there is a lone '@' at the end of the message string.
345 */
346 msg[i++] = *message++;
347 }
348
349 /* i is always less than (sizeof msg), so: */
350 msg[i] = '\0';
351
352 /* And this is the formatted message. It may be larger than
353 * PNG_MAX_ERROR_TEXT, but that is only used for 'chunk' errors and these
354 * are not (currently) formatted.
355 */
356 png_warning(png_ptr, msg);
357}
358#endif /* WARNINGS */
359
360#ifdef PNG_BENIGN_ERRORS_SUPPORTED
361void PNGAPI
363{
364 if ((png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN) != 0)
365 {
366# ifdef PNG_READ_SUPPORTED
367 if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
368 png_ptr->chunk_name != 0)
369 png_chunk_warning(png_ptr, error_message);
370 else
371# endif
372 png_warning(png_ptr, error_message);
373 }
374
375 else
376 {
377# ifdef PNG_READ_SUPPORTED
378 if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
379 png_ptr->chunk_name != 0)
380 png_chunk_error(png_ptr, error_message);
381 else
382# endif
383 png_error(png_ptr, error_message);
384 }
385
386# ifndef PNG_ERROR_TEXT_SUPPORTED
388# endif
389}
390
391void /* PRIVATE */
393{
394 if ((png_ptr->flags & PNG_FLAG_APP_WARNINGS_WARN) != 0)
395 png_warning(png_ptr, error_message);
396 else
397 png_error(png_ptr, error_message);
398
399# ifndef PNG_ERROR_TEXT_SUPPORTED
401# endif
402}
403
404void /* PRIVATE */
406{
407 if ((png_ptr->flags & PNG_FLAG_APP_ERRORS_WARN) != 0)
408 png_warning(png_ptr, error_message);
409 else
410 png_error(png_ptr, error_message);
411
412# ifndef PNG_ERROR_TEXT_SUPPORTED
414# endif
415}
416#endif /* BENIGN_ERRORS */
417
418#define PNG_MAX_ERROR_TEXT 196 /* Currently limited by profile_error in png.c */
419#if defined(PNG_WARNINGS_SUPPORTED) || \
420 (defined(PNG_READ_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED))
421/* These utilities are used internally to build an error message that relates
422 * to the current chunk. The chunk name comes from png_ptr->chunk_name,
423 * which is used to prefix the message. The message is limited in length
424 * to 63 bytes. The name characters are output as hex digits wrapped in []
425 * if the character is invalid.
426 */
427#define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))
428static const char png_digit[16] = {
429 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
430 'A', 'B', 'C', 'D', 'E', 'F'
431};
432
433static void /* PRIVATE */
436{
437 png_uint_32 chunk_name = png_ptr->chunk_name;
438 int iout = 0, ishift = 24;
439
440 while (ishift >= 0)
441 {
442 int c = (int)(chunk_name >> ishift) & 0xff;
443
444 ishift -= 8;
445 if (isnonalpha(c) != 0)
446 {
448 buffer[iout++] = png_digit[(c & 0xf0) >> 4];
449 buffer[iout++] = png_digit[c & 0x0f];
451 }
452
453 else
454 {
455 buffer[iout++] = (char)c;
456 }
457 }
458
459 if (error_message == NULL)
460 buffer[iout] = '\0';
461
462 else
463 {
464 int iin = 0;
465
466 buffer[iout++] = ':';
467 buffer[iout++] = ' ';
468
469 while (iin < PNG_MAX_ERROR_TEXT-1 && error_message[iin] != '\0')
470 buffer[iout++] = error_message[iin++];
471
472 /* iin < PNG_MAX_ERROR_TEXT, so the following is safe: */
473 buffer[iout] = '\0';
474 }
475}
476#endif /* WARNINGS || ERROR_TEXT */
477
478#if defined(PNG_READ_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED)
482{
483 char msg[18+PNG_MAX_ERROR_TEXT];
484 if (png_ptr == NULL)
485 png_error(png_ptr, error_message);
486
487 else
488 {
489 png_format_buffer(png_ptr, msg, error_message);
490 png_error(png_ptr, msg);
491 }
492}
493#endif /* READ && ERROR_TEXT */
494
495#ifdef PNG_WARNINGS_SUPPORTED
496void PNGAPI
497png_chunk_warning(png_const_structrp png_ptr, png_const_charp warning_message)
498{
499 char msg[18+PNG_MAX_ERROR_TEXT];
500 if (png_ptr == NULL)
501 png_warning(png_ptr, warning_message);
502
503 else
504 {
505 png_format_buffer(png_ptr, msg, warning_message);
506 png_warning(png_ptr, msg);
507 }
508}
509#endif /* WARNINGS */
510
511#ifdef PNG_READ_SUPPORTED
512#ifdef PNG_BENIGN_ERRORS_SUPPORTED
513void PNGAPI
514png_chunk_benign_error(png_const_structrp png_ptr, png_const_charp
516{
517 if ((png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN) != 0)
518 png_chunk_warning(png_ptr, error_message);
519
520 else
521 png_chunk_error(png_ptr, error_message);
522
523# ifndef PNG_ERROR_TEXT_SUPPORTED
525# endif
526}
527#endif
528#endif /* READ */
529
530void /* PRIVATE */
532{
533# ifndef PNG_WARNINGS_SUPPORTED
535# endif
536
537 /* This is always supported, but for just read or just write it
538 * unconditionally does the right thing.
539 */
540# if defined(PNG_READ_SUPPORTED) && defined(PNG_WRITE_SUPPORTED)
541 if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
542# endif
543
544# ifdef PNG_READ_SUPPORTED
545 {
547 png_chunk_warning(png_ptr, message);
548
549 else
550 png_chunk_benign_error(png_ptr, message);
551 }
552# endif
553
554# if defined(PNG_READ_SUPPORTED) && defined(PNG_WRITE_SUPPORTED)
555 else if ((png_ptr->mode & PNG_IS_READ_STRUCT) == 0)
556# endif
557
558# ifdef PNG_WRITE_SUPPORTED
559 {
562
563 else
565 }
566# endif
567}
568
569#ifdef PNG_ERROR_TEXT_SUPPORTED
570#ifdef PNG_FLOATING_POINT_SUPPORTED
571PNG_FUNCTION(void,
573{
574# define fixed_message "fixed point overflow in "
575# define fixed_message_ln ((sizeof fixed_message)-1)
576 unsigned int iin;
577 char msg[fixed_message_ln+PNG_MAX_ERROR_TEXT];
578 memcpy(msg, fixed_message, fixed_message_ln);
579 iin = 0;
580 if (name != NULL)
581 while (iin < (PNG_MAX_ERROR_TEXT-1) && name[iin] != 0)
582 {
583 msg[fixed_message_ln + iin] = name[iin];
584 ++iin;
585 }
586 msg[fixed_message_ln + iin] = 0;
587 png_error(png_ptr, msg);
588}
589#endif
590#endif
591
592#ifdef PNG_SETJMP_SUPPORTED
593/* This API only exists if ANSI-C style error handling is used,
594 * otherwise it is necessary for png_default_error to be overridden.
595 */
597png_set_longjmp_fn(png_structrp png_ptr, png_longjmp_ptr longjmp_fn,
598 size_t jmp_buf_size)
599{
600 /* From libpng 1.6.0 the app gets one chance to set a 'jmpbuf_size' value
601 * and it must not change after that. Libpng doesn't care how big the
602 * buffer is, just that it doesn't change.
603 *
604 * If the buffer size is no *larger* than the size of jmp_buf when libpng is
605 * compiled a built in jmp_buf is returned; this preserves the pre-1.6.0
606 * semantics that this call will not fail. If the size is larger, however,
607 * the buffer is allocated and this may fail, causing the function to return
608 * NULL.
609 */
610 if (png_ptr == NULL)
611 return NULL;
612
613 if (png_ptr->jmp_buf_ptr == NULL)
614 {
615 png_ptr->jmp_buf_size = 0; /* not allocated */
616
617 if (jmp_buf_size <= (sizeof png_ptr->jmp_buf_local))
618 png_ptr->jmp_buf_ptr = &png_ptr->jmp_buf_local;
619
620 else
621 {
622 png_ptr->jmp_buf_ptr = png_voidcast(jmp_buf *,
623 png_malloc_warn(png_ptr, jmp_buf_size));
624
625 if (png_ptr->jmp_buf_ptr == NULL)
626 return NULL; /* new NULL return on OOM */
627
628 png_ptr->jmp_buf_size = jmp_buf_size;
629 }
630 }
631
632 else /* Already allocated: check the size */
633 {
634 size_t size = png_ptr->jmp_buf_size;
635
636 if (size == 0)
637 {
638 size = (sizeof png_ptr->jmp_buf_local);
639 if (png_ptr->jmp_buf_ptr != &png_ptr->jmp_buf_local)
640 {
641 /* This is an internal error in libpng: somehow we have been left
642 * with a stack allocated jmp_buf when the application regained
643 * control. It's always possible to fix this up, but for the moment
644 * this is a png_error because that makes it easy to detect.
645 */
646 png_error(png_ptr, "Libpng jmp_buf still allocated");
647 /* png_ptr->jmp_buf_ptr = &png_ptr->jmp_buf_local; */
648 }
649 }
650
651 if (size != jmp_buf_size)
652 {
653 png_warning(png_ptr, "Application jmp_buf size changed");
654 return NULL; /* caller will probably crash: no choice here */
655 }
656 }
657
658 /* Finally fill in the function, now we have a satisfactory buffer. It is
659 * valid to change the function on every call.
660 */
661 png_ptr->longjmp_fn = longjmp_fn;
662 return png_ptr->jmp_buf_ptr;
663}
664
665void /* PRIVATE */
666png_free_jmpbuf(png_structrp png_ptr)
667{
668 if (png_ptr != NULL)
669 {
670 jmp_buf *jb = png_ptr->jmp_buf_ptr;
671
672 /* A size of 0 is used to indicate a local, stack, allocation of the
673 * pointer; used here and in png.c
674 */
675 if (jb != NULL && png_ptr->jmp_buf_size > 0)
676 {
677
678 /* This stuff is so that a failure to free the error control structure
679 * does not leave libpng in a state with no valid error handling: the
680 * free always succeeds, if there is an error it gets ignored.
681 */
682 if (jb != &png_ptr->jmp_buf_local)
683 {
684 /* Make an internal, libpng, jmp_buf to return here */
685 jmp_buf free_jmp_buf;
686
687 if (!setjmp(free_jmp_buf))
688 {
689 png_ptr->jmp_buf_ptr = &free_jmp_buf; /* come back here */
690 png_ptr->jmp_buf_size = 0; /* stack allocation */
691 png_ptr->longjmp_fn = longjmp;
692 png_free(png_ptr, jb); /* Return to setjmp on error */
693 }
694 }
695 }
696
697 /* *Always* cancel everything out: */
698 png_ptr->jmp_buf_size = 0;
699 png_ptr->jmp_buf_ptr = NULL;
700 png_ptr->longjmp_fn = 0;
701 }
702}
703#endif
704
705/* This is the default error handling function. Note that replacements for
706 * this function MUST NOT RETURN, or the program will likely crash. This
707 * function is used by default, or if the program supplies NULL for the
708 * error function pointer in png_set_error_fn().
709 */
710static PNG_FUNCTION(void /* PRIVATE */,
713{
714#ifdef PNG_CONSOLE_IO_SUPPORTED
715#ifdef PNG_ERROR_NUMBERS_SUPPORTED
716 /* Check on NULL only added in 1.5.4 */
718 {
719 /* Strip "#nnnn " from beginning of error message. */
720 int offset;
721 char error_number[16];
722 for (offset = 0; offset<15; offset++)
723 {
724 error_number[offset] = error_message[offset + 1];
725 if (error_message[offset] == ' ')
726 break;
727 }
728
729 if ((offset > 1) && (offset < 15))
730 {
731 error_number[offset - 1] = '\0';
732 fprintf(stderr, "libpng error no. %s: %s",
733 error_number, error_message + offset + 1);
735 }
736
737 else
738 {
739 fprintf(stderr, "libpng error: %s, offset=%d",
742 }
743 }
744 else
745#endif
746 {
747 fprintf(stderr, "libpng error: %s", error_message ? error_message :
748 "undefined");
750 }
751#else
752 PNG_UNUSED(error_message) /* Make compiler happy */
753#endif
754 png_longjmp(png_ptr, 1);
755}
756
758png_longjmp,(png_const_structrp png_ptr, int val),PNG_NORETURN)
759{
760#ifdef PNG_SETJMP_SUPPORTED
761 if (png_ptr != NULL && png_ptr->longjmp_fn != NULL &&
762 png_ptr->jmp_buf_ptr != NULL)
763 png_ptr->longjmp_fn(*png_ptr->jmp_buf_ptr, val);
764#else
767#endif
768
769 /* If control reaches this point, png_longjmp() must not return. The only
770 * choice is to terminate the whole process (or maybe the thread); to do
771 * this the ANSI-C abort() function is used unless a different method is
772 * implemented by overriding the default configuration setting for
773 * PNG_ABORT().
774 */
775 PNG_ABORT();
776}
777
778#ifdef PNG_WARNINGS_SUPPORTED
779/* This function is called when there is a warning, but the library thinks
780 * it can continue anyway. Replacement functions don't have to do anything
781 * here if you don't want them to. In the default configuration, png_ptr is
782 * not used, but it is passed in case it may be useful.
783 */
784static void /* PRIVATE */
785png_default_warning(png_const_structrp png_ptr, png_const_charp warning_message)
786{
787#ifdef PNG_CONSOLE_IO_SUPPORTED
788# ifdef PNG_ERROR_NUMBERS_SUPPORTED
789 if (*warning_message == PNG_LITERAL_SHARP)
790 {
791 int offset;
792 char warning_number[16];
793 for (offset = 0; offset < 15; offset++)
794 {
795 warning_number[offset] = warning_message[offset + 1];
796 if (warning_message[offset] == ' ')
797 break;
798 }
799
800 if ((offset > 1) && (offset < 15))
801 {
802 warning_number[offset + 1] = '\0';
803 fprintf(stderr, "libpng warning no. %s: %s",
804 warning_number, warning_message + offset);
806 }
807
808 else
809 {
810 fprintf(stderr, "libpng warning: %s",
811 warning_message);
813 }
814 }
815 else
816# endif
817
818 {
819 fprintf(stderr, "libpng warning: %s", warning_message);
821 }
822#else
823 PNG_UNUSED(warning_message) /* Make compiler happy */
824#endif
825 PNG_UNUSED(png_ptr) /* Make compiler happy */
826}
827#endif /* WARNINGS */
828
829/* This function is called when the application wants to use another method
830 * of handling errors and warnings. Note that the error function MUST NOT
831 * return to the calling routine or serious problems will occur. The return
832 * method used in the default routine calls longjmp(png_ptr->jmp_buf_ptr, 1)
833 */
834void PNGAPI
835png_set_error_fn(png_structrp png_ptr, png_voidp error_ptr,
836 png_error_ptr error_fn, png_error_ptr warning_fn)
837{
838 if (png_ptr == NULL)
839 return;
840
841 png_ptr->error_ptr = error_ptr;
842 png_ptr->error_fn = error_fn;
843#ifdef PNG_WARNINGS_SUPPORTED
844 png_ptr->warning_fn = warning_fn;
845#else
846 PNG_UNUSED(warning_fn)
847#endif
848}
849
850
851/* This function returns a pointer to the error_ptr associated with the user
852 * functions. The application should free any memory associated with this
853 * pointer before png_write_destroy and png_read_destroy are called.
854 */
856png_get_error_ptr(png_const_structrp png_ptr)
857{
858 if (png_ptr == NULL)
859 return NULL;
860
861 return ((png_voidp)png_ptr->error_ptr);
862}
863
864
865#ifdef PNG_ERROR_NUMBERS_SUPPORTED
866void PNGAPI
867png_set_strip_error_numbers(png_structrp png_ptr, png_uint_32 strip_mode)
868{
869 if (png_ptr != NULL)
870 {
871 png_ptr->flags &=
873 PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode);
874 }
875}
876#endif
877
878#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\
879 defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
880 /* Currently the above both depend on SETJMP_SUPPORTED, however it would be
881 * possible to implement without setjmp support just so long as there is some
882 * way to handle the error return here:
883 */
884PNG_FUNCTION(void /* PRIVATE */, (PNGCBAPI
885png_safe_error),(png_structp png_nonconst_ptr, png_const_charp error_message),
887{
888 png_const_structrp png_ptr = png_nonconst_ptr;
890
891 /* An error is always logged here, overwriting anything (typically a warning)
892 * that is already there:
893 */
894 if (image != NULL)
895 {
896 png_safecat(image->message, (sizeof image->message), 0, error_message);
897 image->warning_or_error |= PNG_IMAGE_ERROR;
898
899 /* Retrieve the jmp_buf from within the png_control, making this work for
900 * C++ compilation too is pretty tricky: C++ wants a pointer to the first
901 * element of a jmp_buf, but C doesn't tell us the type of that.
902 */
903 if (image->opaque != NULL && image->opaque->error_buf != NULL)
904 longjmp(png_control_jmp_buf(image->opaque), 1);
905
906 /* Missing longjmp buffer, the following is to help debugging: */
907 {
908 size_t pos = png_safecat(image->message, (sizeof image->message), 0,
909 "bad longjmp: ");
910 png_safecat(image->message, (sizeof image->message), pos,
912 }
913 }
914
915 /* Here on an internal programming error. */
916 abort();
917}
918
919#ifdef PNG_WARNINGS_SUPPORTED
920void /* PRIVATE */ PNGCBAPI
921png_safe_warning(png_structp png_nonconst_ptr, png_const_charp warning_message)
922{
923 png_const_structrp png_ptr = png_nonconst_ptr;
925
926 /* A warning is only logged if there is no prior warning or error. */
927 if (image->warning_or_error == 0)
928 {
929 png_safecat(image->message, (sizeof image->message), 0, warning_message);
930 image->warning_or_error |= PNG_IMAGE_WARNING;
931 }
932}
933#endif
934
935int /* PRIVATE */
936png_safe_execute(png_imagep image_in, int (*function)(png_voidp), png_voidp arg)
937{
938 volatile png_imagep image = image_in;
939 volatile int result;
940 volatile png_voidp saved_error_buf;
941 jmp_buf safe_jmpbuf;
942
943 /* Safely execute function(arg) with png_error returning to this function. */
944 saved_error_buf = image->opaque->error_buf;
945 result = setjmp(safe_jmpbuf) == 0;
946
947 if (result != 0)
948 {
949
950 image->opaque->error_buf = safe_jmpbuf;
951 result = function(arg);
952 }
953
954 image->opaque->error_buf = saved_error_buf;
955
956 /* And do the cleanup prior to any failure return. */
957 if (result == 0)
958 png_image_free(image);
959
960 return result;
961}
962#endif /* SIMPLIFIED READ || SIMPLIFIED_WRITE */
963#endif /* READ || WRITE */
#define msg(x)
Definition: auth_time.c:54
#define setjmp
Definition: setjmp.h:209
_JBTYPE jmp_buf[_JBLEN]
Definition: setjmp.h:186
#define NULL
Definition: types.h:112
void error_message(HWND hwnd, const char *msg)
Definition: main.cpp:783
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
unsigned char
Definition: typeof.h:29
GLuint start
Definition: gl.h:1545
GLuint GLuint end
Definition: gl.h:1545
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
GLsizeiptr size
Definition: glext.h:5919
GLuint buffer
Definition: glext.h:5915
const GLubyte * c
Definition: glext.h:8905
GLuint GLfloat * val
Definition: glext.h:7180
GLfloat GLfloat p
Definition: glext.h:8902
GLenum GLuint GLsizei bufsize
Definition: glext.h:7473
GLuint64EXT * result
Definition: glext.h:11304
GLintptr offset
Definition: glext.h:5920
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
#define abort()
Definition: i386-dis.c:34
#define stderr
Definition: stdio.h:100
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
static const int digits[]
Definition: decode.c:71
#define error(str)
Definition: mkdosfs.c:1605
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
char string[160]
Definition: util.h:11
static unsigned int number
Definition: dsound.c:1479
#define PNG_IMAGE_WARNING
Definition: png.h:2689
#define PNG_IMAGE_ERROR
Definition: png.h:2690
png_structrp png_ptr
Definition: png.h:1080
png_uint_32
Definition: png.h:1936
const png_struct *PNG_RESTRICT png_const_structrp
Definition: png.h:467
png_struct *PNG_RESTRICT png_structrp
Definition: png.h:466
#define PNG_NORETURN
Definition: pngconf.h:436
#define PNG_FUNCTION(type, name, args, attributes)
Definition: pngconf.h:287
char * png_charp
Definition: pngconf.h:589
size_t png_alloc_size_t
Definition: pngconf.h:557
#define PNGAPI
Definition: pngconf.h:261
#define PNGARG(arglist)
Definition: pngconf.h:94
#define PNGCBAPI
Definition: pngconf.h:258
const char * png_const_charp
Definition: pngconf.h:590
#define PNG_STRING_NEWLINE
Definition: pngdebug.h:48
#define PNG_LITERAL_SHARP
Definition: pngdebug.h:39
#define PNG_LITERAL_LEFT_SQUARE_BRACKET
Definition: pngdebug.h:42
#define PNG_LITERAL_RIGHT_SQUARE_BRACKET
Definition: pngdebug.h:45
#define PNG_UNUSED(param)
Definition: pngpriv.h:444
#define png_constcast(type, value)
Definition: pngpriv.h:501
#define PNG_CHUNK_WRITE_ERROR
Definition: pngpriv.h:1834
#define png_fixed_error(s1, s2)
Definition: pngpriv.h:469
#define PNG_FLAG_APP_ERRORS_WARN
Definition: pngpriv.h:692
#define png_warning_parameter_unsigned(p, number, format, value)
Definition: pngpriv.h:463
#define png_app_error(pp, s)
Definition: pngpriv.h:1819
#define PNG_CHUNK_ERROR
Definition: pngpriv.h:1835
#define png_app_warning(pp, s)
Definition: pngpriv.h:1818
#define PNG_FLAG_BENIGN_ERRORS_WARN
Definition: pngpriv.h:690
#define png_warning_parameter_signed(p, number, format, value)
Definition: pngpriv.h:464
#define PNG_FLAG_APP_WARNINGS_WARN
Definition: pngpriv.h:691
#define PNG_IS_READ_STRUCT
Definition: pngpriv.h:630
#define PNG_FLAG_STRIP_ERROR_NUMBERS
Definition: pngpriv.h:688
#define PNG_ABORT()
Definition: pngpriv.h:555
#define PNG_FLAG_STRIP_ERROR_TEXT
Definition: pngpriv.h:689
#define png_warning_parameter(p, number, string)
Definition: pngpriv.h:462
#define png_voidcast(type, value)
Definition: pngpriv.h:500
#define png_formatted_warning(pp, p, message)
Definition: pngpriv.h:465
const WCHAR * str
Definition: tftpd.h:60
Definition: name.c:39
Definition: pdh_main.c:94