kit

install.c (8018B)

---

 #include <kit/core.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
 #include "driver.h"
 #include "env.h"
 
 /* `kit install` — busybox-style toolchain installer. Populates a target
  * directory with one entry per kit tool, each pointing at the running kit
  * binary, so the tools can be invoked by their bare names (cc, ld, nm, ...)
  * as a drop-in toolchain. Entries are symlinks on POSIX and hard links on
  * Windows (where unprivileged symlinks aren't generally available); either
  * can be forced with -s/-H.
  *
  * Multi-call dispatch in main.c resolves a link named `cc` to the cc tool by
  * argv[0]'s basename, so no extra wiring is needed for the links to work.
  *
  * The default set (no TOOL args, no --all) is the tools tagged with a non-zero
  * DriverToolGroup in the centralized table: the binutils/compiler toolchain
  * plus the standard-named byte utilities (xxd, cmp). */
 
 #define INSTALL_TOOL "install"
 
 void driver_help_install(void) {
   driver_printf(
       "kit install — symlink the kit tools into a directory\n"
       "\n"
       "USAGE\n"
       "  kit install [OPTIONS] DIR [TOOL...]\n"
       "\n"
       "DESCRIPTION\n"
       "  Populates DIR with one entry per kit tool, each pointing at the\n"
       "  running kit binary, so the tools can be invoked by their bare\n"
       "  names (cc, ld, nm, ...) as a drop-in toolchain. Entries are\n"
       "  symlinks on POSIX and hard links on Windows by default.\n"
       "\n"
       "  With no TOOL given, installs the default set: the binutils/compiler\n"
       "  toolchain (cc cpp as ld ar ranlib strip objcopy objdump nm size\n"
       "  addr2line strings) plus the standard-named byte utilities (xxd cmp\n"
       "  sha256sum b2sum crc32 gzip gunzip lz4 lz4c). Use --all for every\n"
       "  tool, or name specific TOOLs to install just those.\n"
       "\n"
       "OPTIONS\n"
       "  -s, --symlink    create symlinks (default except on Windows)\n"
       "  -H, --hardlink   create hard links (default on Windows)\n"
       "  -a, --all        install every tool compiled into this binary\n"
       "  -f, --force      replace existing entries\n"
       "  -n, --dry-run    print what would be done; change nothing\n"
       "  -v, --verbose    print each link as it is created\n"
       "  -h, --help       show this help\n"
       "\n"
       "EXIT CODES\n"
       "  0   success      1   one or more links failed      2   bad usage\n");
 }
 
 /* Join DIR + "/" + NAME into a freshly allocated, NUL-terminated path. Returns
  * NULL on allocation failure; on success stores the allocation size in
  * *out_size for driver_free. */
 static char* install_join(DriverEnv* env, const char* dir, const char* name,
                           size_t* out_size) {
   size_t dl = driver_strlen(dir);
   size_t nl = driver_strlen(name);
   int slash = dl > 0 && dir[dl - 1u] != '/';
   size_t size = dl + (slash ? 1u : 0u) + nl + 1u;
   size_t off;
   char* p = (char*)driver_alloc(env, size);
   if (!p) return NULL;
   driver_memcpy(p, dir, dl);
   off = dl;
   if (slash) p[off++] = '/';
   driver_memcpy(p + off, name, nl);
   off += nl;
   p[off] = '\0';
   *out_size = size;
   return p;
 }
 
 /* Create one link DIR/NAME -> self. Returns 0 on success, nonzero on failure
  * (already emitted a diagnostic). Honors dry-run (prints, no change), force
  * (replace existing), and verbose. */
 static int install_one(DriverEnv* env, const char* dir, const char* name,
                        const char* self, int want_hard, int force, int dry,
                        int verbose) {
   size_t path_size = 0;
   char* link_path = install_join(env, dir, name, &path_size);
   int rc = 0;
 
   if (!link_path) {
     driver_errf(INSTALL_TOOL, "out of memory building path for %s", name);
     return 1;
   }
 
   if (driver_path_lexists(link_path)) {
     if (!force) {
       driver_errf(INSTALL_TOOL, "%s already exists (use -f to overwrite)",
                   link_path);
       rc = 1;
       goto done;
     }
     if (!dry && driver_remove_file(link_path) != 0) {
       driver_errf(INSTALL_TOOL, "cannot replace %s", link_path);
       rc = 1;
       goto done;
     }
   }
 
   if (dry) {
     driver_printf("%s -> %s (dry-run)\n", link_path, self);
     goto done;
   }
 
   rc = want_hard ? driver_create_hardlink(self, link_path)
                  : driver_create_symlink(self, link_path);
   if (rc != 0) {
     driver_errf(INSTALL_TOOL, "failed to %s %s",
                 want_hard ? "hard-link" : "symlink", link_path);
     rc = 1;
     goto done;
   }
   if (verbose) driver_printf("%s -> %s\n", link_path, self);
 
 done:
   driver_free(env, link_path, path_size);
   return rc;
 }
 
 int driver_install(int argc, char** argv) {
   DriverEnv env;
   const char* dir = NULL;
   const char** explicit_tools = NULL;
   int nexplicit = 0;
   int want_hard = -1; /* -1 = pick by host OS; 0 = symlink; 1 = hard link */
   int all = 0, force = 0, dry = 0, verbose = 0, opts_done = 0;
   char* self = NULL;
   size_t self_size = 0;
   unsigned done_count = 0, failures = 0;
   int i, rc = 2;
 
   if (driver_argv_wants_help(argc, argv, 1)) {
     driver_help_install();
     return 0;
   }
 
   driver_env_init(&env);
 
   explicit_tools =
       (const char**)driver_alloc(&env, (size_t)argc * sizeof(*explicit_tools));
   if (!explicit_tools) {
     driver_errf(INSTALL_TOOL, "out of memory");
     rc = 1;
     goto done;
   }
 
   for (i = 1; i < argc; ++i) {
     const char* a = argv[i];
     if (!opts_done && driver_streq(a, "--")) {
       opts_done = 1;
       continue;
     }
     if (!opts_done && a[0] == '-' && a[1] != '\0') {
       if (driver_streq(a, "-s") || driver_streq(a, "--symlink")) {
         want_hard = 0;
       } else if (driver_streq(a, "-H") || driver_streq(a, "--hardlink")) {
         want_hard = 1;
       } else if (driver_streq(a, "-a") || driver_streq(a, "--all")) {
         all = 1;
       } else if (driver_streq(a, "-f") || driver_streq(a, "--force")) {
         force = 1;
       } else if (driver_streq(a, "-n") || driver_streq(a, "--dry-run")) {
         dry = 1;
       } else if (driver_streq(a, "-v") || driver_streq(a, "--verbose")) {
         verbose = 1;
       } else {
         driver_errf(INSTALL_TOOL, "unknown option: %s", a);
         goto done;
       }
       continue;
     }
     if (!dir)
       dir = a;
     else
       explicit_tools[nexplicit++] = a;
   }
 
   if (!dir) {
     driver_errf(INSTALL_TOOL, "missing target directory");
     goto done;
   }
 
   /* Validate explicit tool names up front so a typo fails before we touch the
    * filesystem. */
   for (i = 0; i < nexplicit; ++i) {
     if (driver_tool_find(explicit_tools[i]) < 0) {
       driver_errf(INSTALL_TOOL, "no such tool: %s", explicit_tools[i]);
       goto done;
     }
   }
 
   if (want_hard < 0)
     want_hard = (driver_host_target().os == KIT_OS_WINDOWS) ? 1 : 0;
 
   if (driver_self_exe_path(&env, &self, &self_size) != 0) {
     driver_errf(INSTALL_TOOL, "cannot determine path to the kit binary");
     rc = 1;
     goto done;
   }
 
   if (!dry && driver_mkdir_p(&env, dir) != 0) {
     driver_errf(INSTALL_TOOL, "cannot create directory %s", dir);
     rc = 1;
     goto done;
   }
 
   if (nexplicit > 0) {
     for (i = 0; i < nexplicit; ++i) {
       if (install_one(&env, dir, explicit_tools[i], self, want_hard, force, dry,
                       verbose) != 0)
         ++failures;
       else
         ++done_count;
     }
   } else {
     unsigned n = driver_tool_count();
     unsigned j;
     for (j = 0; j < n; ++j) {
       if (!all && driver_tool_groups(j) == 0) continue;
       if (install_one(&env, dir, driver_tool_name(j), self, want_hard, force,
                       dry, verbose) != 0)
         ++failures;
       else
         ++done_count;
     }
   }
 
   driver_printf("install: %s %u tool%s in %s\n",
                 dry ? "would install" : "installed", done_count,
                 done_count == 1u ? "" : "s", dir);
   rc = failures ? 1 : 0;
 
 done:
   if (self) driver_free(&env, self, self_size);
   if (explicit_tools)
     driver_free(&env, explicit_tools, (size_t)argc * sizeof(*explicit_tools));
   driver_env_fini(&env);
   return rc;
 }