1
2 /* pngunknown.c - test the read side unknown chunk handling
3 *
4 * Copyright (c) 2021 Cosmin Truta
5 * Copyright (c) 2015,2017 Glenn Randers-Pehrson
6 * Written by John Cunningham Bowler
7 *
8 * This code is released under the libpng license.
9 * For conditions of distribution and use, see the disclaimer
10 * and license in png.h
11 *
12 * NOTES:
13 * This is a C program that is intended to be linked against libpng. It
14 * allows the libpng unknown handling code to be tested by interpreting
15 * arguments to save or discard combinations of chunks. The program is
16 * currently just a minimal validation for the built-in libpng facilities.
17 */
18
19 #include <stdlib.h>
20 #include <string.h>
21 #include <stdio.h>
22 #include <setjmp.h>
23
24 /* Define the following to use this test against your installed libpng, rather
25 * than the one being built here:
26 */
27 #ifdef PNG_FREESTANDING_TESTS
28 # include <png.h>
29 #else
30 # include "../../png.h"
31 #endif
32
33 /* 1.6.1 added support for the configure test harness, which uses 77 to indicate
34 * a skipped test, in earlier versions we need to succeed on a skipped test, so:
35 */
36 #if PNG_LIBPNG_VER >= 10601 && defined(HAVE_CONFIG_H)
37 # define SKIP 77
38 #else
39 # define SKIP 0
40 #endif
41
42
43 /* Since this program tests the ability to change the unknown chunk handling
44 * these must be defined:
45 */
46 #if defined(PNG_SET_UNKNOWN_CHUNKS_SUPPORTED) &&\
47 defined(PNG_STDIO_SUPPORTED) &&\
48 defined(PNG_READ_SUPPORTED)
49
50 /* One of these must be defined to allow us to find out what happened. It is
51 * still useful to set unknown chunk handling without either of these in order
52 * to cause *known* chunks to be discarded. This can be a significant
53 * efficiency gain, but it can't really be tested here.
54 */
55 #if defined(PNG_READ_USER_CHUNKS_SUPPORTED) ||\
56 defined(PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED)
57
58 #if PNG_LIBPNG_VER < 10500
59 /* This deliberately lacks the const. */
60 typedef png_byte *png_const_bytep;
61
62 /* This is copied from 1.5.1 png.h: */
63 #define PNG_INTERLACE_ADAM7_PASSES 7
64 #define PNG_PASS_START_ROW(pass) (((1U&~(pass))<<(3-((pass)>>1)))&7)
65 #define PNG_PASS_START_COL(pass) (((1U& (pass))<<(3-(((pass)+1)>>1)))&7)
66 #define PNG_PASS_ROW_SHIFT(pass) ((pass)>2?(8-(pass))>>1:3)
67 #define PNG_PASS_COL_SHIFT(pass) ((pass)>1?(7-(pass))>>1:3)
68 #define PNG_PASS_ROWS(height, pass) (((height)+(((1<<PNG_PASS_ROW_SHIFT(pass))\
69 -1)-PNG_PASS_START_ROW(pass)))>>PNG_PASS_ROW_SHIFT(pass))
70 #define PNG_PASS_COLS(width, pass) (((width)+(((1<<PNG_PASS_COL_SHIFT(pass))\
71 -1)-PNG_PASS_START_COL(pass)))>>PNG_PASS_COL_SHIFT(pass))
72 #define PNG_ROW_FROM_PASS_ROW(yIn, pass) \
73 (((yIn)<<PNG_PASS_ROW_SHIFT(pass))+PNG_PASS_START_ROW(pass))
74 #define PNG_COL_FROM_PASS_COL(xIn, pass) \
75 (((xIn)<<PNG_PASS_COL_SHIFT(pass))+PNG_PASS_START_COL(pass))
76 #define PNG_PASS_MASK(pass,off) ( \
77 ((0x110145AFU>>(((7-(off))-(pass))<<2)) & 0xFU) | \
78 ((0x01145AF0U>>(((7-(off))-(pass))<<2)) & 0xF0U))
79 #define PNG_ROW_IN_INTERLACE_PASS(y, pass) \
80 ((PNG_PASS_MASK(pass,0) >> ((y)&7)) & 1)
81 #define PNG_COL_IN_INTERLACE_PASS(x, pass) \
82 ((PNG_PASS_MASK(pass,1) >> ((x)&7)) & 1)
83
84 /* These are needed too for the default build: */
85 #define PNG_WRITE_16BIT_SUPPORTED
86 #define PNG_READ_16BIT_SUPPORTED
87
88 /* This comes from pnglibconf.h after 1.5: */
89 #define PNG_FP_1 100000
90 #define PNG_GAMMA_THRESHOLD_FIXED\
91 ((png_fixed_point)(PNG_GAMMA_THRESHOLD * PNG_FP_1))
92 #endif
93
94 #if PNG_LIBPNG_VER < 10600
95 /* 1.6.0 constifies many APIs. The following exists to allow pngvalid to be
96 * compiled against earlier versions.
97 */
98 # define png_const_structp png_structp
99 #endif
100
101 #if PNG_LIBPNG_VER < 10700
102 /* Copied from libpng 1.7.0 png.h */
103 #define PNG_u2(b1, b2) (((unsigned int)(b1) << 8) + (b2))
104
105 #define PNG_U16(b1, b2) ((png_uint_16)PNG_u2(b1, b2))
106 #define PNG_U32(b1, b2, b3, b4)\
107 (((png_uint_32)PNG_u2(b1, b2) << 16) + PNG_u2(b3, b4))
108
109 /* Constants for known chunk types.
110 */
111 #define png_IDAT PNG_U32( 73, 68, 65, 84)
112 #define png_IEND PNG_U32( 73, 69, 78, 68)
113 #define png_IHDR PNG_U32( 73, 72, 68, 82)
114 #define png_PLTE PNG_U32( 80, 76, 84, 69)
115 #define png_bKGD PNG_U32( 98, 75, 71, 68)
116 #define png_cHRM PNG_U32( 99, 72, 82, 77)
117 #define png_eXIf PNG_U32(101, 88, 73, 102) /* registered July 2017 */
118 #define png_fRAc PNG_U32(102, 82, 65, 99) /* registered, not defined */
119 #define png_gAMA PNG_U32(103, 65, 77, 65)
120 #define png_gIFg PNG_U32(103, 73, 70, 103)
121 #define png_gIFt PNG_U32(103, 73, 70, 116) /* deprecated */
122 #define png_gIFx PNG_U32(103, 73, 70, 120)
123 #define png_hIST PNG_U32(104, 73, 83, 84)
124 #define png_iCCP PNG_U32(105, 67, 67, 80)
125 #define png_iTXt PNG_U32(105, 84, 88, 116)
126 #define png_oFFs PNG_U32(111, 70, 70, 115)
127 #define png_pCAL PNG_U32(112, 67, 65, 76)
128 #define png_pHYs PNG_U32(112, 72, 89, 115)
129 #define png_sBIT PNG_U32(115, 66, 73, 84)
130 #define png_sCAL PNG_U32(115, 67, 65, 76)
131 #define png_sPLT PNG_U32(115, 80, 76, 84)
132 #define png_sRGB PNG_U32(115, 82, 71, 66)
133 #define png_sTER PNG_U32(115, 84, 69, 82)
134 #define png_tEXt PNG_U32(116, 69, 88, 116)
135 #define png_tIME PNG_U32(116, 73, 77, 69)
136 #define png_tRNS PNG_U32(116, 82, 78, 83)
137 #define png_zTXt PNG_U32(122, 84, 88, 116)
138
139 /* Test on flag values as defined in the spec (section 5.4): */
140 #define PNG_CHUNK_ANCILLARY(c) (1 & ((c) >> 29))
141 #define PNG_CHUNK_CRITICAL(c) (!PNG_CHUNK_ANCILLARY(c))
142 #define PNG_CHUNK_PRIVATE(c) (1 & ((c) >> 21))
143 #define PNG_CHUNK_RESERVED(c) (1 & ((c) >> 13))
144 #define PNG_CHUNK_SAFE_TO_COPY(c) (1 & ((c) >> 5))
145
146 #endif /* PNG_LIBPNG_VER < 10700 */
147
148 #ifdef __cplusplus
149 # define this not_the_cpp_this
150 # define new not_the_cpp_new
151 # define voidcast(type, value) static_cast<type>(value)
152 #else
153 # define voidcast(type, value) (value)
154 #endif /* __cplusplus */
155
156 /* Unused formal parameter errors are removed using the following macro which is
157 * expected to have no bad effects on performance.
158 */
159 #ifndef UNUSED
160 # if defined(__GNUC__) || defined(_MSC_VER)
161 # define UNUSED(param) (void)param;
162 # else
163 # define UNUSED(param)
164 # endif
165 #endif
166
167 /* Types of chunks not known to libpng */
168 #define png_vpAg PNG_U32(118, 112, 65, 103)
169
170 /* Chunk information */
171 #define PNG_INFO_tEXt 0x10000000U
172 #define PNG_INFO_iTXt 0x20000000U
173 #define PNG_INFO_zTXt 0x40000000U
174
175 #define PNG_INFO_sTER 0x01000000U
176 #define PNG_INFO_vpAg 0x02000000U
177
178 #define ABSENT 0
179 #define START 1
180 #define END 2
181
182 static struct
183 {
184 char name[5];
185 png_uint_32 flag;
186 png_uint_32 tag;
187 int unknown; /* Chunk not known to libpng */
188 int all; /* Chunk set by the '-1' option */
189 int position; /* position in pngtest.png */
190 int keep; /* unknown handling setting */
191 } chunk_info[] = {
192 /* Critical chunks */
193 { "IDAT", PNG_INFO_IDAT, png_IDAT, 0, 0, START, 0 }, /* must be [0] */
194 { "PLTE", PNG_INFO_PLTE, png_PLTE, 0, 0, ABSENT, 0 },
195
196 /* Non-critical chunks that libpng handles */
197 /* This is a mess but it seems to be the only way to do it - there is no way
198 * to check for a definition outside a #if.
199 */
200 { "bKGD", PNG_INFO_bKGD, png_bKGD,
201 # ifdef PNG_READ_bKGD_SUPPORTED
202 0,
203 # else
204 1,
205 # endif
206 1, START, 0 },
207 { "cHRM", PNG_INFO_cHRM, png_cHRM,
208 # ifdef PNG_READ_cHRM_SUPPORTED
209 0,
210 # else
211 1,
212 # endif
213 1, START, 0 },
214 { "eXIf", PNG_INFO_eXIf, png_eXIf,
215 # ifdef PNG_READ_eXIf_SUPPORTED
216 0,
217 # else
218 1,
219 # endif
220 1, END, 0 },
221 { "gAMA", PNG_INFO_gAMA, png_gAMA,
222 # ifdef PNG_READ_gAMA_SUPPORTED
223 0,
224 # else
225 1,
226 # endif
227 1, START, 0 },
228 { "hIST", PNG_INFO_hIST, png_hIST,
229 # ifdef PNG_READ_hIST_SUPPORTED
230 0,
231 # else
232 1,
233 # endif
234 1, ABSENT, 0 },
235 { "iCCP", PNG_INFO_iCCP, png_iCCP,
236 # ifdef PNG_READ_iCCP_SUPPORTED
237 0,
238 # else
239 1,
240 # endif
241 1, ABSENT, 0 },
242 { "iTXt", PNG_INFO_iTXt, png_iTXt,
243 # ifdef PNG_READ_iTXt_SUPPORTED
244 0,
245 # else
246 1,
247 # endif
248 1, ABSENT, 0 },
249 { "oFFs", PNG_INFO_oFFs, png_oFFs,
250 # ifdef PNG_READ_oFFs_SUPPORTED
251 0,
252 # else
253 1,
254 # endif
255 1, START, 0 },
256 { "pCAL", PNG_INFO_pCAL, png_pCAL,
257 # ifdef PNG_READ_pCAL_SUPPORTED
258 0,
259 # else
260 1,
261 # endif
262 1, START, 0 },
263 { "pHYs", PNG_INFO_pHYs, png_pHYs,
264 # ifdef PNG_READ_pHYs_SUPPORTED
265 0,
266 # else
267 1,
268 # endif
269 1, START, 0 },
270 { "sBIT", PNG_INFO_sBIT, png_sBIT,
271 # ifdef PNG_READ_sBIT_SUPPORTED
272 0,
273 # else
274 1,
275 # endif
276 1, START, 0 },
277 { "sCAL", PNG_INFO_sCAL, png_sCAL,
278 # ifdef PNG_READ_sCAL_SUPPORTED
279 0,
280 # else
281 1,
282 # endif
283 1, START, 0 },
284 { "sPLT", PNG_INFO_sPLT, png_sPLT,
285 # ifdef PNG_READ_sPLT_SUPPORTED
286 0,
287 # else
288 1,
289 # endif
290 1, ABSENT, 0 },
291 { "sRGB", PNG_INFO_sRGB, png_sRGB,
292 # ifdef PNG_READ_sRGB_SUPPORTED
293 0,
294 # else
295 1,
296 # endif
297 1, START, 0 },
298 { "tEXt", PNG_INFO_tEXt, png_tEXt,
299 # ifdef PNG_READ_tEXt_SUPPORTED
300 0,
301 # else
302 1,
303 # endif
304 1, START, 0 },
305 { "tIME", PNG_INFO_tIME, png_tIME,
306 # ifdef PNG_READ_tIME_SUPPORTED
307 0,
308 # else
309 1,
310 # endif
311 1, START, 0 },
312 { "tRNS", PNG_INFO_tRNS, png_tRNS,
313 # ifdef PNG_READ_tRNS_SUPPORTED
314 0,
315 # else
316 1,
317 # endif
318 0, ABSENT, 0 },
319 { "zTXt", PNG_INFO_zTXt, png_zTXt,
320 # ifdef PNG_READ_zTXt_SUPPORTED
321 0,
322 # else
323 1,
324 # endif
325 1, END, 0 },
326
327 /* No libpng handling */
328 { "sTER", PNG_INFO_sTER, png_sTER, 1, 1, START, 0 },
329 { "vpAg", PNG_INFO_vpAg, png_vpAg, 1, 0, START, 0 },
330 };
331
332 #define NINFO ((int)((sizeof chunk_info)/(sizeof chunk_info[0])))
333
334 static void
335 clear_keep(void)
336 {
337 int i = NINFO;
338 while (--i >= 0)
339 chunk_info[i].keep = 0;
340 }
341
342 static int
343 find(const char *name)
344 {
345 int i = NINFO;
346 while (--i >= 0)
347 {
348 if (memcmp(chunk_info[i].name, name, 4) == 0)
349 break;
350 }
351
352 return i;
353 }
354
355 static int
356 findb(const png_byte *name)
357 {
358 int i = NINFO;
359 while (--i >= 0)
360 {
361 if (memcmp(chunk_info[i].name, name, 4) == 0)
362 break;
363 }
364
365 return i;
366 }
367
368 static int
369 find_by_flag(png_uint_32 flag)
370 {
371 int i = NINFO;
372
373 while (--i >= 0)
374 if (chunk_info[i].flag == flag)
375 return i;
376
377 fprintf(stderr, "pngunknown: internal error\n");
378 exit(4);
379 }
380
381 static int
382 ancillary(const char *name)
383 {
384 return PNG_CHUNK_ANCILLARY(PNG_U32(name[0], name[1], name[2], name[3]));
385 }
386
387 #ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
388 static int
389 ancillaryb(const png_byte *name)
390 {
391 return PNG_CHUNK_ANCILLARY(PNG_U32(name[0], name[1], name[2], name[3]));
392 }
393 #endif
394
395 /* Type of an error_ptr */
396 typedef struct
397 {
398 jmp_buf error_return;
399 png_structp png_ptr;
400 png_infop info_ptr, end_ptr;
401 png_uint_32 before_IDAT;
402 png_uint_32 after_IDAT;
403 int error_count;
404 int warning_count;
405 int keep; /* the default value */
406 const char *program;
407 const char *file;
408 const char *test;
409 } display;
410
411 static const char init[] = "initialization";
412 static const char cmd[] = "command line";
413
414 static void
415 init_display(display *d, const char *program)
416 {
417 memset(d, 0, sizeof *d);
418 d->png_ptr = NULL;
419 d->info_ptr = d->end_ptr = NULL;
420 d->error_count = d->warning_count = 0;
421 d->program = program;
422 d->file = program;
423 d->test = init;
424 }
425
426 static void
427 clean_display(display *d)
428 {
429 png_destroy_read_struct(&d->png_ptr, &d->info_ptr, &d->end_ptr);
430
431 /* This must not happen - it might cause an app crash */
432 if (d->png_ptr != NULL || d->info_ptr != NULL || d->end_ptr != NULL)
433 {
434 fprintf(stderr, "%s(%s): png_destroy_read_struct error\n", d->file,
435 d->test);
436 exit(1);
437 }
438 }
439
440 PNG_FUNCTION(void, display_exit, (display *d), static PNG_NORETURN)
441 {
442 ++(d->error_count);
443
444 if (d->png_ptr != NULL)
445 clean_display(d);
446
447 /* During initialization and if this is a single command line argument set
448 * exit now - there is only one test, otherwise longjmp to do the next test.
449 */
450 if (d->test == init || d->test == cmd)
451 exit(1);
452
453 longjmp(d->error_return, 1);
454 }
455
456 static int
457 display_rc(const display *d, int strict)
458 {
459 return d->error_count + (strict ? d->warning_count : 0);
460 }
461
462 /* libpng error and warning callbacks */
463 PNG_FUNCTION(void, (PNGCBAPI error), (png_structp png_ptr, const char *message),
464 static PNG_NORETURN)
465 {
466 display *d = (display*)png_get_error_ptr(png_ptr);
467
468 fprintf(stderr, "%s(%s): libpng error: %s\n", d->file, d->test, message);
469 display_exit(d);
470 }
471
472 static void PNGCBAPI
473 warning(png_structp png_ptr, const char *message)
474 {
475 display *d = (display*)png_get_error_ptr(png_ptr);
476
477 fprintf(stderr, "%s(%s): libpng warning: %s\n", d->file, d->test, message);
478 ++(d->warning_count);
479 }
480
481 static png_uint_32
482 get_valid(display *d, png_infop info_ptr)
483 {
484 png_uint_32 flags = png_get_valid(d->png_ptr, info_ptr, (png_uint_32)~0);
485
486 /* Map the text chunks back into the flags */
487 {
488 png_textp text;
489 png_uint_32 ntext = png_get_text(d->png_ptr, info_ptr, &text, NULL);
490
491 while (ntext > 0) switch (text[--ntext].compression)
492 {
493 case -1:
494 flags |= PNG_INFO_tEXt;
495 break;
496 case 0:
497 flags |= PNG_INFO_zTXt;
498 break;
499 case 1:
500 case 2:
501 flags |= PNG_INFO_iTXt;
502 break;
503 default:
504 fprintf(stderr, "%s(%s): unknown text compression %d\n", d->file,
505 d->test, text[ntext].compression);
506 display_exit(d);
507 }
508 }
509
510 return flags;
511 }
512
513 #ifdef PNG_READ_USER_CHUNKS_SUPPORTED
514 static int PNGCBAPI
515 read_callback(png_structp pp, png_unknown_chunkp pc)
516 {
517 /* This function mimics the behavior of png_set_keep_unknown_chunks by
518 * returning '0' to keep the chunk and '1' to discard it.
519 */
520 display *d = voidcast(display*, png_get_user_chunk_ptr(pp));
521 int chunk = findb(pc->name);
522 int keep, discard;
523
524 if (chunk < 0) /* not one in our list, so not a known chunk */
525 keep = d->keep;
526
527 else
528 {
529 keep = chunk_info[chunk].keep;
530 if (keep == PNG_HANDLE_CHUNK_AS_DEFAULT)
531 {
532 /* See the comments in png.h - use the default for unknown chunks,
533 * do not keep known chunks.
534 */
535 if (chunk_info[chunk].unknown)
536 keep = d->keep;
537
538 else
539 keep = PNG_HANDLE_CHUNK_NEVER;
540 }
541 }
542
543 switch (keep)
544 {
545 default:
546 fprintf(stderr, "%s(%s): %d: unrecognized chunk option\n", d->file,
547 d->test, chunk_info[chunk].keep);
548 display_exit(d);
549
550 case PNG_HANDLE_CHUNK_AS_DEFAULT:
551 case PNG_HANDLE_CHUNK_NEVER:
552 discard = 1; /*handled; discard*/
553 break;
554
555 case PNG_HANDLE_CHUNK_IF_SAFE:
556 case PNG_HANDLE_CHUNK_ALWAYS:
557 discard = 0; /*not handled; keep*/
558 break;
559 }
560
561 /* Also store information about this chunk in the display, the relevant flag
562 * is set if the chunk is to be kept ('not handled'.)
563 */
564 if (chunk >= 0)
565 {
566 if (!discard) /* stupidity to stop a GCC warning */
567 {
568 png_uint_32 flag = chunk_info[chunk].flag;
569
570 if (pc->location & PNG_AFTER_IDAT)
571 d->after_IDAT |= flag;
572
573 else
574 d->before_IDAT |= flag;
575 }
576 }
577
578 /* However if there is no support to store unknown chunks don't ask libpng to
579 * do it; there will be an png_error.
580 */
581 # ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
582 return discard;
583 # else
584 return 1; /*handled; discard*/
585 # endif
586 }
587 #endif /* READ_USER_CHUNKS_SUPPORTED */
588
589 #ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
590 static png_uint_32
591 get_unknown(display *d, png_infop info_ptr, int after_IDAT)
592 {
593 /* Create corresponding 'unknown' flags */
594 png_uint_32 flags = 0;
595
596 UNUSED(after_IDAT)
597
598 {
599 png_unknown_chunkp unknown;
600 int num_unknown = png_get_unknown_chunks(d->png_ptr, info_ptr, &unknown);
601
602 while (--num_unknown >= 0)
603 {
604 int chunk = findb(unknown[num_unknown].name);
605
606 /* Chunks not known to pngunknown must be validated here; since they
607 * must also be unknown to libpng the 'display->keep' behavior should
608 * have been used.
609 */
610 if (chunk < 0) switch (d->keep)
611 {
612 default: /* impossible */
613 case PNG_HANDLE_CHUNK_AS_DEFAULT:
614 case PNG_HANDLE_CHUNK_NEVER:
615 fprintf(stderr, "%s(%s): %s: %s: unknown chunk saved\n",
616 d->file, d->test, d->keep ? "discard" : "default",
617 unknown[num_unknown].name);
618 ++(d->error_count);
619 break;
620
621 case PNG_HANDLE_CHUNK_IF_SAFE:
622 if (!ancillaryb(unknown[num_unknown].name))
623 {
624 fprintf(stderr,
625 "%s(%s): if-safe: %s: unknown critical chunk saved\n",
626 d->file, d->test, unknown[num_unknown].name);
627 ++(d->error_count);
628 break;
629 }
630 /* FALLTHROUGH */ /* (safe) */
631 case PNG_HANDLE_CHUNK_ALWAYS:
632 break;
633 }
634
635 else
636 flags |= chunk_info[chunk].flag;
637 }
638 }
639
640 return flags;
641 }
642 #else /* SAVE_UNKNOWN_CHUNKS */
643 static png_uint_32
644 get_unknown(display *d, png_infop info_ptr, int after_IDAT)
645 /* Otherwise this will return the cached values set by any user callback */
646 {
647 UNUSED(info_ptr);
648
649 if (after_IDAT)
650 return d->after_IDAT;
651
652 else
653 return d->before_IDAT;
654 }
655
656 # ifndef PNG_READ_USER_CHUNKS_SUPPORTED
657 /* The #defines above should mean this is never reached, it's just here as
658 * a check to ensure the logic is correct.
659 */
660 # error No store support and no user chunk support, this will not work
661 # endif /* READ_USER_CHUNKS */
662 #endif /* SAVE_UNKNOWN_CHUNKS */
663
664 static int
665 check(FILE *fp, int argc, const char **argv, png_uint_32p flags/*out*/,
666 display *d, int set_callback)
667 {
668 int i, npasses, ipass;
669 png_uint_32 height;
670
671 d->keep = PNG_HANDLE_CHUNK_AS_DEFAULT;
672 d->before_IDAT = 0;
673 d->after_IDAT = 0;
674
675 /* Some of these errors are permanently fatal and cause an exit here, others
676 * are per-test and cause an error return.
677 */
678 d->png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, d, error,
679 warning);
680 if (d->png_ptr == NULL)
681 {
682 fprintf(stderr, "%s(%s): could not allocate png struct\n", d->file,
683 d->test);
684 /* Terminate here, this error is not test specific. */
685 exit(1);
686 }
687
688 d->info_ptr = png_create_info_struct(d->png_ptr);
689 d->end_ptr = png_create_info_struct(d->png_ptr);
690 if (d->info_ptr == NULL || d->end_ptr == NULL)
691 {
692 fprintf(stderr, "%s(%s): could not allocate png info\n", d->file,
693 d->test);
694 clean_display(d);
695 exit(1);
696 }
697
698 png_init_io(d->png_ptr, fp);
699
700 # ifdef PNG_READ_USER_CHUNKS_SUPPORTED
701 /* This is only done if requested by the caller; it interferes with the
702 * standard store/save mechanism.
703 */
704 if (set_callback)
705 png_set_read_user_chunk_fn(d->png_ptr, d, read_callback);
706 # else
707 UNUSED(set_callback)
708 # endif
709
710 /* Handle each argument in turn; multiple settings are possible for the same
711 * chunk and multiple calls will occur (the last one should override all
712 * preceding ones).
713 */
714 for (i=0; i<argc; ++i)
715 {
716 const char *equals = strchr(argv[i], '=');
717
718 if (equals != NULL)
719 {
720 int chunk, option;
721
722 if (strcmp(equals+1, "default") == 0)
723 option = PNG_HANDLE_CHUNK_AS_DEFAULT;
724 else if (strcmp(equals+1, "discard") == 0)
725 option = PNG_HANDLE_CHUNK_NEVER;
726 else if (strcmp(equals+1, "if-safe") == 0)
727 option = PNG_HANDLE_CHUNK_IF_SAFE;
728 else if (strcmp(equals+1, "save") == 0)
729 option = PNG_HANDLE_CHUNK_ALWAYS;
730 else
731 {
732 fprintf(stderr, "%s(%s): %s: unrecognized chunk option\n", d->file,
733 d->test, argv[i]);
734 display_exit(d);
735 }
736
737 switch (equals - argv[i])
738 {
739 case 4: /* chunk name */
740 chunk = find(argv[i]);
741
742 if (chunk >= 0)
743 {
744 /* These #if tests have the effect of skipping the arguments
745 * if SAVE support is unavailable - we can't do a useful test
746 * in this case, so we just check the arguments! This could
747 * be improved in the future by using the read callback.
748 */
749 # if PNG_LIBPNG_VER >= 10700 &&\
750 !defined(PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED)
751 if (option < PNG_HANDLE_CHUNK_IF_SAFE)
752 # endif /* 1.7+ SAVE_UNKNOWN_CHUNKS */
753 {
754 png_byte name[5];
755
756 memcpy(name, chunk_info[chunk].name, 5);
757 png_set_keep_unknown_chunks(d->png_ptr, option, name, 1);
758 chunk_info[chunk].keep = option;
759 }
760 continue;
761 }
762
763 break;
764
765 case 7: /* default */
766 if (memcmp(argv[i], "default", 7) == 0)
767 {
768 # if PNG_LIBPNG_VER >= 10700 &&\
769 !defined(PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED)
770 if (option < PNG_HANDLE_CHUNK_IF_SAFE)
771 # endif /* 1.7+ SAVE_UNKNOWN_CHUNKS */
772 png_set_keep_unknown_chunks(d->png_ptr, option, NULL, 0);
773
774 d->keep = option;
775 continue;
776 }
777
778 break;
779
780 case 3: /* all */
781 if (memcmp(argv[i], "all", 3) == 0)
782 {
783 # if PNG_LIBPNG_VER >= 10700 &&\
784 !defined(PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED)
785 if (option < PNG_HANDLE_CHUNK_IF_SAFE)
786 # endif /* 1.7+ SAVE_UNKNOWN_CHUNKS */
787 png_set_keep_unknown_chunks(d->png_ptr, option, NULL, -1);
788
789 d->keep = option;
790
791 for (chunk = 0; chunk < NINFO; ++chunk)
792 if (chunk_info[chunk].all)
793 chunk_info[chunk].keep = option;
794 continue;
795 }
796
797 break;
798
799 default: /* some misplaced = */
800
801 break;
802 }
803 }
804
805 fprintf(stderr, "%s(%s): %s: unrecognized chunk argument\n", d->file,
806 d->test, argv[i]);
807 display_exit(d);
808 }
809
810 png_read_info(d->png_ptr, d->info_ptr);
811
812 switch (png_get_interlace_type(d->png_ptr, d->info_ptr))
813 {
814 case PNG_INTERLACE_NONE:
815 npasses = 1;
816 break;
817
818 case PNG_INTERLACE_ADAM7:
819 npasses = PNG_INTERLACE_ADAM7_PASSES;
820 break;
821
822 default:
823 /* Hard error because it is not test specific */
824 fprintf(stderr, "%s(%s): invalid interlace type\n", d->file, d->test);
825 clean_display(d);
826 exit(1);
827 }
828
829 /* Skip the image data, if IDAT is not being handled then don't do this
830 * because it will cause a CRC error.
831 */
832 if (chunk_info[0/*IDAT*/].keep == PNG_HANDLE_CHUNK_AS_DEFAULT)
833 {
834 png_start_read_image(d->png_ptr);
835 height = png_get_image_height(d->png_ptr, d->info_ptr);
836
837 if (npasses > 1)
838 {
839 png_uint_32 width = png_get_image_width(d->png_ptr, d->info_ptr);
840
841 for (ipass=0; ipass<npasses; ++ipass)
842 {
843 png_uint_32 wPass = PNG_PASS_COLS(width, ipass);
844
845 if (wPass > 0)
846 {
847 png_uint_32 y;
848
849 for (y=0; y<height; ++y)
850 if (PNG_ROW_IN_INTERLACE_PASS(y, ipass))
851 png_read_row(d->png_ptr, NULL, NULL);
852 }
853 }
854 } /* interlaced */
855
856 else /* not interlaced */
857 {
858 png_uint_32 y;
859
860 for (y=0; y<height; ++y)
861 png_read_row(d->png_ptr, NULL, NULL);
862 }
863 }
864
865 png_read_end(d->png_ptr, d->end_ptr);
866
867 flags[0] = get_valid(d, d->info_ptr);
868 flags[1] = get_unknown(d, d->info_ptr, 0/*before IDAT*/);
869
870 /* Only png_read_png sets PNG_INFO_IDAT! */
871 flags[chunk_info[0/*IDAT*/].keep != PNG_HANDLE_CHUNK_AS_DEFAULT] |=
872 PNG_INFO_IDAT;
873
874 flags[2] = get_valid(d, d->end_ptr);
875 flags[3] = get_unknown(d, d->end_ptr, 1/*after IDAT*/);
876
877 clean_display(d);
878
879 return d->keep;
880 }
881
882 static void
883 check_error(display *d, png_uint_32 flags, const char *message)
884 {
885 while (flags)
886 {
887 png_uint_32 flag = flags & -(png_int_32)flags;
888 int i = find_by_flag(flag);
889
890 fprintf(stderr, "%s(%s): chunk %s: %s\n", d->file, d->test,
891 chunk_info[i].name, message);
892 ++(d->error_count);
893
894 flags &= ~flag;
895 }
896 }
897
898 static void
899 check_handling(display *d, int def, png_uint_32 chunks, png_uint_32 known,
900 png_uint_32 unknown, const char *position, int set_callback)
901 {
902 while (chunks)
903 {
904 png_uint_32 flag = chunks & -(png_int_32)chunks;
905 int i = find_by_flag(flag);
906 int keep = chunk_info[i].keep;
907 const char *type;
908 const char *errorx = NULL;
909
910 if (chunk_info[i].unknown)
911 {
912 if (keep == PNG_HANDLE_CHUNK_AS_DEFAULT)
913 {
914 type = "UNKNOWN (default)";
915 keep = def;
916 }
917
918 else
919 type = "UNKNOWN (specified)";
920
921 if (flag & known)
922 errorx = "chunk processed";
923
924 else switch (keep)
925 {
926 case PNG_HANDLE_CHUNK_AS_DEFAULT:
927 if (flag & unknown)
928 errorx = "DEFAULT: unknown chunk saved";
929 break;
930
931 case PNG_HANDLE_CHUNK_NEVER:
932 if (flag & unknown)
933 errorx = "DISCARD: unknown chunk saved";
934 break;
935
936 case PNG_HANDLE_CHUNK_IF_SAFE:
937 if (ancillary(chunk_info[i].name))
938 {
939 if (!(flag & unknown))
940 errorx = "IF-SAFE: unknown ancillary chunk lost";
941 }
942
943 else if (flag & unknown)
944 errorx = "IF-SAFE: unknown critical chunk saved";
945 break;
946
947 case PNG_HANDLE_CHUNK_ALWAYS:
948 if (!(flag & unknown))
949 errorx = "SAVE: unknown chunk lost";
950 break;
951
952 default:
953 errorx = "internal error: bad keep";
954 break;
955 }
956 } /* unknown chunk */
957
958 else /* known chunk */
959 {
960 type = "KNOWN";
961
962 if (flag & known)
963 {
964 /* chunk was processed, it won't have been saved because that is
965 * caught below when checking for inconsistent processing.
966 */
967 if (keep != PNG_HANDLE_CHUNK_AS_DEFAULT)
968 errorx = "!DEFAULT: known chunk processed";
969 }
970
971 else /* not processed */ switch (keep)
972 {
973 case PNG_HANDLE_CHUNK_AS_DEFAULT:
974 errorx = "DEFAULT: known chunk not processed";
975 break;
976
977 case PNG_HANDLE_CHUNK_NEVER:
978 if (flag & unknown)
979 errorx = "DISCARD: known chunk saved";
980 break;
981
982 case PNG_HANDLE_CHUNK_IF_SAFE:
983 if (ancillary(chunk_info[i].name))
984 {
985 if (!(flag & unknown))
986 errorx = "IF-SAFE: known ancillary chunk lost";
987 }
988
989 else if (flag & unknown)
990 errorx = "IF-SAFE: known critical chunk saved";
991 break;
992
993 case PNG_HANDLE_CHUNK_ALWAYS:
994 if (!(flag & unknown))
995 errorx = "SAVE: known chunk lost";
996 break;
997
998 default:
999 errorx = "internal error: bad keep (2)";
1000 break;
1001 }
1002 }
1003
1004 if (errorx != NULL)
1005 {
1006 ++(d->error_count);
1007 fprintf(stderr, "%s(%s%s): %s %s %s: %s\n", d->file, d->test,
1008 set_callback ? ",callback" : "",
1009 type, chunk_info[i].name, position, errorx);
1010 }
1011
1012 chunks &= ~flag;
1013 }
1014 }
1015
1016 static void
1017 perform_one_test(FILE *fp, int argc, const char **argv,
1018 png_uint_32 *default_flags, display *d, int set_callback)
1019 {
1020 int def;
1021 png_uint_32 flags[2][4];
1022
1023 rewind(fp);
1024 clear_keep();
1025 memcpy(flags[0], default_flags, sizeof flags[0]);
1026
1027 def = check(fp, argc, argv, flags[1], d, set_callback);
1028
1029 /* If IDAT is being handled as unknown the image read is skipped and all the
1030 * IDATs after the first end up in the end info struct, so in this case add
1031 * IDAT to the list of unknowns. (Do this after 'check' above sets the
1032 * chunk_info 'keep' fields.)
1033 *
1034 * Note that the flag setting has to be in the 'known' field to avoid
1035 * triggering the consistency check below and the flag must only be set if
1036 * there are multiple IDATs, so if the check above did find an unknown IDAT
1037 * after IDAT.
1038 */
1039 if (chunk_info[0/*IDAT*/].keep != PNG_HANDLE_CHUNK_AS_DEFAULT &&
1040 (flags[1][3] & PNG_INFO_IDAT) != 0)
1041 flags[0][2] |= PNG_INFO_IDAT;
1042
1043 /* Chunks should either be known or unknown, never both and this should apply
1044 * whether the chunk is before or after the IDAT (actually, the app can
1045 * probably change this by swapping the handling after the image, but this
1046 * test does not do that.)
1047 */
1048 check_error(d, (flags[0][0]|flags[0][2]) & (flags[0][1]|flags[0][3]),
1049 "chunk handled inconsistently in count tests");
1050 check_error(d, (flags[1][0]|flags[1][2]) & (flags[1][1]|flags[1][3]),
1051 "chunk handled inconsistently in option tests");
1052
1053 /* Now find out what happened to each chunk before and after the IDAT and
1054 * determine if the behavior was correct. First some basic sanity checks,
1055 * any known chunk should be known in the original count, any unknown chunk
1056 * should be either known or unknown in the original.
1057 */
1058 {
1059 png_uint_32 test;
1060
1061 test = flags[1][0] & ~flags[0][0];
1062 check_error(d, test, "new known chunk before IDAT");
1063 test = flags[1][1] & ~(flags[0][0] | flags[0][1]);
1064 check_error(d, test, "new unknown chunk before IDAT");
1065 test = flags[1][2] & ~flags[0][2];
1066 check_error(d, test, "new known chunk after IDAT");
1067 test = flags[1][3] & ~(flags[0][2] | flags[0][3]);
1068 check_error(d, test, "new unknown chunk after IDAT");
1069 }
1070
1071 /* Now each chunk in the original list should have been handled according to
1072 * the options set for that chunk, regardless of whether libpng knows about
1073 * it or not.
1074 */
1075 check_handling(d, def, flags[0][0] | flags[0][1], flags[1][0], flags[1][1],
1076 "before IDAT", set_callback);
1077 check_handling(d, def, flags[0][2] | flags[0][3], flags[1][2], flags[1][3],
1078 "after IDAT", set_callback);
1079 }
1080
1081 static void
1082 perform_one_test_safe(FILE *fp, int argc, const char **argv,
1083 png_uint_32 *default_flags, display *d, const char *test)
1084 {
1085 if (setjmp(d->error_return) == 0)
1086 {
1087 d->test = test; /* allow use of d->error_return */
1088 # ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
1089 perform_one_test(fp, argc, argv, default_flags, d, 0);
1090 # endif
1091 # ifdef PNG_READ_USER_CHUNKS_SUPPORTED
1092 perform_one_test(fp, argc, argv, default_flags, d, 1);
1093 # endif
1094 d->test = init; /* prevent use of d->error_return */
1095 }
1096 }
1097
1098 static const char *standard_tests[] =
1099 {
1100 "discard", "default=discard", NULL,
1101 "save", "default=save", NULL,
1102 "if-safe", "default=if-safe", NULL,
1103 "vpAg", "vpAg=if-safe", NULL,
1104 "sTER", "sTER=if-safe", NULL,
1105 "IDAT", "default=discard", "IDAT=save", NULL,
1106 "sAPI", "bKGD=save", "cHRM=save", "gAMA=save", "all=discard", "iCCP=save",
1107 "sBIT=save", "sRGB=save", "eXIf=save", NULL,
1108 NULL /*end*/
1109 };
1110
1111 static PNG_NORETURN void
1112 usage(const char *program, const char *reason)
1113 {
1114 fprintf(stderr, "pngunknown: %s: usage:\n %s [--strict] "
1115 "--default|{(CHNK|default|all)=(default|discard|if-safe|save)} "
1116 "testfile.png\n", reason, program);
1117 exit(99);
1118 }
1119
1120 int
1121 main(int argc, const char **argv)
1122 {
1123 FILE *fp;
1124 png_uint_32 default_flags[4]; /*valid,unknown{before,after}*/
1125 int strict = 0, default_tests = 0;
1126 const char *count_argv = "default=save";
1127 const char *touch_file = NULL;
1128 display d;
1129
1130 init_display(&d, argv[0]);
1131
1132 while (++argv, --argc > 0)
1133 {
1134 if (strcmp(*argv, "--strict") == 0)
1135 strict = 1;
1136
1137 else if (strcmp(*argv, "--default") == 0)
1138 default_tests = 1;
1139
1140 else if (strcmp(*argv, "--touch") == 0)
1141 {
1142 if (argc > 1)
1143 touch_file = *++argv, --argc;
1144
1145 else
1146 usage(d.program, "--touch: missing file name");
1147 }
1148
1149 else
1150 break;
1151 }
1152
1153 /* A file name is required, but there should be no other arguments if
1154 * --default was specified.
1155 */
1156 if (argc <= 0)
1157 usage(d.program, "missing test file");
1158
1159 /* GCC BUG: if (default_tests && argc != 1) triggers some weird GCC argc
1160 * optimization which causes warnings with -Wstrict-overflow!
1161 */
1162 else if (default_tests)
1163 if (argc != 1)
1164 usage(d.program, "extra arguments");
1165
1166 /* The name of the test file is the last argument; remove it. */
1167 d.file = argv[--argc];
1168
1169 fp = fopen(d.file, "rb");
1170 if (fp == NULL)
1171 {
1172 perror(d.file);
1173 exit(99);
1174 }
1175
1176 /* First find all the chunks, known and unknown, in the test file, a failure
1177 * here aborts the whole test.
1178 *
1179 * If 'save' is supported then the normal saving method should happen,
1180 * otherwise if 'read' is supported then the read callback will do the
1181 * same thing. If both are supported the 'read' callback won't be
1182 * instantiated by default. If 'save' is *not* supported then a user
1183 * callback is required even though we can call png_get_unknown_chunks.
1184 */
1185 if (check(fp, 1, &count_argv, default_flags, &d,
1186 # ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
1187 0
1188 # else
1189 1
1190 # endif
1191 ) != PNG_HANDLE_CHUNK_ALWAYS)
1192 {
1193 fprintf(stderr, "%s: %s: internal error\n", d.program, d.file);
1194 exit(99);
1195 }
1196
1197 /* Now find what the various supplied options cause to change: */
1198 if (!default_tests)
1199 {
1200 d.test = cmd; /* acts as a flag to say exit, do not longjmp */
1201 # ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
1202 perform_one_test(fp, argc, argv, default_flags, &d, 0);
1203 # endif
1204 # ifdef PNG_READ_USER_CHUNKS_SUPPORTED
1205 perform_one_test(fp, argc, argv, default_flags, &d, 1);
1206 # endif
1207 d.test = init;
1208 }
1209
1210 else
1211 {
1212 const char **test = standard_tests;
1213
1214 /* Set the exit_test pointer here so we can continue after a libpng error.
1215 * NOTE: this leaks memory because the png_struct data from the failing
1216 * test is never freed.
1217 */
1218 while (*test)
1219 {
1220 const char *this_test = *test++;
1221 const char **next = test;
1222 int count = display_rc(&d, strict), new_count;
1223 const char *result;
1224 int arg_count = 0;
1225
1226 while (*next != NULL)
1227 {
1228 ++next;
1229 ++arg_count;
1230 }
1231
1232 perform_one_test_safe(fp, arg_count, test, default_flags, &d,
1233 this_test);
1234
1235 new_count = display_rc(&d, strict);
1236
1237 if (new_count == count)
1238 result = "PASS";
1239
1240 else
1241 result = "FAIL";
1242
1243 printf("%s: %s %s\n", result, d.program, this_test);
1244
1245 test = next+1;
1246 }
1247 }
1248
1249 fclose(fp);
1250
1251 if (display_rc(&d, strict) == 0)
1252 {
1253 /* Success, touch the success file if appropriate */
1254 if (touch_file != NULL)
1255 {
1256 FILE *fsuccess = fopen(touch_file, "wt");
1257
1258 if (fsuccess != NULL)
1259 {
1260 int err = 0;
1261 fprintf(fsuccess, "PNG unknown tests succeeded\n");
1262 fflush(fsuccess);
1263 err = ferror(fsuccess);
1264
1265 if (fclose(fsuccess) || err)
1266 {
1267 fprintf(stderr, "%s: write failed\n", touch_file);
1268 exit(99);
1269 }
1270 }
1271
1272 else
1273 {
1274 fprintf(stderr, "%s: open failed\n", touch_file);
1275 exit(99);
1276 }
1277 }
1278
1279 return 0;
1280 }
1281
1282 return 1;
1283 }
1284
1285 #else /* !(READ_USER_CHUNKS || SAVE_UNKNOWN_CHUNKS) */
1286 int
1287 main(void)
1288 {
1289 fprintf(stderr,
1290 " test ignored: no support to find out about unknown chunks\n");
1291 /* So the test is skipped: */
1292 return SKIP;
1293 }
1294 #endif /* READ_USER_CHUNKS || SAVE_UNKNOWN_CHUNKS */
1295
1296 #else /* !(SET_UNKNOWN_CHUNKS && READ) */
1297 int
1298 main(void)
1299 {
1300 fprintf(stderr,
1301 " test ignored: no support to modify unknown chunk handling\n");
1302 /* So the test is skipped: */
1303 return SKIP;
1304 }
1305 #endif /* SET_UNKNOWN_CHUNKS && READ*/