get_helper: use run-command's internal argv_array
[git/git.git] / transport-helper.c
CommitLineData
6eb996b5
DB
1#include "cache.h"
2#include "transport.h"
ae4efe19 3#include "quote.h"
6eb996b5
DB
4#include "run-command.h"
5#include "commit.h"
6#include "diff.h"
7#include "revision.h"
ef08ef9e 8#include "quote.h"
72ff8943 9#include "remote.h"
73b49a75 10#include "string-list.h"
7851b1e6 11#include "thread-utils.h"
c34fe630 12#include "sigchain.h"
bfc366d9 13#include "argv-array.h"
664059fb 14#include "refs.h"
7851b1e6 15
bf3c523c
IL
16static int debug;
17
9cba13ca 18struct helper_data {
6eb996b5
DB
19 const char *name;
20 struct child_process *helper;
292ce46b 21 FILE *out;
ef08ef9e 22 unsigned fetch : 1,
a24a32dd 23 import : 1,
bfc366d9 24 bidi_import : 1,
73b49a75 25 export : 1,
ae4efe19 26 option : 1,
fa8c097c
IL
27 push : 1,
28 connect : 1,
0d957a4d 29 signed_tags : 1,
9ba38048 30 check_connectivity : 1,
597b831a
MM
31 no_disconnect_req : 1,
32 no_private_update : 1;
a515ebe9
SR
33 char *export_marks;
34 char *import_marks;
72ff8943
DB
35 /* These go from remote name (as in "list") to private name */
36 struct refspec *refspecs;
37 int refspec_nr;
61b075bd
IL
38 /* Transport options for fetch-pack/send-pack (should one of
39 * those be invoked).
40 */
41 struct git_transport_options transport_options;
6eb996b5
DB
42};
43
bf3c523c
IL
44static void sendline(struct helper_data *helper, struct strbuf *buffer)
45{
46 if (debug)
47 fprintf(stderr, "Debug: Remote helper: -> %s", buffer->buf);
48 if (write_in_full(helper->helper->in, buffer->buf, buffer->len)
49 != buffer->len)
50 die_errno("Full write to remote helper failed");
51}
52
c096955c 53static int recvline_fh(FILE *helper, struct strbuf *buffer, const char *name)
bf3c523c
IL
54{
55 strbuf_reset(buffer);
56 if (debug)
57 fprintf(stderr, "Debug: Remote helper: Waiting...\n");
fa8c097c 58 if (strbuf_getline(buffer, helper, '\n') == EOF) {
bf3c523c
IL
59 if (debug)
60 fprintf(stderr, "Debug: Remote helper quit.\n");
5931b33e 61 return 1;
bf3c523c
IL
62 }
63
64 if (debug)
65 fprintf(stderr, "Debug: Remote helper: <- %s\n", buffer->buf);
66 return 0;
67}
68
fa8c097c
IL
69static int recvline(struct helper_data *helper, struct strbuf *buffer)
70{
c096955c 71 return recvline_fh(helper->out, buffer, helper->name);
fa8c097c
IL
72}
73
bf3c523c
IL
74static void write_constant(int fd, const char *str)
75{
76 if (debug)
77 fprintf(stderr, "Debug: Remote helper: -> %s", str);
78 if (write_in_full(fd, str, strlen(str)) != strlen(str))
79 die_errno("Full write to remote helper failed");
80}
81
c2e86add 82static const char *remove_ext_force(const char *url)
25d5cc48
IL
83{
84 if (url) {
85 const char *colon = strchr(url, ':');
86 if (colon && colon[1] == ':')
87 return colon + 2;
88 }
89 return url;
90}
91
fa8c097c
IL
92static void do_take_over(struct transport *transport)
93{
94 struct helper_data *data;
95 data = (struct helper_data *)transport->data;
96 transport_take_over(transport, data->helper);
97 fclose(data->out);
98 free(data);
99}
100
6eb996b5
DB
101static struct child_process *get_helper(struct transport *transport)
102{
103 struct helper_data *data = transport->data;
104 struct strbuf buf = STRBUF_INIT;
105 struct child_process *helper;
72ff8943
DB
106 const char **refspecs = NULL;
107 int refspec_nr = 0;
108 int refspec_alloc = 0;
61b075bd 109 int duped;
6b02de3b 110 int code;
e1735872
DI
111 char git_dir_buf[sizeof(GIT_DIR_ENVIRONMENT) + PATH_MAX + 1];
112 const char *helper_env[] = {
113 git_dir_buf,
114 NULL
115 };
116
6eb996b5
DB
117
118 if (data->helper)
119 return data->helper;
120
121 helper = xcalloc(1, sizeof(*helper));
122 helper->in = -1;
123 helper->out = -1;
124 helper->err = 0;
e0ab2ac6
JK
125 argv_array_pushf(&helper->args, "git-remote-%s", data->name);
126 argv_array_push(&helper->args, transport->remote->name);
127 argv_array_push(&helper->args, remove_ext_force(transport->url));
6b02de3b
IL
128 helper->git_cmd = 0;
129 helper->silent_exec_failure = 1;
e1735872
DI
130
131 snprintf(git_dir_buf, sizeof(git_dir_buf), "%s=%s", GIT_DIR_ENVIRONMENT, get_git_dir());
132 helper->env = helper_env;
133
6b02de3b
IL
134 code = start_command(helper);
135 if (code < 0 && errno == ENOENT)
136 die("Unable to find remote helper for '%s'", data->name);
137 else if (code != 0)
138 exit(code);
139
6eb996b5 140 data->helper = helper;
fa8c097c 141 data->no_disconnect_req = 0;
6eb996b5 142
61b075bd
IL
143 /*
144 * Open the output as FILE* so strbuf_getline() can be used.
145 * Do this with duped fd because fclose() will close the fd,
146 * and stuff like taking over will require the fd to remain.
61b075bd
IL
147 */
148 duped = dup(helper->out);
149 if (duped < 0)
150 die_errno("Can't dup helper output fd");
151 data->out = xfdopen(duped, "r");
152
bf3c523c 153 write_constant(helper->in, "capabilities\n");
2d14d65c 154
6eb996b5 155 while (1) {
28ed5b35
IL
156 const char *capname;
157 int mandatory = 0;
5931b33e
FC
158 if (recvline(data, &buf))
159 exit(128);
6eb996b5
DB
160
161 if (!*buf.buf)
162 break;
28ed5b35
IL
163
164 if (*buf.buf == '*') {
165 capname = buf.buf + 1;
166 mandatory = 1;
167 } else
168 capname = buf.buf;
169
bf3c523c 170 if (debug)
28ed5b35
IL
171 fprintf(stderr, "Debug: Got cap %s\n", capname);
172 if (!strcmp(capname, "fetch"))
6eb996b5 173 data->fetch = 1;
28ed5b35 174 else if (!strcmp(capname, "option"))
ef08ef9e 175 data->option = 1;
28ed5b35 176 else if (!strcmp(capname, "push"))
ae4efe19 177 data->push = 1;
28ed5b35 178 else if (!strcmp(capname, "import"))
e65e91ed 179 data->import = 1;
bfc366d9
FA
180 else if (!strcmp(capname, "bidi-import"))
181 data->bidi_import = 1;
73b49a75
SR
182 else if (!strcmp(capname, "export"))
183 data->export = 1;
9ba38048
NTND
184 else if (!strcmp(capname, "check-connectivity"))
185 data->check_connectivity = 1;
59556548 186 else if (!data->refspecs && starts_with(capname, "refspec ")) {
72ff8943
DB
187 ALLOC_GROW(refspecs,
188 refspec_nr + 1,
189 refspec_alloc);
c28cce55 190 refspecs[refspec_nr++] = xstrdup(capname + strlen("refspec "));
fa8c097c
IL
191 } else if (!strcmp(capname, "connect")) {
192 data->connect = 1;
0d957a4d
JK
193 } else if (!strcmp(capname, "signed-tags")) {
194 data->signed_tags = 1;
59556548 195 } else if (starts_with(capname, "export-marks ")) {
852e54bc 196 data->export_marks = xstrdup(capname + strlen("export-marks "));
59556548 197 } else if (starts_with(capname, "import-marks")) {
852e54bc 198 data->import_marks = xstrdup(capname + strlen("import-marks "));
59556548 199 } else if (starts_with(capname, "no-private-update")) {
597b831a 200 data->no_private_update = 1;
28ed5b35 201 } else if (mandatory) {
9517e6b8 202 die("Unknown mandatory capability %s. This remote "
82247e9b 203 "helper probably needs newer version of Git.",
28ed5b35 204 capname);
72ff8943
DB
205 }
206 }
207 if (refspecs) {
208 int i;
209 data->refspec_nr = refspec_nr;
210 data->refspecs = parse_fetch_refspec(refspec_nr, refspecs);
b120ef3e 211 for (i = 0; i < refspec_nr; i++)
72ff8943 212 free((char *)refspecs[i]);
72ff8943 213 free(refspecs);
a93b4a09
FC
214 } else if (data->import || data->bidi_import || data->export) {
215 warning("This remote helper should implement refspec capability.");
6eb996b5 216 }
b962dbdc 217 strbuf_release(&buf);
bf3c523c
IL
218 if (debug)
219 fprintf(stderr, "Debug: Capabilities complete.\n");
6eb996b5
DB
220 return data->helper;
221}
222
223static int disconnect_helper(struct transport *transport)
224{
225 struct helper_data *data = transport->data;
cc567322 226 int res = 0;
bf3c523c 227
6eb996b5 228 if (data->helper) {
bf3c523c
IL
229 if (debug)
230 fprintf(stderr, "Debug: Disconnecting.\n");
fa8c097c 231 if (!data->no_disconnect_req) {
c34fe630
JK
232 /*
233 * Ignore write errors; there's nothing we can do,
234 * since we're about to close the pipe anyway. And the
235 * most likely error is EPIPE due to the helper dying
236 * to report an error itself.
237 */
238 sigchain_push(SIGPIPE, SIG_IGN);
239 xwrite(data->helper->in, "\n", 1);
240 sigchain_pop(SIGPIPE);
fa8c097c 241 }
6eb996b5 242 close(data->helper->in);
61b075bd 243 close(data->helper->out);
292ce46b 244 fclose(data->out);
cc567322 245 res = finish_command(data->helper);
6eb996b5
DB
246 free(data->helper);
247 data->helper = NULL;
248 }
cc567322 249 return res;
6eb996b5
DB
250}
251
ef08ef9e
SP
252static const char *unsupported_options[] = {
253 TRANS_OPT_UPLOADPACK,
254 TRANS_OPT_RECEIVEPACK,
255 TRANS_OPT_THIN,
256 TRANS_OPT_KEEP
257 };
23cd01ec 258
ef08ef9e
SP
259static const char *boolean_options[] = {
260 TRANS_OPT_THIN,
261 TRANS_OPT_KEEP,
262 TRANS_OPT_FOLLOWTAGS
263 };
264
265static int set_helper_option(struct transport *transport,
266 const char *name, const char *value)
267{
268 struct helper_data *data = transport->data;
ef08ef9e
SP
269 struct strbuf buf = STRBUF_INIT;
270 int i, ret, is_bool = 0;
271
bf3c523c
IL
272 get_helper(transport);
273
ef08ef9e
SP
274 if (!data->option)
275 return 1;
276
277 for (i = 0; i < ARRAY_SIZE(unsupported_options); i++) {
278 if (!strcmp(name, unsupported_options[i]))
279 return 1;
280 }
281
282 for (i = 0; i < ARRAY_SIZE(boolean_options); i++) {
283 if (!strcmp(name, boolean_options[i])) {
284 is_bool = 1;
285 break;
286 }
287 }
288
289 strbuf_addf(&buf, "option %s ", name);
290 if (is_bool)
291 strbuf_addstr(&buf, value ? "true" : "false");
292 else
293 quote_c_style(value, &buf, NULL, 0);
294 strbuf_addch(&buf, '\n');
295
4a1b59c8 296 sendline(data, &buf);
5931b33e
FC
297 if (recvline(data, &buf))
298 exit(128);
ef08ef9e
SP
299
300 if (!strcmp(buf.buf, "ok"))
301 ret = 0;
59556548 302 else if (starts_with(buf.buf, "error")) {
ef08ef9e
SP
303 ret = -1;
304 } else if (!strcmp(buf.buf, "unsupported"))
305 ret = 1;
306 else {
307 warning("%s unexpectedly said: '%s'", data->name, buf.buf);
308 ret = 1;
309 }
310 strbuf_release(&buf);
311 return ret;
312}
313
314static void standard_options(struct transport *t)
315{
316 char buf[16];
317 int n;
318 int v = t->verbose;
ef08ef9e 319
d01b3c02 320 set_helper_option(t, "progress", t->progress ? "true" : "false");
ef08ef9e
SP
321
322 n = snprintf(buf, sizeof(buf), "%d", v + 1);
323 if (n >= sizeof(buf))
324 die("impossibly large verbosity value");
325 set_helper_option(t, "verbosity", buf);
326}
327
f2a37151
DB
328static int release_helper(struct transport *transport)
329{
cc567322 330 int res = 0;
72ff8943
DB
331 struct helper_data *data = transport->data;
332 free_refspec(data->refspec_nr, data->refspecs);
333 data->refspecs = NULL;
cc567322 334 res = disconnect_helper(transport);
f2a37151 335 free(transport->data);
cc567322 336 return res;
f2a37151
DB
337}
338
6eb996b5 339static int fetch_with_fetch(struct transport *transport,
37148311 340 int nr_heads, struct ref **to_fetch)
6eb996b5 341{
292ce46b 342 struct helper_data *data = transport->data;
6eb996b5
DB
343 int i;
344 struct strbuf buf = STRBUF_INIT;
345
ef08ef9e 346 standard_options(transport);
9ba38048
NTND
347 if (data->check_connectivity &&
348 data->transport_options.check_self_contained_and_connected)
349 set_helper_option(transport, "check-connectivity", "true");
ef08ef9e 350
16094885
NTND
351 if (transport->cloning)
352 set_helper_option(transport, "cloning", "true");
353
354 if (data->transport_options.update_shallow)
355 set_helper_option(transport, "update-shallow", "true");
356
6eb996b5 357 for (i = 0; i < nr_heads; i++) {
1088261f 358 const struct ref *posn = to_fetch[i];
6eb996b5
DB
359 if (posn->status & REF_STATUS_UPTODATE)
360 continue;
2d14d65c
DB
361
362 strbuf_addf(&buf, "fetch %s %s\n",
363 sha1_to_hex(posn->old_sha1), posn->name);
292ce46b 364 }
2d14d65c 365
292ce46b 366 strbuf_addch(&buf, '\n');
bf3c523c 367 sendline(data, &buf);
292ce46b
SP
368
369 while (1) {
5931b33e
FC
370 if (recvline(data, &buf))
371 exit(128);
292ce46b 372
59556548 373 if (starts_with(buf.buf, "lock ")) {
292ce46b
SP
374 const char *name = buf.buf + 5;
375 if (transport->pack_lockfile)
376 warning("%s also locked %s", data->name, name);
377 else
378 transport->pack_lockfile = xstrdup(name);
379 }
9ba38048
NTND
380 else if (data->check_connectivity &&
381 data->transport_options.check_self_contained_and_connected &&
382 !strcmp(buf.buf, "connectivity-ok"))
383 data->transport_options.self_contained_and_connected = 1;
292ce46b
SP
384 else if (!buf.len)
385 break;
386 else
387 warning("%s unexpectedly said: '%s'", data->name, buf.buf);
6eb996b5 388 }
292ce46b 389 strbuf_release(&buf);
6eb996b5
DB
390 return 0;
391}
392
e65e91ed
DB
393static int get_importer(struct transport *transport, struct child_process *fastimport)
394{
395 struct child_process *helper = get_helper(transport);
bfc366d9
FA
396 struct helper_data *data = transport->data;
397 struct argv_array argv = ARGV_ARRAY_INIT;
398 int cat_blob_fd, code;
e65e91ed
DB
399 memset(fastimport, 0, sizeof(*fastimport));
400 fastimport->in = helper->out;
bfc366d9 401 argv_array_push(&argv, "fast-import");
19ba02af 402 argv_array_push(&argv, debug ? "--stats" : "--quiet");
e65e91ed 403
bfc366d9
FA
404 if (data->bidi_import) {
405 cat_blob_fd = xdup(helper->in);
406 argv_array_pushf(&argv, "--cat-blob-fd=%d", cat_blob_fd);
407 }
408 fastimport->argv = argv.argv;
e65e91ed 409 fastimport->git_cmd = 1;
bfc366d9
FA
410
411 code = start_command(fastimport);
412 return code;
e65e91ed
DB
413}
414
73b49a75
SR
415static int get_exporter(struct transport *transport,
416 struct child_process *fastexport,
73b49a75
SR
417 struct string_list *revlist_args)
418{
a515ebe9 419 struct helper_data *data = transport->data;
73b49a75
SR
420 struct child_process *helper = get_helper(transport);
421 int argc = 0, i;
852e54bc
FC
422 struct strbuf tmp = STRBUF_INIT;
423
73b49a75
SR
424 memset(fastexport, 0, sizeof(*fastexport));
425
426 /* we need to duplicate helper->in because we want to use it after
427 * fastexport is done with it. */
428 fastexport->out = dup(helper->in);
b8bd826f 429 fastexport->argv = xcalloc(6 + revlist_args->nr, sizeof(*fastexport->argv));
73b49a75 430 fastexport->argv[argc++] = "fast-export";
1f25c504 431 fastexport->argv[argc++] = "--use-done-feature";
0d957a4d
JK
432 fastexport->argv[argc++] = data->signed_tags ?
433 "--signed-tags=verbatim" : "--signed-tags=warn-strip";
852e54bc 434 if (data->export_marks) {
3994e64d 435 strbuf_addf(&tmp, "--export-marks=%s.tmp", data->export_marks);
852e54bc
FC
436 fastexport->argv[argc++] = strbuf_detach(&tmp, NULL);
437 }
438 if (data->import_marks) {
439 strbuf_addf(&tmp, "--import-marks=%s", data->import_marks);
440 fastexport->argv[argc++] = strbuf_detach(&tmp, NULL);
441 }
73b49a75
SR
442
443 for (i = 0; i < revlist_args->nr; i++)
444 fastexport->argv[argc++] = revlist_args->items[i].string;
445
446 fastexport->git_cmd = 1;
447 return start_command(fastexport);
448}
449
e65e91ed
DB
450static int fetch_with_import(struct transport *transport,
451 int nr_heads, struct ref **to_fetch)
452{
453 struct child_process fastimport;
72ff8943 454 struct helper_data *data = transport->data;
e65e91ed
DB
455 int i;
456 struct ref *posn;
457 struct strbuf buf = STRBUF_INIT;
458
bf3c523c
IL
459 get_helper(transport);
460
e65e91ed
DB
461 if (get_importer(transport, &fastimport))
462 die("Couldn't run fast-import");
463
464 for (i = 0; i < nr_heads; i++) {
465 posn = to_fetch[i];
466 if (posn->status & REF_STATUS_UPTODATE)
467 continue;
468
469 strbuf_addf(&buf, "import %s\n", posn->name);
bf3c523c 470 sendline(data, &buf);
e65e91ed
DB
471 strbuf_reset(&buf);
472 }
9504bc9d
SR
473
474 write_constant(data->helper->in, "\n");
bfc366d9
FA
475 /*
476 * remote-helpers that advertise the bidi-import capability are required to
477 * buffer the complete batch of import commands until this newline before
478 * sending data to fast-import.
479 * These helpers read back data from fast-import on their stdin, which could
480 * be mixed with import commands, otherwise.
481 */
9504bc9d 482
cc567322
SR
483 if (finish_command(&fastimport))
484 die("Error while running fast-import");
bfc366d9 485 argv_array_free_detached(fastimport.argv);
e65e91ed 486
dff9d65d
FA
487 /*
488 * The fast-import stream of a remote helper that advertises
489 * the "refspec" capability writes to the refs named after the
490 * right hand side of the first refspec matching each ref we
491 * were fetching.
492 *
493 * (If no "refspec" capability was specified, for historical
7a43c554 494 * reasons we default to the equivalent of *:*.)
dff9d65d
FA
495 *
496 * Store the result in to_fetch[i].old_sha1. Callers such
497 * as "git fetch" can use the value to write feedback to the
498 * terminal, populate FETCH_HEAD, and determine what new value
499 * should be written to peer_ref if the update is a
500 * fast-forward or this is a forced update.
501 */
e65e91ed 502 for (i = 0; i < nr_heads; i++) {
72ff8943 503 char *private;
e65e91ed
DB
504 posn = to_fetch[i];
505 if (posn->status & REF_STATUS_UPTODATE)
506 continue;
72ff8943
DB
507 if (data->refspecs)
508 private = apply_refspecs(data->refspecs, data->refspec_nr, posn->name);
509 else
c28cce55 510 private = xstrdup(posn->name);
d51b720f
MH
511 if (private) {
512 read_ref(private, posn->old_sha1);
513 free(private);
514 }
e65e91ed 515 }
b962dbdc 516 strbuf_release(&buf);
e65e91ed
DB
517 return 0;
518}
519
fa8c097c
IL
520static int process_connect_service(struct transport *transport,
521 const char *name, const char *exec)
522{
523 struct helper_data *data = transport->data;
524 struct strbuf cmdbuf = STRBUF_INIT;
525 struct child_process *helper;
526 int r, duped, ret = 0;
527 FILE *input;
528
529 helper = get_helper(transport);
530
531 /*
532 * Yes, dup the pipe another time, as we need unbuffered version
533 * of input pipe as FILE*. fclose() closes the underlying fd and
534 * stream buffering only can be changed before first I/O operation
535 * on it.
536 */
537 duped = dup(helper->out);
538 if (duped < 0)
539 die_errno("Can't dup helper output fd");
540 input = xfdopen(duped, "r");
541 setvbuf(input, NULL, _IONBF, 0);
542
543 /*
544 * Handle --upload-pack and friends. This is fire and forget...
545 * just warn if it fails.
546 */
547 if (strcmp(name, exec)) {
548 r = set_helper_option(transport, "servpath", exec);
549 if (r > 0)
550 warning("Setting remote service path not supported by protocol.");
551 else if (r < 0)
552 warning("Invalid remote service path.");
553 }
554
555 if (data->connect)
556 strbuf_addf(&cmdbuf, "connect %s\n", name);
557 else
558 goto exit;
559
560 sendline(data, &cmdbuf);
5931b33e
FC
561 if (recvline_fh(input, &cmdbuf, name))
562 exit(128);
563
fa8c097c
IL
564 if (!strcmp(cmdbuf.buf, "")) {
565 data->no_disconnect_req = 1;
566 if (debug)
567 fprintf(stderr, "Debug: Smart transport connection "
568 "ready.\n");
569 ret = 1;
570 } else if (!strcmp(cmdbuf.buf, "fallback")) {
571 if (debug)
572 fprintf(stderr, "Debug: Falling back to dumb "
573 "transport.\n");
574 } else
575 die("Unknown response to connect: %s",
576 cmdbuf.buf);
577
578exit:
579 fclose(input);
580 return ret;
581}
582
583static int process_connect(struct transport *transport,
584 int for_push)
585{
586 struct helper_data *data = transport->data;
587 const char *name;
588 const char *exec;
589
590 name = for_push ? "git-receive-pack" : "git-upload-pack";
591 if (for_push)
592 exec = data->transport_options.receivepack;
593 else
594 exec = data->transport_options.uploadpack;
595
596 return process_connect_service(transport, name, exec);
597}
598
b236752a
IL
599static int connect_helper(struct transport *transport, const char *name,
600 const char *exec, int fd[2])
601{
602 struct helper_data *data = transport->data;
603
604 /* Get_helper so connect is inited. */
605 get_helper(transport);
606 if (!data->connect)
607 die("Operation not supported by protocol.");
608
609 if (!process_connect_service(transport, name, exec))
610 die("Can't connect to subservice %s.", name);
611
612 fd[0] = data->helper->out;
613 fd[1] = data->helper->in;
614 return 0;
615}
616
6eb996b5 617static int fetch(struct transport *transport,
37148311 618 int nr_heads, struct ref **to_fetch)
6eb996b5
DB
619{
620 struct helper_data *data = transport->data;
621 int i, count;
622
fa8c097c
IL
623 if (process_connect(transport, 0)) {
624 do_take_over(transport);
625 return transport->fetch(transport, nr_heads, to_fetch);
626 }
627
6eb996b5
DB
628 count = 0;
629 for (i = 0; i < nr_heads; i++)
630 if (!(to_fetch[i]->status & REF_STATUS_UPTODATE))
631 count++;
632
633 if (!count)
634 return 0;
635
636 if (data->fetch)
637 return fetch_with_fetch(transport, nr_heads, to_fetch);
638
e65e91ed
DB
639 if (data->import)
640 return fetch_with_import(transport, nr_heads, to_fetch);
641
6eb996b5
DB
642 return -1;
643}
644
664059fb 645static int push_update_ref_status(struct strbuf *buf,
d2e73c6f
SR
646 struct ref **ref,
647 struct ref *remote_refs)
648{
649 char *refname, *msg;
f9e3c6be 650 int status, forced = 0;
d2e73c6f 651
59556548 652 if (starts_with(buf->buf, "ok ")) {
d2e73c6f
SR
653 status = REF_STATUS_OK;
654 refname = buf->buf + 3;
59556548 655 } else if (starts_with(buf->buf, "error ")) {
d2e73c6f
SR
656 status = REF_STATUS_REMOTE_REJECT;
657 refname = buf->buf + 6;
658 } else
82247e9b 659 die("expected ok/error, helper said '%s'", buf->buf);
d2e73c6f
SR
660
661 msg = strchr(refname, ' ');
662 if (msg) {
663 struct strbuf msg_buf = STRBUF_INIT;
664 const char *end;
665
666 *msg++ = '\0';
667 if (!unquote_c_style(&msg_buf, msg, &end))
668 msg = strbuf_detach(&msg_buf, NULL);
669 else
670 msg = xstrdup(msg);
671 strbuf_release(&msg_buf);
672
673 if (!strcmp(msg, "no match")) {
674 status = REF_STATUS_NONE;
675 free(msg);
676 msg = NULL;
677 }
678 else if (!strcmp(msg, "up to date")) {
679 status = REF_STATUS_UPTODATE;
680 free(msg);
681 msg = NULL;
682 }
683 else if (!strcmp(msg, "non-fast forward")) {
684 status = REF_STATUS_REJECT_NONFASTFORWARD;
685 free(msg);
686 msg = NULL;
687 }
dbfeddb1
CR
688 else if (!strcmp(msg, "already exists")) {
689 status = REF_STATUS_REJECT_ALREADY_EXISTS;
690 free(msg);
691 msg = NULL;
692 }
75e5c0dc
JH
693 else if (!strcmp(msg, "fetch first")) {
694 status = REF_STATUS_REJECT_FETCH_FIRST;
695 free(msg);
696 msg = NULL;
697 }
698 else if (!strcmp(msg, "needs force")) {
699 status = REF_STATUS_REJECT_NEEDS_FORCE;
700 free(msg);
701 msg = NULL;
702 }
631b5ef2
JH
703 else if (!strcmp(msg, "stale info")) {
704 status = REF_STATUS_REJECT_STALE;
705 free(msg);
706 msg = NULL;
707 }
f9e3c6be
FC
708 else if (!strcmp(msg, "forced update")) {
709 forced = 1;
710 free(msg);
711 msg = NULL;
712 }
d2e73c6f
SR
713 }
714
715 if (*ref)
716 *ref = find_ref_by_name(*ref, refname);
717 if (!*ref)
718 *ref = find_ref_by_name(remote_refs, refname);
719 if (!*ref) {
720 warning("helper reported unexpected status of %s", refname);
664059fb 721 return 1;
d2e73c6f
SR
722 }
723
724 if ((*ref)->status != REF_STATUS_NONE) {
725 /*
726 * Earlier, the ref was marked not to be pushed, so ignore the ref
727 * status reported by the remote helper if the latter is 'no match'.
728 */
729 if (status == REF_STATUS_NONE)
664059fb 730 return 1;
d2e73c6f
SR
731 }
732
733 (*ref)->status = status;
cf31f70c 734 (*ref)->forced_update |= forced;
d2e73c6f 735 (*ref)->remote_status = msg;
126aac5c 736 return !(status == REF_STATUS_OK);
d2e73c6f
SR
737}
738
0551a06c 739static int push_update_refs_status(struct helper_data *data,
5a75353f
FC
740 struct ref *remote_refs,
741 int flags)
d2e73c6f
SR
742{
743 struct strbuf buf = STRBUF_INIT;
744 struct ref *ref = remote_refs;
0551a06c
FC
745 int ret = 0;
746
d2e73c6f 747 for (;;) {
664059fb
FC
748 char *private;
749
0551a06c
FC
750 if (recvline(data, &buf)) {
751 ret = 1;
752 break;
753 }
754
d2e73c6f
SR
755 if (!buf.len)
756 break;
757
664059fb
FC
758 if (push_update_ref_status(&buf, &ref, remote_refs))
759 continue;
760
5a75353f 761 if (flags & TRANSPORT_PUSH_DRY_RUN || !data->refspecs || data->no_private_update)
664059fb
FC
762 continue;
763
764 /* propagate back the update to the remote namespace */
765 private = apply_refspecs(data->refspecs, data->refspec_nr, ref->name);
766 if (!private)
767 continue;
768 update_ref("update by helper", private, ref->new_sha1, NULL, 0, 0);
769 free(private);
d2e73c6f
SR
770 }
771 strbuf_release(&buf);
0551a06c 772 return ret;
d2e73c6f
SR
773}
774
73b49a75 775static int push_refs_with_push(struct transport *transport,
05c1eb10 776 struct ref *remote_refs, int flags)
ae4efe19
SP
777{
778 int force_all = flags & TRANSPORT_PUSH_FORCE;
779 int mirror = flags & TRANSPORT_PUSH_MIRROR;
780 struct helper_data *data = transport->data;
781 struct strbuf buf = STRBUF_INIT;
ae4efe19 782 struct ref *ref;
05c1eb10
JH
783 struct string_list cas_options = STRING_LIST_INIT_DUP;
784 struct string_list_item *cas_option;
ae4efe19 785
c0aa335c 786 get_helper(transport);
ae4efe19
SP
787 if (!data->push)
788 return 1;
789
790 for (ref = remote_refs; ref; ref = ref->next) {
20e8b465 791 if (!ref->peer_ref && !mirror)
ae4efe19
SP
792 continue;
793
20e8b465
TRC
794 /* Check for statuses set by set_ref_status_for_push() */
795 switch (ref->status) {
796 case REF_STATUS_REJECT_NONFASTFORWARD:
631b5ef2 797 case REF_STATUS_REJECT_STALE:
dbfeddb1 798 case REF_STATUS_REJECT_ALREADY_EXISTS:
20e8b465 799 case REF_STATUS_UPTODATE:
ae4efe19 800 continue;
20e8b465
TRC
801 default:
802 ; /* do nothing */
ae4efe19
SP
803 }
804
805 if (force_all)
806 ref->force = 1;
807
808 strbuf_addstr(&buf, "push ");
809 if (!ref->deletion) {
810 if (ref->force)
811 strbuf_addch(&buf, '+');
812 if (ref->peer_ref)
813 strbuf_addstr(&buf, ref->peer_ref->name);
814 else
815 strbuf_addstr(&buf, sha1_to_hex(ref->new_sha1));
816 }
817 strbuf_addch(&buf, ':');
818 strbuf_addstr(&buf, ref->name);
819 strbuf_addch(&buf, '\n');
05c1eb10
JH
820
821 /*
822 * The "--force-with-lease" options without explicit
823 * values to expect have already been expanded into
824 * the ref->old_sha1_expect[] field; we can ignore
825 * transport->smart_options->cas altogether and instead
826 * can enumerate them from the refs.
827 */
828 if (ref->expect_old_sha1) {
829 struct strbuf cas = STRBUF_INIT;
830 strbuf_addf(&cas, "%s:%s",
831 ref->name, sha1_to_hex(ref->old_sha1_expect));
832 string_list_append(&cas_options, strbuf_detach(&cas, NULL));
833 }
ae4efe19 834 }
05c1eb10
JH
835 if (buf.len == 0) {
836 string_list_clear(&cas_options, 0);
d8f67d20 837 return 0;
05c1eb10 838 }
ae4efe19 839
ae4efe19 840 standard_options(transport);
05c1eb10
JH
841 for_each_string_list_item(cas_option, &cas_options)
842 set_helper_option(transport, "cas", cas_option->string);
ae4efe19
SP
843
844 if (flags & TRANSPORT_PUSH_DRY_RUN) {
845 if (set_helper_option(transport, "dry-run", "true") != 0)
846 die("helper %s does not support dry-run", data->name);
847 }
848
849 strbuf_addch(&buf, '\n');
bf3c523c 850 sendline(data, &buf);
ae4efe19 851 strbuf_release(&buf);
d2e73c6f 852
0551a06c 853 return push_update_refs_status(data, remote_refs, flags);
ae4efe19
SP
854}
855
73b49a75
SR
856static int push_refs_with_export(struct transport *transport,
857 struct ref *remote_refs, int flags)
858{
859 struct ref *ref;
860 struct child_process *helper, exporter;
861 struct helper_data *data = transport->data;
183113a5 862 struct string_list revlist_args = STRING_LIST_INIT_NODUP;
73b49a75
SR
863 struct strbuf buf = STRBUF_INIT;
864
21610d82
FC
865 if (!data->refspecs)
866 die("remote-helper doesn't support push; refspec needed");
867
21457f57
FC
868 if (flags & TRANSPORT_PUSH_DRY_RUN) {
869 if (set_helper_option(transport, "dry-run", "true") != 0)
870 die("helper %s does not support dry-run", data->name);
871 }
872
510fa6f5
FC
873 if (flags & TRANSPORT_PUSH_FORCE) {
874 if (set_helper_option(transport, "force", "true") != 0)
875 warning("helper %s does not support 'force'", data->name);
876 }
877
73b49a75
SR
878 helper = get_helper(transport);
879
880 write_constant(helper->in, "export\n");
881
73b49a75
SR
882 strbuf_reset(&buf);
883
884 for (ref = remote_refs; ref; ref = ref->next) {
885 char *private;
886 unsigned char sha1[20];
887
9c51558c
FC
888 if (ref->deletion)
889 die("remote-helpers do not support ref deletion");
890
73b49a75
SR
891 private = apply_refspecs(data->refspecs, data->refspec_nr, ref->name);
892 if (private && !get_sha1(private, sha1)) {
893 strbuf_addf(&buf, "^%s", private);
1d2f80fa 894 string_list_append(&revlist_args, strbuf_detach(&buf, NULL));
b056620f 895 hashcpy(ref->old_sha1, sha1);
73b49a75 896 }
2faa1527 897 free(private);
73b49a75 898
67c9c782
FC
899 if (ref->peer_ref) {
900 if (strcmp(ref->peer_ref->name, ref->name))
901 die("remote-helpers do not support old:new syntax");
3ea7d094 902 string_list_append(&revlist_args, ref->peer_ref->name);
67c9c782 903 }
73b49a75
SR
904 }
905
a515ebe9 906 if (get_exporter(transport, &exporter, &revlist_args))
73b49a75
SR
907 die("Couldn't run fast-export");
908
cc567322
SR
909 if (finish_command(&exporter))
910 die("Error while running fast-export");
3994e64d
FC
911 if (push_update_refs_status(data, remote_refs, flags))
912 return 1;
913
914 if (data->export_marks) {
915 strbuf_addf(&buf, "%s.tmp", data->export_marks);
916 rename(buf.buf, data->export_marks);
917 strbuf_release(&buf);
918 }
919
920 return 0;
73b49a75
SR
921}
922
923static int push_refs(struct transport *transport,
924 struct ref *remote_refs, int flags)
925{
926 struct helper_data *data = transport->data;
927
928 if (process_connect(transport, 1)) {
929 do_take_over(transport);
930 return transport->push_refs(transport, remote_refs, flags);
931 }
932
933 if (!remote_refs) {
934 fprintf(stderr, "No refs in common and none specified; doing nothing.\n"
935 "Perhaps you should specify a branch such as 'master'.\n");
936 return 0;
937 }
938
939 if (data->push)
940 return push_refs_with_push(transport, remote_refs, flags);
941
942 if (data->export)
943 return push_refs_with_export(transport, remote_refs, flags);
944
945 return -1;
946}
947
948
f8ec9167
DB
949static int has_attribute(const char *attrs, const char *attr) {
950 int len;
951 if (!attrs)
952 return 0;
953
954 len = strlen(attr);
955 for (;;) {
956 const char *space = strchrnul(attrs, ' ');
957 if (len == space - attrs && !strncmp(attrs, attr, len))
958 return 1;
959 if (!*space)
960 return 0;
961 attrs = space + 1;
962 }
963}
964
6eb996b5
DB
965static struct ref *get_refs_list(struct transport *transport, int for_push)
966{
292ce46b 967 struct helper_data *data = transport->data;
6eb996b5
DB
968 struct child_process *helper;
969 struct ref *ret = NULL;
970 struct ref **tail = &ret;
971 struct ref *posn;
972 struct strbuf buf = STRBUF_INIT;
6eb996b5
DB
973
974 helper = get_helper(transport);
2d14d65c 975
fa8c097c
IL
976 if (process_connect(transport, for_push)) {
977 do_take_over(transport);
978 return transport->get_refs_list(transport, for_push);
979 }
980
ae4efe19
SP
981 if (data->push && for_push)
982 write_str_in_full(helper->in, "list for-push\n");
983 else
984 write_str_in_full(helper->in, "list\n");
6eb996b5 985
6eb996b5
DB
986 while (1) {
987 char *eov, *eon;
5931b33e
FC
988 if (recvline(data, &buf))
989 exit(128);
6eb996b5
DB
990
991 if (!*buf.buf)
992 break;
993
994 eov = strchr(buf.buf, ' ');
995 if (!eov)
996 die("Malformed response in ref list: %s", buf.buf);
997 eon = strchr(eov + 1, ' ');
998 *eov = '\0';
999 if (eon)
1000 *eon = '\0';
1001 *tail = alloc_ref(eov + 1);
1002 if (buf.buf[0] == '@')
1003 (*tail)->symref = xstrdup(buf.buf + 1);
1004 else if (buf.buf[0] != '?')
1005 get_sha1_hex(buf.buf, (*tail)->old_sha1);
f8ec9167
DB
1006 if (eon) {
1007 if (has_attribute(eon + 1, "unchanged")) {
1008 (*tail)->status |= REF_STATUS_UPTODATE;
1009 read_ref((*tail)->name, (*tail)->old_sha1);
1010 }
1011 }
6eb996b5
DB
1012 tail = &((*tail)->next);
1013 }
bf3c523c
IL
1014 if (debug)
1015 fprintf(stderr, "Debug: Read ref listing.\n");
6eb996b5
DB
1016 strbuf_release(&buf);
1017
1018 for (posn = ret; posn; posn = posn->next)
1019 resolve_remote_symref(posn, ret);
1020
1021 return ret;
1022}
1023
c9e388bb 1024int transport_helper_init(struct transport *transport, const char *name)
6eb996b5
DB
1025{
1026 struct helper_data *data = xcalloc(sizeof(*data), 1);
c9e388bb 1027 data->name = name;
6eb996b5 1028
bf3c523c
IL
1029 if (getenv("GIT_TRANSPORT_HELPER_DEBUG"))
1030 debug = 1;
1031
6eb996b5 1032 transport->data = data;
ef08ef9e 1033 transport->set_option = set_helper_option;
6eb996b5
DB
1034 transport->get_refs_list = get_refs_list;
1035 transport->fetch = fetch;
ae4efe19 1036 transport->push_refs = push_refs;
f2a37151 1037 transport->disconnect = release_helper;
b236752a 1038 transport->connect = connect_helper;
61b075bd 1039 transport->smart_options = &(data->transport_options);
6eb996b5
DB
1040 return 0;
1041}
419f37db
IL
1042
1043/*
1044 * Linux pipes can buffer 65536 bytes at once (and most platforms can
1045 * buffer less), so attempt reads and writes with up to that size.
1046 */
1047#define BUFFERSIZE 65536
1048/* This should be enough to hold debugging message. */
1049#define PBUFFERSIZE 8192
1050
1051/* Print bidirectional transfer loop debug message. */
4621085b 1052__attribute__((format (printf, 1, 2)))
419f37db
IL
1053static void transfer_debug(const char *fmt, ...)
1054{
1055 va_list args;
1056 char msgbuf[PBUFFERSIZE];
1057 static int debug_enabled = -1;
1058
1059 if (debug_enabled < 0)
1060 debug_enabled = getenv("GIT_TRANSLOOP_DEBUG") ? 1 : 0;
1061 if (!debug_enabled)
1062 return;
1063
1064 va_start(args, fmt);
1065 vsnprintf(msgbuf, PBUFFERSIZE, fmt, args);
1066 va_end(args);
1067 fprintf(stderr, "Transfer loop debugging: %s\n", msgbuf);
1068}
1069
1070/* Stream state: More data may be coming in this direction. */
1071#define SSTATE_TRANSFERING 0
1072/*
1073 * Stream state: No more data coming in this direction, flushing rest of
1074 * data.
1075 */
1076#define SSTATE_FLUSHING 1
1077/* Stream state: Transfer in this direction finished. */
1078#define SSTATE_FINISHED 2
1079
1080#define STATE_NEEDS_READING(state) ((state) <= SSTATE_TRANSFERING)
1081#define STATE_NEEDS_WRITING(state) ((state) <= SSTATE_FLUSHING)
1082#define STATE_NEEDS_CLOSING(state) ((state) == SSTATE_FLUSHING)
1083
1084/* Unidirectional transfer. */
1085struct unidirectional_transfer {
1086 /* Source */
1087 int src;
1088 /* Destination */
1089 int dest;
1090 /* Is source socket? */
1091 int src_is_sock;
1092 /* Is destination socket? */
1093 int dest_is_sock;
41ccfdd9 1094 /* Transfer state (TRANSFERRING/FLUSHING/FINISHED) */
419f37db
IL
1095 int state;
1096 /* Buffer. */
1097 char buf[BUFFERSIZE];
1098 /* Buffer used. */
1099 size_t bufuse;
1100 /* Name of source. */
1101 const char *src_name;
1102 /* Name of destination. */
1103 const char *dest_name;
1104};
1105
1106/* Closes the target (for writing) if transfer has finished. */
1107static void udt_close_if_finished(struct unidirectional_transfer *t)
1108{
1109 if (STATE_NEEDS_CLOSING(t->state) && !t->bufuse) {
1110 t->state = SSTATE_FINISHED;
1111 if (t->dest_is_sock)
1112 shutdown(t->dest, SHUT_WR);
1113 else
1114 close(t->dest);
1115 transfer_debug("Closed %s.", t->dest_name);
1116 }
1117}
1118
1119/*
1120 * Tries to read read data from source into buffer. If buffer is full,
1121 * no data is read. Returns 0 on success, -1 on error.
1122 */
1123static int udt_do_read(struct unidirectional_transfer *t)
1124{
1125 ssize_t bytes;
1126
1127 if (t->bufuse == BUFFERSIZE)
1128 return 0; /* No space for more. */
1129
1130 transfer_debug("%s is readable", t->src_name);
1131 bytes = read(t->src, t->buf + t->bufuse, BUFFERSIZE - t->bufuse);
1132 if (bytes < 0 && errno != EWOULDBLOCK && errno != EAGAIN &&
1133 errno != EINTR) {
1134 error("read(%s) failed: %s", t->src_name, strerror(errno));
1135 return -1;
1136 } else if (bytes == 0) {
1137 transfer_debug("%s EOF (with %i bytes in buffer)",
4621085b 1138 t->src_name, (int)t->bufuse);
419f37db
IL
1139 t->state = SSTATE_FLUSHING;
1140 } else if (bytes > 0) {
1141 t->bufuse += bytes;
1142 transfer_debug("Read %i bytes from %s (buffer now at %i)",
1143 (int)bytes, t->src_name, (int)t->bufuse);
1144 }
1145 return 0;
1146}
1147
1148/* Tries to write data from buffer into destination. If buffer is empty,
1149 * no data is written. Returns 0 on success, -1 on error.
1150 */
1151static int udt_do_write(struct unidirectional_transfer *t)
1152{
803dbdb9 1153 ssize_t bytes;
419f37db
IL
1154
1155 if (t->bufuse == 0)
1156 return 0; /* Nothing to write. */
1157
1158 transfer_debug("%s is writable", t->dest_name);
7edc02f4
EFL
1159 bytes = xwrite(t->dest, t->buf, t->bufuse);
1160 if (bytes < 0 && errno != EWOULDBLOCK) {
419f37db
IL
1161 error("write(%s) failed: %s", t->dest_name, strerror(errno));
1162 return -1;
1163 } else if (bytes > 0) {
1164 t->bufuse -= bytes;
1165 if (t->bufuse)
1166 memmove(t->buf, t->buf + bytes, t->bufuse);
1167 transfer_debug("Wrote %i bytes to %s (buffer now at %i)",
1168 (int)bytes, t->dest_name, (int)t->bufuse);
1169 }
1170 return 0;
1171}
1172
1173
1174/* State of bidirectional transfer loop. */
1175struct bidirectional_transfer_state {
1176 /* Direction from program to git. */
1177 struct unidirectional_transfer ptg;
1178 /* Direction from git to program. */
1179 struct unidirectional_transfer gtp;
1180};
1181
1182static void *udt_copy_task_routine(void *udt)
1183{
1184 struct unidirectional_transfer *t = (struct unidirectional_transfer *)udt;
1185 while (t->state != SSTATE_FINISHED) {
1186 if (STATE_NEEDS_READING(t->state))
1187 if (udt_do_read(t))
1188 return NULL;
1189 if (STATE_NEEDS_WRITING(t->state))
1190 if (udt_do_write(t))
1191 return NULL;
1192 if (STATE_NEEDS_CLOSING(t->state))
1193 udt_close_if_finished(t);
1194 }
1195 return udt; /* Just some non-NULL value. */
1196}
1197
1198#ifndef NO_PTHREADS
1199
1200/*
98e023de 1201 * Join thread, with appropriate errors on failure. Name is name for the
419f37db
IL
1202 * thread (for error messages). Returns 0 on success, 1 on failure.
1203 */
1204static int tloop_join(pthread_t thread, const char *name)
1205{
1206 int err;
1207 void *tret;
1208 err = pthread_join(thread, &tret);
1209 if (!tret) {
1210 error("%s thread failed", name);
1211 return 1;
1212 }
1213 if (err) {
1214 error("%s thread failed to join: %s", name, strerror(err));
1215 return 1;
1216 }
1217 return 0;
1218}
1219
1220/*
1221 * Spawn the transfer tasks and then wait for them. Returns 0 on success,
1222 * -1 on failure.
1223 */
1224static int tloop_spawnwait_tasks(struct bidirectional_transfer_state *s)
1225{
1226 pthread_t gtp_thread;
1227 pthread_t ptg_thread;
1228 int err;
1229 int ret = 0;
1230 err = pthread_create(&gtp_thread, NULL, udt_copy_task_routine,
1231 &s->gtp);
1232 if (err)
1233 die("Can't start thread for copying data: %s", strerror(err));
1234 err = pthread_create(&ptg_thread, NULL, udt_copy_task_routine,
1235 &s->ptg);
1236 if (err)
1237 die("Can't start thread for copying data: %s", strerror(err));
1238
1239 ret |= tloop_join(gtp_thread, "Git to program copy");
1240 ret |= tloop_join(ptg_thread, "Program to git copy");
1241 return ret;
1242}
1243#else
1244
1245/* Close the source and target (for writing) for transfer. */
1246static void udt_kill_transfer(struct unidirectional_transfer *t)
1247{
1248 t->state = SSTATE_FINISHED;
1249 /*
1250 * Socket read end left open isn't a disaster if nobody
1251 * attempts to read from it (mingw compat headers do not
1252 * have SHUT_RD)...
1253 *
1254 * We can't fully close the socket since otherwise gtp
1255 * task would first close the socket it sends data to
1256 * while closing the ptg file descriptors.
1257 */
1258 if (!t->src_is_sock)
1259 close(t->src);
1260 if (t->dest_is_sock)
1261 shutdown(t->dest, SHUT_WR);
1262 else
1263 close(t->dest);
1264}
1265
1266/*
98e023de 1267 * Join process, with appropriate errors on failure. Name is name for the
419f37db
IL
1268 * process (for error messages). Returns 0 on success, 1 on failure.
1269 */
1270static int tloop_join(pid_t pid, const char *name)
1271{
1272 int tret;
1273 if (waitpid(pid, &tret, 0) < 0) {
1274 error("%s process failed to wait: %s", name, strerror(errno));
1275 return 1;
1276 }
1277 if (!WIFEXITED(tret) || WEXITSTATUS(tret)) {
1278 error("%s process failed", name);
1279 return 1;
1280 }
1281 return 0;
1282}
1283
1284/*
1285 * Spawn the transfer tasks and then wait for them. Returns 0 on success,
1286 * -1 on failure.
1287 */
1288static int tloop_spawnwait_tasks(struct bidirectional_transfer_state *s)
1289{
1290 pid_t pid1, pid2;
1291 int ret = 0;
1292
1293 /* Fork thread #1: git to program. */
1294 pid1 = fork();
1295 if (pid1 < 0)
1296 die_errno("Can't start thread for copying data");
1297 else if (pid1 == 0) {
1298 udt_kill_transfer(&s->ptg);
1299 exit(udt_copy_task_routine(&s->gtp) ? 0 : 1);
1300 }
1301
1302 /* Fork thread #2: program to git. */
1303 pid2 = fork();
1304 if (pid2 < 0)
1305 die_errno("Can't start thread for copying data");
1306 else if (pid2 == 0) {
1307 udt_kill_transfer(&s->gtp);
1308 exit(udt_copy_task_routine(&s->ptg) ? 0 : 1);
1309 }
1310
1311 /*
1312 * Close both streams in parent as to not interfere with
1313 * end of file detection and wait for both tasks to finish.
1314 */
1315 udt_kill_transfer(&s->gtp);
1316 udt_kill_transfer(&s->ptg);
1317 ret |= tloop_join(pid1, "Git to program copy");
1318 ret |= tloop_join(pid2, "Program to git copy");
1319 return ret;
1320}
1321#endif
1322
1323/*
1324 * Copies data from stdin to output and from input to stdout simultaneously.
1325 * Additionally filtering through given filter. If filter is NULL, uses
1326 * identity filter.
1327 */
1328int bidirectional_transfer_loop(int input, int output)
1329{
1330 struct bidirectional_transfer_state state;
1331
1332 /* Fill the state fields. */
1333 state.ptg.src = input;
1334 state.ptg.dest = 1;
1335 state.ptg.src_is_sock = (input == output);
1336 state.ptg.dest_is_sock = 0;
1337 state.ptg.state = SSTATE_TRANSFERING;
1338 state.ptg.bufuse = 0;
1339 state.ptg.src_name = "remote input";
1340 state.ptg.dest_name = "stdout";
1341
1342 state.gtp.src = 0;
1343 state.gtp.dest = output;
1344 state.gtp.src_is_sock = 0;
1345 state.gtp.dest_is_sock = (input == output);
1346 state.gtp.state = SSTATE_TRANSFERING;
1347 state.gtp.bufuse = 0;
1348 state.gtp.src_name = "stdin";
1349 state.gtp.dest_name = "remote output";
1350
1351 return tloop_spawnwait_tasks(&state);
1352}