hook.c

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