git

1
/*
2
 * Generic implementation of background process infrastructure.
3
 */
4
#include "git-compat-util.h"
5
#include "sub-process.h"
6
#include "sigchain.h"
7
#include "pkt-line.h"
8

9
int cmd2process_cmp(const void *cmp_data UNUSED,
10
		    const struct hashmap_entry *eptr,
11
		    const struct hashmap_entry *entry_or_key,
12
		    const void *keydata UNUSED)
13
{
14
	const struct subprocess_entry *e1, *e2;
15

16
	e1 = container_of(eptr, const struct subprocess_entry, ent);
17
	e2 = container_of(entry_or_key, const struct subprocess_entry, ent);
18

19
	return strcmp(e1->cmd, e2->cmd);
20
}
21

22
struct subprocess_entry *subprocess_find_entry(struct hashmap *hashmap, const char *cmd)
23
{
24
	struct subprocess_entry key;
25

26
	hashmap_entry_init(&key.ent, strhash(cmd));
27
	key.cmd = cmd;
28
	return hashmap_get_entry(hashmap, &key, ent, NULL);
29
}
30

31
int subprocess_read_status(int fd, struct strbuf *status)
32
{
33
	struct strbuf **pair;
34
	char *line;
35
	int len;
36

37
	for (;;) {
38
		len = packet_read_line_gently(fd, NULL, &line);
39
		if ((len < 0) || !line)
40
			break;
41
		pair = strbuf_split_str(line, '=', 2);
42
		if (pair[0] && pair[0]->len && pair[1]) {
43
			/* the last "status=<foo>" line wins */
44
			if (!strcmp(pair[0]->buf, "status=")) {
45
				strbuf_reset(status);
46
				strbuf_addbuf(status, pair[1]);
47
			}
48
		}
49
		strbuf_list_free(pair);
50
	}
51

52
	return (len < 0) ? len : 0;
53
}
54

55
void subprocess_stop(struct hashmap *hashmap, struct subprocess_entry *entry)
56
{
57
	if (!entry)
58
		return;
59

60
	entry->process.clean_on_exit = 0;
61
	kill(entry->process.pid, SIGTERM);
62
	finish_command(&entry->process);
63

64
	hashmap_remove(hashmap, &entry->ent, NULL);
65
}
66

67
static void subprocess_exit_handler(struct child_process *process)
68
{
69
	sigchain_push(SIGPIPE, SIG_IGN);
70
	/* Closing the pipe signals the subprocess to initiate a shutdown. */
71
	close(process->in);
72
	close(process->out);
73
	sigchain_pop(SIGPIPE);
74
	/* Finish command will wait until the shutdown is complete. */
75
	finish_command(process);
76
}
77

78
int subprocess_start(struct hashmap *hashmap, struct subprocess_entry *entry, const char *cmd,
79
	subprocess_start_fn startfn)
80
{
81
	int err;
82
	struct child_process *process;
83

84
	entry->cmd = cmd;
85
	process = &entry->process;
86

87
	child_process_init(process);
88
	strvec_push(&process->args, cmd);
89
	process->use_shell = 1;
90
	process->in = -1;
91
	process->out = -1;
92
	process->clean_on_exit = 1;
93
	process->clean_on_exit_handler = subprocess_exit_handler;
94
	process->trace2_child_class = "subprocess";
95

96
	err = start_command(process);
97
	if (err) {
98
		error("cannot fork to run subprocess '%s'", cmd);
99
		return err;
100
	}
101

102
	hashmap_entry_init(&entry->ent, strhash(cmd));
103

104
	err = startfn(entry);
105
	if (err) {
106
		error("initialization for subprocess '%s' failed", cmd);
107
		subprocess_stop(hashmap, entry);
108
		return err;
109
	}
110

111
	hashmap_add(hashmap, &entry->ent);
112
	return 0;
113
}
114

115
static int handshake_version(struct child_process *process,
116
			     const char *welcome_prefix, int *versions,
117
			     int *chosen_version)
118
{
119
	int version_scratch;
120
	int i;
121
	char *line;
122
	const char *p;
123

124
	if (!chosen_version)
125
		chosen_version = &version_scratch;
126

127
	if (packet_write_fmt_gently(process->in, "%s-client\n",
128
				    welcome_prefix))
129
		return error("Could not write client identification");
130
	for (i = 0; versions[i]; i++) {
131
		if (packet_write_fmt_gently(process->in, "version=%d\n",
132
					    versions[i]))
133
			return error("Could not write requested version");
134
	}
135
	if (packet_flush_gently(process->in))
136
		return error("Could not write flush packet");
137

138
	if (!(line = packet_read_line(process->out, NULL)) ||
139
	    !skip_prefix(line, welcome_prefix, &p) ||
140
	    strcmp(p, "-server"))
141
		return error("Unexpected line '%s', expected %s-server",
142
			     line ? line : "<flush packet>", welcome_prefix);
143
	if (!(line = packet_read_line(process->out, NULL)) ||
144
	    !skip_prefix(line, "version=", &p) ||
145
	    strtol_i(p, 10, chosen_version))
146
		return error("Unexpected line '%s', expected version",
147
			     line ? line : "<flush packet>");
148
	if ((line = packet_read_line(process->out, NULL)))
149
		return error("Unexpected line '%s', expected flush", line);
150

151
	/* Check to make sure that the version received is supported */
152
	for (i = 0; versions[i]; i++) {
153
		if (versions[i] == *chosen_version)
154
			break;
155
	}
156
	if (!versions[i])
157
		return error("Version %d not supported", *chosen_version);
158

159
	return 0;
160
}
161

162
static int handshake_capabilities(struct child_process *process,
163
				  struct subprocess_capability *capabilities,
164
				  unsigned int *supported_capabilities)
165
{
166
	int i;
167
	char *line;
168

169
	for (i = 0; capabilities[i].name; i++) {
170
		if (packet_write_fmt_gently(process->in, "capability=%s\n",
171
					    capabilities[i].name))
172
			return error("Could not write requested capability");
173
	}
174
	if (packet_flush_gently(process->in))
175
		return error("Could not write flush packet");
176

177
	while ((line = packet_read_line(process->out, NULL))) {
178
		const char *p;
179
		if (!skip_prefix(line, "capability=", &p))
180
			continue;
181

182
		for (i = 0;
183
		     capabilities[i].name && strcmp(p, capabilities[i].name);
184
		     i++)
185
			;
186
		if (capabilities[i].name) {
187
			if (supported_capabilities)
188
				*supported_capabilities |= capabilities[i].flag;
189
		} else {
190
			die("subprocess '%s' requested unsupported capability '%s'",
191
			    process->args.v[0], p);
192
		}
193
	}
194

195
	return 0;
196
}
197

198
int subprocess_handshake(struct subprocess_entry *entry,
199
			 const char *welcome_prefix,
200
			 int *versions,
201
			 int *chosen_version,
202
			 struct subprocess_capability *capabilities,
203
			 unsigned int *supported_capabilities)
204
{
205
	int retval;
206
	struct child_process *process = &entry->process;
207

208
	sigchain_push(SIGPIPE, SIG_IGN);
209

210
	retval = handshake_version(process, welcome_prefix, versions,
211
				   chosen_version) ||
212
		 handshake_capabilities(process, capabilities,
213
					supported_capabilities);
214

215
	sigchain_pop(SIGPIPE);
216
	return retval;
217
}
218