hook.c

   1 #include "git-compat-util.h"
   2 #include "abspath.h"
   3 #include "advice.h"
   4 #include "gettext.h"
   5 #include "hook.h"
   6 #include "path.h"
   7 #include "run-command.h"
   8 #include "config.h"
   9 #include "strbuf.h"
  10
  11 const char *find_hook(const char *name)
  12 {
  13         static struct strbuf path = STRBUF_INIT;
  14
  15         strbuf_reset(&path);
  16         strbuf_git_path(&path, "hooks/%s", name);
  17         if (access(path.buf, X_OK) < 0) {
  18                 int err = errno;
  19
  20 #ifdef STRIP_EXTENSION
  21                 strbuf_addstr(&path, STRIP_EXTENSION);
  22                 if (access(path.buf, X_OK) >= 0)
  23                         return path.buf;
  24                 if (errno == EACCES)
  25                         err = errno;
  26 #endif
  27
  28                 if (err == EACCES && advice_enabled(ADVICE_IGNORED_HOOK)) {
  29                         static struct string_list advise_given = STRING_LIST_INIT_DUP;
  30
  31                         if (!string_list_lookup(&advise_given, name)) {
  32                                 string_list_insert(&advise_given, name);
  33                                 advise(_("The '%s' hook was ignored because "
  34                                          "it's not set as executable.\n"
  35                                          "You can disable this warning with "
  36                                          "`git config advice.ignoredHook false`."),
  37                                        path.buf);
  38                         }
  39                 }
  40                 return NULL;
  41         }
  42         return path.buf;
  43 }
  44
  45 int hook_exists(const char *name)
  46 {
  47         return !!find_hook(name);
  48 }
  49
  50 static int pick_next_hook(struct child_process *cp,
  51                           struct strbuf *out UNUSED,
  52                           void *pp_cb,
  53                           void **pp_task_cb UNUSED)
  54 {
  55         struct hook_cb_data *hook_cb = pp_cb;
  56         const char *hook_path = hook_cb->hook_path;
  57
  58         if (!hook_path)
  59                 return 0;
  60
  61         cp->no_stdin = 1;
  62         strvec_pushv(&cp->env, hook_cb->options->env.v);
  63         /* reopen the file for stdin; run_command closes it. */
  64         if (hook_cb->options->path_to_stdin) {
  65                 cp->no_stdin = 0;
  66                 cp->in = xopen(hook_cb->options->path_to_stdin, O_RDONLY);
  67         }
  68         cp->stdout_to_stderr = 1;
  69         cp->trace2_hook_name = hook_cb->hook_name;
  70         cp->dir = hook_cb->options->dir;
  71
  72         strvec_push(&cp->args, hook_path);
  73         strvec_pushv(&cp->args, hook_cb->options->args.v);
  74
  75         /*
  76          * This pick_next_hook() will be called again, we're only
  77          * running one hook, so indicate that no more work will be
  78          * done.
  79          */
  80         hook_cb->hook_path = NULL;
  81
  82         return 1;
  83 }
  84
  85 static int notify_start_failure(struct strbuf *out UNUSED,
  86                                 void *pp_cb,
  87                                 void *pp_task_cp UNUSED)
  88 {
  89         struct hook_cb_data *hook_cb = pp_cb;
  90
  91         hook_cb->rc |= 1;
  92
  93         return 1;
  94 }
  95
  96 static int notify_hook_finished(int result,
  97                                 struct strbuf *out UNUSED,
  98                                 void *pp_cb,
  99                                 void *pp_task_cb UNUSED)
 100 {
 101         struct hook_cb_data *hook_cb = pp_cb;
 102         struct run_hooks_opt *opt = hook_cb->options;
 103
 104         hook_cb->rc |= result;
 105
 106         if (opt->invoked_hook)
 107                 *opt->invoked_hook = 1;
 108
 109         return 0;
 110 }
 111
 112 static void run_hooks_opt_clear(struct run_hooks_opt *options)
 113 {
 114         strvec_clear(&options->env);
 115         strvec_clear(&options->args);
 116 }
 117
 118 int run_hooks_opt(const char *hook_name, struct run_hooks_opt *options)
 119 {
 120         struct strbuf abs_path = STRBUF_INIT;
 121         struct hook_cb_data cb_data = {
 122                 .rc = 0,
 123                 .hook_name = hook_name,
 124                 .options = options,
 125         };
 126         const char *const hook_path = find_hook(hook_name);
 127         int ret = 0;
 128         const struct run_process_parallel_opts opts = {
 129                 .tr2_category = "hook",
 130                 .tr2_label = hook_name,
 131
 132                 .processes = 1,
 133                 .ungroup = 1,
 134
 135                 .get_next_task = pick_next_hook,
 136                 .start_failure = notify_start_failure,
 137                 .task_finished = notify_hook_finished,
 138
 139                 .data = &cb_data,
 140         };
 141
 142         if (!options)
 143                 BUG("a struct run_hooks_opt must be provided to run_hooks");
 144
 145         if (options->invoked_hook)
 146                 *options->invoked_hook = 0;
 147
 148         if (!hook_path && !options->error_if_missing)
 149                 goto cleanup;
 150
 151         if (!hook_path) {
 152                 ret = error("cannot find a hook named %s", hook_name);
 153                 goto cleanup;
 154         }
 155
 156         cb_data.hook_path = hook_path;
 157         if (options->dir) {
 158                 strbuf_add_absolute_path(&abs_path, hook_path);
 159                 cb_data.hook_path = abs_path.buf;
 160         }
 161
 162         run_processes_parallel(&opts);
 163         ret = cb_data.rc;
 164 cleanup:
 165         strbuf_release(&abs_path);
 166         run_hooks_opt_clear(options);
 167         return ret;
 168 }
 169
 170 int run_hooks(const char *hook_name)
 171 {
 172         struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT;
 173
 174         return run_hooks_opt(hook_name, &opt);
 175 }
 176
 177 int run_hooks_l(const char *hook_name, ...)
 178 {
 179         struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT;
 180         va_list ap;
 181         const char *arg;
 182
 183         va_start(ap, hook_name);
 184         while ((arg = va_arg(ap, const char *)))
 185                 strvec_push(&opt.args, arg);
 186         va_end(ap);
 187
 188         return run_hooks_opt(hook_name, &opt);
 189 }