contrib/libtests/pngunknown.c

   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*/