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