blob: 3f380d87d99eab317d5ac567b43e3cea05885145 [file] [log] [blame]
Daniel Barkalow6eb996b2009-08-05 01:01:53 -04001#include "cache.h"
2#include "transport.h"
Shawn O. Pearceae4efe12009-10-30 17:47:30 -07003#include "quote.h"
Daniel Barkalow6eb996b2009-08-05 01:01:53 -04004#include "run-command.h"
5#include "commit.h"
6#include "diff.h"
7#include "revision.h"
Daniel Barkalow72ff8942009-11-18 02:42:28 +01008#include "remote.h"
Sverre Rabbelier73b49a72010-03-29 11:48:27 -05009#include "string-list.h"
Ilari Liusvaara7851b1e2010-11-17 09:15:34 -080010#include "thread-utils.h"
Jeff Kingc34fe632012-02-23 05:04:34 -050011#include "sigchain.h"
Florian Achleitnerbfc366d2012-09-19 17:21:19 +020012#include "argv-array.h"
Felipe Contreras664059f2013-04-17 23:14:33 -050013#include "refs.h"
Jonathan Tane967ca32017-12-14 13:44:45 -080014#include "transport-internal.h"
Ilari Liusvaara7851b1e2010-11-17 09:15:34 -080015
Ilari Liusvaarabf3c5232009-12-09 17:26:27 +020016static int debug;
17
Jonathan Nieder9cba13c2011-03-16 02:08:34 -050018struct helper_data {
Daniel Barkalow6eb996b2009-08-05 01:01:53 -040019 const char *name;
20 struct child_process *helper;
Shawn O. Pearce292ce462009-10-30 17:47:28 -070021 FILE *out;
Shawn O. Pearceef08ef92009-10-30 17:47:29 -070022 unsigned fetch : 1,
Junio C Hamanoa24a32d2009-12-06 22:40:16 -080023 import : 1,
Florian Achleitnerbfc366d2012-09-19 17:21:19 +020024 bidi_import : 1,
Sverre Rabbelier73b49a72010-03-29 11:48:27 -050025 export : 1,
Shawn O. Pearceae4efe12009-10-30 17:47:30 -070026 option : 1,
Ilari Liusvaarafa8c0972009-12-09 17:26:32 +020027 push : 1,
28 connect : 1,
John Keeping0d957a42013-04-14 11:57:08 +010029 signed_tags : 1,
Nguyễn Thái Ngọc Duy9ba38042013-07-21 15:18:05 +070030 check_connectivity : 1,
Matthieu Moy597b8312013-09-03 17:45:14 +020031 no_disconnect_req : 1,
32 no_private_update : 1;
Sverre Rabbeliera515ebe2011-07-16 15:03:40 +020033 char *export_marks;
34 char *import_marks;
Daniel Barkalow72ff8942009-11-18 02:42:28 +010035 /* These go from remote name (as in "list") to private name */
36 struct refspec *refspecs;
37 int refspec_nr;
Ilari Liusvaara61b075b2009-12-09 17:26:31 +020038 /* Transport options for fetch-pack/send-pack (should one of
39 * those be invoked).
40 */
41 struct git_transport_options transport_options;
Daniel Barkalow6eb996b2009-08-05 01:01:53 -040042};
43
Ilari Liusvaarabf3c5232009-12-09 17:26:27 +020044static void sendline(struct helper_data *helper, struct strbuf *buffer)
45{
46 if (debug)
47 fprintf(stderr, "Debug: Remote helper: -> %s", buffer->buf);
Jeff King06f46f22017-09-13 13:16:03 -040048 if (write_in_full(helper->helper->in, buffer->buf, buffer->len) < 0)
Ilari Liusvaarabf3c5232009-12-09 17:26:27 +020049 die_errno("Full write to remote helper failed");
50}
51
Jeff Kingc0969552013-04-10 17:16:03 -040052static int recvline_fh(FILE *helper, struct strbuf *buffer, const char *name)
Ilari Liusvaarabf3c5232009-12-09 17:26:27 +020053{
54 strbuf_reset(buffer);
55 if (debug)
56 fprintf(stderr, "Debug: Remote helper: Waiting...\n");
Junio C Hamano692dfdf2015-10-28 13:36:00 -070057 if (strbuf_getline(buffer, helper) == EOF) {
Ilari Liusvaarabf3c5232009-12-09 17:26:27 +020058 if (debug)
59 fprintf(stderr, "Debug: Remote helper quit.\n");
Felipe Contreras5931b332014-04-12 15:33:29 -050060 return 1;
Ilari Liusvaarabf3c5232009-12-09 17:26:27 +020061 }
62
63 if (debug)
64 fprintf(stderr, "Debug: Remote helper: <- %s\n", buffer->buf);
65 return 0;
66}
67
Ilari Liusvaarafa8c0972009-12-09 17:26:32 +020068static int recvline(struct helper_data *helper, struct strbuf *buffer)
69{
Jeff Kingc0969552013-04-10 17:16:03 -040070 return recvline_fh(helper->out, buffer, helper->name);
Ilari Liusvaarafa8c0972009-12-09 17:26:32 +020071}
72
Ilari Liusvaarabf3c5232009-12-09 17:26:27 +020073static void write_constant(int fd, const char *str)
74{
75 if (debug)
76 fprintf(stderr, "Debug: Remote helper: -> %s", str);
Jeff King06f46f22017-09-13 13:16:03 -040077 if (write_in_full(fd, str, strlen(str)) < 0)
Ilari Liusvaarabf3c5232009-12-09 17:26:27 +020078 die_errno("Full write to remote helper failed");
79}
80
Stephen Boydc2e86ad2011-03-22 00:51:05 -070081static const char *remove_ext_force(const char *url)
Ilari Liusvaara25d5cc42009-12-09 17:26:29 +020082{
83 if (url) {
84 const char *colon = strchr(url, ':');
85 if (colon && colon[1] == ':')
86 return colon + 2;
87 }
88 return url;
89}
90
Ilari Liusvaarafa8c0972009-12-09 17:26:32 +020091static void do_take_over(struct transport *transport)
92{
93 struct helper_data *data;
94 data = (struct helper_data *)transport->data;
95 transport_take_over(transport, data->helper);
96 fclose(data->out);
97 free(data);
98}
99
Mike Hommey2879bc32015-02-13 14:24:45 +0900100static void standard_options(struct transport *t);
101
Daniel Barkalow6eb996b2009-08-05 01:01:53 -0400102static struct child_process *get_helper(struct transport *transport)
103{
104 struct helper_data *data = transport->data;
105 struct strbuf buf = STRBUF_INIT;
106 struct child_process *helper;
Daniel Barkalow72ff8942009-11-18 02:42:28 +0100107 const char **refspecs = NULL;
108 int refspec_nr = 0;
109 int refspec_alloc = 0;
Ilari Liusvaara61b075b2009-12-09 17:26:31 +0200110 int duped;
Ilari Liusvaara6b02de32010-01-12 20:53:29 +0100111 int code;
Daniel Barkalow6eb996b2009-08-05 01:01:53 -0400112
113 if (data->helper)
114 return data->helper;
115
René Scharfe483bbd42014-08-19 21:10:48 +0200116 helper = xmalloc(sizeof(*helper));
117 child_process_init(helper);
Daniel Barkalow6eb996b2009-08-05 01:01:53 -0400118 helper->in = -1;
119 helper->out = -1;
120 helper->err = 0;
Jeff Kinge0ab2ac2014-05-15 04:34:18 -0400121 argv_array_pushf(&helper->args, "git-remote-%s", data->name);
122 argv_array_push(&helper->args, transport->remote->name);
123 argv_array_push(&helper->args, remove_ext_force(transport->url));
Ilari Liusvaara6b02de32010-01-12 20:53:29 +0100124 helper->git_cmd = 0;
125 helper->silent_exec_failure = 1;
Dmitry Ivankove1735872011-07-16 15:03:28 +0200126
Jonathan Nieder4b0c3c72017-02-14 15:36:19 -0500127 if (have_git_dir())
128 argv_array_pushf(&helper->env_array, "%s=%s",
129 GIT_DIR_ENVIRONMENT, get_git_dir());
Dmitry Ivankove1735872011-07-16 15:03:28 +0200130
Ilari Liusvaara6b02de32010-01-12 20:53:29 +0100131 code = start_command(helper);
132 if (code < 0 && errno == ENOENT)
133 die("Unable to find remote helper for '%s'", data->name);
134 else if (code != 0)
135 exit(code);
136
Daniel Barkalow6eb996b2009-08-05 01:01:53 -0400137 data->helper = helper;
Ilari Liusvaarafa8c0972009-12-09 17:26:32 +0200138 data->no_disconnect_req = 0;
Daniel Barkalow6eb996b2009-08-05 01:01:53 -0400139
Ilari Liusvaara61b075b2009-12-09 17:26:31 +0200140 /*
Junio C Hamano1a0c8df2016-01-13 18:32:23 -0800141 * Open the output as FILE* so strbuf_getline_*() family of
142 * functions can be used.
Ilari Liusvaara61b075b2009-12-09 17:26:31 +0200143 * Do this with duped fd because fclose() will close the fd,
144 * and stuff like taking over will require the fd to remain.
Ilari Liusvaara61b075b2009-12-09 17:26:31 +0200145 */
146 duped = dup(helper->out);
147 if (duped < 0)
148 die_errno("Can't dup helper output fd");
149 data->out = xfdopen(duped, "r");
150
Ilari Liusvaarabf3c5232009-12-09 17:26:27 +0200151 write_constant(helper->in, "capabilities\n");
Daniel Barkalow2d14d652009-09-03 22:13:51 -0400152
Daniel Barkalow6eb996b2009-08-05 01:01:53 -0400153 while (1) {
Jeff King21a2d4a2014-06-18 15:47:17 -0400154 const char *capname, *arg;
Ilari Liusvaara28ed5b32009-12-09 17:26:28 +0200155 int mandatory = 0;
Felipe Contreras5931b332014-04-12 15:33:29 -0500156 if (recvline(data, &buf))
157 exit(128);
Daniel Barkalow6eb996b2009-08-05 01:01:53 -0400158
159 if (!*buf.buf)
160 break;
Ilari Liusvaara28ed5b32009-12-09 17:26:28 +0200161
162 if (*buf.buf == '*') {
163 capname = buf.buf + 1;
164 mandatory = 1;
165 } else
166 capname = buf.buf;
167
Ilari Liusvaarabf3c5232009-12-09 17:26:27 +0200168 if (debug)
Ilari Liusvaara28ed5b32009-12-09 17:26:28 +0200169 fprintf(stderr, "Debug: Got cap %s\n", capname);
170 if (!strcmp(capname, "fetch"))
Daniel Barkalow6eb996b2009-08-05 01:01:53 -0400171 data->fetch = 1;
Ilari Liusvaara28ed5b32009-12-09 17:26:28 +0200172 else if (!strcmp(capname, "option"))
Shawn O. Pearceef08ef92009-10-30 17:47:29 -0700173 data->option = 1;
Ilari Liusvaara28ed5b32009-12-09 17:26:28 +0200174 else if (!strcmp(capname, "push"))
Shawn O. Pearceae4efe12009-10-30 17:47:30 -0700175 data->push = 1;
Ilari Liusvaara28ed5b32009-12-09 17:26:28 +0200176 else if (!strcmp(capname, "import"))
Daniel Barkalowe65e91e2009-11-18 02:42:27 +0100177 data->import = 1;
Florian Achleitnerbfc366d2012-09-19 17:21:19 +0200178 else if (!strcmp(capname, "bidi-import"))
179 data->bidi_import = 1;
Sverre Rabbelier73b49a72010-03-29 11:48:27 -0500180 else if (!strcmp(capname, "export"))
181 data->export = 1;
Nguyễn Thái Ngọc Duy9ba38042013-07-21 15:18:05 +0700182 else if (!strcmp(capname, "check-connectivity"))
183 data->check_connectivity = 1;
Jeff King21a2d4a2014-06-18 15:47:17 -0400184 else if (!data->refspecs && skip_prefix(capname, "refspec ", &arg)) {
Daniel Barkalow72ff8942009-11-18 02:42:28 +0100185 ALLOC_GROW(refspecs,
186 refspec_nr + 1,
187 refspec_alloc);
Jeff King21a2d4a2014-06-18 15:47:17 -0400188 refspecs[refspec_nr++] = xstrdup(arg);
Ilari Liusvaarafa8c0972009-12-09 17:26:32 +0200189 } else if (!strcmp(capname, "connect")) {
190 data->connect = 1;
John Keeping0d957a42013-04-14 11:57:08 +0100191 } else if (!strcmp(capname, "signed-tags")) {
192 data->signed_tags = 1;
Jeff King21a2d4a2014-06-18 15:47:17 -0400193 } else if (skip_prefix(capname, "export-marks ", &arg)) {
194 data->export_marks = xstrdup(arg);
195 } else if (skip_prefix(capname, "import-marks ", &arg)) {
196 data->import_marks = xstrdup(arg);
Christian Couder59556542013-11-30 21:55:40 +0100197 } else if (starts_with(capname, "no-private-update")) {
Matthieu Moy597b8312013-09-03 17:45:14 +0200198 data->no_private_update = 1;
Ilari Liusvaara28ed5b32009-12-09 17:26:28 +0200199 } else if (mandatory) {
Junio C Hamano9517e6b2010-02-03 21:23:18 -0800200 die("Unknown mandatory capability %s. This remote "
Pete Wyckoff82247e92012-04-29 20:28:45 -0400201 "helper probably needs newer version of Git.",
Ilari Liusvaara28ed5b32009-12-09 17:26:28 +0200202 capname);
Daniel Barkalow72ff8942009-11-18 02:42:28 +0100203 }
204 }
205 if (refspecs) {
206 int i;
207 data->refspec_nr = refspec_nr;
208 data->refspecs = parse_fetch_refspec(refspec_nr, refspecs);
Felipe Contrerasb120ef32013-05-08 20:16:56 -0500209 for (i = 0; i < refspec_nr; i++)
Daniel Barkalow72ff8942009-11-18 02:42:28 +0100210 free((char *)refspecs[i]);
Daniel Barkalow72ff8942009-11-18 02:42:28 +0100211 free(refspecs);
Felipe Contrerasa93b4a02013-04-17 23:14:31 -0500212 } else if (data->import || data->bidi_import || data->export) {
213 warning("This remote helper should implement refspec capability.");
Daniel Barkalow6eb996b2009-08-05 01:01:53 -0400214 }
Sverre Rabbelierb962dbd2009-11-18 02:42:29 +0100215 strbuf_release(&buf);
Ilari Liusvaarabf3c5232009-12-09 17:26:27 +0200216 if (debug)
217 fprintf(stderr, "Debug: Capabilities complete.\n");
Mike Hommey2879bc32015-02-13 14:24:45 +0900218 standard_options(transport);
Daniel Barkalow6eb996b2009-08-05 01:01:53 -0400219 return data->helper;
220}
221
222static int disconnect_helper(struct transport *transport)
223{
224 struct helper_data *data = transport->data;
Sverre Rabbeliercc567322011-07-16 15:03:35 +0200225 int res = 0;
Ilari Liusvaarabf3c5232009-12-09 17:26:27 +0200226
Daniel Barkalow6eb996b2009-08-05 01:01:53 -0400227 if (data->helper) {
Ilari Liusvaarabf3c5232009-12-09 17:26:27 +0200228 if (debug)
229 fprintf(stderr, "Debug: Disconnecting.\n");
Ilari Liusvaarafa8c0972009-12-09 17:26:32 +0200230 if (!data->no_disconnect_req) {
Jeff Kingc34fe632012-02-23 05:04:34 -0500231 /*
232 * Ignore write errors; there's nothing we can do,
233 * since we're about to close the pipe anyway. And the
234 * most likely error is EPIPE due to the helper dying
235 * to report an error itself.
236 */
237 sigchain_push(SIGPIPE, SIG_IGN);
238 xwrite(data->helper->in, "\n", 1);
239 sigchain_pop(SIGPIPE);
Ilari Liusvaarafa8c0972009-12-09 17:26:32 +0200240 }
Daniel Barkalow6eb996b2009-08-05 01:01:53 -0400241 close(data->helper->in);
Ilari Liusvaara61b075b2009-12-09 17:26:31 +0200242 close(data->helper->out);
Shawn O. Pearce292ce462009-10-30 17:47:28 -0700243 fclose(data->out);
Sverre Rabbeliercc567322011-07-16 15:03:35 +0200244 res = finish_command(data->helper);
Ævar Arnfjörð Bjarmason6a83d902017-06-15 23:15:46 +0000245 FREE_AND_NULL(data->helper);
Daniel Barkalow6eb996b2009-08-05 01:01:53 -0400246 }
Sverre Rabbeliercc567322011-07-16 15:03:35 +0200247 return res;
Daniel Barkalow6eb996b2009-08-05 01:01:53 -0400248}
249
Shawn O. Pearceef08ef92009-10-30 17:47:29 -0700250static const char *unsupported_options[] = {
251 TRANS_OPT_UPLOADPACK,
252 TRANS_OPT_RECEIVEPACK,
253 TRANS_OPT_THIN,
254 TRANS_OPT_KEEP
255 };
Felipe Contreras23cd01e2013-10-31 03:25:40 -0600256
Shawn O. Pearceef08ef92009-10-30 17:47:29 -0700257static const char *boolean_options[] = {
258 TRANS_OPT_THIN,
259 TRANS_OPT_KEEP,
Junio C Hamano0ea47f92014-09-15 14:59:00 -0700260 TRANS_OPT_FOLLOWTAGS,
Nguyễn Thái Ngọc Duycccf74e2016-06-12 17:54:09 +0700261 TRANS_OPT_DEEPEN_RELATIVE
Shawn O. Pearceef08ef92009-10-30 17:47:29 -0700262 };
263
Nguyễn Thái Ngọc Duy9318c5d2016-06-12 17:53:44 +0700264static int strbuf_set_helper_option(struct helper_data *data,
265 struct strbuf *buf)
266{
267 int ret;
268
269 sendline(data, buf);
270 if (recvline(data, buf))
271 exit(128);
272
273 if (!strcmp(buf->buf, "ok"))
274 ret = 0;
275 else if (starts_with(buf->buf, "error"))
276 ret = -1;
277 else if (!strcmp(buf->buf, "unsupported"))
278 ret = 1;
279 else {
280 warning("%s unexpectedly said: '%s'", data->name, buf->buf);
281 ret = 1;
282 }
283 return ret;
284}
285
Nguyễn Thái Ngọc Duya45a2602016-06-12 17:54:04 +0700286static int string_list_set_helper_option(struct helper_data *data,
287 const char *name,
288 struct string_list *list)
289{
290 struct strbuf buf = STRBUF_INIT;
291 int i, ret = 0;
292
293 for (i = 0; i < list->nr; i++) {
294 strbuf_addf(&buf, "option %s ", name);
295 quote_c_style(list->items[i].string, &buf, NULL, 0);
296 strbuf_addch(&buf, '\n');
297
298 if ((ret = strbuf_set_helper_option(data, &buf)))
299 break;
300 strbuf_reset(&buf);
301 }
302 strbuf_release(&buf);
303 return ret;
304}
305
Shawn O. Pearceef08ef92009-10-30 17:47:29 -0700306static int set_helper_option(struct transport *transport,
307 const char *name, const char *value)
308{
309 struct helper_data *data = transport->data;
Shawn O. Pearceef08ef92009-10-30 17:47:29 -0700310 struct strbuf buf = STRBUF_INIT;
311 int i, ret, is_bool = 0;
312
Ilari Liusvaarabf3c5232009-12-09 17:26:27 +0200313 get_helper(transport);
314
Shawn O. Pearceef08ef92009-10-30 17:47:29 -0700315 if (!data->option)
316 return 1;
317
Nguyễn Thái Ngọc Duya45a2602016-06-12 17:54:04 +0700318 if (!strcmp(name, "deepen-not"))
319 return string_list_set_helper_option(data, name,
320 (struct string_list *)value);
321
Shawn O. Pearceef08ef92009-10-30 17:47:29 -0700322 for (i = 0; i < ARRAY_SIZE(unsupported_options); i++) {
323 if (!strcmp(name, unsupported_options[i]))
324 return 1;
325 }
326
327 for (i = 0; i < ARRAY_SIZE(boolean_options); i++) {
328 if (!strcmp(name, boolean_options[i])) {
329 is_bool = 1;
330 break;
331 }
332 }
333
334 strbuf_addf(&buf, "option %s ", name);
335 if (is_bool)
336 strbuf_addstr(&buf, value ? "true" : "false");
337 else
338 quote_c_style(value, &buf, NULL, 0);
339 strbuf_addch(&buf, '\n');
340
Nguyễn Thái Ngọc Duy9318c5d2016-06-12 17:53:44 +0700341 ret = strbuf_set_helper_option(data, &buf);
Shawn O. Pearceef08ef92009-10-30 17:47:29 -0700342 strbuf_release(&buf);
343 return ret;
344}
345
346static void standard_options(struct transport *t)
347{
348 char buf[16];
Shawn O. Pearceef08ef92009-10-30 17:47:29 -0700349 int v = t->verbose;
Shawn O. Pearceef08ef92009-10-30 17:47:29 -0700350
Tay Ray Chuand01b3c02010-02-24 20:50:26 +0800351 set_helper_option(t, "progress", t->progress ? "true" : "false");
Shawn O. Pearceef08ef92009-10-30 17:47:29 -0700352
Jeff King8c5acfb2017-03-28 15:47:00 -0400353 xsnprintf(buf, sizeof(buf), "%d", v + 1);
Shawn O. Pearceef08ef92009-10-30 17:47:29 -0700354 set_helper_option(t, "verbosity", buf);
Eric Wongc915f112016-02-03 04:09:14 +0000355
356 switch (t->family) {
357 case TRANSPORT_FAMILY_ALL:
358 /*
359 * this is already the default,
360 * do not break old remote helpers by setting "all" here
361 */
362 break;
363 case TRANSPORT_FAMILY_IPV4:
364 set_helper_option(t, "family", "ipv4");
365 break;
366 case TRANSPORT_FAMILY_IPV6:
367 set_helper_option(t, "family", "ipv6");
368 break;
369 }
Shawn O. Pearceef08ef92009-10-30 17:47:29 -0700370}
371
Daniel Barkalowf2a37152009-11-18 02:42:21 +0100372static int release_helper(struct transport *transport)
373{
Sverre Rabbeliercc567322011-07-16 15:03:35 +0200374 int res = 0;
Daniel Barkalow72ff8942009-11-18 02:42:28 +0100375 struct helper_data *data = transport->data;
376 free_refspec(data->refspec_nr, data->refspecs);
377 data->refspecs = NULL;
Sverre Rabbeliercc567322011-07-16 15:03:35 +0200378 res = disconnect_helper(transport);
Daniel Barkalowf2a37152009-11-18 02:42:21 +0100379 free(transport->data);
Sverre Rabbeliercc567322011-07-16 15:03:35 +0200380 return res;
Daniel Barkalowf2a37152009-11-18 02:42:21 +0100381}
382
Daniel Barkalow6eb996b2009-08-05 01:01:53 -0400383static int fetch_with_fetch(struct transport *transport,
Daniel Barkalow37148312009-11-18 02:42:24 +0100384 int nr_heads, struct ref **to_fetch)
Daniel Barkalow6eb996b2009-08-05 01:01:53 -0400385{
Shawn O. Pearce292ce462009-10-30 17:47:28 -0700386 struct helper_data *data = transport->data;
Daniel Barkalow6eb996b2009-08-05 01:01:53 -0400387 int i;
388 struct strbuf buf = STRBUF_INIT;
389
390 for (i = 0; i < nr_heads; i++) {
Linus Torvalds10882612009-08-05 01:01:59 -0400391 const struct ref *posn = to_fetch[i];
Daniel Barkalow6eb996b2009-08-05 01:01:53 -0400392 if (posn->status & REF_STATUS_UPTODATE)
393 continue;
Daniel Barkalow2d14d652009-09-03 22:13:51 -0400394
395 strbuf_addf(&buf, "fetch %s %s\n",
brian m. carlsonf4e54d02015-11-10 02:22:20 +0000396 oid_to_hex(&posn->old_oid),
Mike Hommey33cae542015-01-19 10:35:07 +0900397 posn->symref ? posn->symref : posn->name);
Daniel Barkalow6eb996b2009-08-05 01:01:53 -0400398 }
Shawn O. Pearce292ce462009-10-30 17:47:28 -0700399
400 strbuf_addch(&buf, '\n');
Ilari Liusvaarabf3c5232009-12-09 17:26:27 +0200401 sendline(data, &buf);
Shawn O. Pearce292ce462009-10-30 17:47:28 -0700402
403 while (1) {
Felipe Contreras5931b332014-04-12 15:33:29 -0500404 if (recvline(data, &buf))
405 exit(128);
Shawn O. Pearce292ce462009-10-30 17:47:28 -0700406
Christian Couder59556542013-11-30 21:55:40 +0100407 if (starts_with(buf.buf, "lock ")) {
Shawn O. Pearce292ce462009-10-30 17:47:28 -0700408 const char *name = buf.buf + 5;
409 if (transport->pack_lockfile)
410 warning("%s also locked %s", data->name, name);
411 else
412 transport->pack_lockfile = xstrdup(name);
413 }
Nguyễn Thái Ngọc Duy9ba38042013-07-21 15:18:05 +0700414 else if (data->check_connectivity &&
415 data->transport_options.check_self_contained_and_connected &&
416 !strcmp(buf.buf, "connectivity-ok"))
417 data->transport_options.self_contained_and_connected = 1;
Shawn O. Pearce292ce462009-10-30 17:47:28 -0700418 else if (!buf.len)
419 break;
420 else
421 warning("%s unexpectedly said: '%s'", data->name, buf.buf);
422 }
423 strbuf_release(&buf);
Daniel Barkalow6eb996b2009-08-05 01:01:53 -0400424 return 0;
425}
426
Daniel Barkalowe65e91e2009-11-18 02:42:27 +0100427static int get_importer(struct transport *transport, struct child_process *fastimport)
428{
429 struct child_process *helper = get_helper(transport);
Florian Achleitnerbfc366d2012-09-19 17:21:19 +0200430 struct helper_data *data = transport->data;
Florian Achleitnerbfc366d2012-09-19 17:21:19 +0200431 int cat_blob_fd, code;
René Scharfe483bbd42014-08-19 21:10:48 +0200432 child_process_init(fastimport);
Daniel Barkalowe65e91e2009-11-18 02:42:27 +0100433 fastimport->in = helper->out;
Jeff King173fd1a2014-05-15 04:35:06 -0400434 argv_array_push(&fastimport->args, "fast-import");
435 argv_array_push(&fastimport->args, debug ? "--stats" : "--quiet");
Daniel Barkalowe65e91e2009-11-18 02:42:27 +0100436
Florian Achleitnerbfc366d2012-09-19 17:21:19 +0200437 if (data->bidi_import) {
438 cat_blob_fd = xdup(helper->in);
Jeff King173fd1a2014-05-15 04:35:06 -0400439 argv_array_pushf(&fastimport->args, "--cat-blob-fd=%d", cat_blob_fd);
Florian Achleitnerbfc366d2012-09-19 17:21:19 +0200440 }
Daniel Barkalowe65e91e2009-11-18 02:42:27 +0100441 fastimport->git_cmd = 1;
Florian Achleitnerbfc366d2012-09-19 17:21:19 +0200442
443 code = start_command(fastimport);
444 return code;
Daniel Barkalowe65e91e2009-11-18 02:42:27 +0100445}
446
Sverre Rabbelier73b49a72010-03-29 11:48:27 -0500447static int get_exporter(struct transport *transport,
448 struct child_process *fastexport,
Sverre Rabbelier73b49a72010-03-29 11:48:27 -0500449 struct string_list *revlist_args)
450{
Sverre Rabbeliera515ebe2011-07-16 15:03:40 +0200451 struct helper_data *data = transport->data;
Sverre Rabbelier73b49a72010-03-29 11:48:27 -0500452 struct child_process *helper = get_helper(transport);
Jeff King2aeae402014-05-15 04:34:44 -0400453 int i;
Felipe Contreras852e54b2014-04-12 15:33:31 -0500454
René Scharfe8828f292014-10-28 21:52:34 +0100455 child_process_init(fastexport);
Sverre Rabbelier73b49a72010-03-29 11:48:27 -0500456
457 /* we need to duplicate helper->in because we want to use it after
458 * fastexport is done with it. */
459 fastexport->out = dup(helper->in);
Jeff King2aeae402014-05-15 04:34:44 -0400460 argv_array_push(&fastexport->args, "fast-export");
461 argv_array_push(&fastexport->args, "--use-done-feature");
462 argv_array_push(&fastexport->args, data->signed_tags ?
463 "--signed-tags=verbatim" : "--signed-tags=warn-strip");
464 if (data->export_marks)
465 argv_array_pushf(&fastexport->args, "--export-marks=%s.tmp", data->export_marks);
466 if (data->import_marks)
467 argv_array_pushf(&fastexport->args, "--import-marks=%s", data->import_marks);
Sverre Rabbelier73b49a72010-03-29 11:48:27 -0500468
469 for (i = 0; i < revlist_args->nr; i++)
Jeff King2aeae402014-05-15 04:34:44 -0400470 argv_array_push(&fastexport->args, revlist_args->items[i].string);
Sverre Rabbelier73b49a72010-03-29 11:48:27 -0500471
472 fastexport->git_cmd = 1;
473 return start_command(fastexport);
474}
475
Daniel Barkalowe65e91e2009-11-18 02:42:27 +0100476static int fetch_with_import(struct transport *transport,
477 int nr_heads, struct ref **to_fetch)
478{
479 struct child_process fastimport;
Daniel Barkalow72ff8942009-11-18 02:42:28 +0100480 struct helper_data *data = transport->data;
Daniel Barkalowe65e91e2009-11-18 02:42:27 +0100481 int i;
482 struct ref *posn;
483 struct strbuf buf = STRBUF_INIT;
484
Ilari Liusvaarabf3c5232009-12-09 17:26:27 +0200485 get_helper(transport);
486
Daniel Barkalowe65e91e2009-11-18 02:42:27 +0100487 if (get_importer(transport, &fastimport))
488 die("Couldn't run fast-import");
489
490 for (i = 0; i < nr_heads; i++) {
491 posn = to_fetch[i];
492 if (posn->status & REF_STATUS_UPTODATE)
493 continue;
494
Mike Hommey33cae542015-01-19 10:35:07 +0900495 strbuf_addf(&buf, "import %s\n",
496 posn->symref ? posn->symref : posn->name);
Ilari Liusvaarabf3c5232009-12-09 17:26:27 +0200497 sendline(data, &buf);
Daniel Barkalowe65e91e2009-11-18 02:42:27 +0100498 strbuf_reset(&buf);
499 }
Sverre Rabbelier9504bc92011-07-16 15:03:38 +0200500
501 write_constant(data->helper->in, "\n");
Florian Achleitnerbfc366d2012-09-19 17:21:19 +0200502 /*
503 * remote-helpers that advertise the bidi-import capability are required to
504 * buffer the complete batch of import commands until this newline before
505 * sending data to fast-import.
506 * These helpers read back data from fast-import on their stdin, which could
507 * be mixed with import commands, otherwise.
508 */
Sverre Rabbelier9504bc92011-07-16 15:03:38 +0200509
Sverre Rabbeliercc567322011-07-16 15:03:35 +0200510 if (finish_command(&fastimport))
511 die("Error while running fast-import");
Daniel Barkalowe65e91e2009-11-18 02:42:27 +0100512
Florian Achleitnerdff9d652012-07-30 16:31:18 +0200513 /*
514 * The fast-import stream of a remote helper that advertises
515 * the "refspec" capability writes to the refs named after the
516 * right hand side of the first refspec matching each ref we
517 * were fetching.
518 *
519 * (If no "refspec" capability was specified, for historical
Felipe Contreras7a43c552013-04-17 23:14:28 -0500520 * reasons we default to the equivalent of *:*.)
Florian Achleitnerdff9d652012-07-30 16:31:18 +0200521 *
522 * Store the result in to_fetch[i].old_sha1. Callers such
523 * as "git fetch" can use the value to write feedback to the
524 * terminal, populate FETCH_HEAD, and determine what new value
525 * should be written to peer_ref if the update is a
526 * fast-forward or this is a forced update.
527 */
Daniel Barkalowe65e91e2009-11-18 02:42:27 +0100528 for (i = 0; i < nr_heads; i++) {
Mike Hommey33cae542015-01-19 10:35:07 +0900529 char *private, *name;
Daniel Barkalowe65e91e2009-11-18 02:42:27 +0100530 posn = to_fetch[i];
531 if (posn->status & REF_STATUS_UPTODATE)
532 continue;
Mike Hommey33cae542015-01-19 10:35:07 +0900533 name = posn->symref ? posn->symref : posn->name;
Daniel Barkalow72ff8942009-11-18 02:42:28 +0100534 if (data->refspecs)
Mike Hommey33cae542015-01-19 10:35:07 +0900535 private = apply_refspecs(data->refspecs, data->refspec_nr, name);
Daniel Barkalow72ff8942009-11-18 02:42:28 +0100536 else
Mike Hommey33cae542015-01-19 10:35:07 +0900537 private = xstrdup(name);
Michael Haggertyd51b7202011-09-15 23:10:38 +0200538 if (private) {
brian m. carlson34c290a2017-10-15 22:06:56 +0000539 if (read_ref(private, &posn->old_oid) < 0)
Stefan Bellerae25fd32015-07-31 16:57:57 -0700540 die("Could not read ref %s", private);
Michael Haggertyd51b7202011-09-15 23:10:38 +0200541 free(private);
542 }
Daniel Barkalowe65e91e2009-11-18 02:42:27 +0100543 }
Sverre Rabbelierb962dbd2009-11-18 02:42:29 +0100544 strbuf_release(&buf);
Daniel Barkalowe65e91e2009-11-18 02:42:27 +0100545 return 0;
546}
547
Ilari Liusvaarafa8c0972009-12-09 17:26:32 +0200548static int process_connect_service(struct transport *transport,
549 const char *name, const char *exec)
550{
551 struct helper_data *data = transport->data;
552 struct strbuf cmdbuf = STRBUF_INIT;
553 struct child_process *helper;
554 int r, duped, ret = 0;
555 FILE *input;
556
557 helper = get_helper(transport);
558
559 /*
560 * Yes, dup the pipe another time, as we need unbuffered version
561 * of input pipe as FILE*. fclose() closes the underlying fd and
562 * stream buffering only can be changed before first I/O operation
563 * on it.
564 */
565 duped = dup(helper->out);
566 if (duped < 0)
567 die_errno("Can't dup helper output fd");
568 input = xfdopen(duped, "r");
569 setvbuf(input, NULL, _IONBF, 0);
570
571 /*
572 * Handle --upload-pack and friends. This is fire and forget...
573 * just warn if it fails.
574 */
575 if (strcmp(name, exec)) {
576 r = set_helper_option(transport, "servpath", exec);
577 if (r > 0)
578 warning("Setting remote service path not supported by protocol.");
579 else if (r < 0)
580 warning("Invalid remote service path.");
581 }
582
583 if (data->connect)
584 strbuf_addf(&cmdbuf, "connect %s\n", name);
585 else
586 goto exit;
587
588 sendline(data, &cmdbuf);
Felipe Contreras5931b332014-04-12 15:33:29 -0500589 if (recvline_fh(input, &cmdbuf, name))
590 exit(128);
591
Ilari Liusvaarafa8c0972009-12-09 17:26:32 +0200592 if (!strcmp(cmdbuf.buf, "")) {
593 data->no_disconnect_req = 1;
594 if (debug)
595 fprintf(stderr, "Debug: Smart transport connection "
596 "ready.\n");
597 ret = 1;
598 } else if (!strcmp(cmdbuf.buf, "fallback")) {
599 if (debug)
600 fprintf(stderr, "Debug: Falling back to dumb "
601 "transport.\n");
602 } else
603 die("Unknown response to connect: %s",
604 cmdbuf.buf);
605
606exit:
Rene Scharfe4168be82017-08-30 20:20:15 +0200607 strbuf_release(&cmdbuf);
Ilari Liusvaarafa8c0972009-12-09 17:26:32 +0200608 fclose(input);
609 return ret;
610}
611
612static int process_connect(struct transport *transport,
613 int for_push)
614{
615 struct helper_data *data = transport->data;
616 const char *name;
617 const char *exec;
618
619 name = for_push ? "git-receive-pack" : "git-upload-pack";
620 if (for_push)
621 exec = data->transport_options.receivepack;
622 else
623 exec = data->transport_options.uploadpack;
624
625 return process_connect_service(transport, name, exec);
626}
627
Ilari Liusvaarab2367522009-12-09 17:26:33 +0200628static int connect_helper(struct transport *transport, const char *name,
629 const char *exec, int fd[2])
630{
631 struct helper_data *data = transport->data;
632
633 /* Get_helper so connect is inited. */
634 get_helper(transport);
635 if (!data->connect)
636 die("Operation not supported by protocol.");
637
638 if (!process_connect_service(transport, name, exec))
639 die("Can't connect to subservice %s.", name);
640
641 fd[0] = data->helper->out;
642 fd[1] = data->helper->in;
643 return 0;
644}
645
Daniel Barkalow6eb996b2009-08-05 01:01:53 -0400646static int fetch(struct transport *transport,
Daniel Barkalow37148312009-11-18 02:42:24 +0100647 int nr_heads, struct ref **to_fetch)
Daniel Barkalow6eb996b2009-08-05 01:01:53 -0400648{
649 struct helper_data *data = transport->data;
650 int i, count;
651
Ilari Liusvaarafa8c0972009-12-09 17:26:32 +0200652 if (process_connect(transport, 0)) {
653 do_take_over(transport);
Jonathan Tane967ca32017-12-14 13:44:45 -0800654 return transport->vtable->fetch(transport, nr_heads, to_fetch);
Ilari Liusvaarafa8c0972009-12-09 17:26:32 +0200655 }
656
Daniel Barkalow6eb996b2009-08-05 01:01:53 -0400657 count = 0;
658 for (i = 0; i < nr_heads; i++)
659 if (!(to_fetch[i]->status & REF_STATUS_UPTODATE))
660 count++;
661
662 if (!count)
663 return 0;
664
Mike Hommeyaab1beb2015-02-13 14:24:46 +0900665 if (data->check_connectivity &&
666 data->transport_options.check_self_contained_and_connected)
667 set_helper_option(transport, "check-connectivity", "true");
668
669 if (transport->cloning)
670 set_helper_option(transport, "cloning", "true");
671
672 if (data->transport_options.update_shallow)
673 set_helper_option(transport, "update-shallow", "true");
674
Jeff Hostetler640d8b72017-12-08 15:58:40 +0000675 if (data->transport_options.filter_options.choice)
676 set_helper_option(
677 transport, "filter",
678 data->transport_options.filter_options.filter_spec);
679
Daniel Barkalow6eb996b2009-08-05 01:01:53 -0400680 if (data->fetch)
681 return fetch_with_fetch(transport, nr_heads, to_fetch);
682
Daniel Barkalowe65e91e2009-11-18 02:42:27 +0100683 if (data->import)
684 return fetch_with_import(transport, nr_heads, to_fetch);
685
Daniel Barkalow6eb996b2009-08-05 01:01:53 -0400686 return -1;
687}
688
Felipe Contreras664059f2013-04-17 23:14:33 -0500689static int push_update_ref_status(struct strbuf *buf,
Sverre Rabbelierd2e73c62011-07-16 15:03:34 +0200690 struct ref **ref,
691 struct ref *remote_refs)
692{
693 char *refname, *msg;
Felipe Contrerasf9e3c6b2013-11-12 14:56:57 -0600694 int status, forced = 0;
Sverre Rabbelierd2e73c62011-07-16 15:03:34 +0200695
Christian Couder59556542013-11-30 21:55:40 +0100696 if (starts_with(buf->buf, "ok ")) {
Sverre Rabbelierd2e73c62011-07-16 15:03:34 +0200697 status = REF_STATUS_OK;
698 refname = buf->buf + 3;
Christian Couder59556542013-11-30 21:55:40 +0100699 } else if (starts_with(buf->buf, "error ")) {
Sverre Rabbelierd2e73c62011-07-16 15:03:34 +0200700 status = REF_STATUS_REMOTE_REJECT;
701 refname = buf->buf + 6;
702 } else
Pete Wyckoff82247e92012-04-29 20:28:45 -0400703 die("expected ok/error, helper said '%s'", buf->buf);
Sverre Rabbelierd2e73c62011-07-16 15:03:34 +0200704
705 msg = strchr(refname, ' ');
706 if (msg) {
707 struct strbuf msg_buf = STRBUF_INIT;
708 const char *end;
709
710 *msg++ = '\0';
711 if (!unquote_c_style(&msg_buf, msg, &end))
712 msg = strbuf_detach(&msg_buf, NULL);
713 else
714 msg = xstrdup(msg);
715 strbuf_release(&msg_buf);
716
717 if (!strcmp(msg, "no match")) {
718 status = REF_STATUS_NONE;
Ævar Arnfjörð Bjarmason6a83d902017-06-15 23:15:46 +0000719 FREE_AND_NULL(msg);
Sverre Rabbelierd2e73c62011-07-16 15:03:34 +0200720 }
721 else if (!strcmp(msg, "up to date")) {
722 status = REF_STATUS_UPTODATE;
Ævar Arnfjörð Bjarmason6a83d902017-06-15 23:15:46 +0000723 FREE_AND_NULL(msg);
Sverre Rabbelierd2e73c62011-07-16 15:03:34 +0200724 }
725 else if (!strcmp(msg, "non-fast forward")) {
726 status = REF_STATUS_REJECT_NONFASTFORWARD;
Ævar Arnfjörð Bjarmason6a83d902017-06-15 23:15:46 +0000727 FREE_AND_NULL(msg);
Sverre Rabbelierd2e73c62011-07-16 15:03:34 +0200728 }
Chris Rorvickdbfeddb2012-11-29 19:41:37 -0600729 else if (!strcmp(msg, "already exists")) {
730 status = REF_STATUS_REJECT_ALREADY_EXISTS;
Ævar Arnfjörð Bjarmason6a83d902017-06-15 23:15:46 +0000731 FREE_AND_NULL(msg);
Chris Rorvickdbfeddb2012-11-29 19:41:37 -0600732 }
Junio C Hamano75e5c0d2013-01-23 13:55:30 -0800733 else if (!strcmp(msg, "fetch first")) {
734 status = REF_STATUS_REJECT_FETCH_FIRST;
Ævar Arnfjörð Bjarmason6a83d902017-06-15 23:15:46 +0000735 FREE_AND_NULL(msg);
Junio C Hamano75e5c0d2013-01-23 13:55:30 -0800736 }
737 else if (!strcmp(msg, "needs force")) {
738 status = REF_STATUS_REJECT_NEEDS_FORCE;
Ævar Arnfjörð Bjarmason6a83d902017-06-15 23:15:46 +0000739 FREE_AND_NULL(msg);
Junio C Hamano75e5c0d2013-01-23 13:55:30 -0800740 }
Junio C Hamano631b5ef2013-07-08 14:42:40 -0700741 else if (!strcmp(msg, "stale info")) {
742 status = REF_STATUS_REJECT_STALE;
Ævar Arnfjörð Bjarmason6a83d902017-06-15 23:15:46 +0000743 FREE_AND_NULL(msg);
Junio C Hamano631b5ef2013-07-08 14:42:40 -0700744 }
Felipe Contrerasf9e3c6b2013-11-12 14:56:57 -0600745 else if (!strcmp(msg, "forced update")) {
746 forced = 1;
Ævar Arnfjörð Bjarmason6a83d902017-06-15 23:15:46 +0000747 FREE_AND_NULL(msg);
Felipe Contrerasf9e3c6b2013-11-12 14:56:57 -0600748 }
Sverre Rabbelierd2e73c62011-07-16 15:03:34 +0200749 }
750
751 if (*ref)
752 *ref = find_ref_by_name(*ref, refname);
753 if (!*ref)
754 *ref = find_ref_by_name(remote_refs, refname);
755 if (!*ref) {
756 warning("helper reported unexpected status of %s", refname);
Felipe Contreras664059f2013-04-17 23:14:33 -0500757 return 1;
Sverre Rabbelierd2e73c62011-07-16 15:03:34 +0200758 }
759
760 if ((*ref)->status != REF_STATUS_NONE) {
761 /*
762 * Earlier, the ref was marked not to be pushed, so ignore the ref
763 * status reported by the remote helper if the latter is 'no match'.
764 */
765 if (status == REF_STATUS_NONE)
Felipe Contreras664059f2013-04-17 23:14:33 -0500766 return 1;
Sverre Rabbelierd2e73c62011-07-16 15:03:34 +0200767 }
768
769 (*ref)->status = status;
Max Horncf31f702014-02-21 10:55:59 +0100770 (*ref)->forced_update |= forced;
Sverre Rabbelierd2e73c62011-07-16 15:03:34 +0200771 (*ref)->remote_status = msg;
Felipe Contreras126aac52013-05-10 07:08:30 -0500772 return !(status == REF_STATUS_OK);
Sverre Rabbelierd2e73c62011-07-16 15:03:34 +0200773}
774
Felipe Contreras0551a062014-04-12 15:33:30 -0500775static int push_update_refs_status(struct helper_data *data,
Felipe Contreras5a753532013-10-31 03:36:37 -0600776 struct ref *remote_refs,
777 int flags)
Sverre Rabbelierd2e73c62011-07-16 15:03:34 +0200778{
779 struct strbuf buf = STRBUF_INIT;
780 struct ref *ref = remote_refs;
Felipe Contreras0551a062014-04-12 15:33:30 -0500781 int ret = 0;
782
Sverre Rabbelierd2e73c62011-07-16 15:03:34 +0200783 for (;;) {
Felipe Contreras664059f2013-04-17 23:14:33 -0500784 char *private;
785
Felipe Contreras0551a062014-04-12 15:33:30 -0500786 if (recvline(data, &buf)) {
787 ret = 1;
788 break;
789 }
790
Sverre Rabbelierd2e73c62011-07-16 15:03:34 +0200791 if (!buf.len)
792 break;
793
Felipe Contreras664059f2013-04-17 23:14:33 -0500794 if (push_update_ref_status(&buf, &ref, remote_refs))
795 continue;
796
Felipe Contreras5a753532013-10-31 03:36:37 -0600797 if (flags & TRANSPORT_PUSH_DRY_RUN || !data->refspecs || data->no_private_update)
Felipe Contreras664059f2013-04-17 23:14:33 -0500798 continue;
799
800 /* propagate back the update to the remote namespace */
801 private = apply_refspecs(data->refspecs, data->refspec_nr, ref->name);
802 if (!private)
803 continue;
brian m. carlsonae077772017-10-15 22:06:51 +0000804 update_ref("update by helper", private, &ref->new_oid, NULL,
805 0, 0);
Felipe Contreras664059f2013-04-17 23:14:33 -0500806 free(private);
Sverre Rabbelierd2e73c62011-07-16 15:03:34 +0200807 }
808 strbuf_release(&buf);
Felipe Contreras0551a062014-04-12 15:33:30 -0500809 return ret;
Sverre Rabbelierd2e73c62011-07-16 15:03:34 +0200810}
811
Dave Borowitz30261092015-08-19 11:26:46 -0400812static void set_common_push_options(struct transport *transport,
813 const char *name, int flags)
814{
815 if (flags & TRANSPORT_PUSH_DRY_RUN) {
816 if (set_helper_option(transport, "dry-run", "true") != 0)
817 die("helper %s does not support dry-run", name);
818 } else if (flags & TRANSPORT_PUSH_CERT_ALWAYS) {
819 if (set_helper_option(transport, TRANS_OPT_PUSH_CERT, "true") != 0)
820 die("helper %s does not support --signed", name);
821 } else if (flags & TRANSPORT_PUSH_CERT_IF_ASKED) {
822 if (set_helper_option(transport, TRANS_OPT_PUSH_CERT, "if-asked") != 0)
823 die("helper %s does not support --signed=if-asked", name);
824 }
Stefan Beller438fc682017-02-08 14:04:00 -0800825
826 if (flags & TRANSPORT_PUSH_OPTIONS) {
827 struct string_list_item *item;
828 for_each_string_list_item(item, transport->push_options)
829 if (set_helper_option(transport, "push-option", item->string) != 0)
830 die("helper %s does not support 'push-option'", name);
831 }
Dave Borowitz30261092015-08-19 11:26:46 -0400832}
833
Sverre Rabbelier73b49a72010-03-29 11:48:27 -0500834static int push_refs_with_push(struct transport *transport,
Junio C Hamano05c1eb12013-08-02 15:14:50 -0700835 struct ref *remote_refs, int flags)
Shawn O. Pearceae4efe12009-10-30 17:47:30 -0700836{
837 int force_all = flags & TRANSPORT_PUSH_FORCE;
838 int mirror = flags & TRANSPORT_PUSH_MIRROR;
839 struct helper_data *data = transport->data;
840 struct strbuf buf = STRBUF_INIT;
Shawn O. Pearceae4efe12009-10-30 17:47:30 -0700841 struct ref *ref;
Junio C Hamano05c1eb12013-08-02 15:14:50 -0700842 struct string_list cas_options = STRING_LIST_INIT_DUP;
843 struct string_list_item *cas_option;
Shawn O. Pearceae4efe12009-10-30 17:47:30 -0700844
Johannes Schindelinc0aa3352011-03-22 13:50:08 +0100845 get_helper(transport);
Shawn O. Pearceae4efe12009-10-30 17:47:30 -0700846 if (!data->push)
847 return 1;
848
849 for (ref = remote_refs; ref; ref = ref->next) {
Tay Ray Chuan20e8b462010-01-08 10:12:42 +0800850 if (!ref->peer_ref && !mirror)
Shawn O. Pearceae4efe12009-10-30 17:47:30 -0700851 continue;
852
Tay Ray Chuan20e8b462010-01-08 10:12:42 +0800853 /* Check for statuses set by set_ref_status_for_push() */
854 switch (ref->status) {
855 case REF_STATUS_REJECT_NONFASTFORWARD:
Junio C Hamano631b5ef2013-07-08 14:42:40 -0700856 case REF_STATUS_REJECT_STALE:
Chris Rorvickdbfeddb2012-11-29 19:41:37 -0600857 case REF_STATUS_REJECT_ALREADY_EXISTS:
Tay Ray Chuan20e8b462010-01-08 10:12:42 +0800858 case REF_STATUS_UPTODATE:
Shawn O. Pearceae4efe12009-10-30 17:47:30 -0700859 continue;
Tay Ray Chuan20e8b462010-01-08 10:12:42 +0800860 default:
861 ; /* do nothing */
Shawn O. Pearceae4efe12009-10-30 17:47:30 -0700862 }
863
864 if (force_all)
865 ref->force = 1;
866
867 strbuf_addstr(&buf, "push ");
868 if (!ref->deletion) {
869 if (ref->force)
870 strbuf_addch(&buf, '+');
871 if (ref->peer_ref)
872 strbuf_addstr(&buf, ref->peer_ref->name);
873 else
brian m. carlsonf4e54d02015-11-10 02:22:20 +0000874 strbuf_addstr(&buf, oid_to_hex(&ref->new_oid));
Shawn O. Pearceae4efe12009-10-30 17:47:30 -0700875 }
876 strbuf_addch(&buf, ':');
877 strbuf_addstr(&buf, ref->name);
878 strbuf_addch(&buf, '\n');
Junio C Hamano05c1eb12013-08-02 15:14:50 -0700879
880 /*
881 * The "--force-with-lease" options without explicit
882 * values to expect have already been expanded into
brian m. carlsonf4e54d02015-11-10 02:22:20 +0000883 * the ref->old_oid_expect[] field; we can ignore
Junio C Hamano05c1eb12013-08-02 15:14:50 -0700884 * transport->smart_options->cas altogether and instead
885 * can enumerate them from the refs.
886 */
887 if (ref->expect_old_sha1) {
888 struct strbuf cas = STRBUF_INIT;
889 strbuf_addf(&cas, "%s:%s",
brian m. carlsonf4e54d02015-11-10 02:22:20 +0000890 ref->name, oid_to_hex(&ref->old_oid_expect));
René Scharfe176cb972017-12-08 18:29:31 +0100891 string_list_append_nodup(&cas_options,
892 strbuf_detach(&cas, NULL));
Junio C Hamano05c1eb12013-08-02 15:14:50 -0700893 }
Shawn O. Pearceae4efe12009-10-30 17:47:30 -0700894 }
Junio C Hamano05c1eb12013-08-02 15:14:50 -0700895 if (buf.len == 0) {
896 string_list_clear(&cas_options, 0);
Clemens Buchacherd8f67d22009-10-30 17:47:31 -0700897 return 0;
Junio C Hamano05c1eb12013-08-02 15:14:50 -0700898 }
Shawn O. Pearceae4efe12009-10-30 17:47:30 -0700899
Junio C Hamano05c1eb12013-08-02 15:14:50 -0700900 for_each_string_list_item(cas_option, &cas_options)
901 set_helper_option(transport, "cas", cas_option->string);
Dave Borowitz30261092015-08-19 11:26:46 -0400902 set_common_push_options(transport, data->name, flags);
Shawn O. Pearceae4efe12009-10-30 17:47:30 -0700903
904 strbuf_addch(&buf, '\n');
Ilari Liusvaarabf3c5232009-12-09 17:26:27 +0200905 sendline(data, &buf);
Shawn O. Pearceae4efe12009-10-30 17:47:30 -0700906 strbuf_release(&buf);
René Scharfe176cb972017-12-08 18:29:31 +0100907 string_list_clear(&cas_options, 0);
Sverre Rabbelierd2e73c62011-07-16 15:03:34 +0200908
Felipe Contreras0551a062014-04-12 15:33:30 -0500909 return push_update_refs_status(data, remote_refs, flags);
Shawn O. Pearceae4efe12009-10-30 17:47:30 -0700910}
911
Sverre Rabbelier73b49a72010-03-29 11:48:27 -0500912static int push_refs_with_export(struct transport *transport,
913 struct ref *remote_refs, int flags)
914{
915 struct ref *ref;
916 struct child_process *helper, exporter;
917 struct helper_data *data = transport->data;
Felipe Contrerasd98c8152014-04-20 13:59:25 -0500918 struct string_list revlist_args = STRING_LIST_INIT_DUP;
Sverre Rabbelier73b49a72010-03-29 11:48:27 -0500919 struct strbuf buf = STRBUF_INIT;
920
Felipe Contreras21610d82013-04-17 23:14:30 -0500921 if (!data->refspecs)
922 die("remote-helper doesn't support push; refspec needed");
923
Dave Borowitz30261092015-08-19 11:26:46 -0400924 set_common_push_options(transport, data->name, flags);
Felipe Contreras510fa6f2013-11-12 14:56:56 -0600925 if (flags & TRANSPORT_PUSH_FORCE) {
926 if (set_helper_option(transport, "force", "true") != 0)
927 warning("helper %s does not support 'force'", data->name);
928 }
929
Sverre Rabbelier73b49a72010-03-29 11:48:27 -0500930 helper = get_helper(transport);
931
932 write_constant(helper->in, "export\n");
933
Sverre Rabbelier73b49a72010-03-29 11:48:27 -0500934 for (ref = remote_refs; ref; ref = ref->next) {
935 char *private;
brian m. carlson27912a02015-11-10 02:22:24 +0000936 struct object_id oid;
Sverre Rabbelier73b49a72010-03-29 11:48:27 -0500937
Sverre Rabbelier73b49a72010-03-29 11:48:27 -0500938 private = apply_refspecs(data->refspecs, data->refspec_nr, ref->name);
brian m. carlsone82caf32017-07-13 23:49:28 +0000939 if (private && !get_oid(private, &oid)) {
Sverre Rabbelier73b49a72010-03-29 11:48:27 -0500940 strbuf_addf(&buf, "^%s", private);
René Scharfe176cb972017-12-08 18:29:31 +0100941 string_list_append_nodup(&revlist_args,
942 strbuf_detach(&buf, NULL));
brian m. carlson27912a02015-11-10 02:22:24 +0000943 oidcpy(&ref->old_oid, &oid);
Sverre Rabbelier73b49a72010-03-29 11:48:27 -0500944 }
Jeff King2faa1522011-07-16 15:03:21 +0200945 free(private);
Sverre Rabbelier73b49a72010-03-29 11:48:27 -0500946
Felipe Contreras67c9c782013-05-20 20:02:45 -0500947 if (ref->peer_ref) {
Felipe Contrerasd98c8152014-04-20 13:59:25 -0500948 if (strcmp(ref->name, ref->peer_ref->name)) {
Felipe Contrerasf3d03762014-04-20 13:59:29 -0500949 if (!ref->deletion) {
950 const char *name;
951 int flag;
Felipe Contreras9193f742014-04-20 13:59:26 -0500952
Felipe Contrerasf3d03762014-04-20 13:59:29 -0500953 /* Follow symbolic refs (mainly for HEAD). */
brian m. carlson49e61472017-10-15 22:07:09 +0000954 name = resolve_ref_unsafe(ref->peer_ref->name,
955 RESOLVE_REF_READING,
956 &oid, &flag);
Felipe Contrerasf3d03762014-04-20 13:59:29 -0500957 if (!name || !(flag & REF_ISSYMREF))
958 name = ref->peer_ref->name;
959
960 strbuf_addf(&buf, "%s:%s", name, ref->name);
961 } else
962 strbuf_addf(&buf, ":%s", ref->name);
Felipe Contreras9193f742014-04-20 13:59:26 -0500963
Felipe Contrerasd98c8152014-04-20 13:59:25 -0500964 string_list_append(&revlist_args, "--refspec");
965 string_list_append(&revlist_args, buf.buf);
966 strbuf_release(&buf);
967 }
Felipe Contrerasf3d03762014-04-20 13:59:29 -0500968 if (!ref->deletion)
969 string_list_append(&revlist_args, ref->peer_ref->name);
Felipe Contreras67c9c782013-05-20 20:02:45 -0500970 }
Sverre Rabbelier73b49a72010-03-29 11:48:27 -0500971 }
972
Sverre Rabbeliera515ebe2011-07-16 15:03:40 +0200973 if (get_exporter(transport, &exporter, &revlist_args))
Sverre Rabbelier73b49a72010-03-29 11:48:27 -0500974 die("Couldn't run fast-export");
975
Felipe Contrerasd98c8152014-04-20 13:59:25 -0500976 string_list_clear(&revlist_args, 1);
977
Sverre Rabbeliercc567322011-07-16 15:03:35 +0200978 if (finish_command(&exporter))
979 die("Error while running fast-export");
Felipe Contreras3994e642014-04-12 15:33:32 -0500980 if (push_update_refs_status(data, remote_refs, flags))
981 return 1;
982
983 if (data->export_marks) {
984 strbuf_addf(&buf, "%s.tmp", data->export_marks);
985 rename(buf.buf, data->export_marks);
986 strbuf_release(&buf);
987 }
988
989 return 0;
Sverre Rabbelier73b49a72010-03-29 11:48:27 -0500990}
991
992static int push_refs(struct transport *transport,
993 struct ref *remote_refs, int flags)
994{
995 struct helper_data *data = transport->data;
996
997 if (process_connect(transport, 1)) {
998 do_take_over(transport);
Jonathan Tane967ca32017-12-14 13:44:45 -0800999 return transport->vtable->push_refs(transport, remote_refs, flags);
Sverre Rabbelier73b49a72010-03-29 11:48:27 -05001000 }
1001
1002 if (!remote_refs) {
1003 fprintf(stderr, "No refs in common and none specified; doing nothing.\n"
1004 "Perhaps you should specify a branch such as 'master'.\n");
1005 return 0;
1006 }
1007
1008 if (data->push)
1009 return push_refs_with_push(transport, remote_refs, flags);
1010
1011 if (data->export)
1012 return push_refs_with_export(transport, remote_refs, flags);
1013
1014 return -1;
1015}
1016
1017
Daniel Barkalowf8ec9162009-11-18 02:42:30 +01001018static int has_attribute(const char *attrs, const char *attr) {
1019 int len;
1020 if (!attrs)
1021 return 0;
1022
1023 len = strlen(attr);
1024 for (;;) {
1025 const char *space = strchrnul(attrs, ' ');
1026 if (len == space - attrs && !strncmp(attrs, attr, len))
1027 return 1;
1028 if (!*space)
1029 return 0;
1030 attrs = space + 1;
1031 }
1032}
1033
Daniel Barkalow6eb996b2009-08-05 01:01:53 -04001034static struct ref *get_refs_list(struct transport *transport, int for_push)
1035{
Shawn O. Pearce292ce462009-10-30 17:47:28 -07001036 struct helper_data *data = transport->data;
Daniel Barkalow6eb996b2009-08-05 01:01:53 -04001037 struct child_process *helper;
1038 struct ref *ret = NULL;
1039 struct ref **tail = &ret;
1040 struct ref *posn;
1041 struct strbuf buf = STRBUF_INIT;
Daniel Barkalow6eb996b2009-08-05 01:01:53 -04001042
1043 helper = get_helper(transport);
Daniel Barkalow2d14d652009-09-03 22:13:51 -04001044
Ilari Liusvaarafa8c0972009-12-09 17:26:32 +02001045 if (process_connect(transport, for_push)) {
1046 do_take_over(transport);
Jonathan Tane967ca32017-12-14 13:44:45 -08001047 return transport->vtable->get_refs_list(transport, for_push);
Ilari Liusvaarafa8c0972009-12-09 17:26:32 +02001048 }
1049
Shawn O. Pearceae4efe12009-10-30 17:47:30 -07001050 if (data->push && for_push)
1051 write_str_in_full(helper->in, "list for-push\n");
1052 else
1053 write_str_in_full(helper->in, "list\n");
Daniel Barkalow6eb996b2009-08-05 01:01:53 -04001054
Daniel Barkalow6eb996b2009-08-05 01:01:53 -04001055 while (1) {
1056 char *eov, *eon;
Felipe Contreras5931b332014-04-12 15:33:29 -05001057 if (recvline(data, &buf))
1058 exit(128);
Daniel Barkalow6eb996b2009-08-05 01:01:53 -04001059
1060 if (!*buf.buf)
1061 break;
1062
1063 eov = strchr(buf.buf, ' ');
1064 if (!eov)
1065 die("Malformed response in ref list: %s", buf.buf);
1066 eon = strchr(eov + 1, ' ');
1067 *eov = '\0';
1068 if (eon)
1069 *eon = '\0';
1070 *tail = alloc_ref(eov + 1);
1071 if (buf.buf[0] == '@')
1072 (*tail)->symref = xstrdup(buf.buf + 1);
1073 else if (buf.buf[0] != '?')
brian m. carlsonf4e54d02015-11-10 02:22:20 +00001074 get_oid_hex(buf.buf, &(*tail)->old_oid);
Daniel Barkalowf8ec9162009-11-18 02:42:30 +01001075 if (eon) {
1076 if (has_attribute(eon + 1, "unchanged")) {
1077 (*tail)->status |= REF_STATUS_UPTODATE;
brian m. carlson34c290a2017-10-15 22:06:56 +00001078 if (read_ref((*tail)->name, &(*tail)->old_oid) < 0)
Vasco Almeida3c5077f2016-06-17 20:21:13 +00001079 die(_("Could not read ref %s"),
Stefan Bellerae25fd32015-07-31 16:57:57 -07001080 (*tail)->name);
Daniel Barkalowf8ec9162009-11-18 02:42:30 +01001081 }
1082 }
Daniel Barkalow6eb996b2009-08-05 01:01:53 -04001083 tail = &((*tail)->next);
1084 }
Ilari Liusvaarabf3c5232009-12-09 17:26:27 +02001085 if (debug)
1086 fprintf(stderr, "Debug: Read ref listing.\n");
Daniel Barkalow6eb996b2009-08-05 01:01:53 -04001087 strbuf_release(&buf);
1088
1089 for (posn = ret; posn; posn = posn->next)
1090 resolve_remote_symref(posn, ret);
1091
1092 return ret;
1093}
1094
Jonathan Tane967ca32017-12-14 13:44:45 -08001095static struct transport_vtable vtable = {
1096 set_helper_option,
1097 get_refs_list,
1098 fetch,
1099 push_refs,
1100 connect_helper,
1101 release_helper
1102};
1103
Daniel Barkalowc9e388b2009-09-03 22:13:49 -04001104int transport_helper_init(struct transport *transport, const char *name)
Daniel Barkalow6eb996b2009-08-05 01:01:53 -04001105{
Brian Gesiak92e25b62014-05-27 00:33:56 +09001106 struct helper_data *data = xcalloc(1, sizeof(*data));
Daniel Barkalowc9e388b2009-09-03 22:13:49 -04001107 data->name = name;
Daniel Barkalow6eb996b2009-08-05 01:01:53 -04001108
Jeff Kinga5adace2015-09-16 13:12:52 -04001109 transport_check_allowed(name);
1110
Ilari Liusvaarabf3c5232009-12-09 17:26:27 +02001111 if (getenv("GIT_TRANSPORT_HELPER_DEBUG"))
1112 debug = 1;
1113
Daniel Barkalow6eb996b2009-08-05 01:01:53 -04001114 transport->data = data;
Jonathan Tane967ca32017-12-14 13:44:45 -08001115 transport->vtable = &vtable;
Ilari Liusvaara61b075b2009-12-09 17:26:31 +02001116 transport->smart_options = &(data->transport_options);
Daniel Barkalow6eb996b2009-08-05 01:01:53 -04001117 return 0;
1118}
Ilari Liusvaara419f37d2010-10-12 19:39:41 +03001119
1120/*
1121 * Linux pipes can buffer 65536 bytes at once (and most platforms can
1122 * buffer less), so attempt reads and writes with up to that size.
1123 */
1124#define BUFFERSIZE 65536
1125/* This should be enough to hold debugging message. */
1126#define PBUFFERSIZE 8192
1127
1128/* Print bidirectional transfer loop debug message. */
Jeff King46210852013-07-09 20:18:40 -04001129__attribute__((format (printf, 1, 2)))
Ilari Liusvaara419f37d2010-10-12 19:39:41 +03001130static void transfer_debug(const char *fmt, ...)
1131{
Martin Ågren6cdf8a72017-08-21 19:43:48 +02001132 /*
1133 * NEEDSWORK: This function is sometimes used from multiple threads, and
1134 * we end up using debug_enabled racily. That "should not matter" since
1135 * we always write the same value, but it's still wrong. This function
1136 * is listed in .tsan-suppressions for the time being.
1137 */
1138
Ilari Liusvaara419f37d2010-10-12 19:39:41 +03001139 va_list args;
1140 char msgbuf[PBUFFERSIZE];
1141 static int debug_enabled = -1;
1142
1143 if (debug_enabled < 0)
1144 debug_enabled = getenv("GIT_TRANSLOOP_DEBUG") ? 1 : 0;
1145 if (!debug_enabled)
1146 return;
1147
1148 va_start(args, fmt);
1149 vsnprintf(msgbuf, PBUFFERSIZE, fmt, args);
1150 va_end(args);
1151 fprintf(stderr, "Transfer loop debugging: %s\n", msgbuf);
1152}
1153
1154/* Stream state: More data may be coming in this direction. */
Ville Skyttä2e3a16b2016-08-09 11:53:38 +03001155#define SSTATE_TRANSFERRING 0
Ilari Liusvaara419f37d2010-10-12 19:39:41 +03001156/*
1157 * Stream state: No more data coming in this direction, flushing rest of
1158 * data.
1159 */
1160#define SSTATE_FLUSHING 1
1161/* Stream state: Transfer in this direction finished. */
1162#define SSTATE_FINISHED 2
1163
Ville Skyttä2e3a16b2016-08-09 11:53:38 +03001164#define STATE_NEEDS_READING(state) ((state) <= SSTATE_TRANSFERRING)
Ilari Liusvaara419f37d2010-10-12 19:39:41 +03001165#define STATE_NEEDS_WRITING(state) ((state) <= SSTATE_FLUSHING)
1166#define STATE_NEEDS_CLOSING(state) ((state) == SSTATE_FLUSHING)
1167
1168/* Unidirectional transfer. */
1169struct unidirectional_transfer {
1170 /* Source */
1171 int src;
1172 /* Destination */
1173 int dest;
1174 /* Is source socket? */
1175 int src_is_sock;
1176 /* Is destination socket? */
1177 int dest_is_sock;
Stefano Lattarini41ccfdd2013-04-12 00:36:10 +02001178 /* Transfer state (TRANSFERRING/FLUSHING/FINISHED) */
Ilari Liusvaara419f37d2010-10-12 19:39:41 +03001179 int state;
1180 /* Buffer. */
1181 char buf[BUFFERSIZE];
1182 /* Buffer used. */
1183 size_t bufuse;
1184 /* Name of source. */
1185 const char *src_name;
1186 /* Name of destination. */
1187 const char *dest_name;
1188};
1189
1190/* Closes the target (for writing) if transfer has finished. */
1191static void udt_close_if_finished(struct unidirectional_transfer *t)
1192{
1193 if (STATE_NEEDS_CLOSING(t->state) && !t->bufuse) {
1194 t->state = SSTATE_FINISHED;
1195 if (t->dest_is_sock)
1196 shutdown(t->dest, SHUT_WR);
1197 else
1198 close(t->dest);
1199 transfer_debug("Closed %s.", t->dest_name);
1200 }
1201}
1202
1203/*
Li Peng832c0e52016-05-06 20:36:46 +08001204 * Tries to read data from source into buffer. If buffer is full,
Ilari Liusvaara419f37d2010-10-12 19:39:41 +03001205 * no data is read. Returns 0 on success, -1 on error.
1206 */
1207static int udt_do_read(struct unidirectional_transfer *t)
1208{
1209 ssize_t bytes;
1210
1211 if (t->bufuse == BUFFERSIZE)
1212 return 0; /* No space for more. */
1213
1214 transfer_debug("%s is readable", t->src_name);
1215 bytes = read(t->src, t->buf + t->bufuse, BUFFERSIZE - t->bufuse);
1216 if (bytes < 0 && errno != EWOULDBLOCK && errno != EAGAIN &&
1217 errno != EINTR) {
Nguyễn Thái Ngọc Duy1fee1dc2016-05-08 16:47:57 +07001218 error_errno("read(%s) failed", t->src_name);
Ilari Liusvaara419f37d2010-10-12 19:39:41 +03001219 return -1;
1220 } else if (bytes == 0) {
1221 transfer_debug("%s EOF (with %i bytes in buffer)",
Jeff King46210852013-07-09 20:18:40 -04001222 t->src_name, (int)t->bufuse);
Ilari Liusvaara419f37d2010-10-12 19:39:41 +03001223 t->state = SSTATE_FLUSHING;
1224 } else if (bytes > 0) {
1225 t->bufuse += bytes;
1226 transfer_debug("Read %i bytes from %s (buffer now at %i)",
1227 (int)bytes, t->src_name, (int)t->bufuse);
1228 }
1229 return 0;
1230}
1231
1232/* Tries to write data from buffer into destination. If buffer is empty,
1233 * no data is written. Returns 0 on success, -1 on error.
1234 */
1235static int udt_do_write(struct unidirectional_transfer *t)
1236{
Nicolas Kaiser803dbdb2011-03-05 00:16:26 +01001237 ssize_t bytes;
Ilari Liusvaara419f37d2010-10-12 19:39:41 +03001238
1239 if (t->bufuse == 0)
1240 return 0; /* Nothing to write. */
1241
1242 transfer_debug("%s is writable", t->dest_name);
Erik Faye-Lund7edc02f2014-01-17 15:17:09 +01001243 bytes = xwrite(t->dest, t->buf, t->bufuse);
1244 if (bytes < 0 && errno != EWOULDBLOCK) {
Nguyễn Thái Ngọc Duy1fee1dc2016-05-08 16:47:57 +07001245 error_errno("write(%s) failed", t->dest_name);
Ilari Liusvaara419f37d2010-10-12 19:39:41 +03001246 return -1;
1247 } else if (bytes > 0) {
1248 t->bufuse -= bytes;
1249 if (t->bufuse)
1250 memmove(t->buf, t->buf + bytes, t->bufuse);
1251 transfer_debug("Wrote %i bytes to %s (buffer now at %i)",
1252 (int)bytes, t->dest_name, (int)t->bufuse);
1253 }
1254 return 0;
1255}
1256
1257
1258/* State of bidirectional transfer loop. */
1259struct bidirectional_transfer_state {
1260 /* Direction from program to git. */
1261 struct unidirectional_transfer ptg;
1262 /* Direction from git to program. */
1263 struct unidirectional_transfer gtp;
1264};
1265
1266static void *udt_copy_task_routine(void *udt)
1267{
1268 struct unidirectional_transfer *t = (struct unidirectional_transfer *)udt;
1269 while (t->state != SSTATE_FINISHED) {
1270 if (STATE_NEEDS_READING(t->state))
1271 if (udt_do_read(t))
1272 return NULL;
1273 if (STATE_NEEDS_WRITING(t->state))
1274 if (udt_do_write(t))
1275 return NULL;
1276 if (STATE_NEEDS_CLOSING(t->state))
1277 udt_close_if_finished(t);
1278 }
1279 return udt; /* Just some non-NULL value. */
1280}
1281
1282#ifndef NO_PTHREADS
1283
1284/*
Ondřej Bílka98e023d2013-07-29 10:18:21 +02001285 * Join thread, with appropriate errors on failure. Name is name for the
Ilari Liusvaara419f37d2010-10-12 19:39:41 +03001286 * thread (for error messages). Returns 0 on success, 1 on failure.
1287 */
1288static int tloop_join(pthread_t thread, const char *name)
1289{
1290 int err;
1291 void *tret;
1292 err = pthread_join(thread, &tret);
1293 if (!tret) {
1294 error("%s thread failed", name);
1295 return 1;
1296 }
1297 if (err) {
1298 error("%s thread failed to join: %s", name, strerror(err));
1299 return 1;
1300 }
1301 return 0;
1302}
1303
1304/*
1305 * Spawn the transfer tasks and then wait for them. Returns 0 on success,
1306 * -1 on failure.
1307 */
1308static int tloop_spawnwait_tasks(struct bidirectional_transfer_state *s)
1309{
1310 pthread_t gtp_thread;
1311 pthread_t ptg_thread;
1312 int err;
1313 int ret = 0;
1314 err = pthread_create(&gtp_thread, NULL, udt_copy_task_routine,
1315 &s->gtp);
1316 if (err)
1317 die("Can't start thread for copying data: %s", strerror(err));
1318 err = pthread_create(&ptg_thread, NULL, udt_copy_task_routine,
1319 &s->ptg);
1320 if (err)
1321 die("Can't start thread for copying data: %s", strerror(err));
1322
1323 ret |= tloop_join(gtp_thread, "Git to program copy");
1324 ret |= tloop_join(ptg_thread, "Program to git copy");
1325 return ret;
1326}
1327#else
1328
1329/* Close the source and target (for writing) for transfer. */
1330static void udt_kill_transfer(struct unidirectional_transfer *t)
1331{
1332 t->state = SSTATE_FINISHED;
1333 /*
1334 * Socket read end left open isn't a disaster if nobody
1335 * attempts to read from it (mingw compat headers do not
1336 * have SHUT_RD)...
1337 *
1338 * We can't fully close the socket since otherwise gtp
1339 * task would first close the socket it sends data to
1340 * while closing the ptg file descriptors.
1341 */
1342 if (!t->src_is_sock)
1343 close(t->src);
1344 if (t->dest_is_sock)
1345 shutdown(t->dest, SHUT_WR);
1346 else
1347 close(t->dest);
1348}
1349
1350/*
Ondřej Bílka98e023d2013-07-29 10:18:21 +02001351 * Join process, with appropriate errors on failure. Name is name for the
Ilari Liusvaara419f37d2010-10-12 19:39:41 +03001352 * process (for error messages). Returns 0 on success, 1 on failure.
1353 */
1354static int tloop_join(pid_t pid, const char *name)
1355{
1356 int tret;
1357 if (waitpid(pid, &tret, 0) < 0) {
Nguyễn Thái Ngọc Duy1fee1dc2016-05-08 16:47:57 +07001358 error_errno("%s process failed to wait", name);
Ilari Liusvaara419f37d2010-10-12 19:39:41 +03001359 return 1;
1360 }
1361 if (!WIFEXITED(tret) || WEXITSTATUS(tret)) {
1362 error("%s process failed", name);
1363 return 1;
1364 }
1365 return 0;
1366}
1367
1368/*
1369 * Spawn the transfer tasks and then wait for them. Returns 0 on success,
1370 * -1 on failure.
1371 */
1372static int tloop_spawnwait_tasks(struct bidirectional_transfer_state *s)
1373{
1374 pid_t pid1, pid2;
1375 int ret = 0;
1376
1377 /* Fork thread #1: git to program. */
1378 pid1 = fork();
1379 if (pid1 < 0)
1380 die_errno("Can't start thread for copying data");
1381 else if (pid1 == 0) {
1382 udt_kill_transfer(&s->ptg);
1383 exit(udt_copy_task_routine(&s->gtp) ? 0 : 1);
1384 }
1385
1386 /* Fork thread #2: program to git. */
1387 pid2 = fork();
1388 if (pid2 < 0)
1389 die_errno("Can't start thread for copying data");
1390 else if (pid2 == 0) {
1391 udt_kill_transfer(&s->gtp);
1392 exit(udt_copy_task_routine(&s->ptg) ? 0 : 1);
1393 }
1394
1395 /*
1396 * Close both streams in parent as to not interfere with
1397 * end of file detection and wait for both tasks to finish.
1398 */
1399 udt_kill_transfer(&s->gtp);
1400 udt_kill_transfer(&s->ptg);
1401 ret |= tloop_join(pid1, "Git to program copy");
1402 ret |= tloop_join(pid2, "Program to git copy");
1403 return ret;
1404}
1405#endif
1406
1407/*
1408 * Copies data from stdin to output and from input to stdout simultaneously.
1409 * Additionally filtering through given filter. If filter is NULL, uses
1410 * identity filter.
1411 */
1412int bidirectional_transfer_loop(int input, int output)
1413{
1414 struct bidirectional_transfer_state state;
1415
1416 /* Fill the state fields. */
1417 state.ptg.src = input;
1418 state.ptg.dest = 1;
1419 state.ptg.src_is_sock = (input == output);
1420 state.ptg.dest_is_sock = 0;
Ville Skyttä2e3a16b2016-08-09 11:53:38 +03001421 state.ptg.state = SSTATE_TRANSFERRING;
Ilari Liusvaara419f37d2010-10-12 19:39:41 +03001422 state.ptg.bufuse = 0;
1423 state.ptg.src_name = "remote input";
1424 state.ptg.dest_name = "stdout";
1425
1426 state.gtp.src = 0;
1427 state.gtp.dest = output;
1428 state.gtp.src_is_sock = 0;
1429 state.gtp.dest_is_sock = (input == output);
Ville Skyttä2e3a16b2016-08-09 11:53:38 +03001430 state.gtp.state = SSTATE_TRANSFERRING;
Ilari Liusvaara419f37d2010-10-12 19:39:41 +03001431 state.gtp.bufuse = 0;
1432 state.gtp.src_name = "stdin";
1433 state.gtp.dest_name = "remote output";
1434
1435 return tloop_spawnwait_tasks(&state);
1436}