| #include "git-compat-util.h" |
| #include "abspath.h" |
| #include "environment.h" |
| #include "exec-cmd.h" |
| #include "gettext.h" |
| #include "path.h" |
| #include "run-command.h" |
| #include "strvec.h" |
| #include "trace.h" |
| #include "trace2.h" |
| |
| #if defined(RUNTIME_PREFIX) |
| |
| #if defined(HAVE_NS_GET_EXECUTABLE_PATH) |
| #include <mach-o/dyld.h> |
| #endif |
| |
| #if defined(HAVE_BSD_KERN_PROC_SYSCTL) |
| #include <sys/param.h> |
| #include <sys/types.h> |
| #include <sys/sysctl.h> |
| #endif |
| |
| #endif /* RUNTIME_PREFIX */ |
| |
| #define MAX_ARGS 32 |
| |
| static const char *system_prefix(void); |
| |
| #ifdef RUNTIME_PREFIX |
| |
| /** |
| * When using a runtime prefix, Git dynamically resolves paths relative to its |
| * executable. |
| * |
| * The method for determining the path of the executable is highly |
| * platform-specific. |
| */ |
| |
| /** |
| * Path to the current Git executable. Resolved on startup by |
| * 'git_resolve_executable_dir'. |
| */ |
| static const char *executable_dirname; |
| |
| static const char *system_prefix(void) |
| { |
| static const char *prefix; |
| |
| assert(executable_dirname); |
| assert(is_absolute_path(executable_dirname)); |
| |
| if (!prefix && |
| !(prefix = strip_path_suffix(executable_dirname, GIT_EXEC_PATH)) && |
| !(prefix = strip_path_suffix(executable_dirname, BINDIR)) && |
| !(prefix = strip_path_suffix(executable_dirname, "git"))) { |
| prefix = FALLBACK_RUNTIME_PREFIX; |
| trace_printf("RUNTIME_PREFIX requested, " |
| "but prefix computation failed. " |
| "Using static fallback '%s'.\n", prefix); |
| } |
| return prefix; |
| } |
| |
| /* |
| * Resolves the executable path from argv[0], only if it is absolute. |
| * |
| * Returns 0 on success, -1 on failure. |
| */ |
| static int git_get_exec_path_from_argv0(struct strbuf *buf, const char *argv0) |
| { |
| const char *slash; |
| |
| if (!argv0 || !*argv0) |
| return -1; |
| |
| slash = find_last_dir_sep(argv0); |
| if (slash) { |
| trace_printf("trace: resolved executable path from argv0: %s\n", |
| argv0); |
| strbuf_add_absolute_path(buf, argv0); |
| return 0; |
| } |
| return -1; |
| } |
| |
| #ifdef PROCFS_EXECUTABLE_PATH |
| /* |
| * Resolves the executable path by examining a procfs symlink. |
| * |
| * Returns 0 on success, -1 on failure. |
| */ |
| static int git_get_exec_path_procfs(struct strbuf *buf) |
| { |
| if (strbuf_realpath(buf, PROCFS_EXECUTABLE_PATH, 0)) { |
| trace_printf( |
| "trace: resolved executable path from procfs: %s\n", |
| buf->buf); |
| return 0; |
| } |
| return -1; |
| } |
| #endif /* PROCFS_EXECUTABLE_PATH */ |
| |
| #ifdef HAVE_BSD_KERN_PROC_SYSCTL |
| /* |
| * Resolves the executable path using KERN_PROC_PATHNAME BSD sysctl. |
| * |
| * Returns 0 on success, -1 on failure. |
| */ |
| static int git_get_exec_path_bsd_sysctl(struct strbuf *buf) |
| { |
| int mib[4]; |
| char path[MAXPATHLEN]; |
| size_t cb = sizeof(path); |
| |
| mib[0] = CTL_KERN; |
| mib[1] = KERN_PROC; |
| mib[2] = KERN_PROC_PATHNAME; |
| mib[3] = -1; |
| if (!sysctl(mib, 4, path, &cb, NULL, 0)) { |
| trace_printf( |
| "trace: resolved executable path from sysctl: %s\n", |
| path); |
| strbuf_addstr(buf, path); |
| return 0; |
| } |
| return -1; |
| } |
| #endif /* HAVE_BSD_KERN_PROC_SYSCTL */ |
| |
| #ifdef HAVE_NS_GET_EXECUTABLE_PATH |
| /* |
| * Resolves the executable path by querying Darwin application stack. |
| * |
| * Returns 0 on success, -1 on failure. |
| */ |
| static int git_get_exec_path_darwin(struct strbuf *buf) |
| { |
| char path[PATH_MAX]; |
| uint32_t size = sizeof(path); |
| if (!_NSGetExecutablePath(path, &size)) { |
| trace_printf( |
| "trace: resolved executable path from Darwin stack: %s\n", |
| path); |
| strbuf_addstr(buf, path); |
| return 0; |
| } |
| return -1; |
| } |
| #endif /* HAVE_NS_GET_EXECUTABLE_PATH */ |
| |
| #ifdef HAVE_ZOS_GET_EXECUTABLE_PATH |
| /* |
| * Resolves the executable path from current program's directory and name. |
| * |
| * Returns 0 on success, -1 on failure. |
| */ |
| static int git_get_exec_path_zos(struct strbuf *buf) |
| { |
| char *dir = __getprogramdir(); |
| char *exe = getprogname(); |
| if (dir && exe) { |
| strbuf_addf(buf, "%s/%s", dir, exe); |
| return 0; |
| } |
| return -1; |
| } |
| |
| #endif /* HAVE_ZOS_GET_EXECUTABLE_PATH */ |
| |
| #ifdef HAVE_WPGMPTR |
| /* |
| * Resolves the executable path by using the global variable _wpgmptr. |
| * |
| * Returns 0 on success, -1 on failure. |
| */ |
| static int git_get_exec_path_wpgmptr(struct strbuf *buf) |
| { |
| int len = wcslen(_wpgmptr) * 3 + 1; |
| strbuf_grow(buf, len); |
| len = xwcstoutf(buf->buf, _wpgmptr, len); |
| if (len < 0) |
| return -1; |
| buf->len += len; |
| return 0; |
| } |
| #endif /* HAVE_WPGMPTR */ |
| |
| /* |
| * Resolves the absolute path of the current executable. |
| * |
| * Returns 0 on success, -1 on failure. |
| */ |
| static int git_get_exec_path(struct strbuf *buf, const char *argv0) |
| { |
| /* |
| * Identifying the executable path is operating system specific. |
| * Selectively employ all available methods in order of preference, |
| * preferring highly-available authoritative methods over |
| * selectively-available or non-authoritative methods. |
| * |
| * All cases fall back on resolving against argv[0] if there isn't a |
| * better functional method. However, note that argv[0] can be |
| * used-supplied on many operating systems, and is not authoritative |
| * in those cases. |
| * |
| * Each of these functions returns 0 on success, so evaluation will stop |
| * after the first successful method. |
| */ |
| if ( |
| #ifdef HAVE_BSD_KERN_PROC_SYSCTL |
| git_get_exec_path_bsd_sysctl(buf) && |
| #endif /* HAVE_BSD_KERN_PROC_SYSCTL */ |
| |
| #ifdef HAVE_NS_GET_EXECUTABLE_PATH |
| git_get_exec_path_darwin(buf) && |
| #endif /* HAVE_NS_GET_EXECUTABLE_PATH */ |
| |
| #ifdef PROCFS_EXECUTABLE_PATH |
| git_get_exec_path_procfs(buf) && |
| #endif /* PROCFS_EXECUTABLE_PATH */ |
| |
| #ifdef HAVE_WPGMPTR |
| git_get_exec_path_wpgmptr(buf) && |
| #endif /* HAVE_WPGMPTR */ |
| |
| #ifdef HAVE_ZOS_GET_EXECUTABLE_PATH |
| git_get_exec_path_zos(buf) && |
| #endif /*HAVE_ZOS_GET_EXECUTABLE_PATH */ |
| |
| git_get_exec_path_from_argv0(buf, argv0)) { |
| return -1; |
| } |
| |
| if (strbuf_normalize_path(buf)) { |
| trace_printf("trace: could not normalize path: %s\n", buf->buf); |
| return -1; |
| } |
| |
| trace2_cmd_path(buf->buf); |
| |
| return 0; |
| } |
| |
| void git_resolve_executable_dir(const char *argv0) |
| { |
| struct strbuf buf = STRBUF_INIT; |
| char *resolved; |
| const char *slash; |
| |
| if (git_get_exec_path(&buf, argv0)) { |
| trace_printf( |
| "trace: could not determine executable path from: %s\n", |
| argv0); |
| strbuf_release(&buf); |
| return; |
| } |
| |
| resolved = strbuf_detach(&buf, NULL); |
| slash = find_last_dir_sep(resolved); |
| if (slash) |
| resolved[slash - resolved] = '\0'; |
| |
| executable_dirname = resolved; |
| trace_printf("trace: resolved executable dir: %s\n", |
| executable_dirname); |
| } |
| |
| #else |
| |
| /* |
| * When not using a runtime prefix, Git uses a hard-coded path. |
| */ |
| static const char *system_prefix(void) |
| { |
| return FALLBACK_RUNTIME_PREFIX; |
| } |
| |
| /* |
| * This is called during initialization, but No work needs to be done here when |
| * runtime prefix is not being used. |
| */ |
| void git_resolve_executable_dir(const char *argv0 UNUSED) |
| { |
| } |
| |
| #endif /* RUNTIME_PREFIX */ |
| |
| char *system_path(const char *path) |
| { |
| struct strbuf d = STRBUF_INIT; |
| |
| if (is_absolute_path(path)) |
| return xstrdup(path); |
| |
| strbuf_addf(&d, "%s/%s", system_prefix(), path); |
| return strbuf_detach(&d, NULL); |
| } |
| |
| static const char *exec_path_value; |
| |
| void git_set_exec_path(const char *exec_path) |
| { |
| exec_path_value = exec_path; |
| /* |
| * Propagate this setting to external programs. |
| */ |
| setenv(EXEC_PATH_ENVIRONMENT, exec_path, 1); |
| } |
| |
| /* Returns the highest-priority location to look for git programs. */ |
| const char *git_exec_path(void) |
| { |
| if (!exec_path_value) { |
| const char *env = getenv(EXEC_PATH_ENVIRONMENT); |
| if (env && *env) |
| exec_path_value = xstrdup(env); |
| else |
| exec_path_value = system_path(GIT_EXEC_PATH); |
| } |
| return exec_path_value; |
| } |
| |
| static void add_path(struct strbuf *out, const char *path) |
| { |
| if (path && *path) { |
| strbuf_add_absolute_path(out, path); |
| strbuf_addch(out, PATH_SEP); |
| } |
| } |
| |
| void setup_path(void) |
| { |
| const char *exec_path = git_exec_path(); |
| const char *old_path = getenv("PATH"); |
| struct strbuf new_path = STRBUF_INIT; |
| |
| git_set_exec_path(exec_path); |
| add_path(&new_path, exec_path); |
| |
| if (old_path) |
| strbuf_addstr(&new_path, old_path); |
| else |
| strbuf_addstr(&new_path, _PATH_DEFPATH); |
| |
| setenv("PATH", new_path.buf, 1); |
| |
| strbuf_release(&new_path); |
| } |
| |
| const char **prepare_git_cmd(struct strvec *out, const char **argv) |
| { |
| strvec_push(out, "git"); |
| strvec_pushv(out, argv); |
| return out->v; |
| } |
| |
| int execv_git_cmd(const char **argv) |
| { |
| struct strvec nargv = STRVEC_INIT; |
| |
| prepare_git_cmd(&nargv, argv); |
| trace_argv_printf(nargv.v, "trace: exec:"); |
| |
| /* execvp() can only ever return if it fails */ |
| sane_execvp("git", (char **)nargv.v); |
| |
| trace_printf("trace: exec failed: %s\n", strerror(errno)); |
| |
| strvec_clear(&nargv); |
| return -1; |
| } |
| |
| int execl_git_cmd(const char *cmd, ...) |
| { |
| int argc; |
| const char *argv[MAX_ARGS + 1]; |
| const char *arg; |
| va_list param; |
| |
| va_start(param, cmd); |
| argv[0] = cmd; |
| argc = 1; |
| while (argc < MAX_ARGS) { |
| arg = argv[argc++] = va_arg(param, char *); |
| if (!arg) |
| break; |
| } |
| va_end(param); |
| if (MAX_ARGS <= argc) |
| return error(_("too many args to run %s"), cmd); |
| |
| argv[argc] = NULL; |
| return execv_git_cmd(argv); |
| } |