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