add_packed_git: convert strcpy into xsnprintf

diff --git a/run-command.c b/run-command.c
index 41d94c111edad552a375921dce464f0d10d56319..3277cf797ed41e5834b3b94fa8d2e9e9d5b4a317 100644 (file)
--- a/run-command.c
+++ b/run-command.c
@@ -4,14 +4,11 @@
 #include "sigchain.h"
 #include "argv-array.h"
 
-#ifndef SHELL_PATH
-# define SHELL_PATH "/bin/sh"
-#endif
-
 void child_process_init(struct child_process *child)
 {
        memset(child, 0, sizeof(*child));
        argv_array_init(&child->args);
+       argv_array_init(&child->env_array);
 }
 
 struct child_to_clean {
@@ -203,7 +200,6 @@ static int execv_shell_cmd(const char **argv)
 #endif
 
 #ifndef GIT_WINDOWS_NATIVE
-static int child_err = 2;
 static int child_notifier = -1;
 
 static void notify_parent(void)
@@ -215,17 +211,6 @@ static void notify_parent(void)
         */
        xwrite(child_notifier, "", 1);
 }
-
-static NORETURN void die_child(const char *err, va_list params)
-{
-       vwritef(child_err, "fatal: ", err, params);
-       exit(128);
-}
-
-static void error_child(const char *err, va_list params)
-{
-       vwritef(child_err, "error: ", err, params);
-}
 #endif
 
 static inline void set_cloexec(int fd)
@@ -287,6 +272,8 @@ int start_command(struct child_process *cmd)
 
        if (!cmd->argv)
                cmd->argv = cmd->args.argv;
+       if (!cmd->env)
+               cmd->env = cmd->env_array.argv;
 
        /*
         * In case of errors we must keep the promise to close FDs
@@ -338,6 +325,7 @@ int start_command(struct child_process *cmd)
                        error("cannot create %s pipe for %s: %s",
                                str, cmd->argv[0], strerror(failed_errno));
                        argv_array_clear(&cmd->args);
+                       argv_array_clear(&cmd->env_array);
                        errno = failed_errno;
                        return -1;
                }
@@ -362,11 +350,10 @@ int start_command(struct child_process *cmd)
                 * in subsequent call paths use the parent's stderr.
                 */
                if (cmd->no_stderr || need_err) {
-                       child_err = dup(2);
+                       int child_err = dup(2);
                        set_cloexec(child_err);
+                       set_error_handle(fdopen(child_err, "w"));
                }
-               set_die_routine(die_child);
-               set_error_routine(error_child);
 
                close(notify_pipe[0]);
                set_cloexec(notify_pipe[1]);
@@ -524,6 +511,7 @@ int start_command(struct child_process *cmd)
                else if (cmd->err)
                        close(cmd->err);
                argv_array_clear(&cmd->args);
+               argv_array_clear(&cmd->env_array);
                errno = failed_errno;
                return -1;
        }
@@ -550,12 +538,18 @@ int finish_command(struct child_process *cmd)
 {
        int ret = wait_or_whine(cmd->pid, cmd->argv[0]);
        argv_array_clear(&cmd->args);
+       argv_array_clear(&cmd->env_array);
        return ret;
 }
 
 int run_command(struct child_process *cmd)
 {
-       int code = start_command(cmd);
+       int code;
+
+       if (cmd->out < 0 || cmd->err < 0)
+               die("BUG: run_command with a pipe can cause deadlock");
+
+       code = start_command(cmd);
        if (code)
                return code;
        return finish_command(cmd);
@@ -630,7 +624,7 @@ static struct {
 
 static int git_atexit_installed;
 
-static void git_atexit_dispatch()
+static void git_atexit_dispatch(void)
 {
        size_t i;
 
@@ -638,7 +632,7 @@ static void git_atexit_dispatch()
                git_atexit_hdlrs.handlers[i-1]();
 }
 
-static void git_atexit_clear()
+static void git_atexit_clear(void)
 {
        free(git_atexit_hdlrs.handlers);
        memset(&git_atexit_hdlrs, 0, sizeof(git_atexit_hdlrs));
@@ -788,13 +782,15 @@ int finish_async(struct async *async)
 #endif
 }
 
-char *find_hook(const char *name)
+const char *find_hook(const char *name)
 {
-       char *path = git_path("hooks/%s", name);
-       if (access(path, X_OK) < 0)
-               path = NULL;
+       static struct strbuf path = STRBUF_INIT;
 
-       return path;
+       strbuf_reset(&path);
+       strbuf_git_path(&path, "hooks/%s", name);
+       if (access(path.buf, X_OK) < 0)
+               return NULL;
+       return path.buf;
 }
 
 int run_hook_ve(const char *const *env, const char *name, va_list args)
@@ -828,19 +824,18 @@ int run_hook_le(const char *const *env, const char *name, ...)
        return ret;
 }
 
-int run_hook_with_custom_index(const char *index_file, const char *name, ...)
+int capture_command(struct child_process *cmd, struct strbuf *buf, size_t hint)
 {
-       const char *hook_env[3] =  { NULL };
-       char index[PATH_MAX];
-       va_list args;
-       int ret;
-
-       snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
-       hook_env[0] = index;
+       cmd->out = -1;
+       if (start_command(cmd) < 0)
+               return -1;
 
-       va_start(args, name);
-       ret = run_hook_ve(hook_env, name, args);
-       va_end(args);
+       if (strbuf_read(buf, cmd->out, hint) < 0) {
+               close(cmd->out);
+               finish_command(cmd); /* throw away exit code */
+               return -1;
+       }
 
-       return ret;
+       close(cmd->out);
+       return finish_command(cmd);
 }