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 0 : 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 0 : if (png_ptr != NULL && png_ptr->error_fn != NULL)
98 0 : (*(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 0 : 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 0 : png_safecat(png_charp buffer, size_t bufsize, size_t pos,
111 : png_const_charp string)
112 : {
113 0 : if (buffer != NULL && pos < bufsize)
114 : {
115 0 : if (string != NULL)
116 0 : while (*string != '\0' && pos < bufsize-1)
117 0 : buffer[pos++] = *string++;
118 :
119 0 : buffer[pos] = '\0';
120 : }
121 :
122 0 : 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 141 : png_set_longjmp_fn(png_structp png_ptr, png_longjmp_ptr longjmp_fn,
502 : size_t jmp_buf_size)
503 : {
504 141 : if (png_ptr == NULL || jmp_buf_size != png_sizeof(jmp_buf))
505 0 : return NULL;
506 :
507 141 : png_ptr->longjmp_fn = longjmp_fn;
508 141 : 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 0 : 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 0 : png_longjmp(png_ptr, 1);
562 : }
563 :
564 0 : PNG_FUNCTION(void,PNGAPI
565 : png_longjmp,(png_structp png_ptr, int val),PNG_NORETURN)
566 : {
567 : #ifdef PNG_SETJMP_SUPPORTED
568 0 : 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 0 : 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 0 : 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 30 : 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 30 : if (png_ptr == NULL)
647 0 : return;
648 :
649 30 : png_ptr->error_ptr = error_ptr;
650 30 : 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 0 : png_get_error_ptr(png_const_structp png_ptr)
665 : {
666 0 : if (png_ptr == NULL)
667 0 : return NULL;
668 :
669 0 : 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 */
|