kit

compress.c (10266B)

---

 #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;
 }
 
 /* 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;
 }
 
 void driver_help_compress(void) {
   driver_printf(
       "%.*s",
       KIT_SLICE_ARG(KIT_SLICE_LIT(
           "kit compress — compress or decompress with gzip or LZ4 frame\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 with no FILE, or `-`) and writes the result\n"
           "  to OUT (or stdout). Containers are standard: a `.gz` any gzip\n"
           "  reads, or a `.lz4` frame the lz4 CLI reads.\n"
           "\n"
           "OPTIONS\n"
           "  -d                 decompress (default: compress)\n"
           "  -z, --format FMT   gzip (default) | lz4. When decompressing, the\n"
           "                     format is auto-detected from the input's "
           "magic\n"
           "                     bytes unless -z is given.\n"
           "  -o OUT             write output to OUT (default: stdout)\n"
           "  -h, --help         show this help\n"
           "\n"
           "ALIASES\n"
           "  Invoked as gzip / lz4 (or lz4c) compresses to that container; as\n"
           "  gunzip decompresses gzip. -d flips direction; -z is rejected "
           "(the\n"
           "  container is fixed). Common gzip/lz4 flags (-c/--stdout, -k, -f,\n"
           "  -1..-9, --fast, --best) are accepted; output still goes to "
           "stdout\n"
           "  or -o, never rewriting the input in place.\n"
           "\n"
           "EXIT CODES\n"
           "  0   success           1   I/O or codec error   2   bad usage\n")));
 }
 
 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;
   KitCompressFormat fmt;
 
   if (driver_argv_wants_help(argc, argv, 1)) {
     driver_help_compress();
     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 (driver_streq(a, "-d") ||
         (persona->compat && (driver_streq(a, "--decompress") ||
                              driver_streq(a, "--uncompress")))) {
       o.decompress = 1;
       continue;
     }
     if (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 || compress_parse_format(argv[++i], &o.format) != 0) {
         driver_errf(persona->name, "-z requires gzip or lz4");
         goto done;
       }
       o.have_format = 1;
       continue;
     }
     if (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 (persona->compat && compress_compat_noop(a)) continue;
     if (a[0] == '-' && a[1] != '\0') {
       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);
 }