kit

compress.c (15863B)

---

 #include <kit/compress.h>
 #include <kit/core.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
 #include "driver.h"
 #include "env.h"
 
 /* `kit compress` — compress or decompress a stream with one of two standard,
  * interoperable containers: gzip (`.gz`, default) or the LZ4 frame format
  * (`.lz4`). Reads a FILE operand or stdin, writes to `-o OUT` or stdout. On
  * decompress the format is auto-detected from the input's magic bytes unless
  * `-z` forces it. Drives the public kit/compress.h API.
  *
  * The same core backs the standard-named aliases, each pinning a container and
  * a default direction so it drops in for the matching command:
  *   gzip  -> compress, gzip       gunzip -> decompress, gzip
  *   lz4   -> compress, LZ4 frame  lz4c   -> compress, LZ4 frame (legacy name)
  * Under an alias -z is rejected (the container is fixed), the common
  * gzip/lz4 flags (-c/-k/-f, levels, ...) are accepted, and -d still flips the
  * direction. kit always streams to stdout/`-o` and never rewrites the input in
  * place, so the in-place file flags are deliberately not emulated. */
 
 #define COMPRESS_TOOL "compress"
 
 /* Invocation personality. The generic `compress` leaves format and direction
  * to flags; the aliases pin a container and a starting direction. */
 typedef struct CompressPersona {
   const char* name;         /* tool name for diagnostics: compress/gzip/... */
   KitCompressFormat format; /* default (and, when locked, the only) container */
   int locked_format;        /* alias pins the container: -z is rejected, no
                              * decompress auto-detection */
   int default_decompress;   /* alias starts in decompress mode (gunzip) */
   int compat;               /* accept gzip/lz4-style compatibility flags */
 } CompressPersona;
 
 static const CompressPersona CZ_GENERIC = {"compress", KIT_COMPRESS_GZIP, 0, 0,
                                            0};
 static const CompressPersona CZ_GZIP = {"gzip", KIT_COMPRESS_GZIP, 1, 0, 1};
 static const CompressPersona CZ_GUNZIP = {"gunzip", KIT_COMPRESS_GZIP, 1, 1, 1};
 static const CompressPersona CZ_LZ4 = {"lz4", KIT_COMPRESS_LZ4_FRAME, 1, 0, 1};
 static const CompressPersona CZ_LZ4C = {"lz4c", KIT_COMPRESS_LZ4_FRAME, 1, 0,
                                         1};
 
 typedef struct CompressOpts {
   int decompress;  /* -d */
   int have_format; /* whether -z/--format (or a pinned container) was given */
   KitCompressFormat format;
   int seen_input;  /* a FILE or `-` operand was seen */
   const char* in;  /* input path, or NULL = stdin */
   const char* out; /* output path, or NULL = stdout */
 } CompressOpts;
 
 static int compress_parse_format(const char* s, KitCompressFormat* out) {
   if (driver_streq(s, "gzip") || driver_streq(s, "gz")) {
     *out = KIT_COMPRESS_GZIP;
     return 0;
   }
   if (driver_streq(s, "lz4")) {
     *out = KIT_COMPRESS_LZ4_FRAME;
     return 0;
   }
   return 1;
 }
 
 static void compress_unknown_format(const char* tool, const char* value) {
   const char* const formats[] = {"gzip", "gz", "lz4"};
   DriverSuggestion suggestions[3];
   size_t n = driver_suggest_values(value, formats,
                                    sizeof formats / sizeof formats[0],
                                    suggestions, 3);
   if (n)
     driver_errf(tool, "unknown format: %s; did you mean '%s'?", value,
                 suggestions[0].value);
   else
     driver_errf(tool, "unknown format: %s (use gzip or lz4)", value);
 }
 
 /* gzip/lz4-style flags accepted (as no-ops) under an alias so the tool works
  * as a drop-in. kit always streams stdin/-o to stdout and never mutates the
  * input in place, so -c/--stdout, -k/--keep and -f/--force have nothing to do;
  * the codecs expose no level, so -1..-9 / --fast[=N] / --best are ignored too.
  * Direction (-d) and the long decompress spellings are handled by the caller.
  * Returns 1 if `a` is one of these accepted no-ops. */
 static int compress_compat_noop(const char* a) {
   if (driver_streq(a, "-c") || driver_streq(a, "--stdout") ||
       driver_streq(a, "--to-stdout"))
     return 1;
   if (driver_streq(a, "-k") || driver_streq(a, "--keep")) return 1;
   if (driver_streq(a, "-f") || driver_streq(a, "--force")) return 1;
   if (driver_streq(a, "-n") || driver_streq(a, "--no-name")) return 1;
   if (driver_streq(a, "-q") || driver_streq(a, "--quiet")) return 1;
   if (driver_streq(a, "--best") || driver_streq(a, "--fast")) return 1;
   if (driver_strneq(a, "--fast=", 7)) return 1;
   /* -N / -NN compression level (gzip 1-9, lz4 up to 12): a dash then digits. */
   if (a[0] == '-' && a[1] >= '1' && a[1] <= '9') {
     size_t k = 2;
     while (a[k] >= '0' && a[k] <= '9') ++k;
     if (a[k] == '\0') return 1;
   }
   return 0;
 }
 
 static void compress_help(const CompressPersona* persona) {
   if (!persona->locked_format) {
     driver_printf(
         "%.*s",
         KIT_SLICE_ARG(KIT_SLICE_LIT(
             "kit compress — compress or decompress gzip and LZ4 frames\n"
             "\n"
             "USAGE\n"
             "  kit compress    [-z FMT] [-o OUT] [FILE]\n"
             "  kit compress -d [-z FMT] [-o OUT] [FILE]\n"
             "\n"
             "DESCRIPTION\n"
             "  Reads FILE, or stdin when FILE is absent or -, and writes to\n"
             "  OUT (stdout by default). gzip and LZ4-frame output interoperates\n"
             "  with standard gzip/lz4 tools. Input files are never rewritten.\n"
             "\n"
             "OPTIONS\n"
             "  -d                 decompress (default: compress)\n"
             "  -z, --format FMT   gzip (compression default) | lz4. On\n"
             "                     decompression, magic auto-detects the format\n"
             "                     unless this option fixes it.\n"
             "  -o OUT             write OUT instead of stdout\n"
             "  -h, --help         show this help and exit\n"
             "\n"
             "ALIASES\n"
             "  gzip, gunzip, lz4, and lz4c fix the container. Their own help\n"
             "  describes default direction and accepted compatibility flags.\n"
             "\n"
             "PATHS\n"
             "  Use -- before a leading-dash file name.\n"
             "\n"
             "EXAMPLES\n"
             "  kit compress -z gzip -o data.gz data.txt\n"
             "  kit compress -d -o data.copy data.gz\n"
             "  kit compress -z lz4 data.txt > data.lz4\n"
             "  kit compress -d data.lz4 > data.copy\n"
             "\n"
             "EXIT CODES\n"
             "  0   success       1   I/O or codec error       2   bad usage\n")));
     return;
   }
 
   if (persona == &CZ_GZIP) {
     driver_printf(
         "gzip — write a gzip stream\n"
         "\n"
         "USAGE\n"
         "  gzip [OPTIONS] [FILE]\n"
         "\n"
         "DESCRIPTION\n"
         "  Compresses FILE, or stdin when omitted or -, as gzip. Output goes\n"
         "  to stdout unless -o is given; FILE is never renamed or rewritten.\n"
         "\n"
         "OPTIONS\n"
         "  -d, --decompress, --uncompress  decompress gzip instead\n"
         "  -o OUT                          write OUT instead of stdout\n"
         "  -c/--stdout, -k, -f, -n, -q, -1..-9, --fast, --best\n"
         "                                  accepted compatibility no-ops\n"
         "  -h, --help                      show this help and exit\n"
         "  -z/--format is rejected because gzip fixes the container.\n"
         "\n"
         "PATHS\n"
         "  Use -- before a leading-dash file name.\n"
         "\n"
         "EXAMPLES\n"
         "  gzip -o data.gz data.txt\n"
         "  gzip -d -o data.copy data.gz\n"
         "  printf 'hello\\n' | gzip > hello.gz\n"
         "\n"
         "EXIT CODES\n"
         "  0   success       1   I/O or codec error       2   bad usage\n");
   } else if (persona == &CZ_GUNZIP) {
     driver_printf(
         "gunzip — decompress a gzip stream\n"
         "\n"
         "USAGE\n"
         "  gunzip [OPTIONS] [FILE]\n"
         "\n"
         "DESCRIPTION\n"
         "  Decompresses gzip from FILE, or stdin when omitted or -. Output\n"
         "  goes to stdout unless -o is given; FILE is never renamed or removed.\n"
         "  Empty, corrupt, or non-gzip input is an operational error.\n"
         "\n"
         "OPTIONS\n"
         "  -d, --decompress, --uncompress  accepted; remains decompression\n"
         "  -o OUT                          write OUT instead of stdout\n"
         "  -c/--stdout, -k, -f, -n, -q    accepted compatibility no-ops\n"
         "  -h, --help                      show this help and exit\n"
         "  -z/--format is rejected because gunzip fixes gzip input.\n"
         "\n"
         "PATHS\n"
         "  Use -- before a leading-dash file name.\n"
         "\n"
         "EXAMPLES\n"
         "  gunzip -o data.txt data.gz\n"
         "  cat data.gz | gunzip > data.txt\n"
         "\n"
         "EXIT CODES\n"
         "  0   success       1   I/O or codec error       2   bad usage\n");
   } else {
     driver_printf(
         "%s — write an LZ4-frame stream%s\n"
         "\n"
         "USAGE\n"
         "  %s [OPTIONS] [FILE]\n"
         "\n"
         "DESCRIPTION\n"
         "  Compresses FILE, or stdin when omitted or -, as an LZ4 frame.\n"
         "  Output goes to stdout unless -o is given; FILE is never rewritten.\n"
         "%s"
         "\n"
         "OPTIONS\n"
         "  -d, --decompress, --uncompress  decompress LZ4-frame input\n"
         "  -o OUT                          write OUT instead of stdout\n"
         "  -c/--stdout, -k, -f, -n, -q, -1..-9, --fast, --best\n"
         "                                  accepted compatibility no-ops\n"
         "  -h, --help                      show this help and exit\n"
         "  -z/--format is rejected because the container is fixed.\n"
         "\n"
         "PATHS\n"
         "  Use -- before a leading-dash file name.\n"
         "\n"
         "EXAMPLES\n"
         "  %s -o data.lz4 data.txt\n"
         "  %s -d -o data.copy data.lz4\n"
         "\n"
         "EXIT CODES\n"
         "  0   success       1   I/O or codec error       2   bad usage\n",
         persona->name, persona == &CZ_LZ4C ? " (lz4 alias)" : "",
         persona->name,
         persona == &CZ_LZ4C
             ? "  lz4c is the legacy compression alias for lz4.\n"
             : "",
         persona->name, persona->name);
   }
 }
 
 void driver_help_compress(void) { compress_help(&CZ_GENERIC); }
 void driver_help_gzip(void) { compress_help(&CZ_GZIP); }
 void driver_help_gunzip(void) { compress_help(&CZ_GUNZIP); }
 void driver_help_lz4(void) { compress_help(&CZ_LZ4); }
 void driver_help_lz4c(void) { compress_help(&CZ_LZ4C); }
 
 static int compress_main(int argc, char** argv,
                          const CompressPersona* persona) {
   DriverEnv env;
   KitContext ctx;
   CompressOpts o;
   KitWriter* w = NULL;
   const uint8_t* data = NULL;
   size_t len = 0;
   DriverLoad ld = {0};
   uint8_t* sbuf = NULL;
   size_t sbuf_len = 0;
   int loaded = 0, owned_writer = 0, i, rc = 2, options = 1;
   KitCompressFormat fmt;
 
   if (driver_argv_wants_help(argc, argv, 1)) {
     compress_help(persona);
     return 0;
   }
 
   memset(&o, 0, sizeof o);
   o.format = persona->format;
   /* A pinned container both fixes the format and disables decompress
    * auto-detection (gunzip only reads gzip, lz4 only reads LZ4). */
   o.have_format = persona->locked_format;
   o.decompress = persona->default_decompress;
   driver_env_init(&env);
   ctx = driver_env_to_context(&env);
 
   for (i = 1; i < argc; ++i) {
     const char* a = argv[i];
     if (options && driver_streq(a, "--")) {
       options = 0;
       continue;
     }
     if (options && (driver_streq(a, "-d") ||
         (persona->compat && (driver_streq(a, "--decompress") ||
                              driver_streq(a, "--uncompress"))))) {
       o.decompress = 1;
       continue;
     }
     if (options &&
         (driver_streq(a, "-z") || driver_streq(a, "--format"))) {
       if (persona->locked_format) {
         driver_errf(persona->name, "-z is not accepted; %s always uses %s",
                     persona->name,
                     persona->format == KIT_COMPRESS_GZIP ? "gzip" : "lz4");
         goto done;
       }
       if (i + 1 >= argc) {
         driver_errf(persona->name, "%s requires gzip or lz4", a);
         goto done;
       }
       ++i;
       if (compress_parse_format(argv[i], &o.format) != 0) {
         compress_unknown_format(persona->name, argv[i]);
         goto done;
       }
       o.have_format = 1;
       continue;
     }
     if (options && driver_streq(a, "-o")) {
       if (i + 1 >= argc) {
         driver_errf(persona->name, "-o requires a file path");
         goto done;
       }
       o.out = argv[++i];
       continue;
     }
     if (driver_streq(a, "-")) { /* explicit stdin */
       if (o.seen_input) {
         driver_errf(persona->name, "only one input may be given");
         goto done;
       }
       o.seen_input = 1;
       continue;
     }
     if (options && persona->compat && compress_compat_noop(a)) continue;
     if (options && a[0] == '-' && a[1] != '\0') {
       const char* const valid[] = {
           "-d", "--decompress", "--uncompress", "-z", "--format",
           "-o", "-h",           "--help",       "--version"};
       DriverSuggestion suggestions[3];
       size_t n = driver_suggest_values(a, valid,
                                        sizeof valid / sizeof valid[0],
                                        suggestions, 3);
       if (n)
         driver_errf(persona->name,
                     "unknown option: %s; did you mean '%s'?", a,
                     suggestions[0].value);
       else
         driver_errf(persona->name, "unknown option: %s", a);
       goto done;
     }
     if (o.seen_input) {
       driver_errf(persona->name, "only one input may be given");
       goto done;
     }
     o.seen_input = 1;
     o.in = a;
   }
 
   /* Load the whole input. */
   if (o.in) {
     KitSlice input;
     if (driver_load_bytes(&env.file_io, persona->name, o.in, &ld, &input) !=
         0) {
       rc = 1;
       goto done;
     }
     loaded = 1;
     data = input.data;
     len = input.len;
   } else {
     if (!driver_read_stdin(&env, &sbuf, &sbuf_len)) {
       driver_errf(persona->name, "failed to read stdin");
       rc = 1;
       goto done;
     }
     data = sbuf;
     len = sbuf_len;
   }
 
   /* Resolve the format. Compress uses the requested/default codec; decompress
    * auto-detects from magic bytes unless -z forced one. */
   fmt = o.format;
   if (o.decompress && !o.have_format) {
     if (kit_compress_detect(data, len, &fmt) != KIT_OK) {
       driver_errf(persona->name, "cannot detect input format; use -z gzip|lz4");
       rc = 1;
       goto done;
     }
   }
 
   /* Open the output. */
   if (o.out) {
     if (ctx.file_io->open_writer(ctx.file_io->user, o.out, &w) != KIT_OK) {
       driver_errf(persona->name, "failed to open output: %s", o.out);
       rc = 1;
       goto done;
     }
     owned_writer = 1;
   } else {
     w = driver_stdout_writer(&env);
     owned_writer = 1;
   }
 
   /* Transform. The public API reports the specific reason through ctx->diag
    * (the driver's stderr sink), so we only set the exit status here. */
   if (o.decompress) {
     rc = kit_decompress(&ctx, fmt, data, len, w) == KIT_OK ? 0 : 1;
   } else {
     rc = kit_compress(&ctx, fmt, data, len, w) == KIT_OK ? 0 : 1;
   }
 
 done:
   if (owned_writer && w) kit_writer_close(w);
   if (sbuf) driver_free(&env, sbuf, sbuf_len);
   if (loaded) driver_release_bytes(&env.file_io, &ld);
   driver_env_fini(&env);
   return rc;
 }
 
 int driver_compress(int argc, char** argv) {
   return compress_main(argc, argv, &CZ_GENERIC);
 }
 
 int driver_gzip(int argc, char** argv) {
   return compress_main(argc, argv, &CZ_GZIP);
 }
 
 int driver_gunzip(int argc, char** argv) {
   return compress_main(argc, argv, &CZ_GUNZIP);
 }
 
 int driver_lz4(int argc, char** argv) {
   return compress_main(argc, argv, &CZ_LZ4);
 }
 
 int driver_lz4c(int argc, char** argv) {
   return compress_main(argc, argv, &CZ_LZ4C);
 }