/*

* 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,

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;

}