• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* pngcp.c
2  *
3  * Copyright (c) 2016 John Cunningham Bowler
4  *
5  * Last changed in libpng 1.6.24 [August 4, 2016]
6  *
7  * This code is released under the libpng license.
8  * For conditions of distribution and use, see the disclaimer
9  * and license in png.h
10  *
11  * This is an example of copying a PNG without changes using the png_read_png
12  * and png_write_png interfaces.  A considerable number of options are provided
13  * to manipulate the compression of the PNG data and other compressed chunks.
14  *
15  * For a more extensive example that uses the transforms see
16  * contrib/libtests/pngimage.c in the libpng distribution.
17  */
18 #include "pnglibconf.h" /* To find how libpng was configured. */
19 
20 #ifdef PNG_PNGCP_TIMING_SUPPORTED
21    /* WARNING:
22     *
23     * This test is here to allow POSIX.1b extensions to be used if enabled in
24     * the compile; specifically the code requires_POSIX_C_SOURCE support of
25     * 199309L or later to enable clock_gettime use.
26     *
27     * IF this causes problems THEN compile with a strict ANSI C compiler and let
28     * this code turn on the POSIX features that it minimally requires.
29     *
30     * IF this does not work there is probably a bug in your ANSI C compiler or
31     * your POSIX implementation.
32     */
33 #  define _POSIX_C_SOURCE 199309L
34 #else /* No timing support required */
35 #  define _POSIX_SOURCE 1
36 #endif
37 
38 #if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H)
39 #  include <config.h>
40 #endif
41 
42 #include <stdio.h>
43 
44 /* Define the following to use this test against your installed libpng, rather
45  * than the one being built here:
46  */
47 #ifdef PNG_FREESTANDING_TESTS
48 #  include <png.h>
49 #else
50 #  include "../../png.h"
51 #endif
52 
53 #if PNG_LIBPNG_VER < 10700
54    /* READ_PNG and WRITE_PNG were not defined, so: */
55 #  ifdef PNG_INFO_IMAGE_SUPPORTED
56 #     ifdef PNG_SEQUENTIAL_READ_SUPPORTED
57 #        define PNG_READ_PNG_SUPPORTED
58 #     endif /* SEQUENTIAL_READ */
59 #     ifdef PNG_WRITE_SUPPORTED
60 #        define PNG_WRITE_PNG_SUPPORTED
61 #     endif /* WRITE */
62 #  endif /* INFO_IMAGE */
63 #endif /* pre 1.7.0 */
64 
65 #if (defined(PNG_READ_PNG_SUPPORTED)) && (defined(PNG_WRITE_PNG_SUPPORTED))
66 #include <stdarg.h>
67 #include <stdlib.h>
68 #include <string.h>
69 #include <errno.h>
70 #include <limits.h>
71 #include <assert.h>
72 
73 #include <unistd.h>
74 #include <sys/stat.h>
75 
76 #include <zlib.h>
77 
78 #ifndef PNG_SETJMP_SUPPORTED
79 #  include <setjmp.h> /* because png.h did *not* include this */
80 #endif
81 
82 #ifdef __cplusplus
83 #  define voidcast(type, value) static_cast<type>(value)
84 #else
85 #  define voidcast(type, value) (value)
86 #endif /* __cplusplus */
87 
88 #ifdef __GNUC__
89    /* Many versions of GCC erroneously report that local variables unmodified
90     * within the scope of a setjmp may be clobbered.  This hacks round the
91     * problem (sometimes) without harming other compilers.
92     */
93 #  define gv volatile
94 #else
95 #  define gv
96 #endif
97 
98 /* 'CLOCK_PROCESS_CPUTIME_ID' is one of the clock timers for clock_gettime.  It
99  * need not be supported even when clock_gettime is available.  It returns the
100  * 'CPU' time the process has consumed.  'CPU' time is assumed to include time
101  * when the CPU is actually blocked by a pending cache fill but not time
102  * waiting for page faults.  The attempt is to get a measure of the actual time
103  * the implementation takes to read a PNG ignoring the potentially very large IO
104  * overhead.
105  */
106 #ifdef PNG_PNGCP_TIMING_SUPPORTED
107 #  include <time.h>   /* clock_gettime and associated definitions */
108 #  ifndef CLOCK_PROCESS_CPUTIME_ID
109       /* Prevent inclusion of the spurious code: */
110 #     undef PNG_PNGCP_TIMING_SUPPORTED
111 #  endif
112 #endif /* PNGCP_TIMING */
113 
114 /* So if the timing feature has been activated: */
115 
116 /* This structure is used to control the test of a single file. */
117 typedef enum
118 {
119    VERBOSE,        /* switches on all messages */
120    INFORMATION,
121    WARNINGS,       /* switches on warnings */
122    LIBPNG_WARNING,
123    APP_WARNING,
124    ERRORS,         /* just errors */
125    APP_FAIL,       /* continuable error - no need to longjmp */
126    LIBPNG_ERROR,   /* this and higher cause a longjmp */
127    LIBPNG_BUG,     /* erroneous behavior in libpng */
128    APP_ERROR,      /* such as out-of-memory in a callback */
129    QUIET,          /* no normal messages */
130    USER_ERROR,     /* such as file-not-found */
131    INTERNAL_ERROR
132 } error_level;
133 #define LEVEL_MASK      0xf   /* where the level is in 'options' */
134 
135 #define STRICT          0x010 /* Fail on warnings as well as errors */
136 #define LOG             0x020 /* Log pass/fail to stdout */
137 #define CONTINUE        0x040 /* Continue on APP_FAIL errors */
138 #define SIZES           0x080 /* Report input and output sizes */
139 #define SEARCH          0x100 /* Search IDAT compression options */
140 #define NOWRITE         0x200 /* Do not write an output file */
141 #ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
142 #  define IGNORE_INDEX  0x400 /* Ignore out of range palette indices (BAD!) */
143 #  ifdef PNG_GET_PALETTE_MAX_SUPPORTED
144 #     define FIX_INDEX  0x800 /* 'Fix' out of range palette indices (OK) */
145 #  endif /* GET_PALETTE_MAX */
146 #endif /* CHECK_FOR_INVALID_INDEX */
147 #define OPTION     0x80000000 /* Used for handling options */
148 #define LIST       0x80000001 /* Used for handling options */
149 
150 /* Result masks apply to the result bits in the 'results' field below; these
151  * bits are simple 1U<<error_level.  A pass requires either nothing worse than
152  * warnings (--relaxes) or nothing worse than information (--strict)
153  */
154 #define RESULT_STRICT(r)   (((r) & ~((1U<<WARNINGS)-1)) == 0)
155 #define RESULT_RELAXED(r)  (((r) & ~((1U<<ERRORS)-1)) == 0)
156 
157 /* OPTION DEFINITIONS */
158 static const char range_lo[] = "low";
159 static const char range_hi[] = "high";
160 static const char all[] = "all";
161 #define RANGE(lo,hi) { range_lo, lo }, { range_hi, hi }
162 typedef struct value_list
163 {
164    const char *name;  /* the command line name of the value */
165    int         value; /* the actual value to use */
166 }  value_list;
167 
168 static const value_list
169 #ifdef PNG_SW_COMPRESS_png_level
170 vl_compression[] =
171 {
172    /* Overall compression control.  The order controls the search order for
173     * 'all'.  Since the search is for the smallest the order used is low memory
174     * then high speed.
175     */
176    { "low-memory",      PNG_COMPRESSION_LOW_MEMORY },
177    { "high-speed",      PNG_COMPRESSION_HIGH_SPEED },
178    { "high-read-speed", PNG_COMPRESSION_HIGH_READ_SPEED },
179    { "low",             PNG_COMPRESSION_LOW },
180    { "medium",          PNG_COMPRESSION_MEDIUM },
181    { "old",             PNG_COMPRESSION_COMPAT },
182    { "high",            PNG_COMPRESSION_HIGH },
183    { all, 0 }
184 },
185 #endif /* SW_COMPRESS_png_level */
186 
187 #if defined(PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED) ||\
188     defined(PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED)
189 vl_strategy[] =
190 {
191    /* This controls the order of search. */
192    { "huffman", Z_HUFFMAN_ONLY },
193    { "RLE", Z_RLE },
194    { "fixed", Z_FIXED }, /* the remainder do window searches */
195    { "filtered", Z_FILTERED },
196    { "default", Z_DEFAULT_STRATEGY },
197    { all, 0 }
198 },
199 #ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
200 vl_windowBits_text[] =
201 {
202    { "default", MAX_WBITS/*from zlib*/ },
203    { "minimum", 8 },
204    RANGE(8, MAX_WBITS/*from zlib*/),
205    { all, 0 }
206 },
207 #endif /* text compression */
208 vl_level[] =
209 {
210    { "default", Z_DEFAULT_COMPRESSION /* this is -1 */ },
211    { "none", Z_NO_COMPRESSION },
212    { "speed", Z_BEST_SPEED },
213    { "best", Z_BEST_COMPRESSION },
214    { "0", Z_NO_COMPRESSION },
215    RANGE(1, 9), /* this deliberately excludes '0' */
216    { all, 0 }
217 },
218 vl_memLevel[] =
219 {
220    { "max", MAX_MEM_LEVEL }, /* zlib maximum */
221    { "1", 1 }, /* zlib minimum */
222    { "default", 8 }, /* zlib default */
223    { "2", 2 },
224    { "3", 3 },
225    { "4", 4 },
226    { "5", 5 }, /* for explicit testing */
227    RANGE(6, MAX_MEM_LEVEL/*zlib*/), /* exclude 5 and below: zlib bugs */
228    { all, 0 }
229 },
230 #endif /* WRITE_CUSTOMIZE_*COMPRESSION */
231 #ifdef PNG_WRITE_FILTER_SUPPORTED
232 vl_filter[] =
233 {
234    { all,      PNG_ALL_FILTERS   },
235    { "off",    PNG_NO_FILTERS    },
236    { "none",   PNG_FILTER_NONE   },
237    { "sub",    PNG_FILTER_SUB    },
238    { "up",     PNG_FILTER_UP     },
239    { "avg",    PNG_FILTER_AVG    },
240    { "paeth",  PNG_FILTER_PAETH  }
241 },
242 #endif /* WRITE_FILTER */
243 #ifdef PNG_PNGCP_TIMING_SUPPORTED
244 #  define PNGCP_TIME_READ  1
245 #  define PNGCP_TIME_WRITE 2
246 vl_time[] =
247 {
248    { "both",  PNGCP_TIME_READ+PNGCP_TIME_WRITE },
249    { "off",   0 },
250    { "read",  PNGCP_TIME_READ },
251    { "write", PNGCP_TIME_WRITE }
252 },
253 #endif /* PNGCP_TIMING */
254 vl_IDAT_size[] = /* for png_set_IDAT_size */
255 {
256    { "default", 0x7FFFFFFF },
257    { "minimal", 1 },
258    RANGE(1, 0x7FFFFFFF)
259 },
260 #ifndef PNG_SW_IDAT_size
261    /* Pre 1.7 API: */
262 #  define png_set_IDAT_size(p,v) png_set_compression_buffer_size(p, v)
263 #endif /* !SW_IDAT_size */
264 #define SL 8 /* stack limit in display, below */
265 vl_log_depth[] = { { "on", 1 }, { "off", 0 }, RANGE(0, SL) },
266 vl_on_off[] = { { "on", 1 }, { "off", 0 } };
267 
268 #ifdef PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED
269 static value_list
270 vl_windowBits_IDAT[] =
271 {
272    { "default", MAX_WBITS },
273    { "small", 9 },
274    RANGE(8, MAX_WBITS), /* modified by set_windowBits_hi */
275    { all, 0 }
276 };
277 #endif /* IDAT compression */
278 
279 typedef struct option
280 {
281    const char       *name;         /* name of the option */
282    png_uint_32       opt;          /* an option, or OPTION or LIST */
283    png_byte          search;       /* Search on --search */
284    png_byte          value_count;  /* length of the list of values: */
285    const value_list *values;       /* values for OPTION or LIST */
286 }  option;
287 
288 static const option options[] =
289 {
290    /* struct display options, these are set when the command line is read */
291 #  define S(n,v) { #n, v, 0, 2, vl_on_off },
292    S(verbose,  VERBOSE)
293    S(warnings, WARNINGS)
294    S(errors,   ERRORS)
295    S(quiet,    QUIET)
296    S(strict,   STRICT)
297    S(log,      LOG)
298    S(continue, CONTINUE)
299    S(sizes,    SIZES)
300    S(search,   SEARCH)
301    S(nowrite,  NOWRITE)
302 #  ifdef IGNORE_INDEX
303       S(ignore-palette-index, IGNORE_INDEX)
304 #  endif /* IGNORE_INDEX */
305 #  ifdef FIX_INDEX
306       S(fix-palette-index, FIX_INDEX)
307 #  endif /* FIX_INDEX */
308 #  undef S
309 
310    /* OPTION settings, these and LIST settings are read on demand */
311 #  define VLNAME(name) vl_ ## name
312 #  define VLSIZE(name) voidcast(png_byte,\
313                            (sizeof VLNAME(name))/(sizeof VLNAME(name)[0]))
314 #  define VL(oname, name, type, search)\
315    { oname, type, search, VLSIZE(name), VLNAME(name) },
316 #  define VLO(oname, name, search) VL(oname, name, OPTION, search)
317 
318 #  ifdef PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED
319 #     define VLCIDAT(name) VLO(#name, name, 1/*search*/)
320 #     ifdef PNG_SW_COMPRESS_level
321 #        define VLCiCCP(name) VLO("ICC-profile-" #name, name, 0/*search*/)
322 #     else
323 #        define VLCiCCP(name)
324 #     endif
325 #  else
326 #     define VLCIDAT(name)
327 #     define VLCiCCP(name)
328 #  endif /* WRITE_CUSTOMIZE_COMPRESSION */
329 
330 #  ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
331 #     define VLCzTXt(name) VLO("text-" #name, name, 0/*search*/)
332 #  else
333 #     define VLCzTXt(name)
334 #  endif /* WRITE_CUSTOMIZE_ZTXT_COMPRESSION */
335 
336 #  define VLC(name) VLCIDAT(name) VLCiCCP(name) VLCzTXt(name)
337 
338 #  ifdef PNG_SW_COMPRESS_png_level
339       /* The libpng compression level isn't searched because it justs sets the
340        * other things that are searched!
341        */
342       VLO("compression", compression, 0)
343       VLO("text-compression", compression, 0)
344       VLO("ICC-profile-compression", compression, 0)
345 #  endif /* SW_COMPRESS_png_level */
346    VLC(strategy)
347    VLO("windowBits", windowBits_IDAT, 1)
348 #  ifdef PNG_SW_COMPRESS_windowBits
349       VLO("ICC-profile-windowBits", windowBits_text/*sic*/, 0)
350 #  endif
351    VLO("text-windowBits", windowBits_text, 0)
352    VLC(level)
353    VLC(memLevel)
354    VLO("IDAT-size", IDAT_size, 0)
355    VLO("log-depth", log_depth, 0)
356 
357 #  undef VLO
358 
359    /* LIST settings */
360 #  define VLL(name, search) VL(#name, name, LIST, search)
361 #ifdef PNG_WRITE_FILTER_SUPPORTED
362    VLL(filter, 0)
363 #endif /* WRITE_FILTER */
364 #ifdef PNG_PNGCP_TIMING_SUPPORTED
365    VLL(time, 0)
366 #endif /* PNGCP_TIMING */
367 #  undef VLL
368 #  undef VL
369 };
370 
371 #ifdef __cplusplus
372    static const size_t option_count((sizeof options)/(sizeof options[0]));
373 #else /* !__cplusplus */
374 #  define option_count ((sizeof options)/(sizeof options[0]))
375 #endif /* !__cplusplus */
376 
377 static const char *
cts(int ct)378 cts(int ct)
379 {
380    switch (ct)
381    {
382       case PNG_COLOR_TYPE_PALETTE:     return "P";
383       case PNG_COLOR_TYPE_GRAY:        return "G";
384       case PNG_COLOR_TYPE_GRAY_ALPHA:  return "GA";
385       case PNG_COLOR_TYPE_RGB:         return "RGB";
386       case PNG_COLOR_TYPE_RGB_ALPHA:   return "RGBA";
387       default:                         return "INVALID";
388    }
389 }
390 
391 struct display
392 {
393    jmp_buf          error_return;      /* Where to go to on error */
394    unsigned int     errset;            /* error_return is set */
395 
396    const char      *operation;         /* What is happening */
397    const char      *filename;          /* The name of the original file */
398    const char      *output_file;       /* The name of the output file */
399 
400    /* Used on both read and write: */
401    FILE            *fp;
402 
403    /* Used on a read, both the original read and when validating a written
404     * image.
405     */
406    png_alloc_size_t read_size;
407    png_structp      read_pp;
408    png_infop        ip;
409 #  if PNG_LIBPNG_VER < 10700 && defined PNG_TEXT_SUPPORTED
410       png_textp     text_ptr; /* stash of text chunks */
411       int           num_text;
412       int           text_stashed;
413 #  endif /* pre 1.7 */
414 
415 #  ifdef PNG_PNGCP_TIMING_SUPPORTED
416       struct timespec   read_time;
417       struct timespec   read_time_total;
418       struct timespec   write_time;
419       struct timespec   write_time_total;
420 #  endif /* PNGCP_TIMING */
421 
422    /* Used to write a new image (the original info_ptr is used) */
423 #  define MAX_SIZE ((png_alloc_size_t)(-1))
424    png_alloc_size_t write_size;
425    png_alloc_size_t best_size;
426    png_structp      write_pp;
427 
428    /* Base file information */
429    png_alloc_size_t size;
430    png_uint_32      w;
431    png_uint_32      h;
432    int              bpp;
433    png_byte         ct;
434    int              no_warnings;       /* Do not output libpng warnings */
435    int              min_windowBits;    /* The windowBits range is 8..8 */
436 
437    /* Options handling */
438    png_uint_32      results;             /* A mask of errors seen */
439    png_uint_32      options;             /* See display_log below */
440    png_byte         entry[option_count]; /* The selected entry+1 of an option
441                                           * that appears on the command line, or
442                                           * 0 if it was not given. */
443    int              value[option_count]; /* Corresponding value */
444 
445    /* Compression exhaustive testing */
446    /* Temporary variables used only while testing a single collection of
447     * settings:
448     */
449    unsigned int     csp;               /* next stack entry to use */
450    unsigned int     nsp;               /* highest active entry+1 found so far */
451 
452    /* Values used while iterating through all the combinations of settings for a
453     * single file:
454     */
455    unsigned int     tsp;               /* nsp from the last run; this is the
456                                         * index+1 of the highest active entry on
457                                         * this run; this entry will be advanced.
458                                         */
459    int              opt_string_start;  /* Position in buffer for the first
460                                         * searched option; non-zero if earlier
461                                         * options were set on the command line.
462                                         */
463    struct stack
464    {
465       png_alloc_size_t best_size;      /* Best so far for this option */
466       png_alloc_size_t lo_size;
467       png_alloc_size_t hi_size;
468       int              lo, hi;         /* For binary chop of a range */
469       int              best_val;       /* Best value found so far */
470       int              opt_string_end; /* End of the option string in 'curr' */
471       png_byte         opt;            /* The option being tested */
472       png_byte         entry;          /* The next value entry to be tested */
473       png_byte         end;            /* This is the last entry */
474    }                stack[SL];         /* Stack of entries being tested */
475    char             curr[32*SL];       /* current options being tested */
476    char             best[32*SL];       /* best options */
477 
478    char             namebuf[FILENAME_MAX]; /* output file name */
479 };
480 
481 static void
display_init(struct display * dp)482 display_init(struct display *dp)
483    /* Call this only once right at the start to initialize the control
484     * structure, the (struct buffer) lists are maintained across calls - the
485     * memory is not freed.
486     */
487 {
488    memset(dp, 0, sizeof *dp);
489    dp->operation = "internal error";
490    dp->filename = "command line";
491    dp->output_file = "no output file";
492    dp->options = WARNINGS; /* default to !verbose, !quiet */
493    dp->fp = NULL;
494    dp->read_pp = NULL;
495    dp->ip = NULL;
496    dp->write_pp = NULL;
497    dp->min_windowBits = -1; /* this is an OPTIND, so -1 won't match anything */
498 #  if PNG_LIBPNG_VER < 10700 && defined PNG_TEXT_SUPPORTED
499       dp->text_ptr = NULL;
500       dp->num_text = 0;
501       dp->text_stashed = 0;
502 #  endif /* pre 1.7 */
503 }
504 
505 static void
display_clean_read(struct display * dp)506 display_clean_read(struct display *dp)
507 {
508    if (dp->read_pp != NULL)
509       png_destroy_read_struct(&dp->read_pp, NULL, NULL);
510 
511    if (dp->fp != NULL)
512    {
513       FILE *fp = dp->fp;
514       dp->fp = NULL;
515       (void)fclose(fp);
516    }
517 }
518 
519 static void
display_clean_write(struct display * dp)520 display_clean_write(struct display *dp)
521 {
522    if (dp->fp != NULL)
523    {
524       FILE *fp = dp->fp;
525       dp->fp = NULL;
526       (void)fclose(fp);
527    }
528 
529    if (dp->write_pp != NULL)
530       png_destroy_write_struct(&dp->write_pp, dp->tsp > 0 ? NULL : &dp->ip);
531 }
532 
533 static void
display_clean(struct display * dp)534 display_clean(struct display *dp)
535 {
536    display_clean_read(dp);
537    display_clean_write(dp);
538    dp->output_file = NULL;
539 
540 #  if PNG_LIBPNG_VER < 10700 && defined PNG_TEXT_SUPPORTED
541       /* This is actually created and used by the write code, but only
542        * once; it has to be retained for subsequent writes of the same file.
543        */
544       if (dp->text_stashed)
545       {
546          dp->text_stashed = 0;
547          dp->num_text = 0;
548          free(dp->text_ptr);
549          dp->text_ptr = NULL;
550       }
551 #  endif /* pre 1.7 */
552 
553    /* leave the filename for error detection */
554    dp->results = 0; /* reset for next time */
555 }
556 
557 static void
display_destroy(struct display * dp)558 display_destroy(struct display *dp)
559 {
560    /* Release any memory held in the display. */
561    display_clean(dp);
562 }
563 
564 static struct display *
get_dp(png_structp pp)565 get_dp(png_structp pp)
566    /* The display pointer is always stored in the png_struct error pointer */
567 {
568    struct display *dp = (struct display*)png_get_error_ptr(pp);
569 
570    if (dp == NULL)
571    {
572       fprintf(stderr, "pngcp: internal error (no display)\n");
573       exit(99); /* prevents a crash */
574    }
575 
576    return dp;
577 }
578 
579 /* error handling */
580 #ifdef __GNUC__
581 #  define VGATTR __attribute__((__format__ (__printf__,3,4)))
582    /* Required to quiet GNUC warnings when the compiler sees a stdarg function
583     * that calls one of the stdio v APIs.
584     */
585 #else
586 #  define VGATTR
587 #endif
588 static void VGATTR
display_log(struct display * dp,error_level level,const char * fmt,...)589 display_log(struct display *dp, error_level level, const char *fmt, ...)
590    /* 'level' is as above, fmt is a stdio style format string.  This routine
591     * does not return if level is above LIBPNG_WARNING
592     */
593 {
594    dp->results |= 1U << level;
595 
596    if (level > (error_level)(dp->options & LEVEL_MASK))
597    {
598       const char *lp;
599       va_list ap;
600 
601       switch (level)
602       {
603          case INFORMATION:    lp = "information"; break;
604          case LIBPNG_WARNING: lp = "warning(libpng)"; break;
605          case APP_WARNING:    lp = "warning(pngcp)"; break;
606          case APP_FAIL:       lp = "error(continuable)"; break;
607          case LIBPNG_ERROR:   lp = "error(libpng)"; break;
608          case LIBPNG_BUG:     lp = "bug(libpng)"; break;
609          case APP_ERROR:      lp = "error(pngcp)"; break;
610          case USER_ERROR:     lp = "error(user)"; break;
611 
612          case INTERNAL_ERROR: /* anything unexpected is an internal error: */
613          case VERBOSE: case WARNINGS: case ERRORS: case QUIET:
614          default:             lp = "bug(pngcp)"; break;
615       }
616 
617       fprintf(stderr, "%s: %s: %s",
618          dp->filename != NULL ? dp->filename : "<stdin>", lp, dp->operation);
619 
620       fprintf(stderr, ": ");
621 
622       va_start(ap, fmt);
623       vfprintf(stderr, fmt, ap);
624       va_end(ap);
625 
626       fputc('\n', stderr);
627    }
628    /* else do not output any message */
629 
630    /* Errors cause this routine to exit to the fail code */
631    if (level > APP_FAIL || (level > ERRORS && !(dp->options & CONTINUE)))
632    {
633       if (dp->errset)
634          longjmp(dp->error_return, level);
635 
636       else
637          exit(99);
638    }
639 }
640 
641 #if PNG_LIBPNG_VER < 10700 && defined PNG_TEXT_SUPPORTED
642 static void
text_stash(struct display * dp)643 text_stash(struct display *dp)
644 {
645    /* libpng 1.6 and earlier fixed a bug whereby text chunks were written
646     * multiple times by png_write_png; the issue was that png_write_png passed
647     * the same png_info to both png_write_info and png_write_end.  Rather than
648     * fixing it by recording the information in the png_struct, or by recording
649     * where to write the chunks, the fix made was to change the 'compression'
650     * field of the chunk to invalid values, rendering the png_info somewhat
651     * useless.
652     *
653     * The only fix for this given that we use the png_info more than once is to
654     * make a copy of the text chunks and png_set_text it each time.  This adds a
655     * text chunks, so they get replicated, but only the new set gets written
656     * each time.  This uses memory like crazy but there is no way to delete the
657     * useless chunks from the png_info.
658     *
659     * To make this slightly more efficient only the top level structure is
660     * copied; since the old strings are actually preserved (in 1.6 and earlier)
661     * this happens to work.
662     */
663    png_textp chunks = NULL;
664 
665    dp->num_text = png_get_text(dp->write_pp, dp->ip, &chunks, NULL);
666 
667    if (dp->num_text > 0)
668    {
669       dp->text_ptr = voidcast(png_textp, malloc(dp->num_text * sizeof *chunks));
670 
671       if (dp->text_ptr == NULL)
672          display_log(dp, APP_ERROR, "text chunks: stash malloc failed");
673 
674       else
675          memcpy(dp->text_ptr, chunks, dp->num_text * sizeof *chunks);
676    }
677 
678    dp->text_stashed = 1; /* regardless of whether there are chunks or not */
679 }
680 
681 #define text_stash(dp) if (!dp->text_stashed) text_stash(dp)
682 
683 static void
text_restore(struct display * dp)684 text_restore(struct display *dp)
685 {
686    /* libpng makes a copy, so this is fine: */
687    if (dp->text_ptr != NULL)
688       png_set_text(dp->write_pp, dp->ip, dp->text_ptr, dp->num_text);
689 }
690 
691 #define text_restore(dp) if (dp->text_stashed) text_restore(dp)
692 
693 #else
694 #define text_stash(dp) ((void)0)
695 #define text_restore(dp) ((void)0)
696 #endif /* pre 1.7 */
697 
698 /* OPTIONS:
699  *
700  * The command handles options of the forms:
701  *
702  *    --option
703  *       Turn an option on (Option)
704  *    --no-option
705  *       Turn an option off (Option)
706  *    --option=value
707  *       Set an option to a value (Value)
708  *    --option=val1,val2,val3
709  *       Set an option to a bitmask constructed from the values (List)
710  */
711 static png_byte
option_index(struct display * dp,const char * opt,size_t len)712 option_index(struct display *dp, const char *opt, size_t len)
713    /* Return the index (in options[]) of the given option, outputs an error if
714     * it does not exist.  Takes the name of the option and a length (number of
715     * characters in the name).
716     */
717 {
718    png_byte j;
719 
720    for (j=0; j<option_count; ++j)
721       if (strncmp(options[j].name, opt, len) == 0 && options[j].name[len] == 0)
722          return j;
723 
724    /* If the setjmp buffer is set the code is asking for an option index; this
725     * is bad.  Otherwise this is the command line option parsing.
726     */
727    display_log(dp, dp->errset ? INTERNAL_ERROR : USER_ERROR,
728          "%.*s: unknown option", (int)/*SAFE*/len, opt);
729    abort(); /* NOT REACHED */
730 }
731 
732 /* This works for an option name (no quotes): */
733 #define OPTIND(dp, name) option_index(dp, #name, (sizeof #name)-1)
734 
735 static int
get_option(struct display * dp,const char * opt,int * value)736 get_option(struct display *dp, const char *opt, int *value)
737 {
738    png_byte i = option_index(dp, opt, strlen(opt));
739 
740    if (dp->entry[i]) /* option was set on command line */
741    {
742       *value = dp->value[i];
743       return 1;
744    }
745 
746    else
747       return 0;
748 }
749 
750 static int
set_opt_string_(struct display * dp,unsigned int sp,png_byte opt,const char * entry_name)751 set_opt_string_(struct display *dp, unsigned int sp, png_byte opt,
752       const char *entry_name)
753    /* Add the appropriate option string to dp->curr. */
754 {
755    int offset, add;
756 
757    if (sp > 0)
758       offset = dp->stack[sp-1].opt_string_end;
759 
760    else
761       offset = dp->opt_string_start;
762 
763    if (entry_name == range_lo)
764       add = sprintf(dp->curr+offset, " --%s=%d", options[opt].name,
765             dp->value[opt]);
766 
767    else
768       add = sprintf(dp->curr+offset, " --%s=%s", options[opt].name, entry_name);
769 
770    if (add < 0)
771       display_log(dp, INTERNAL_ERROR, "sprintf failed");
772 
773    assert(offset+add < (int)/*SAFE*/sizeof dp->curr);
774    return offset+add;
775 }
776 
777 static void
set_opt_string(struct display * dp,unsigned int sp)778 set_opt_string(struct display *dp, unsigned int sp)
779    /* Add the appropriate option string to dp->curr. */
780 {
781    dp->stack[sp].opt_string_end = set_opt_string_(dp, sp, dp->stack[sp].opt,
782       options[dp->stack[sp].opt].values[dp->stack[sp].entry].name);
783 }
784 
785 static void
record_opt(struct display * dp,png_byte opt,const char * entry_name)786 record_opt(struct display *dp, png_byte opt, const char *entry_name)
787    /* Record this option in dp->curr; called for an option not being searched,
788     * the caller passes in the name of the value, or range_lo to use the
789     * numerical value.
790     */
791 {
792    unsigned int sp = dp->csp; /* stack entry of next searched option */
793 
794    if (sp >= dp->tsp)
795    {
796       /* At top of stack; add the opt string for this entry to the previous
797        * searched entry or the start of the dp->curr buffer if there is nothing
798        * on the stack yet (sp == 0).
799        */
800       int offset = set_opt_string_(dp, sp, opt, entry_name);
801 
802       if (sp > 0)
803          dp->stack[sp-1].opt_string_end = offset;
804 
805       else
806          dp->opt_string_start = offset;
807    }
808 
809    /* else do nothing: option already recorded */
810 }
811 
812 static int
opt_list_end(struct display * dp,png_byte opt,png_byte entry)813 opt_list_end(struct display *dp, png_byte opt, png_byte entry)
814 {
815    if (options[opt].values[entry].name == range_lo)
816       return entry+1U >= options[opt].value_count /* missing range_hi */ ||
817          options[opt].values[entry+1U].name != range_hi /* likewise */ ||
818          options[opt].values[entry+1U].value <= dp->value[opt] /* range end */;
819 
820    else
821       return entry+1U >= options[opt].value_count /* missing 'all' */ ||
822          options[opt].values[entry+1U].name == all /* last entry */;
823 }
824 
825 static void
push_opt(struct display * dp,unsigned int sp,png_byte opt,int search)826 push_opt(struct display *dp, unsigned int sp, png_byte opt, int search)
827    /* Push a new option onto the stack, initializing the new stack entry
828     * appropriately; this does all the work of next_opt (setting end/nsp) for
829     * the first entry in the list.
830     */
831 {
832    png_byte entry;
833    const char *entry_name;
834 
835    assert(sp == dp->tsp && sp < SL);
836 
837    /* The starting entry is entry 0 unless there is a range in which case it is
838     * the entry corresponding to range_lo:
839     */
840    entry = options[opt].value_count;
841    assert(entry > 0U);
842 
843    do
844    {
845       entry_name = options[opt].values[--entry].name;
846       if (entry_name == range_lo)
847          break;
848    }
849    while (entry > 0U);
850 
851    dp->tsp = sp+1U;
852    dp->stack[sp].best_size =
853       dp->stack[sp].lo_size =
854       dp->stack[sp].hi_size = MAX_SIZE;
855 
856    if (search && entry_name == range_lo) /* search this range */
857    {
858       dp->stack[sp].lo = options[opt].values[entry].value;
859       /* check for a mal-formed RANGE above: */
860       assert(entry+1 < options[opt].value_count &&
861              options[opt].values[entry+1].name == range_hi);
862       dp->stack[sp].hi = options[opt].values[entry+1].value;
863    }
864 
865    else
866    {
867       /* next_opt will just iterate over the range. */
868       dp->stack[sp].lo = INT_MAX;
869       dp->stack[sp].hi = INT_MIN; /* Prevent range chop */
870    }
871 
872    dp->stack[sp].opt = opt;
873    dp->stack[sp].entry = entry;
874    dp->stack[sp].best_val = dp->value[opt] = options[opt].values[entry].value;
875 
876    set_opt_string(dp, sp);
877 
878    /* This works for the search case too; if the range has only one entry 'end'
879     * will be marked here.
880     */
881    if (opt_list_end(dp, opt, entry))
882    {
883       dp->stack[sp].end = 1;
884       /* Skip the warning if pngcp did this itself.  See the code in
885        * set_windowBits_hi.
886        */
887       if (opt != dp->min_windowBits)
888          display_log(dp, APP_WARNING, "%s: only testing one value",
889                options[opt].name);
890    }
891 
892    else
893    {
894       dp->stack[sp].end = 0;
895       dp->nsp = dp->tsp;
896    }
897 
898    /* Do a lazy cache of the text chunks for libpng 1.6 and earlier; this is
899     * because they can only be written once(!) so if we are going to re-use the
900     * png_info we need a copy.
901     */
902    text_stash(dp);
903 }
904 
905 static void
next_opt(struct display * dp,unsigned int sp)906 next_opt(struct display *dp, unsigned int sp)
907    /* Return the next value for this option.  When called 'sp' is expected to be
908     * the topmost stack entry - only the topmost entry changes each time round -
909     * and there must be a valid entry to return.  next_opt will set dp->nsp to
910     * sp+1 if more entries are available, otherwise it will not change it and
911     * set dp->stack[s].end to true.
912     */
913 {
914    int search = 0;
915    png_byte entry, opt;
916    const char *entry_name;
917 
918    /* dp->stack[sp] must be the top stack entry and it must be active: */
919    assert(sp+1U == dp->tsp && !dp->stack[sp].end);
920 
921    opt = dp->stack[sp].opt;
922    entry = dp->stack[sp].entry;
923    assert(entry+1U < options[opt].value_count);
924    entry_name = options[opt].values[entry].name;
925    assert(entry_name != NULL);
926 
927    /* For ranges increment the value but don't change the entry, for all other
928     * cases move to the next entry and load its value:
929     */
930    if (entry_name == range_lo) /* a range */
931    {
932       /* A range can be iterated over or searched.  The default iteration option
933        * is indicated by hi < lo on the stack, otherwise the range being search
934        * is [lo..hi] (inclusive).
935        */
936       if (dp->stack[sp].lo > dp->stack[sp].hi)
937          dp->value[opt]++;
938 
939       else
940       {
941          /* This is the best size found for this option value: */
942          png_alloc_size_t best_size = dp->stack[sp].best_size;
943          int lo = dp->stack[sp].lo;
944          int hi = dp->stack[sp].hi;
945          int val = dp->value[opt];
946 
947          search = 1; /* end is determined here */
948          assert(best_size < MAX_SIZE);
949 
950          if (val == lo)
951          {
952             /* Finding the best for the low end of the range: */
953             dp->stack[sp].lo_size = best_size;
954             assert(hi > val);
955 
956             if (hi == val+1) /* only 2 entries */
957                dp->stack[sp].end = 1;
958 
959             val = hi;
960          }
961 
962          else if (val == hi)
963          {
964             dp->stack[sp].hi_size = best_size;
965             assert(val > lo+1); /* else 'end' set above */
966 
967             if (val == lo+2) /* only three entries to test */
968                dp->stack[sp].end = 1;
969 
970             val = (lo + val)/2;
971          }
972 
973          else
974          {
975             png_alloc_size_t lo_size = dp->stack[sp].lo_size;
976             png_alloc_size_t hi_size = dp->stack[sp].hi_size;
977 
978             /* lo and hi should have been tested. */
979             assert(lo_size < MAX_SIZE && hi_size < MAX_SIZE);
980 
981             /* These cases arise with the 'probe' handling below when there is a
982              * dip or peak in the size curve.
983              */
984             if (val < lo) /* probing a new lo */
985             {
986                /* Swap lo and val: */
987                dp->stack[sp].lo = val;
988                dp->stack[sp].lo_size = best_size;
989                val = lo;
990                best_size = lo_size;
991                lo = dp->stack[sp].lo;
992                lo_size = dp->stack[sp].lo_size;
993             }
994 
995             else if (val > hi) /* probing a new hi */
996             {
997                /* Swap hi and val: */
998                dp->stack[sp].hi = val;
999                dp->stack[sp].hi_size = best_size;
1000                val = hi;
1001                best_size = hi_size;
1002                hi = dp->stack[sp].hi;
1003                hi_size = dp->stack[sp].hi_size;
1004             }
1005 
1006             /* The following should be true or something got messed up above. */
1007             assert(lo < val && val < hi);
1008 
1009             /* If there are only four entries (lo, val, hi plus one more) just
1010              * test the remaining entry.
1011              */
1012             if (hi == lo+3)
1013             {
1014                /* Because of the 'probe' code val can either be lo+1 or hi-1; we
1015                 * need to test the other.
1016                 */
1017                val = lo + ((val == lo+1) ? 2 : 1);
1018                assert(lo < val && val < hi);
1019                dp->stack[sp].end = 1;
1020             }
1021 
1022             else
1023             {
1024                /* There are at least 2 entries still untested between lo and hi,
1025                 * i.e. hi >= lo+4.  'val' is the midpoint +/- 0.5
1026                 *
1027                 * Separate out the four easy cases when lo..val..hi are
1028                 * monotonically decreased or (more weird) increasing:
1029                 */
1030                assert(hi > lo+3);
1031 
1032                if (lo_size <= best_size && best_size <= hi_size)
1033                {
1034                   /* Select the low range; testing this first favours the low
1035                    * range over the high range when everything comes out equal.
1036                    * Because of the probing 'val' may be lo+1.  In that case end
1037                    * the search and set 'val' to lo+2.
1038                    */
1039                   if (val == lo+1)
1040                   {
1041                      ++val;
1042                      dp->stack[sp].end = 1;
1043                   }
1044 
1045                   else
1046                   {
1047                      dp->stack[sp].hi = hi = val;
1048                      dp->stack[sp].hi_size = best_size;
1049                      val = (lo + val) / 2;
1050                   }
1051                }
1052 
1053                else if (lo_size >= best_size && best_size >= hi_size)
1054                {
1055                   /* Monotonically decreasing size; this is the expected case.
1056                    * Select the high end of the range.  As above, val may be
1057                    * hi-1.
1058                    */
1059                   if (val == hi-1)
1060                   {
1061                      --val;
1062                      dp->stack[sp].end = 1;
1063                   }
1064 
1065                   else
1066                   {
1067                      dp->stack[sp].lo = lo = val;
1068                      dp->stack[sp].lo_size = best_size;
1069                      val = (val + hi) / 2;
1070                   }
1071                }
1072 
1073                /* If both those tests failed 'best_size' is either greater than
1074                 * or less than both lo_size and hi_size.  There is a peak or dip
1075                 * in the curve of sizes from lo to hi and val is on the peak or
1076                 * dip.
1077                 *
1078                 * Because the ranges being searched as so small (level is 1..9,
1079                 * windowBits 8..15, memLevel 1..9) there will only be at most
1080                 * three untested values between lo..val and val..hi, so solve
1081                 * the problem by probing down from hi or up from lo, whichever
1082                 * is the higher.
1083                 *
1084                 * This is the place where 'val' is set to outside the range
1085                 * lo..hi, described as 'probing', though maybe 'narrowing' would
1086                 * be more accurate.
1087                 */
1088                else if (lo_size <= hi_size) /* down from hi */
1089                {
1090                   dp->stack[sp].hi = val;
1091                   dp->stack[sp].hi_size = best_size;
1092                   val = --hi;
1093                }
1094 
1095                else /* up from low */
1096                {
1097                   dp->stack[sp].lo = val;
1098                   dp->stack[sp].lo_size = best_size;
1099                   val = ++lo;
1100                }
1101 
1102                /* lo and hi are still the true range limits, check for the end
1103                 * condition.
1104                 */
1105                assert(hi > lo+1);
1106                if (hi <= lo+2)
1107                   dp->stack[sp].end = 1;
1108             }
1109          }
1110 
1111          assert(val != dp->stack[sp].best_val); /* should be a new value */
1112          dp->value[opt] = val;
1113          dp->stack[sp].best_size = MAX_SIZE;
1114       }
1115    }
1116 
1117    else
1118    {
1119       /* Increment 'entry' */
1120       dp->value[opt] = options[opt].values[++entry].value;
1121       dp->stack[sp].entry = entry;
1122    }
1123 
1124    set_opt_string(dp, sp);
1125 
1126    if (!search && opt_list_end(dp, opt, entry)) /* end of list */
1127       dp->stack[sp].end = 1;
1128 
1129    else if (!dp->stack[sp].end) /* still active after all these tests */
1130       dp->nsp = dp->tsp;
1131 }
1132 
1133 static int
compare_option(const struct display * dp,unsigned int sp)1134 compare_option(const struct display *dp, unsigned int sp)
1135 {
1136    int opt = dp->stack[sp].opt;
1137 
1138    /* If the best so far is numerically less than the current value the
1139     * current set of options is invariably worse.
1140     */
1141    if (dp->stack[sp].best_val < dp->value[opt])
1142       return -1;
1143 
1144    /* Lists of options are searched out of numerical order (currently only
1145     * strategy), so only return +1 here when a range is being searched.
1146     */
1147    else if (dp->stack[sp].best_val > dp->value[opt])
1148    {
1149       if (dp->stack[sp].lo <= dp->stack[sp].hi /*searching*/)
1150          return 1;
1151 
1152       else
1153          return -1;
1154    }
1155 
1156    else
1157       return 0; /* match; current value is the best one */
1158 }
1159 
1160 static int
advance_opt(struct display * dp,png_byte opt,int search)1161 advance_opt(struct display *dp, png_byte opt, int search)
1162 {
1163    unsigned int sp = dp->csp++; /* my stack entry */
1164 
1165    assert(sp >= dp->nsp); /* nsp starts off zero */
1166 
1167    /* If the entry was active in the previous run dp->stack[sp] is already
1168     * set up and dp->tsp will be greater than sp, otherwise a new entry
1169     * needs to be created.
1170     *
1171     * dp->nsp is handled this way:
1172     *
1173     * 1) When an option is pushed onto the stack dp->nsp and dp->tsp are
1174     *    both set (by push_opt) to the next stack entry *unless* there is
1175     *    only one entry in the new list, in which case dp->stack[sp].end
1176     *    is set.
1177     *
1178     * 2) For the top stack entry next_opt is called.  The entry must be
1179     *    active (dp->stack[sp].end is not set) and either 'nsp' or 'end'
1180     *    will be updated as appropriate.
1181     *
1182     * 3) For lower stack entries nsp is set unless the stack entry is
1183     *    already at the end.  This means that when all the higher entries
1184     *    are popped this entry will be too.
1185     */
1186    if (sp >= dp->tsp)
1187    {
1188       push_opt(dp, sp, opt, search); /* This sets tsp to sp+1 */
1189       return 1; /* initialized */
1190    }
1191 
1192    else
1193    {
1194       int ret = 0; /* unchanged */
1195 
1196       /* An option that is already on the stack; update best_size and best_val
1197        * if appropriate.  On the first run there are no previous values and
1198        * dp->write_size will be MAX_SIZE, however on the first run dp->tsp
1199        * starts off as 0.
1200        */
1201       assert(dp->write_size > 0U && dp->write_size < MAX_SIZE);
1202 
1203       if (dp->stack[sp].best_size > dp->write_size ||
1204           (dp->stack[sp].best_size == dp->write_size &&
1205            compare_option(dp, sp) > 0))
1206       {
1207          dp->stack[sp].best_size = dp->write_size;
1208          dp->stack[sp].best_val = dp->value[opt];
1209       }
1210 
1211       if (sp+1U >= dp->tsp)
1212       {
1213          next_opt(dp, sp);
1214          ret = 1; /* advanced */
1215       }
1216 
1217       else if (!dp->stack[sp].end) /* Active, not at top of stack */
1218          dp->nsp = sp+1U;
1219 
1220       return ret; /* advanced || unchanged */
1221    }
1222 }
1223 
1224 static int
getallopts_(struct display * dp,png_byte opt,int * value,int record)1225 getallopts_(struct display *dp, png_byte opt, int *value, int record)
1226    /* Like getop but iterate over all the values if the option was set to "all".
1227     */
1228 {
1229    if (dp->entry[opt]) /* option was set on command line */
1230    {
1231       /* Simple, single value, entries don't have a stack frame and have a fixed
1232        * value (it doesn't change once set on the command line).  Otherwise the
1233        * value (entry) selected from the command line is 'all':
1234        */
1235       const char *entry_name = options[opt].values[dp->entry[opt]-1].name;
1236 
1237       if (entry_name == all)
1238          (void)advance_opt(dp, opt, 0/*do not search; iterate*/);
1239 
1240       else if (record)
1241          record_opt(dp, opt, entry_name);
1242 
1243       *value = dp->value[opt];
1244       return 1; /* set */
1245    }
1246 
1247    else
1248       return 0; /* not set */
1249 }
1250 
1251 static int
getallopts(struct display * dp,const char * opt_str,int * value)1252 getallopts(struct display *dp, const char *opt_str, int *value)
1253 {
1254    return getallopts_(dp, option_index(dp, opt_str, strlen(opt_str)), value, 0);
1255 }
1256 
1257 static int
getsearchopts(struct display * dp,const char * opt_str,int * value)1258 getsearchopts(struct display *dp, const char *opt_str, int *value)
1259    /* As above except that if the option was not set try a search */
1260 {
1261    png_byte istrat;
1262    png_byte opt = option_index(dp, opt_str, strlen(opt_str));
1263    int record = options[opt].search;
1264    const char *entry_name;
1265 
1266    /* If it was set on the command line honour the setting, including 'all'
1267     * which will override the built in search:
1268     */
1269    if (getallopts_(dp, opt, value, record))
1270       return 1;
1271 
1272    else if (!record) /* not a search option */
1273       return 0; /* unset and not searched */
1274 
1275    /* Otherwise decide what to do here. */
1276    istrat = OPTIND(dp, strategy);
1277    entry_name = range_lo; /* record the value, not the name */
1278 
1279    if (opt == istrat) /* search all strategies */
1280       (void)advance_opt(dp, opt, 0/*iterate*/), record=0;
1281 
1282    else if (opt == OPTIND(dp, level))
1283    {
1284       /* Both RLE and HUFFMAN don't benefit from level increases */
1285       if (dp->value[istrat] == Z_RLE || dp->value[istrat] == Z_HUFFMAN_ONLY)
1286          dp->value[opt] = 1;
1287 
1288       else /* fixed, filtered or default */
1289          (void)advance_opt(dp, opt, 1/*search*/), record=0;
1290    }
1291 
1292    else if (opt == OPTIND(dp, windowBits))
1293    {
1294       /* Changing windowBits for strategies that do not search the window is
1295        * pointless.  Huffman-only does not search, RLE only searches backwards
1296        * one byte, so given that the maximum string length is 258, a windowBits
1297        * of 9 is always sufficient.
1298        */
1299       if (dp->value[istrat] == Z_HUFFMAN_ONLY)
1300          dp->value[opt] = 8;
1301 
1302       else if (dp->value[istrat] == Z_RLE)
1303          dp->value[opt] = 9;
1304 
1305       else /* fixed, filtered or default */
1306          (void)advance_opt(dp, opt, 1/*search*/), record=0;
1307    }
1308 
1309    else if (opt == OPTIND(dp, memLevel))
1310    {
1311 #     if 0
1312          (void)advance_opt(dp, opt, 0/*all*/), record=0;
1313 #     else
1314          dp->value[opt] = MAX_MEM_LEVEL;
1315 #     endif
1316    }
1317 
1318    else /* something else */
1319       assert(0=="reached");
1320 
1321    if (record)
1322       record_opt(dp, opt, entry_name);
1323 
1324    /* One of the above searched options: */
1325    *value = dp->value[opt];
1326    return 1;
1327 }
1328 
1329 static int
find_val(struct display * dp,png_byte opt,const char * str,size_t len)1330 find_val(struct display *dp, png_byte opt, const char *str, size_t len)
1331    /* Like option_index but sets (index+i) of the entry in options[opt] that
1332     * matches str[0..len-1] into dp->entry[opt] as well as returning the actual
1333     * value.
1334     */
1335 {
1336    int rlo = INT_MAX, rhi = INT_MIN;
1337    png_byte j, irange = 0;
1338 
1339    for (j=1U; j<=options[opt].value_count; ++j)
1340    {
1341       if (strncmp(options[opt].values[j-1U].name, str, len) == 0 &&
1342           options[opt].values[j-1U].name[len] == 0)
1343       {
1344          dp->entry[opt] = j;
1345          return options[opt].values[j-1U].value;
1346       }
1347       else if (options[opt].values[j-1U].name == range_lo)
1348          rlo = options[opt].values[j-1U].value, irange = j;
1349       else if (options[opt].values[j-1U].name == range_hi)
1350          rhi = options[opt].values[j-1U].value;
1351    }
1352 
1353    /* No match on the name, but there may be a range. */
1354    if (irange > 0)
1355    {
1356       char *ep = NULL;
1357       long l = strtol(str, &ep, 0);
1358 
1359       if (ep == str+len && l >= rlo && l <= rhi)
1360       {
1361          dp->entry[opt] = irange; /* range_lo */
1362          return (int)/*SAFE*/l;
1363       }
1364    }
1365 
1366    display_log(dp, dp->errset ? INTERNAL_ERROR : USER_ERROR,
1367          "%s: unknown value setting '%.*s'", options[opt].name,
1368          (int)/*SAFE*/len, str);
1369    abort(); /* NOT REACHED */
1370 }
1371 
1372 static int
opt_check(struct display * dp,const char * arg)1373 opt_check(struct display *dp, const char *arg)
1374 {
1375    assert(dp->errset == 0);
1376 
1377    if (arg != NULL && arg[0] == '-' && arg[1] == '-')
1378    {
1379       int i = 0, negate = (strncmp(arg+2, "no-", 3) == 0), val;
1380       png_byte j;
1381 
1382       if (negate)
1383          arg += 5; /* --no- */
1384 
1385       else
1386          arg += 2; /* -- */
1387 
1388       /* Find the length (expect arg\0 or arg=) */
1389       while (arg[i] != 0 && arg[i] != '=') ++i;
1390 
1391       /* So arg[0..i-1] is the argument name, this does not return if this isn't
1392        * a valid option name.
1393        */
1394       j = option_index(dp, arg, i);
1395 
1396       /* It matcheth an option; check the remainder. */
1397       if (arg[i] == 0) /* no specified value, use the default */
1398       {
1399          val = options[j].values[negate].value;
1400          dp->entry[j] = (png_byte)/*SAFE*/(negate + 1U);
1401       }
1402 
1403       else
1404       {
1405          const char *list = arg + (i+1);
1406 
1407          /* Expect a single value here unless this is a list, in which case
1408           * multiple values are combined.
1409           */
1410          if (options[j].opt != LIST)
1411          {
1412             /* find_val sets 'dp->entry[j]' to a non-zero value: */
1413             val = find_val(dp, j, list, strlen(list));
1414 
1415             if (negate)
1416             {
1417                if (options[j].opt < OPTION)
1418                   val = !val;
1419 
1420                else
1421                {
1422                   display_log(dp, USER_ERROR,
1423                         "%.*s: option=arg cannot be negated", i, arg);
1424                   abort(); /* NOT REACHED */
1425                }
1426             }
1427          }
1428 
1429          else /* multiple options separated by ',' characters */
1430          {
1431             /* --no-option negates list values from the default, which should
1432              * therefore be 'all'.  Notice that if the option list is empty in
1433              * this case nothing will be removed and therefore --no-option= is
1434              * the same as --option.
1435              */
1436             if (negate)
1437                val = options[j].values[0].value;
1438 
1439             else
1440                val = 0;
1441 
1442             while (*list != 0) /* allows option= which sets 0 */
1443             {
1444                /* A value is terminated by the end of the list or a ','
1445                 * character.
1446                 */
1447                int v, iv;
1448 
1449                iv = 0; /* an index into 'list' */
1450                while (list[++iv] != 0 && list[iv] != ',') {}
1451 
1452                v = find_val(dp, j, list, iv);
1453 
1454                if (negate)
1455                   val &= ~v;
1456 
1457                else
1458                   val |= v;
1459 
1460                list += iv;
1461                if (*list != 0)
1462                   ++list; /* skip the ',' */
1463             }
1464          }
1465       }
1466 
1467       /* 'val' is the new value, store it for use later and debugging: */
1468       dp->value[j] = val;
1469 
1470       if (options[j].opt < LEVEL_MASK)
1471       {
1472          /* The handling for error levels is to set the level. */
1473          if (val) /* Set this level */
1474             dp->options = (dp->options & ~LEVEL_MASK) | options[j].opt;
1475 
1476          else
1477             display_log(dp, USER_ERROR,
1478       "%.*s: messages cannot be turned off individually; set a message level",
1479                   i, arg);
1480       }
1481 
1482       else if (options[j].opt < OPTION)
1483       {
1484          if (val)
1485             dp->options |= options[j].opt;
1486 
1487          else
1488             dp->options &= ~options[j].opt;
1489       }
1490 
1491       return 1; /* this is an option */
1492    }
1493 
1494    else
1495       return 0; /* not an option */
1496 }
1497 
1498 #ifdef PNG_PNGCP_TIMING_SUPPORTED
1499 static void
set_timer(struct display * dp,struct timespec * timer)1500 set_timer(struct display *dp, struct timespec *timer)
1501 {
1502    /* Do the timing using clock_gettime and the per-process timer. */
1503    if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, timer))
1504    {
1505       display_log(dp, APP_ERROR,
1506             "CLOCK_PROCESS_CPUTIME_ID: %s: timing disabled\n", strerror(errno));
1507       dp->value[OPTIND(dp,time)] = 0; /* i.e. off */
1508    }
1509 }
1510 
1511 static void
start_timer(struct display * dp,int what)1512 start_timer(struct display *dp, int what)
1513 {
1514    if ((dp->value[OPTIND(dp,time)] & what) != 0)
1515       set_timer(dp, what == PNGCP_TIME_READ ? &dp->read_time : &dp->write_time);
1516 }
1517 
1518 static void
end_timer(struct display * dp,int what)1519 end_timer(struct display *dp, int what)
1520 {
1521    if ((dp->value[OPTIND(dp,time)] & what) != 0)
1522    {
1523       struct timespec t, tmp;
1524 
1525       set_timer(dp, &t);
1526 
1527       if (what == PNGCP_TIME_READ)
1528          tmp = dp->read_time;
1529 
1530       else
1531          tmp = dp->write_time;
1532 
1533       t.tv_sec -= tmp.tv_sec;
1534       t.tv_nsec -= tmp.tv_nsec;
1535 
1536       if (t.tv_nsec < 0)
1537       {
1538          --(t.tv_sec);
1539          t.tv_nsec += 1000000000L;
1540       }
1541 
1542       if (what == PNGCP_TIME_READ)
1543          dp->read_time = t, tmp = dp->read_time_total;
1544 
1545       else
1546          dp->write_time = t, tmp = dp->write_time_total;
1547 
1548       tmp.tv_sec += t.tv_sec;
1549       tmp.tv_nsec += t.tv_nsec;
1550 
1551       if (tmp.tv_nsec >= 1000000000L)
1552       {
1553          ++(tmp.tv_sec);
1554          tmp.tv_nsec -= 1000000000L;
1555       }
1556 
1557       if (what == PNGCP_TIME_READ)
1558          dp->read_time_total = tmp;
1559 
1560       else
1561          dp->write_time_total = tmp;
1562    }
1563 }
1564 
1565 static void
print_time(const char * what,struct timespec t)1566 print_time(const char *what, struct timespec t)
1567 {
1568    printf("%s %.2lu.%.9ld", what, (unsigned long)t.tv_sec, t.tv_nsec);
1569 }
1570 #else /* !PNGCP_TIMING */
1571 #define start_timer(dp, what) ((void)0)
1572 #define end_timer(dp, what) ((void)0)
1573 #endif /* !PNGCP_TIMING */
1574 
1575 /* The following is used in main to verify that the final argument is a
1576  * directory:
1577  */
1578 static int
checkdir(const char * pathname)1579 checkdir(const char *pathname)
1580 {
1581    struct stat buf;
1582    return stat(pathname, &buf) == 0 && S_ISDIR(buf.st_mode);
1583 }
1584 
1585 /* Work out whether a path is valid (if not a display_log occurs), a directory
1586  * (1 is returned) or a file *or* non-existent (0 is returned).
1587  *
1588  * Used for a write path.
1589  */
1590 static int
isdir(struct display * dp,const char * pathname)1591 isdir(struct display *dp, const char *pathname)
1592 {
1593    if (pathname == NULL)
1594       return 0; /* stdout */
1595 
1596    else if (pathname[0] == 0)
1597       return 1; /* empty string */
1598 
1599    else
1600    {
1601       struct stat buf;
1602       int ret = stat(pathname, &buf);
1603 
1604       if (ret == 0) /* the entry exists */
1605       {
1606          if (S_ISDIR(buf.st_mode))
1607             return 1;
1608 
1609          /* Else expect an object that exists and can be written: */
1610          if (access(pathname, W_OK) != 0)
1611             display_log(dp, USER_ERROR, "%s: cannot be written (%s)", pathname,
1612                   strerror(errno));
1613 
1614          return 0; /* file (exists, can be written) */
1615       }
1616 
1617       else /* an error */
1618       {
1619          /* Non-existence is fine, other errors are not: */
1620          if (errno != ENOENT)
1621             display_log(dp, USER_ERROR, "%s: invalid output name (%s)",
1622                   pathname, strerror(errno));
1623 
1624          return 0; /* file (does not exist) */
1625       }
1626    }
1627 }
1628 
1629 static void
makename(struct display * dp,const char * dir,const char * infile)1630 makename(struct display *dp, const char *dir, const char *infile)
1631 {
1632    /* Make a name for an output file (and check it). */
1633    dp->namebuf[0] = 0;
1634 
1635    if (dir == NULL || infile == NULL)
1636       display_log(dp, INTERNAL_ERROR, "NULL name to makename");
1637 
1638    else
1639    {
1640       size_t dsize = strlen(dir);
1641 
1642       if (dsize <= (sizeof dp->namebuf)-2) /* Allow for name + '/' + '\0' */
1643       {
1644          size_t isize = strlen(infile);
1645          size_t istart = isize-1;
1646 
1647          /* This should fail before here: */
1648          if (infile[istart] == '/')
1649             display_log(dp, INTERNAL_ERROR, "infile with trailing /");
1650 
1651          memcpy(dp->namebuf, dir, dsize);
1652          if (dsize > 0 && dp->namebuf[dsize-1] != '/')
1653             dp->namebuf[dsize++] = '/';
1654 
1655          /* Find the rightmost non-/ character: */
1656          while (istart > 0 && infile[istart-1] != '/')
1657             --istart;
1658 
1659          isize -= istart;
1660          infile += istart;
1661 
1662          if (dsize+isize < (sizeof dp->namebuf)) /* dsize + infile + '\0' */
1663          {
1664             memcpy(dp->namebuf+dsize, infile, isize+1);
1665 
1666             if (isdir(dp, dp->namebuf))
1667                display_log(dp, USER_ERROR, "%s: output file is a directory",
1668                      dp->namebuf);
1669          }
1670 
1671          else
1672          {
1673             dp->namebuf[dsize] = 0; /* allowed for: -2 at start */
1674             display_log(dp, USER_ERROR, "%s%s: output file name too long",
1675                   dp->namebuf, infile);
1676          }
1677       }
1678 
1679       else
1680          display_log(dp, USER_ERROR, "%s: output directory name too long", dir);
1681    }
1682 }
1683 
1684 /* error handler callbacks for libpng */
1685 static void PNGCBAPI
display_warning(png_structp pp,png_const_charp warning)1686 display_warning(png_structp pp, png_const_charp warning)
1687 {
1688    struct display *dp = get_dp(pp);
1689 
1690    /* This is used to prevent repeated warnings while searching */
1691    if (!dp->no_warnings)
1692       display_log(get_dp(pp), LIBPNG_WARNING, "%s", warning);
1693 }
1694 
1695 static void PNGCBAPI
display_error(png_structp pp,png_const_charp error)1696 display_error(png_structp pp, png_const_charp error)
1697 {
1698    struct display *dp = get_dp(pp);
1699 
1700    display_log(dp, LIBPNG_ERROR, "%s", error);
1701 }
1702 
1703 static void
display_start_read(struct display * dp,const char * filename)1704 display_start_read(struct display *dp, const char *filename)
1705 {
1706    if (filename != NULL)
1707    {
1708       dp->filename = filename;
1709       dp->fp = fopen(filename, "rb");
1710    }
1711 
1712    else
1713    {
1714       dp->filename = "<stdin>";
1715       dp->fp = stdin;
1716    }
1717 
1718    dp->w = dp->h = 0U;
1719    dp->bpp = 0U;
1720    dp->size = 0U;
1721    dp->read_size = 0U;
1722 
1723    if (dp->fp == NULL)
1724       display_log(dp, USER_ERROR, "file open failed (%s)", strerror(errno));
1725 }
1726 
1727 static void PNGCBAPI
read_function(png_structp pp,png_bytep data,size_t size)1728 read_function(png_structp pp, png_bytep data, size_t size)
1729 {
1730    struct display *dp = get_dp(pp);
1731 
1732    if (size == 0U || fread(data, size, 1U, dp->fp) == 1U)
1733       dp->read_size += size;
1734 
1735    else
1736    {
1737       if (feof(dp->fp))
1738          display_log(dp, LIBPNG_ERROR, "PNG file truncated");
1739       else
1740          display_log(dp, LIBPNG_ERROR, "PNG file read failed (%s)",
1741                strerror(errno));
1742    }
1743 }
1744 
1745 static void
read_png(struct display * dp,const char * filename)1746 read_png(struct display *dp, const char *filename)
1747 {
1748    display_clean_read(dp); /* safety */
1749    display_start_read(dp, filename);
1750 
1751    dp->read_pp = png_create_read_struct(PNG_LIBPNG_VER_STRING, dp,
1752       display_error, display_warning);
1753    if (dp->read_pp == NULL)
1754       display_log(dp, LIBPNG_ERROR, "failed to create read struct");
1755 
1756 #  ifdef PNG_BENIGN_ERRORS_SUPPORTED
1757       png_set_benign_errors(dp->read_pp, 1/*allowed*/);
1758 #  endif /* BENIGN_ERRORS */
1759 
1760 #  ifdef FIX_INDEX
1761       if ((dp->options & FIX_INDEX) != 0)
1762          png_set_check_for_invalid_index(dp->read_pp, 1/*on, no warning*/);
1763 #     ifdef IGNORE_INDEX
1764          else
1765 #     endif /* IGNORE_INDEX */
1766 #  endif /* FIX_INDEX */
1767 #  ifdef IGNORE_INDEX
1768       if ((dp->options & IGNORE_INDEX) != 0) /* DANGEROUS */
1769          png_set_check_for_invalid_index(dp->read_pp, -1/*off completely*/);
1770 #  endif /* IGNORE_INDEX */
1771 
1772    /* The png_read_png API requires us to make the info struct, but it does the
1773     * call to png_read_info.
1774     */
1775    dp->ip = png_create_info_struct(dp->read_pp);
1776    if (dp->ip == NULL)
1777       png_error(dp->read_pp, "failed to create info struct");
1778 
1779    /* Set the IO handling */
1780    png_set_read_fn(dp->read_pp, dp, read_function);
1781 
1782 #  ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
1783       png_set_keep_unknown_chunks(dp->read_pp, PNG_HANDLE_CHUNK_ALWAYS, NULL,
1784             0);
1785 #  endif /* HANDLE_AS_UNKNOWN */
1786 
1787 #  ifdef PNG_SET_USER_LIMITS_SUPPORTED
1788       /* Remove the user limits, if any */
1789       png_set_user_limits(dp->read_pp, 0x7fffffff, 0x7fffffff);
1790 #  endif /* SET_USER_LIMITS */
1791 
1792    /* Now read the PNG. */
1793    start_timer(dp, PNGCP_TIME_READ);
1794    png_read_png(dp->read_pp, dp->ip, 0U/*transforms*/, NULL/*params*/);
1795    end_timer(dp, PNGCP_TIME_READ);
1796    dp->w = png_get_image_width(dp->read_pp, dp->ip);
1797    dp->h = png_get_image_height(dp->read_pp, dp->ip);
1798    dp->ct = png_get_color_type(dp->read_pp, dp->ip);
1799    dp->bpp = png_get_bit_depth(dp->read_pp, dp->ip) *
1800              png_get_channels(dp->read_pp, dp->ip);
1801    {
1802       /* png_get_rowbytes should never return 0 because the value is set by the
1803        * first call to png_set_IHDR, which should have happened by now, but just
1804        * in case:
1805        */
1806       png_alloc_size_t rb = png_get_rowbytes(dp->read_pp, dp->ip);
1807 
1808       if (rb == 0)
1809          png_error(dp->read_pp, "invalid row byte count from libpng");
1810 
1811       /* The size calc can overflow. */
1812       if ((MAX_SIZE-dp->h)/rb < dp->h)
1813          png_error(dp->read_pp, "image too large");
1814 
1815       dp->size = rb * dp->h + dp->h/*filter byte*/;
1816    }
1817 
1818 #ifdef FIX_INDEX
1819    if (dp->ct == PNG_COLOR_TYPE_PALETTE && (dp->options & FIX_INDEX) != 0)
1820    {
1821       int max = png_get_palette_max(dp->read_pp, dp->ip);
1822       png_colorp palette = NULL;
1823       int num = -1;
1824 
1825       if (png_get_PLTE(dp->read_pp, dp->ip, &palette, &num) != PNG_INFO_PLTE
1826           || max < 0 || num <= 0 || palette == NULL)
1827          display_log(dp, LIBPNG_ERROR, "invalid png_get_PLTE result");
1828 
1829       if (max >= num)
1830       {
1831          /* 'Fix' the palette. */
1832          int i;
1833          png_color newpal[256];
1834 
1835          for (i=0; i<num; ++i)
1836             newpal[i] = palette[i];
1837 
1838          /* Fill in any remainder with a warning color: */
1839          for (; i<=max; ++i)
1840          {
1841             newpal[i].red = 0xbe;
1842             newpal[i].green = 0xad;
1843             newpal[i].blue = 0xed;
1844          }
1845 
1846          png_set_PLTE(dp->read_pp, dp->ip, newpal, i);
1847       }
1848    }
1849 #endif /* FIX_INDEX */
1850 
1851    display_clean_read(dp);
1852    dp->operation = "none";
1853 }
1854 
1855 static void
display_start_write(struct display * dp,const char * filename)1856 display_start_write(struct display *dp, const char *filename)
1857 {
1858    assert(dp->fp == NULL);
1859 
1860    if ((dp->options & NOWRITE) != 0)
1861       dp->output_file = "<no write>";
1862 
1863    else
1864    {
1865       if (filename != NULL)
1866       {
1867          dp->output_file = filename;
1868          dp->fp = fopen(filename, "wb");
1869       }
1870 
1871       else
1872       {
1873          dp->output_file = "<stdout>";
1874          dp->fp = stdout;
1875       }
1876 
1877       if (dp->fp == NULL)
1878          display_log(dp, USER_ERROR, "%s: file open failed (%s)",
1879                dp->output_file, strerror(errno));
1880    }
1881 }
1882 
1883 static void PNGCBAPI
write_function(png_structp pp,png_bytep data,size_t size)1884 write_function(png_structp pp, png_bytep data, size_t size)
1885 {
1886    struct display *dp = get_dp(pp);
1887 
1888    /* The write fail is classed as a USER_ERROR, so --quiet does not turn it
1889     * off, this seems more likely to be correct.
1890     */
1891    if (dp->fp == NULL || fwrite(data, size, 1U, dp->fp) == 1U)
1892    {
1893       dp->write_size += size;
1894       if (dp->write_size < size || dp->write_size == MAX_SIZE)
1895          png_error(pp, "IDAT size overflow");
1896    }
1897 
1898    else
1899       display_log(dp, USER_ERROR, "%s: PNG file write failed (%s)",
1900             dp->output_file, strerror(errno));
1901 }
1902 
1903 /* Compression option, 'method' is never set: there is no choice.
1904  *
1905  * IMPORTANT: the order of the entries in this macro determines the preference
1906  * order when two different combos of two of these options produce an IDAT of
1907  * the same size.  The logic here is to put the things that affect the decoding
1908  * of the PNG image ahead of those that are relevant only to the encoding.
1909  */
1910 #define SET_COMPRESSION\
1911    SET(strategy, strategy);\
1912    SET(windowBits, window_bits);\
1913    SET(level, level);\
1914    SET(memLevel, mem_level);
1915 
1916 #ifdef PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED
1917 static void
search_compression(struct display * dp)1918 search_compression(struct display *dp)
1919 {
1920    /* Like set_compression below but use a more restricted search than 'all' */
1921    int val;
1922 
1923 #  define SET(name, func) if (getsearchopts(dp, #name, &val))\
1924       png_set_compression_ ## func(dp->write_pp, val);
1925    SET_COMPRESSION
1926 #  undef SET
1927 }
1928 
1929 static void
set_compression(struct display * dp)1930 set_compression(struct display *dp)
1931 {
1932    int val;
1933 
1934 #  define SET(name, func) if (getallopts(dp, #name, &val))\
1935       png_set_compression_ ## func(dp->write_pp, val);
1936    SET_COMPRESSION
1937 #  undef SET
1938 }
1939 
1940 #ifdef PNG_SW_COMPRESS_level /* 1.7.0+ */
1941 static void
set_ICC_profile_compression(struct display * dp)1942 set_ICC_profile_compression(struct display *dp)
1943 {
1944    int val;
1945 
1946 #  define SET(name, func) if (getallopts(dp, "ICC-profile-" #name, &val))\
1947       png_set_ICC_profile_compression_ ## func(dp->write_pp, val);
1948    SET_COMPRESSION
1949 #  undef SET
1950 }
1951 #else
1952 #  define set_ICC_profile_compression(dp) ((void)0)
1953 #endif
1954 #else
1955 #  define search_compression(dp) ((void)0)
1956 #  define set_compression(dp) ((void)0)
1957 #  define set_ICC_profile_compression(dp) ((void)0)
1958 #endif /* WRITE_CUSTOMIZE_COMPRESSION */
1959 
1960 #ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
1961 static void
set_text_compression(struct display * dp)1962 set_text_compression(struct display *dp)
1963 {
1964    int val;
1965 
1966 #  define SET(name, func) if (getallopts(dp, "text-" #name, &val))\
1967       png_set_text_compression_ ## func(dp->write_pp, val);
1968    SET_COMPRESSION
1969 #  undef SET
1970 }
1971 #else
1972 #  define set_text_compression(dp) ((void)0)
1973 #endif /* WRITE_CUSTOMIZE_ZTXT_COMPRESSION */
1974 
1975 static void
write_png(struct display * dp,const char * destname)1976 write_png(struct display *dp, const char *destname)
1977 {
1978    display_clean_write(dp); /* safety */
1979    display_start_write(dp, destname);
1980 
1981    dp->write_pp = png_create_write_struct(PNG_LIBPNG_VER_STRING, dp,
1982       display_error, display_warning);
1983 
1984    if (dp->write_pp == NULL)
1985       display_log(dp, LIBPNG_ERROR, "failed to create write png_struct");
1986 
1987 #  ifdef PNG_BENIGN_ERRORS_SUPPORTED
1988       png_set_benign_errors(dp->write_pp, 1/*allowed*/);
1989 #  endif /* BENIGN_ERRORS */
1990 
1991    png_set_write_fn(dp->write_pp, dp, write_function, NULL/*flush*/);
1992 
1993 #ifdef IGNORE_INDEX
1994    if ((dp->options & IGNORE_INDEX) != 0) /* DANGEROUS */
1995       png_set_check_for_invalid_index(dp->write_pp, -1/*off completely*/);
1996 #endif /* IGNORE_INDEX */
1997 
1998    /* Restore the text chunks when using libpng 1.6 or less; this is a macro
1999     * which expands to nothing in 1.7+  In earlier versions it tests
2000     * dp->text_stashed, which is only set (below) *after* the first write.
2001     */
2002    text_restore(dp);
2003 
2004 #  ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
2005       png_set_keep_unknown_chunks(dp->write_pp, PNG_HANDLE_CHUNK_ALWAYS, NULL,
2006             0);
2007 #  endif /* HANDLE_AS_UNKNOWN */
2008 
2009 #  ifdef PNG_SET_USER_LIMITS_SUPPORTED
2010       /* Remove the user limits, if any */
2011       png_set_user_limits(dp->write_pp, 0x7fffffff, 0x7fffffff);
2012 #  endif
2013 
2014    /* OPTION HANDLING */
2015    /* compression outputs, IDAT and zTXt/iTXt: */
2016    dp->tsp = dp->nsp;
2017    dp->nsp = dp->csp = 0;
2018 #  ifdef PNG_SW_COMPRESS_png_level
2019       {
2020          int val;
2021 
2022          /* This sets everything, but then the following options just override
2023           * the specific settings for ICC profiles and text.
2024           */
2025          if (getallopts(dp, "compression", &val))
2026             png_set_compression(dp->write_pp, val);
2027 
2028          if (getallopts(dp, "ICC-profile-compression", &val))
2029             png_set_ICC_profile_compression(dp->write_pp, val);
2030 
2031          if (getallopts(dp, "text-compression", &val))
2032             png_set_text_compression(dp->write_pp, val);
2033       }
2034 #  endif /* png_level support */
2035    if (dp->options & SEARCH)
2036       search_compression(dp);
2037    else
2038       set_compression(dp);
2039    set_ICC_profile_compression(dp);
2040    set_text_compression(dp);
2041 
2042    {
2043       int val;
2044 
2045       /* The permitted range is 1..0x7FFFFFFF, so the cast is safe */
2046       if (get_option(dp, "IDAT-size", &val))
2047          png_set_IDAT_size(dp->write_pp, val);
2048    }
2049 
2050    /* filter handling */
2051 #  ifdef PNG_WRITE_FILTER_SUPPORTED
2052       {
2053          int val;
2054 
2055          if (get_option(dp, "filter", &val))
2056             png_set_filter(dp->write_pp, PNG_FILTER_TYPE_BASE, val);
2057       }
2058 #  endif /* WRITE_FILTER */
2059 
2060    /* This just uses the 'read' info_struct directly, it contains the image. */
2061    dp->write_size = 0U;
2062    start_timer(dp, PNGCP_TIME_WRITE);
2063    png_write_png(dp->write_pp, dp->ip, 0U/*transforms*/, NULL/*params*/);
2064    end_timer(dp, PNGCP_TIME_WRITE);
2065 
2066    /* Make sure the file was written ok: */
2067    if (dp->fp != NULL)
2068    {
2069       FILE *fp = dp->fp;
2070       dp->fp = NULL;
2071       if (fclose(fp))
2072          display_log(dp, APP_ERROR, "%s: write failed (%s)",
2073                destname == NULL ? "stdout" : destname, strerror(errno));
2074    }
2075 
2076    /* Clean it on the way out - if control returns to the caller then the
2077     * written_file contains the required data.
2078     */
2079    display_clean_write(dp);
2080    dp->operation = "none";
2081 }
2082 
2083 static void
set_windowBits_hi(struct display * dp)2084 set_windowBits_hi(struct display *dp)
2085 {
2086    /* windowBits is in the range 8..15 but zlib maps '8' to '9' so it is only
2087     * worth using if the data size is 256 byte or less.
2088     */
2089    int wb = MAX_WBITS; /* for large images */
2090    int i = VLSIZE(windowBits_IDAT);
2091 
2092    while (wb > 8 && dp->size <= 1U<<(wb-1)) --wb;
2093 
2094    while (--i >= 0) if (VLNAME(windowBits_IDAT)[i].name == range_hi) break;
2095 
2096    assert(i > 1); /* vl_windowBits_IDAT always has a RANGE() */
2097    VLNAME(windowBits_IDAT)[i].value = wb;
2098 
2099    assert(VLNAME(windowBits_IDAT)[--i].name == range_lo);
2100    VLNAME(windowBits_IDAT)[i].value = wb > 8 ? 9 : 8;
2101 
2102    /* If wb == 8 then any search has been restricted to just one windowBits
2103     * entry.  Record that here to avoid producing a spurious app-level warning
2104     * above.
2105     */
2106    if (wb == 8)
2107       dp->min_windowBits = OPTIND(dp, windowBits);
2108 }
2109 
2110 static int
better_options(const struct display * dp)2111 better_options(const struct display *dp)
2112 {
2113    /* Are these options better than the best found so far?  Normally the
2114     * options are tested in preference order, best first, however when doing a
2115     * search operation on a range the range values are tested out of order.  In
2116     * that case preferable options will get tested later.
2117     *
2118     * This function looks through the stack from the bottom up looking for an
2119     * option that does not match the current best value.  When it finds one it
2120     * checks to see if it is more or less desirable and returns true or false
2121     * as appropriate.
2122     *
2123     * Notice that this means that the order options are pushed onto the stack
2124     * conveys a priority; lower/earlier options are more important than later
2125     * ones.
2126     */
2127    unsigned int sp;
2128 
2129    for (sp=0; sp<dp->csp; ++sp)
2130    {
2131       int c = compare_option(dp, sp);
2132 
2133       if (c < 0)
2134          return 0; /* worse */
2135 
2136       else if (c > 0)
2137          return 1; /* better */
2138    }
2139 
2140    assert(0 && "unreached");
2141 }
2142 
2143 static void
print_search_results(struct display * dp)2144 print_search_results(struct display *dp)
2145 {
2146    assert(dp->filename != NULL);
2147    printf("%s [%ld x %ld %d bpp %s, %lu bytes] %lu -> %lu with '%s'\n",
2148       dp->filename, (unsigned long)dp->w, (unsigned long)dp->h, dp->bpp,
2149       cts(dp->ct), (unsigned long)dp->size, (unsigned long)dp->read_size,
2150       (unsigned long)dp->best_size, dp->best);
2151    fflush(stdout);
2152 }
2153 
2154 static void
log_search(struct display * dp,unsigned int log_depth)2155 log_search(struct display *dp, unsigned int log_depth)
2156 {
2157    /* Log, and reset, the search so far: */
2158    if (dp->nsp/*next entry to change*/ <= log_depth)
2159    {
2160       print_search_results(dp);
2161       /* Start again with this entry: */
2162       dp->best_size = MAX_SIZE;
2163    }
2164 }
2165 
2166 static void
cp_one_file(struct display * dp,const char * filename,const char * destname)2167 cp_one_file(struct display *dp, const char *filename, const char *destname)
2168 {
2169    unsigned int log_depth;
2170 
2171    dp->filename = filename;
2172    dp->operation = "read";
2173    dp->no_warnings = 0;
2174 
2175    /* Read it then write it: */
2176    if (filename != NULL && access(filename, R_OK) != 0)
2177       display_log(dp, USER_ERROR, "%s: invalid file name (%s)",
2178             filename, strerror(errno));
2179 
2180    read_png(dp, filename);
2181 
2182    /* But 'destname' may be a directory. */
2183    dp->operation = "write";
2184 
2185    /* Limit the upper end of the windowBits range for this file */
2186    set_windowBits_hi(dp);
2187 
2188    /* For logging, depth to log: */
2189    {
2190       int val;
2191 
2192       if (get_option(dp, "log-depth", &val) && val >= 0)
2193          log_depth = (unsigned int)/*SAFE*/val;
2194 
2195       else
2196          log_depth = 0U;
2197    }
2198 
2199    if (destname != NULL) /* else stdout */
2200    {
2201       if (isdir(dp, destname))
2202       {
2203          makename(dp, destname, filename);
2204          destname = dp->namebuf;
2205       }
2206 
2207       else if (access(destname, W_OK) != 0 && errno != ENOENT)
2208          display_log(dp, USER_ERROR, "%s: invalid output name (%s)", destname,
2209                strerror(errno));
2210    }
2211 
2212    dp->nsp = 0;
2213    dp->curr[0] = 0; /* acts as a flag for the caller */
2214    dp->opt_string_start = 0;
2215    dp->best[0] = 0; /* safety */
2216    dp->best_size = MAX_SIZE;
2217    write_png(dp, destname);
2218 
2219    /* Initialize the 'best' fields: */
2220    strcpy(dp->best, dp->curr);
2221    dp->best_size = dp->write_size;
2222 
2223    if (dp->nsp > 0) /* iterating over lists */
2224    {
2225       char *tmpname, tmpbuf[(sizeof dp->namebuf) + 4];
2226       assert(dp->curr[0] == ' ' && dp->tsp > 0);
2227 
2228       /* Cancel warnings on subsequent writes */
2229       log_search(dp, log_depth);
2230       dp->no_warnings = 1;
2231 
2232       /* Make a temporary name for the subsequent tests: */
2233       if (destname != NULL)
2234       {
2235          strcpy(tmpbuf, destname);
2236          strcat(tmpbuf, ".tmp"); /* space for .tmp allocated above */
2237          tmpname = tmpbuf;
2238       }
2239 
2240       else
2241          tmpname = NULL; /* stdout */
2242 
2243       /* Loop to find the best option. */
2244       do
2245       {
2246          write_png(dp, tmpname);
2247 
2248          /* And compare the sizes (the write function makes sure write_size
2249           * doesn't overflow.)
2250           */
2251          assert(dp->csp > 0);
2252 
2253          if (dp->write_size < dp->best_size ||
2254              (dp->write_size == dp->best_size && better_options(dp)))
2255          {
2256             if (destname != NULL && rename(tmpname, destname) != 0)
2257                display_log(dp, APP_ERROR, "rename %s %s failed (%s)", tmpname,
2258                      destname, strerror(errno));
2259 
2260             strcpy(dp->best, dp->curr);
2261             dp->best_size = dp->write_size;
2262          }
2263 
2264          else if (tmpname != NULL && unlink(tmpname) != 0)
2265             display_log(dp, APP_WARNING, "unlink %s failed (%s)", tmpname,
2266                   strerror(errno));
2267 
2268          log_search(dp, log_depth);
2269       }
2270       while (dp->nsp > 0);
2271 
2272       /* Do this for the 'sizes' option so that it reports the correct size. */
2273       dp->write_size = dp->best_size;
2274    }
2275 }
2276 
2277 static int
cppng(struct display * dp,const char * file,const char * gv dest)2278 cppng(struct display *dp, const char *file, const char *gv dest)
2279    /* Exists solely to isolate the setjmp clobbers which some versions of GCC
2280     * erroneously generate.
2281     */
2282 {
2283    int ret = setjmp(dp->error_return);
2284 
2285    if (ret == 0)
2286    {
2287       dp->errset = 1;
2288       cp_one_file(dp, file, dest);
2289       dp->errset = 0;
2290       return 0;
2291    }
2292 
2293    else
2294    {
2295       dp->errset = 0;
2296 
2297       if (ret < ERRORS) /* shouldn't longjmp on warnings */
2298          display_log(dp, INTERNAL_ERROR, "unexpected return code %d", ret);
2299 
2300       return ret;
2301    }
2302 }
2303 
2304 int
main(int argc,char ** argv)2305 main(int argc, char **argv)
2306 {
2307    /* For each file on the command line test it with a range of transforms */
2308    int option_end;
2309    struct display d;
2310 
2311    display_init(&d);
2312 
2313    d.operation = "options";
2314    for (option_end = 1;
2315         option_end < argc && opt_check(&d, argv[option_end]);
2316         ++option_end)
2317    {
2318    }
2319 
2320    /* Do a quick check on the directory target case; when there are more than
2321     * two arguments the last one must be a directory.
2322     */
2323    if (!(d.options & NOWRITE) && option_end+2 < argc && !checkdir(argv[argc-1]))
2324    {
2325       fprintf(stderr,
2326             "pngcp: %s: directory required with more than two arguments\n",
2327             argv[argc-1]);
2328       return 99;
2329    }
2330 
2331    {
2332       int errors = 0;
2333       int i = option_end;
2334 
2335       /* Do this at least once; if there are no arguments stdin/stdout are used.
2336        */
2337       d.operation = "files";
2338       do
2339       {
2340          const char *infile = NULL;
2341          const char *outfile = NULL;
2342          int ret;
2343 
2344          if (i < argc)
2345          {
2346             infile = argv[i++];
2347             if (!(d.options & NOWRITE) && i < argc)
2348                outfile = argv[argc-1];
2349          }
2350 
2351          ret = cppng(&d, infile, outfile);
2352 
2353          if (ret)
2354          {
2355             if (ret > QUIET) /* abort on user or internal error */
2356                return 99;
2357 
2358             /* An error: the output is meaningless */
2359          }
2360 
2361          else if (d.best[0] != 0)
2362          {
2363             /* This result may already have been output, in which case best_size
2364              * has been reset.
2365              */
2366             if (d.best_size < MAX_SIZE)
2367                print_search_results(&d);
2368          }
2369 
2370          else if (d.options & SIZES)
2371          {
2372             printf("%s [%ld x %ld %d bpp %s, %lu bytes] %lu -> %lu [0x%lx]\n",
2373                   infile, (unsigned long)d.w, (unsigned long)d.h, d.bpp,
2374                   cts(d.ct), (unsigned long)d.size, (unsigned long)d.read_size,
2375                   (unsigned long)d.write_size, (unsigned long)d.results);
2376             fflush(stdout);
2377          }
2378 
2379          /* Here on any return, including failures, except user/internal issues
2380           */
2381          {
2382             int pass = (d.options & STRICT) ?
2383                RESULT_STRICT(d.results) : RESULT_RELAXED(d.results);
2384 
2385             if (!pass)
2386                ++errors;
2387 
2388             if (d.options & LOG)
2389             {
2390                int j;
2391 
2392                printf("%s: pngcp", pass ? "PASS" : "FAIL");
2393 
2394                for (j=1; j<option_end; ++j)
2395                   printf(" %s", argv[j]);
2396 
2397                if (infile != NULL)
2398                   printf(" %s", infile);
2399 
2400 #              ifdef PNG_PNGCP_TIMING_SUPPORTED
2401                   /* When logging output the files for each file, if enabled. */
2402                   if ((d.value[OPTIND(&d,time)] & PNGCP_TIME_READ) != 0)
2403                      print_time(" read", d.read_time);
2404 
2405                   if ((d.value[OPTIND(&d,time)] & PNGCP_TIME_WRITE) != 0)
2406                      print_time(" write", d.write_time);
2407 #              endif /* PNGCP_TIMING */
2408 
2409                printf("\n");
2410                fflush(stdout);
2411             }
2412          }
2413 
2414          display_clean(&d);
2415       }
2416       while (i+!(d.options & NOWRITE) < argc);
2417          /* I.e. for write cases after the first time through the loop require
2418           * there to be at least two arguments left and for the last one to be a
2419           * directory (this was checked above).
2420           */
2421 
2422       /* Release allocated memory */
2423       display_destroy(&d);
2424 
2425 #     ifdef PNG_PNGCP_TIMING_SUPPORTED
2426          {
2427             int output = 0;
2428 
2429             if ((d.value[OPTIND(&d,time)] & PNGCP_TIME_READ) != 0)
2430                print_time("read", d.read_time_total), output = 1;
2431 
2432             if ((d.value[OPTIND(&d,time)] & PNGCP_TIME_WRITE) != 0)
2433             {
2434                if (output) putchar(' ');
2435                print_time("write", d.write_time_total);
2436                output = 1;
2437             }
2438 
2439             if (output) putchar('\n');
2440          }
2441 #     endif /* PNGCP_TIMING */
2442 
2443       return errors != 0;
2444    }
2445 }
2446 #else /* !READ_PNG || !WRITE_PNG */
2447 int
main(void)2448 main(void)
2449 {
2450    fprintf(stderr, "pngcp: no support for png_read/write_image\n");
2451    return 77;
2452 }
2453 #endif /* !READ_PNG || !WRITE_PNG */
2454