kit

install.c (7043B)

---

 #include <kit/core.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
 #include "driver.h"
 #include "env.h"
 #include "install_links.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 arguments, prints this help without changing anything.\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"
       "  --version        show Kit version\n"
       "\n"
       "RELOCATION NOTE\n"
       "  POSIX symlinks created by this release contain the absolute path to\n"
       "  the current Kit binary. If the distribution tree is moved afterward,\n"
       "  those links become dangling. Invoke the moved bin/kit directly and\n"
       "  rerun `kit install --force` for the same prefix. Windows hard links\n"
       "  likewise belong to the installed filesystem entry rather than a\n"
       "  relocatable path lookup.\n"
       "\n"
       "EXAMPLES\n"
       "  PREFIX=\"$PWD/isolated prefix\"\n"
       "  mkdir -p \"$PREFIX/bin\"\n"
       "  kit install --all \"$PREFIX/bin\"\n"
       "  PATH=\"$PREFIX/bin:/usr/bin:/bin\" cc --help\n"
       "\n"
       "  kit install --all --force \"$PREFIX/bin\"\n"
       "\n"
       "EXIT CODES\n"
       "  0   success      1   one or more links failed      2   bad usage\n");
 }
 
 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 (argc < 2 || 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) {
     int tool_index = driver_tool_find(explicit_tools[i]);
     if (tool_index < 0) {
       driver_errf(INSTALL_TOOL, "no such tool: %s", explicit_tools[i]);
       goto done;
     }
     if (driver_tool_groups((unsigned)tool_index) == 0u) {
       driver_errf(INSTALL_TOOL, "tool is not installable: %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;
   }
 
   {
     DriverInstallLinkOpts opts;
     opts.target_exe = self;
     opts.tool_tag = INSTALL_TOOL;
     opts.use_hardlink = want_hard;
     opts.force = force;
     opts.dry_run = dry;
     opts.verbose = verbose;
 
     if (nexplicit > 0) {
       for (i = 0; i < nexplicit; ++i) {
         if (driver_install_link_one(&env, dir, explicit_tools[i], &opts) != 0)
           ++failures;
         else
           ++done_count;
       }
     } else {
       unsigned mask = all ? DRIVER_GROUP_ALL
                           : (DRIVER_GROUP_TOOLCHAIN | DRIVER_GROUP_BYTEUTIL);
       failures = driver_install_links(&env, dir, mask, &opts, &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;
 }