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