You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
217 lines
5.6 KiB
217 lines
5.6 KiB
/* |
|
* Generic implementation of background process infrastructure. |
|
*/ |
|
#include "git-compat-util.h" |
|
#include "sub-process.h" |
|
#include "sigchain.h" |
|
#include "pkt-line.h" |
|
|
|
int cmd2process_cmp(const void *cmp_data UNUSED, |
|
const struct hashmap_entry *eptr, |
|
const struct hashmap_entry *entry_or_key, |
|
const void *keydata UNUSED) |
|
{ |
|
const struct subprocess_entry *e1, *e2; |
|
|
|
e1 = container_of(eptr, const struct subprocess_entry, ent); |
|
e2 = container_of(entry_or_key, const struct subprocess_entry, ent); |
|
|
|
return strcmp(e1->cmd, e2->cmd); |
|
} |
|
|
|
struct subprocess_entry *subprocess_find_entry(struct hashmap *hashmap, const char *cmd) |
|
{ |
|
struct subprocess_entry key; |
|
|
|
hashmap_entry_init(&key.ent, strhash(cmd)); |
|
key.cmd = cmd; |
|
return hashmap_get_entry(hashmap, &key, ent, NULL); |
|
} |
|
|
|
int subprocess_read_status(int fd, struct strbuf *status) |
|
{ |
|
struct strbuf **pair; |
|
char *line; |
|
int len; |
|
|
|
for (;;) { |
|
len = packet_read_line_gently(fd, NULL, &line); |
|
if ((len < 0) || !line) |
|
break; |
|
pair = strbuf_split_str(line, '=', 2); |
|
if (pair[0] && pair[0]->len && pair[1]) { |
|
/* the last "status=<foo>" line wins */ |
|
if (!strcmp(pair[0]->buf, "status=")) { |
|
strbuf_reset(status); |
|
strbuf_addbuf(status, pair[1]); |
|
} |
|
} |
|
strbuf_list_free(pair); |
|
} |
|
|
|
return (len < 0) ? len : 0; |
|
} |
|
|
|
void subprocess_stop(struct hashmap *hashmap, struct subprocess_entry *entry) |
|
{ |
|
if (!entry) |
|
return; |
|
|
|
entry->process.clean_on_exit = 0; |
|
kill(entry->process.pid, SIGTERM); |
|
finish_command(&entry->process); |
|
|
|
hashmap_remove(hashmap, &entry->ent, NULL); |
|
} |
|
|
|
static void subprocess_exit_handler(struct child_process *process) |
|
{ |
|
sigchain_push(SIGPIPE, SIG_IGN); |
|
/* Closing the pipe signals the subprocess to initiate a shutdown. */ |
|
close(process->in); |
|
close(process->out); |
|
sigchain_pop(SIGPIPE); |
|
/* Finish command will wait until the shutdown is complete. */ |
|
finish_command(process); |
|
} |
|
|
|
int subprocess_start(struct hashmap *hashmap, struct subprocess_entry *entry, const char *cmd, |
|
subprocess_start_fn startfn) |
|
{ |
|
int err; |
|
struct child_process *process; |
|
|
|
entry->cmd = cmd; |
|
process = &entry->process; |
|
|
|
child_process_init(process); |
|
strvec_push(&process->args, cmd); |
|
process->use_shell = 1; |
|
process->in = -1; |
|
process->out = -1; |
|
process->clean_on_exit = 1; |
|
process->clean_on_exit_handler = subprocess_exit_handler; |
|
process->trace2_child_class = "subprocess"; |
|
|
|
err = start_command(process); |
|
if (err) { |
|
error("cannot fork to run subprocess '%s'", cmd); |
|
return err; |
|
} |
|
|
|
hashmap_entry_init(&entry->ent, strhash(cmd)); |
|
|
|
err = startfn(entry); |
|
if (err) { |
|
error("initialization for subprocess '%s' failed", cmd); |
|
subprocess_stop(hashmap, entry); |
|
return err; |
|
} |
|
|
|
hashmap_add(hashmap, &entry->ent); |
|
return 0; |
|
} |
|
|
|
static int handshake_version(struct child_process *process, |
|
const char *welcome_prefix, int *versions, |
|
int *chosen_version) |
|
{ |
|
int version_scratch; |
|
int i; |
|
char *line; |
|
const char *p; |
|
|
|
if (!chosen_version) |
|
chosen_version = &version_scratch; |
|
|
|
if (packet_write_fmt_gently(process->in, "%s-client\n", |
|
welcome_prefix)) |
|
return error("Could not write client identification"); |
|
for (i = 0; versions[i]; i++) { |
|
if (packet_write_fmt_gently(process->in, "version=%d\n", |
|
versions[i])) |
|
return error("Could not write requested version"); |
|
} |
|
if (packet_flush_gently(process->in)) |
|
return error("Could not write flush packet"); |
|
|
|
if (!(line = packet_read_line(process->out, NULL)) || |
|
!skip_prefix(line, welcome_prefix, &p) || |
|
strcmp(p, "-server")) |
|
return error("Unexpected line '%s', expected %s-server", |
|
line ? line : "<flush packet>", welcome_prefix); |
|
if (!(line = packet_read_line(process->out, NULL)) || |
|
!skip_prefix(line, "version=", &p) || |
|
strtol_i(p, 10, chosen_version)) |
|
return error("Unexpected line '%s', expected version", |
|
line ? line : "<flush packet>"); |
|
if ((line = packet_read_line(process->out, NULL))) |
|
return error("Unexpected line '%s', expected flush", line); |
|
|
|
/* Check to make sure that the version received is supported */ |
|
for (i = 0; versions[i]; i++) { |
|
if (versions[i] == *chosen_version) |
|
break; |
|
} |
|
if (!versions[i]) |
|
return error("Version %d not supported", *chosen_version); |
|
|
|
return 0; |
|
} |
|
|
|
static int handshake_capabilities(struct child_process *process, |
|
struct subprocess_capability *capabilities, |
|
unsigned int *supported_capabilities) |
|
{ |
|
int i; |
|
char *line; |
|
|
|
for (i = 0; capabilities[i].name; i++) { |
|
if (packet_write_fmt_gently(process->in, "capability=%s\n", |
|
capabilities[i].name)) |
|
return error("Could not write requested capability"); |
|
} |
|
if (packet_flush_gently(process->in)) |
|
return error("Could not write flush packet"); |
|
|
|
while ((line = packet_read_line(process->out, NULL))) { |
|
const char *p; |
|
if (!skip_prefix(line, "capability=", &p)) |
|
continue; |
|
|
|
for (i = 0; |
|
capabilities[i].name && strcmp(p, capabilities[i].name); |
|
i++) |
|
; |
|
if (capabilities[i].name) { |
|
if (supported_capabilities) |
|
*supported_capabilities |= capabilities[i].flag; |
|
} else { |
|
die("subprocess '%s' requested unsupported capability '%s'", |
|
process->args.v[0], p); |
|
} |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
int subprocess_handshake(struct subprocess_entry *entry, |
|
const char *welcome_prefix, |
|
int *versions, |
|
int *chosen_version, |
|
struct subprocess_capability *capabilities, |
|
unsigned int *supported_capabilities) |
|
{ |
|
int retval; |
|
struct child_process *process = &entry->process; |
|
|
|
sigchain_push(SIGPIPE, SIG_IGN); |
|
|
|
retval = handshake_version(process, welcome_prefix, versions, |
|
chosen_version) || |
|
handshake_capabilities(process, capabilities, |
|
supported_capabilities); |
|
|
|
sigchain_pop(SIGPIPE); |
|
return retval; |
|
}
|
|
|