git

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
#include "environment.h"
11
#include "setup.h"
12

13
const char *find_hook(struct repository *r, const char *name)
14
{
15
	static struct strbuf path = STRBUF_INIT;
16

17
	int found_hook;
18

19
	strbuf_reset(&path);
20
	strbuf_repo_git_path(&path, r, "hooks/%s", name);
21
	found_hook = access(path.buf, X_OK) >= 0;
22
#ifdef STRIP_EXTENSION
23
	if (!found_hook) {
24
		int err = errno;
25

26
		strbuf_addstr(&path, STRIP_EXTENSION);
27
		found_hook = access(path.buf, X_OK) >= 0;
28
		if (!found_hook)
29
			errno = err;
30
	}
31
#endif
32

33
	if (!found_hook) {
34
		if (errno == EACCES && advice_enabled(ADVICE_IGNORED_HOOK)) {
35
			static struct string_list advise_given = STRING_LIST_INIT_DUP;
36

37
			if (!string_list_lookup(&advise_given, name)) {
38
				string_list_insert(&advise_given, name);
39
				advise(_("The '%s' hook was ignored because "
40
					 "it's not set as executable.\n"
41
					 "You can disable this warning with "
42
					 "`git config advice.ignoredHook false`."),
43
				       path.buf);
44
			}
45
		}
46
		return NULL;
47
	}
48
	return path.buf;
49
}
50

51
int hook_exists(struct repository *r, const char *name)
52
{
53
	return !!find_hook(r, name);
54
}
55

56
static int pick_next_hook(struct child_process *cp,
57
			  struct strbuf *out UNUSED,
58
			  void *pp_cb,
59
			  void **pp_task_cb UNUSED)
60
{
61
	struct hook_cb_data *hook_cb = pp_cb;
62
	const char *hook_path = hook_cb->hook_path;
63

64
	if (!hook_path)
65
		return 0;
66

67
	cp->no_stdin = 1;
68
	strvec_pushv(&cp->env, hook_cb->options->env.v);
69
	/* reopen the file for stdin; run_command closes it. */
70
	if (hook_cb->options->path_to_stdin) {
71
		cp->no_stdin = 0;
72
		cp->in = xopen(hook_cb->options->path_to_stdin, O_RDONLY);
73
	}
74
	cp->stdout_to_stderr = 1;
75
	cp->trace2_hook_name = hook_cb->hook_name;
76
	cp->dir = hook_cb->options->dir;
77

78
	strvec_push(&cp->args, hook_path);
79
	strvec_pushv(&cp->args, hook_cb->options->args.v);
80

81
	/*
82
	 * This pick_next_hook() will be called again, we're only
83
	 * running one hook, so indicate that no more work will be
84
	 * done.
85
	 */
86
	hook_cb->hook_path = NULL;
87

88
	return 1;
89
}
90

91
static int notify_start_failure(struct strbuf *out UNUSED,
92
				void *pp_cb,
93
				void *pp_task_cp UNUSED)
94
{
95
	struct hook_cb_data *hook_cb = pp_cb;
96

97
	hook_cb->rc |= 1;
98

99
	return 1;
100
}
101

102
static int notify_hook_finished(int result,
103
				struct strbuf *out UNUSED,
104
				void *pp_cb,
105
				void *pp_task_cb UNUSED)
106
{
107
	struct hook_cb_data *hook_cb = pp_cb;
108
	struct run_hooks_opt *opt = hook_cb->options;
109

110
	hook_cb->rc |= result;
111

112
	if (opt->invoked_hook)
113
		*opt->invoked_hook = 1;
114

115
	return 0;
116
}
117

118
static void run_hooks_opt_clear(struct run_hooks_opt *options)
119
{
120
	strvec_clear(&options->env);
121
	strvec_clear(&options->args);
122
}
123

124
int run_hooks_opt(struct repository *r, const char *hook_name,
125
		  struct run_hooks_opt *options)
126
{
127
	struct strbuf abs_path = STRBUF_INIT;
128
	struct hook_cb_data cb_data = {
129
		.rc = 0,
130
		.hook_name = hook_name,
131
		.options = options,
132
	};
133
	const char *const hook_path = find_hook(r, hook_name);
134
	int ret = 0;
135
	const struct run_process_parallel_opts opts = {
136
		.tr2_category = "hook",
137
		.tr2_label = hook_name,
138

139
		.processes = 1,
140
		.ungroup = 1,
141

142
		.get_next_task = pick_next_hook,
143
		.start_failure = notify_start_failure,
144
		.task_finished = notify_hook_finished,
145

146
		.data = &cb_data,
147
	};
148

149
	if (!options)
150
		BUG("a struct run_hooks_opt must be provided to run_hooks");
151

152
	if (options->invoked_hook)
153
		*options->invoked_hook = 0;
154

155
	if (!hook_path && !options->error_if_missing)
156
		goto cleanup;
157

158
	if (!hook_path) {
159
		ret = error("cannot find a hook named %s", hook_name);
160
		goto cleanup;
161
	}
162

163
	cb_data.hook_path = hook_path;
164
	if (options->dir) {
165
		strbuf_add_absolute_path(&abs_path, hook_path);
166
		cb_data.hook_path = abs_path.buf;
167
	}
168

169
	run_processes_parallel(&opts);
170
	ret = cb_data.rc;
171
cleanup:
172
	strbuf_release(&abs_path);
173
	run_hooks_opt_clear(options);
174
	return ret;
175
}
176

177
int run_hooks(struct repository *r, const char *hook_name)
178
{
179
	struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT;
180

181
	return run_hooks_opt(r, hook_name, &opt);
182
}
183

184
int run_hooks_l(struct repository *r, const char *hook_name, ...)
185
{
186
	struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT;
187
	va_list ap;
188
	const char *arg;
189

190
	va_start(ap, hook_name);
191
	while ((arg = va_arg(ap, const char *)))
192
		strvec_push(&opt.args, arg);
193
	va_end(ap);
194

195
	return run_hooks_opt(r, hook_name, &opt);
196
}
197