run-command.con commit add missing "format" function attributes (4621085)
   1#include "cache.h"
   2#include "run-command.h"
   3#include "exec_cmd.h"
   4#include "sigchain.h"
   5#include "argv-array.h"
   6
   7#ifndef SHELL_PATH
   8# define SHELL_PATH "/bin/sh"
   9#endif
  10
  11struct child_to_clean {
  12        pid_t pid;
  13        struct child_to_clean *next;
  14};
  15static struct child_to_clean *children_to_clean;
  16static int installed_child_cleanup_handler;
  17
  18static void cleanup_children(int sig)
  19{
  20        while (children_to_clean) {
  21                struct child_to_clean *p = children_to_clean;
  22                children_to_clean = p->next;
  23                kill(p->pid, sig);
  24                free(p);
  25        }
  26}
  27
  28static void cleanup_children_on_signal(int sig)
  29{
  30        cleanup_children(sig);
  31        sigchain_pop(sig);
  32        raise(sig);
  33}
  34
  35static void cleanup_children_on_exit(void)
  36{
  37        cleanup_children(SIGTERM);
  38}
  39
  40static void mark_child_for_cleanup(pid_t pid)
  41{
  42        struct child_to_clean *p = xmalloc(sizeof(*p));
  43        p->pid = pid;
  44        p->next = children_to_clean;
  45        children_to_clean = p;
  46
  47        if (!installed_child_cleanup_handler) {
  48                atexit(cleanup_children_on_exit);
  49                sigchain_push_common(cleanup_children_on_signal);
  50                installed_child_cleanup_handler = 1;
  51        }
  52}
  53
  54static void clear_child_for_cleanup(pid_t pid)
  55{
  56        struct child_to_clean **pp;
  57
  58        for (pp = &children_to_clean; *pp; pp = &(*pp)->next) {
  59                struct child_to_clean *clean_me = *pp;
  60
  61                if (clean_me->pid == pid) {
  62                        *pp = clean_me->next;
  63                        free(clean_me);
  64                        return;
  65                }
  66        }
  67}
  68
  69static inline void close_pair(int fd[2])
  70{
  71        close(fd[0]);
  72        close(fd[1]);
  73}
  74
  75#ifndef WIN32
  76static inline void dup_devnull(int to)
  77{
  78        int fd = open("/dev/null", O_RDWR);
  79        dup2(fd, to);
  80        close(fd);
  81}
  82#endif
  83
  84static char *locate_in_PATH(const char *file)
  85{
  86        const char *p = getenv("PATH");
  87        struct strbuf buf = STRBUF_INIT;
  88
  89        if (!p || !*p)
  90                return NULL;
  91
  92        while (1) {
  93                const char *end = strchrnul(p, ':');
  94
  95                strbuf_reset(&buf);
  96
  97                /* POSIX specifies an empty entry as the current directory. */
  98                if (end != p) {
  99                        strbuf_add(&buf, p, end - p);
 100                        strbuf_addch(&buf, '/');
 101                }
 102                strbuf_addstr(&buf, file);
 103
 104                if (!access(buf.buf, F_OK))
 105                        return strbuf_detach(&buf, NULL);
 106
 107                if (!*end)
 108                        break;
 109                p = end + 1;
 110        }
 111
 112        strbuf_release(&buf);
 113        return NULL;
 114}
 115
 116static int exists_in_PATH(const char *file)
 117{
 118        char *r = locate_in_PATH(file);
 119        free(r);
 120        return r != NULL;
 121}
 122
 123int sane_execvp(const char *file, char * const argv[])
 124{
 125        if (!execvp(file, argv))
 126                return 0; /* cannot happen ;-) */
 127
 128        /*
 129         * When a command can't be found because one of the directories
 130         * listed in $PATH is unsearchable, execvp reports EACCES, but
 131         * careful usability testing (read: analysis of occasional bug
 132         * reports) reveals that "No such file or directory" is more
 133         * intuitive.
 134         *
 135         * We avoid commands with "/", because execvp will not do $PATH
 136         * lookups in that case.
 137         *
 138         * The reassignment of EACCES to errno looks like a no-op below,
 139         * but we need to protect against exists_in_PATH overwriting errno.
 140         */
 141        if (errno == EACCES && !strchr(file, '/'))
 142                errno = exists_in_PATH(file) ? EACCES : ENOENT;
 143        else if (errno == ENOTDIR && !strchr(file, '/'))
 144                errno = ENOENT;
 145        return -1;
 146}
 147
 148static const char **prepare_shell_cmd(const char **argv)
 149{
 150        int argc, nargc = 0;
 151        const char **nargv;
 152
 153        for (argc = 0; argv[argc]; argc++)
 154                ; /* just counting */
 155        /* +1 for NULL, +3 for "sh -c" plus extra $0 */
 156        nargv = xmalloc(sizeof(*nargv) * (argc + 1 + 3));
 157
 158        if (argc < 1)
 159                die("BUG: shell command is empty");
 160
 161        if (strcspn(argv[0], "|&;<>()$`\\\"' \t\n*?[#~=%") != strlen(argv[0])) {
 162#ifndef WIN32
 163                nargv[nargc++] = SHELL_PATH;
 164#else
 165                nargv[nargc++] = "sh";
 166#endif
 167                nargv[nargc++] = "-c";
 168
 169                if (argc < 2)
 170                        nargv[nargc++] = argv[0];
 171                else {
 172                        struct strbuf arg0 = STRBUF_INIT;
 173                        strbuf_addf(&arg0, "%s \"$@\"", argv[0]);
 174                        nargv[nargc++] = strbuf_detach(&arg0, NULL);
 175                }
 176        }
 177
 178        for (argc = 0; argv[argc]; argc++)
 179                nargv[nargc++] = argv[argc];
 180        nargv[nargc] = NULL;
 181
 182        return nargv;
 183}
 184
 185#ifndef WIN32
 186static int execv_shell_cmd(const char **argv)
 187{
 188        const char **nargv = prepare_shell_cmd(argv);
 189        trace_argv_printf(nargv, "trace: exec:");
 190        sane_execvp(nargv[0], (char **)nargv);
 191        free(nargv);
 192        return -1;
 193}
 194#endif
 195
 196#ifndef WIN32
 197static int child_err = 2;
 198static int child_notifier = -1;
 199
 200static void notify_parent(void)
 201{
 202        /*
 203         * execvp failed.  If possible, we'd like to let start_command
 204         * know, so failures like ENOENT can be handled right away; but
 205         * otherwise, finish_command will still report the error.
 206         */
 207        xwrite(child_notifier, "", 1);
 208}
 209
 210static NORETURN void die_child(const char *err, va_list params)
 211{
 212        vwritef(child_err, "fatal: ", err, params);
 213        exit(128);
 214}
 215
 216static void error_child(const char *err, va_list params)
 217{
 218        vwritef(child_err, "error: ", err, params);
 219}
 220#endif
 221
 222static inline void set_cloexec(int fd)
 223{
 224        int flags = fcntl(fd, F_GETFD);
 225        if (flags >= 0)
 226                fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
 227}
 228
 229static int wait_or_whine(pid_t pid, const char *argv0)
 230{
 231        int status, code = -1;
 232        pid_t waiting;
 233        int failed_errno = 0;
 234
 235        while ((waiting = waitpid(pid, &status, 0)) < 0 && errno == EINTR)
 236                ;       /* nothing */
 237
 238        if (waiting < 0) {
 239                failed_errno = errno;
 240                error("waitpid for %s failed: %s", argv0, strerror(errno));
 241        } else if (waiting != pid) {
 242                error("waitpid is confused (%s)", argv0);
 243        } else if (WIFSIGNALED(status)) {
 244                code = WTERMSIG(status);
 245                if (code != SIGINT && code != SIGQUIT)
 246                        error("%s died of signal %d", argv0, code);
 247                /*
 248                 * This return value is chosen so that code & 0xff
 249                 * mimics the exit code that a POSIX shell would report for
 250                 * a program that died from this signal.
 251                 */
 252                code += 128;
 253        } else if (WIFEXITED(status)) {
 254                code = WEXITSTATUS(status);
 255                /*
 256                 * Convert special exit code when execvp failed.
 257                 */
 258                if (code == 127) {
 259                        code = -1;
 260                        failed_errno = ENOENT;
 261                }
 262        } else {
 263                error("waitpid is confused (%s)", argv0);
 264        }
 265
 266        clear_child_for_cleanup(pid);
 267
 268        errno = failed_errno;
 269        return code;
 270}
 271
 272int start_command(struct child_process *cmd)
 273{
 274        int need_in, need_out, need_err;
 275        int fdin[2], fdout[2], fderr[2];
 276        int failed_errno;
 277        char *str;
 278
 279        /*
 280         * In case of errors we must keep the promise to close FDs
 281         * that have been passed in via ->in and ->out.
 282         */
 283
 284        need_in = !cmd->no_stdin && cmd->in < 0;
 285        if (need_in) {
 286                if (pipe(fdin) < 0) {
 287                        failed_errno = errno;
 288                        if (cmd->out > 0)
 289                                close(cmd->out);
 290                        str = "standard input";
 291                        goto fail_pipe;
 292                }
 293                cmd->in = fdin[1];
 294        }
 295
 296        need_out = !cmd->no_stdout
 297                && !cmd->stdout_to_stderr
 298                && cmd->out < 0;
 299        if (need_out) {
 300                if (pipe(fdout) < 0) {
 301                        failed_errno = errno;
 302                        if (need_in)
 303                                close_pair(fdin);
 304                        else if (cmd->in)
 305                                close(cmd->in);
 306                        str = "standard output";
 307                        goto fail_pipe;
 308                }
 309                cmd->out = fdout[0];
 310        }
 311
 312        need_err = !cmd->no_stderr && cmd->err < 0;
 313        if (need_err) {
 314                if (pipe(fderr) < 0) {
 315                        failed_errno = errno;
 316                        if (need_in)
 317                                close_pair(fdin);
 318                        else if (cmd->in)
 319                                close(cmd->in);
 320                        if (need_out)
 321                                close_pair(fdout);
 322                        else if (cmd->out)
 323                                close(cmd->out);
 324                        str = "standard error";
 325fail_pipe:
 326                        error("cannot create %s pipe for %s: %s",
 327                                str, cmd->argv[0], strerror(failed_errno));
 328                        errno = failed_errno;
 329                        return -1;
 330                }
 331                cmd->err = fderr[0];
 332        }
 333
 334        trace_argv_printf(cmd->argv, "trace: run_command:");
 335        fflush(NULL);
 336
 337#ifndef WIN32
 338{
 339        int notify_pipe[2];
 340        if (pipe(notify_pipe))
 341                notify_pipe[0] = notify_pipe[1] = -1;
 342
 343        cmd->pid = fork();
 344        failed_errno = errno;
 345        if (!cmd->pid) {
 346                /*
 347                 * Redirect the channel to write syscall error messages to
 348                 * before redirecting the process's stderr so that all die()
 349                 * in subsequent call paths use the parent's stderr.
 350                 */
 351                if (cmd->no_stderr || need_err) {
 352                        child_err = dup(2);
 353                        set_cloexec(child_err);
 354                }
 355                set_die_routine(die_child);
 356                set_error_routine(error_child);
 357
 358                close(notify_pipe[0]);
 359                set_cloexec(notify_pipe[1]);
 360                child_notifier = notify_pipe[1];
 361                atexit(notify_parent);
 362
 363                if (cmd->no_stdin)
 364                        dup_devnull(0);
 365                else if (need_in) {
 366                        dup2(fdin[0], 0);
 367                        close_pair(fdin);
 368                } else if (cmd->in) {
 369                        dup2(cmd->in, 0);
 370                        close(cmd->in);
 371                }
 372
 373                if (cmd->no_stderr)
 374                        dup_devnull(2);
 375                else if (need_err) {
 376                        dup2(fderr[1], 2);
 377                        close_pair(fderr);
 378                } else if (cmd->err > 1) {
 379                        dup2(cmd->err, 2);
 380                        close(cmd->err);
 381                }
 382
 383                if (cmd->no_stdout)
 384                        dup_devnull(1);
 385                else if (cmd->stdout_to_stderr)
 386                        dup2(2, 1);
 387                else if (need_out) {
 388                        dup2(fdout[1], 1);
 389                        close_pair(fdout);
 390                } else if (cmd->out > 1) {
 391                        dup2(cmd->out, 1);
 392                        close(cmd->out);
 393                }
 394
 395                if (cmd->dir && chdir(cmd->dir))
 396                        die_errno("exec '%s': cd to '%s' failed", cmd->argv[0],
 397                            cmd->dir);
 398                if (cmd->env) {
 399                        for (; *cmd->env; cmd->env++) {
 400                                if (strchr(*cmd->env, '='))
 401                                        putenv((char *)*cmd->env);
 402                                else
 403                                        unsetenv(*cmd->env);
 404                        }
 405                }
 406                if (cmd->git_cmd) {
 407                        execv_git_cmd(cmd->argv);
 408                } else if (cmd->use_shell) {
 409                        execv_shell_cmd(cmd->argv);
 410                } else {
 411                        sane_execvp(cmd->argv[0], (char *const*) cmd->argv);
 412                }
 413                if (errno == ENOENT) {
 414                        if (!cmd->silent_exec_failure)
 415                                error("cannot run %s: %s", cmd->argv[0],
 416                                        strerror(ENOENT));
 417                        exit(127);
 418                } else {
 419                        die_errno("cannot exec '%s'", cmd->argv[0]);
 420                }
 421        }
 422        if (cmd->pid < 0)
 423                error("cannot fork() for %s: %s", cmd->argv[0],
 424                        strerror(errno));
 425        else if (cmd->clean_on_exit)
 426                mark_child_for_cleanup(cmd->pid);
 427
 428        /*
 429         * Wait for child's execvp. If the execvp succeeds (or if fork()
 430         * failed), EOF is seen immediately by the parent. Otherwise, the
 431         * child process sends a single byte.
 432         * Note that use of this infrastructure is completely advisory,
 433         * therefore, we keep error checks minimal.
 434         */
 435        close(notify_pipe[1]);
 436        if (read(notify_pipe[0], &notify_pipe[1], 1) == 1) {
 437                /*
 438                 * At this point we know that fork() succeeded, but execvp()
 439                 * failed. Errors have been reported to our stderr.
 440                 */
 441                wait_or_whine(cmd->pid, cmd->argv[0]);
 442                failed_errno = errno;
 443                cmd->pid = -1;
 444        }
 445        close(notify_pipe[0]);
 446
 447}
 448#else
 449{
 450        int fhin = 0, fhout = 1, fherr = 2;
 451        const char **sargv = cmd->argv;
 452        char **env = environ;
 453
 454        if (cmd->no_stdin)
 455                fhin = open("/dev/null", O_RDWR);
 456        else if (need_in)
 457                fhin = dup(fdin[0]);
 458        else if (cmd->in)
 459                fhin = dup(cmd->in);
 460
 461        if (cmd->no_stderr)
 462                fherr = open("/dev/null", O_RDWR);
 463        else if (need_err)
 464                fherr = dup(fderr[1]);
 465        else if (cmd->err > 2)
 466                fherr = dup(cmd->err);
 467
 468        if (cmd->no_stdout)
 469                fhout = open("/dev/null", O_RDWR);
 470        else if (cmd->stdout_to_stderr)
 471                fhout = dup(fherr);
 472        else if (need_out)
 473                fhout = dup(fdout[1]);
 474        else if (cmd->out > 1)
 475                fhout = dup(cmd->out);
 476
 477        if (cmd->env)
 478                env = make_augmented_environ(cmd->env);
 479
 480        if (cmd->git_cmd) {
 481                cmd->argv = prepare_git_cmd(cmd->argv);
 482        } else if (cmd->use_shell) {
 483                cmd->argv = prepare_shell_cmd(cmd->argv);
 484        }
 485
 486        cmd->pid = mingw_spawnvpe(cmd->argv[0], cmd->argv, env, cmd->dir,
 487                                  fhin, fhout, fherr);
 488        failed_errno = errno;
 489        if (cmd->pid < 0 && (!cmd->silent_exec_failure || errno != ENOENT))
 490                error("cannot spawn %s: %s", cmd->argv[0], strerror(errno));
 491        if (cmd->clean_on_exit && cmd->pid >= 0)
 492                mark_child_for_cleanup(cmd->pid);
 493
 494        if (cmd->env)
 495                free_environ(env);
 496        if (cmd->git_cmd)
 497                free(cmd->argv);
 498
 499        cmd->argv = sargv;
 500        if (fhin != 0)
 501                close(fhin);
 502        if (fhout != 1)
 503                close(fhout);
 504        if (fherr != 2)
 505                close(fherr);
 506}
 507#endif
 508
 509        if (cmd->pid < 0) {
 510                if (need_in)
 511                        close_pair(fdin);
 512                else if (cmd->in)
 513                        close(cmd->in);
 514                if (need_out)
 515                        close_pair(fdout);
 516                else if (cmd->out)
 517                        close(cmd->out);
 518                if (need_err)
 519                        close_pair(fderr);
 520                else if (cmd->err)
 521                        close(cmd->err);
 522                errno = failed_errno;
 523                return -1;
 524        }
 525
 526        if (need_in)
 527                close(fdin[0]);
 528        else if (cmd->in)
 529                close(cmd->in);
 530
 531        if (need_out)
 532                close(fdout[1]);
 533        else if (cmd->out)
 534                close(cmd->out);
 535
 536        if (need_err)
 537                close(fderr[1]);
 538        else if (cmd->err)
 539                close(cmd->err);
 540
 541        return 0;
 542}
 543
 544int finish_command(struct child_process *cmd)
 545{
 546        return wait_or_whine(cmd->pid, cmd->argv[0]);
 547}
 548
 549int run_command(struct child_process *cmd)
 550{
 551        int code = start_command(cmd);
 552        if (code)
 553                return code;
 554        return finish_command(cmd);
 555}
 556
 557static void prepare_run_command_v_opt(struct child_process *cmd,
 558                                      const char **argv,
 559                                      int opt)
 560{
 561        memset(cmd, 0, sizeof(*cmd));
 562        cmd->argv = argv;
 563        cmd->no_stdin = opt & RUN_COMMAND_NO_STDIN ? 1 : 0;
 564        cmd->git_cmd = opt & RUN_GIT_CMD ? 1 : 0;
 565        cmd->stdout_to_stderr = opt & RUN_COMMAND_STDOUT_TO_STDERR ? 1 : 0;
 566        cmd->silent_exec_failure = opt & RUN_SILENT_EXEC_FAILURE ? 1 : 0;
 567        cmd->use_shell = opt & RUN_USING_SHELL ? 1 : 0;
 568        cmd->clean_on_exit = opt & RUN_CLEAN_ON_EXIT ? 1 : 0;
 569}
 570
 571int run_command_v_opt(const char **argv, int opt)
 572{
 573        struct child_process cmd;
 574        prepare_run_command_v_opt(&cmd, argv, opt);
 575        return run_command(&cmd);
 576}
 577
 578int run_command_v_opt_cd_env(const char **argv, int opt, const char *dir, const char *const *env)
 579{
 580        struct child_process cmd;
 581        prepare_run_command_v_opt(&cmd, argv, opt);
 582        cmd.dir = dir;
 583        cmd.env = env;
 584        return run_command(&cmd);
 585}
 586
 587#ifndef NO_PTHREADS
 588static pthread_t main_thread;
 589static int main_thread_set;
 590static pthread_key_t async_key;
 591static pthread_key_t async_die_counter;
 592
 593static void *run_thread(void *data)
 594{
 595        struct async *async = data;
 596        intptr_t ret;
 597
 598        pthread_setspecific(async_key, async);
 599        ret = async->proc(async->proc_in, async->proc_out, async->data);
 600        return (void *)ret;
 601}
 602
 603static NORETURN void die_async(const char *err, va_list params)
 604{
 605        vreportf("fatal: ", err, params);
 606
 607        if (!pthread_equal(main_thread, pthread_self())) {
 608                struct async *async = pthread_getspecific(async_key);
 609                if (async->proc_in >= 0)
 610                        close(async->proc_in);
 611                if (async->proc_out >= 0)
 612                        close(async->proc_out);
 613                pthread_exit((void *)128);
 614        }
 615
 616        exit(128);
 617}
 618
 619static int async_die_is_recursing(void)
 620{
 621        void *ret = pthread_getspecific(async_die_counter);
 622        pthread_setspecific(async_die_counter, (void *)1);
 623        return ret != NULL;
 624}
 625
 626#endif
 627
 628int start_async(struct async *async)
 629{
 630        int need_in, need_out;
 631        int fdin[2], fdout[2];
 632        int proc_in, proc_out;
 633
 634        need_in = async->in < 0;
 635        if (need_in) {
 636                if (pipe(fdin) < 0) {
 637                        if (async->out > 0)
 638                                close(async->out);
 639                        return error("cannot create pipe: %s", strerror(errno));
 640                }
 641                async->in = fdin[1];
 642        }
 643
 644        need_out = async->out < 0;
 645        if (need_out) {
 646                if (pipe(fdout) < 0) {
 647                        if (need_in)
 648                                close_pair(fdin);
 649                        else if (async->in)
 650                                close(async->in);
 651                        return error("cannot create pipe: %s", strerror(errno));
 652                }
 653                async->out = fdout[0];
 654        }
 655
 656        if (need_in)
 657                proc_in = fdin[0];
 658        else if (async->in)
 659                proc_in = async->in;
 660        else
 661                proc_in = -1;
 662
 663        if (need_out)
 664                proc_out = fdout[1];
 665        else if (async->out)
 666                proc_out = async->out;
 667        else
 668                proc_out = -1;
 669
 670#ifdef NO_PTHREADS
 671        /* Flush stdio before fork() to avoid cloning buffers */
 672        fflush(NULL);
 673
 674        async->pid = fork();
 675        if (async->pid < 0) {
 676                error("fork (async) failed: %s", strerror(errno));
 677                goto error;
 678        }
 679        if (!async->pid) {
 680                if (need_in)
 681                        close(fdin[1]);
 682                if (need_out)
 683                        close(fdout[0]);
 684                exit(!!async->proc(proc_in, proc_out, async->data));
 685        }
 686
 687        mark_child_for_cleanup(async->pid);
 688
 689        if (need_in)
 690                close(fdin[0]);
 691        else if (async->in)
 692                close(async->in);
 693
 694        if (need_out)
 695                close(fdout[1]);
 696        else if (async->out)
 697                close(async->out);
 698#else
 699        if (!main_thread_set) {
 700                /*
 701                 * We assume that the first time that start_async is called
 702                 * it is from the main thread.
 703                 */
 704                main_thread_set = 1;
 705                main_thread = pthread_self();
 706                pthread_key_create(&async_key, NULL);
 707                pthread_key_create(&async_die_counter, NULL);
 708                set_die_routine(die_async);
 709                set_die_is_recursing_routine(async_die_is_recursing);
 710        }
 711
 712        if (proc_in >= 0)
 713                set_cloexec(proc_in);
 714        if (proc_out >= 0)
 715                set_cloexec(proc_out);
 716        async->proc_in = proc_in;
 717        async->proc_out = proc_out;
 718        {
 719                int err = pthread_create(&async->tid, NULL, run_thread, async);
 720                if (err) {
 721                        error("cannot create thread: %s", strerror(err));
 722                        goto error;
 723                }
 724        }
 725#endif
 726        return 0;
 727
 728error:
 729        if (need_in)
 730                close_pair(fdin);
 731        else if (async->in)
 732                close(async->in);
 733
 734        if (need_out)
 735                close_pair(fdout);
 736        else if (async->out)
 737                close(async->out);
 738        return -1;
 739}
 740
 741int finish_async(struct async *async)
 742{
 743#ifdef NO_PTHREADS
 744        return wait_or_whine(async->pid, "child process");
 745#else
 746        void *ret = (void *)(intptr_t)(-1);
 747
 748        if (pthread_join(async->tid, &ret))
 749                error("pthread_join failed");
 750        return (int)(intptr_t)ret;
 751#endif
 752}
 753
 754char *find_hook(const char *name)
 755{
 756        char *path = git_path("hooks/%s", name);
 757        if (access(path, X_OK) < 0)
 758                path = NULL;
 759
 760        return path;
 761}
 762
 763int run_hook(const char *index_file, const char *name, ...)
 764{
 765        struct child_process hook;
 766        struct argv_array argv = ARGV_ARRAY_INIT;
 767        const char *p, *env[2];
 768        char index[PATH_MAX];
 769        va_list args;
 770        int ret;
 771
 772        p = find_hook(name);
 773        if (!p)
 774                return 0;
 775
 776        argv_array_push(&argv, p);
 777
 778        va_start(args, name);
 779        while ((p = va_arg(args, const char *)))
 780                argv_array_push(&argv, p);
 781        va_end(args);
 782
 783        memset(&hook, 0, sizeof(hook));
 784        hook.argv = argv.argv;
 785        hook.no_stdin = 1;
 786        hook.stdout_to_stderr = 1;
 787        if (index_file) {
 788                snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
 789                env[0] = index;
 790                env[1] = NULL;
 791                hook.env = env;
 792        }
 793
 794        ret = run_command(&hook);
 795        argv_array_clear(&argv);
 796        return ret;
 797}