sub-process.con commit travis-ci: check that all build artifacts are .gitignore-d (b92cb86)
   1/*
   2 * Generic implementation of background process infrastructure.
   3 */
   4#include "sub-process.h"
   5#include "sigchain.h"
   6#include "pkt-line.h"
   7
   8int cmd2process_cmp(const void *unused_cmp_data,
   9                    const struct subprocess_entry *e1,
  10                    const struct subprocess_entry *e2,
  11                    const void *unused_keydata)
  12{
  13        return strcmp(e1->cmd, e2->cmd);
  14}
  15
  16struct subprocess_entry *subprocess_find_entry(struct hashmap *hashmap, const char *cmd)
  17{
  18        struct subprocess_entry key;
  19
  20        hashmap_entry_init(&key, strhash(cmd));
  21        key.cmd = cmd;
  22        return hashmap_get(hashmap, &key, NULL);
  23}
  24
  25int subprocess_read_status(int fd, struct strbuf *status)
  26{
  27        struct strbuf **pair;
  28        char *line;
  29        int len;
  30
  31        for (;;) {
  32                len = packet_read_line_gently(fd, NULL, &line);
  33                if ((len < 0) || !line)
  34                        break;
  35                pair = strbuf_split_str(line, '=', 2);
  36                if (pair[0] && pair[0]->len && pair[1]) {
  37                        /* the last "status=<foo>" line wins */
  38                        if (!strcmp(pair[0]->buf, "status=")) {
  39                                strbuf_reset(status);
  40                                strbuf_addbuf(status, pair[1]);
  41                        }
  42                }
  43                strbuf_list_free(pair);
  44        }
  45
  46        return (len < 0) ? len : 0;
  47}
  48
  49void subprocess_stop(struct hashmap *hashmap, struct subprocess_entry *entry)
  50{
  51        if (!entry)
  52                return;
  53
  54        entry->process.clean_on_exit = 0;
  55        kill(entry->process.pid, SIGTERM);
  56        finish_command(&entry->process);
  57
  58        hashmap_remove(hashmap, entry, NULL);
  59}
  60
  61static void subprocess_exit_handler(struct child_process *process)
  62{
  63        sigchain_push(SIGPIPE, SIG_IGN);
  64        /* Closing the pipe signals the subprocess to initiate a shutdown. */
  65        close(process->in);
  66        close(process->out);
  67        sigchain_pop(SIGPIPE);
  68        /* Finish command will wait until the shutdown is complete. */
  69        finish_command(process);
  70}
  71
  72int subprocess_start(struct hashmap *hashmap, struct subprocess_entry *entry, const char *cmd,
  73        subprocess_start_fn startfn)
  74{
  75        int err;
  76        struct child_process *process;
  77        const char *argv[] = { cmd, NULL };
  78
  79        entry->cmd = cmd;
  80        process = &entry->process;
  81
  82        child_process_init(process);
  83        process->argv = argv;
  84        process->use_shell = 1;
  85        process->in = -1;
  86        process->out = -1;
  87        process->clean_on_exit = 1;
  88        process->clean_on_exit_handler = subprocess_exit_handler;
  89
  90        err = start_command(process);
  91        if (err) {
  92                error("cannot fork to run subprocess '%s'", cmd);
  93                return err;
  94        }
  95
  96        hashmap_entry_init(entry, strhash(cmd));
  97
  98        err = startfn(entry);
  99        if (err) {
 100                error("initialization for subprocess '%s' failed", cmd);
 101                subprocess_stop(hashmap, entry);
 102                return err;
 103        }
 104
 105        hashmap_add(hashmap, entry);
 106        return 0;
 107}
 108
 109static int handshake_version(struct child_process *process,
 110                             const char *welcome_prefix, int *versions,
 111                             int *chosen_version)
 112{
 113        int version_scratch;
 114        int i;
 115        char *line;
 116        const char *p;
 117
 118        if (!chosen_version)
 119                chosen_version = &version_scratch;
 120
 121        if (packet_write_fmt_gently(process->in, "%s-client\n",
 122                                    welcome_prefix))
 123                return error("Could not write client identification");
 124        for (i = 0; versions[i]; i++) {
 125                if (packet_write_fmt_gently(process->in, "version=%d\n",
 126                                            versions[i]))
 127                        return error("Could not write requested version");
 128        }
 129        if (packet_flush_gently(process->in))
 130                return error("Could not write flush packet");
 131
 132        if (!(line = packet_read_line(process->out, NULL)) ||
 133            !skip_prefix(line, welcome_prefix, &p) ||
 134            strcmp(p, "-server"))
 135                return error("Unexpected line '%s', expected %s-server",
 136                             line ? line : "<flush packet>", welcome_prefix);
 137        if (!(line = packet_read_line(process->out, NULL)) ||
 138            !skip_prefix(line, "version=", &p) ||
 139            strtol_i(p, 10, chosen_version))
 140                return error("Unexpected line '%s', expected version",
 141                             line ? line : "<flush packet>");
 142        if ((line = packet_read_line(process->out, NULL)))
 143                return error("Unexpected line '%s', expected flush", line);
 144
 145        /* Check to make sure that the version received is supported */
 146        for (i = 0; versions[i]; i++) {
 147                if (versions[i] == *chosen_version)
 148                        break;
 149        }
 150        if (!versions[i])
 151                return error("Version %d not supported", *chosen_version);
 152
 153        return 0;
 154}
 155
 156static int handshake_capabilities(struct child_process *process,
 157                                  struct subprocess_capability *capabilities,
 158                                  unsigned int *supported_capabilities)
 159{
 160        int i;
 161        char *line;
 162
 163        for (i = 0; capabilities[i].name; i++) {
 164                if (packet_write_fmt_gently(process->in, "capability=%s\n",
 165                                            capabilities[i].name))
 166                        return error("Could not write requested capability");
 167        }
 168        if (packet_flush_gently(process->in))
 169                return error("Could not write flush packet");
 170
 171        while ((line = packet_read_line(process->out, NULL))) {
 172                const char *p;
 173                if (!skip_prefix(line, "capability=", &p))
 174                        continue;
 175
 176                for (i = 0;
 177                     capabilities[i].name && strcmp(p, capabilities[i].name);
 178                     i++)
 179                        ;
 180                if (capabilities[i].name) {
 181                        if (supported_capabilities)
 182                                *supported_capabilities |= capabilities[i].flag;
 183                } else {
 184                        warning("external filter requested unsupported filter capability '%s'",
 185                                p);
 186                }
 187        }
 188
 189        return 0;
 190}
 191
 192int subprocess_handshake(struct subprocess_entry *entry,
 193                         const char *welcome_prefix,
 194                         int *versions,
 195                         int *chosen_version,
 196                         struct subprocess_capability *capabilities,
 197                         unsigned int *supported_capabilities)
 198{
 199        int retval;
 200        struct child_process *process = &entry->process;
 201
 202        sigchain_push(SIGPIPE, SIG_IGN);
 203
 204        retval = handshake_version(process, welcome_prefix, versions,
 205                                   chosen_version) ||
 206                 handshake_capabilities(process, capabilities,
 207                                        supported_capabilities);
 208
 209        sigchain_pop(SIGPIPE);
 210        return retval;
 211}