mirror of
https://github.com/git/git.git
synced 2024-12-15 04:46:02 +08:00
9c1e657a8f
Currently, the packfile negotiation step within a Git fetch cannot be done independent of sending the packfile, even though there is at least one application wherein this is useful. Therefore, make it possible for this negotiation step to be done independently. A subsequent commit will use this for one such application - push negotiation. This feature is for protocol v2 only. (An implementation for protocol v0 would require a separate implementation in the fetch, transport, and transport helper code.) In the protocol, the main hindrance towards independent negotiation is that the server can unilaterally decide to send the packfile. This is solved by a "wait-for-done" argument: the server will then wait for the client to say "done". In practice, the client will never say it; instead it will cease requests once it is satisfied. In the client, the main change lies in the transport and transport helper code. fetch_refs_via_pack() performs everything needed - protocol version and capability checks, and the negotiation itself. There are 2 code paths that do not go through fetch_refs_via_pack() that needed to be individually excluded: the bundle transport (excluded through requiring smart_options, which the bundle transport doesn't support) and transport helpers that do not support takeover. If or when we support independent negotiation for protocol v0, we will need to modify these 2 code paths to support it. But for now, report failure if independent negotiation is requested in these cases. Signed-off-by: Jonathan Tan <jonathantanmy@google.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
1626 lines
42 KiB
C
1626 lines
42 KiB
C
#include "cache.h"
|
|
#include "transport.h"
|
|
#include "quote.h"
|
|
#include "run-command.h"
|
|
#include "commit.h"
|
|
#include "diff.h"
|
|
#include "revision.h"
|
|
#include "remote.h"
|
|
#include "string-list.h"
|
|
#include "thread-utils.h"
|
|
#include "sigchain.h"
|
|
#include "strvec.h"
|
|
#include "refs.h"
|
|
#include "refspec.h"
|
|
#include "transport-internal.h"
|
|
#include "protocol.h"
|
|
|
|
static int debug;
|
|
|
|
struct helper_data {
|
|
const char *name;
|
|
struct child_process *helper;
|
|
FILE *out;
|
|
unsigned fetch : 1,
|
|
import : 1,
|
|
bidi_import : 1,
|
|
export : 1,
|
|
option : 1,
|
|
push : 1,
|
|
connect : 1,
|
|
stateless_connect : 1,
|
|
signed_tags : 1,
|
|
check_connectivity : 1,
|
|
no_disconnect_req : 1,
|
|
no_private_update : 1,
|
|
object_format : 1;
|
|
|
|
/*
|
|
* As an optimization, the transport code may invoke fetch before
|
|
* get_refs_list. If this happens, and if the transport helper doesn't
|
|
* support connect or stateless_connect, we need to invoke
|
|
* get_refs_list ourselves if we haven't already done so. Keep track of
|
|
* whether we have invoked get_refs_list.
|
|
*/
|
|
unsigned get_refs_list_called : 1;
|
|
|
|
char *export_marks;
|
|
char *import_marks;
|
|
/* These go from remote name (as in "list") to private name */
|
|
struct refspec rs;
|
|
/* Transport options for fetch-pack/send-pack (should one of
|
|
* those be invoked).
|
|
*/
|
|
struct git_transport_options transport_options;
|
|
};
|
|
|
|
static void sendline(struct helper_data *helper, struct strbuf *buffer)
|
|
{
|
|
if (debug)
|
|
fprintf(stderr, "Debug: Remote helper: -> %s", buffer->buf);
|
|
if (write_in_full(helper->helper->in, buffer->buf, buffer->len) < 0)
|
|
die_errno(_("full write to remote helper failed"));
|
|
}
|
|
|
|
static int recvline_fh(FILE *helper, struct strbuf *buffer)
|
|
{
|
|
strbuf_reset(buffer);
|
|
if (debug)
|
|
fprintf(stderr, "Debug: Remote helper: Waiting...\n");
|
|
if (strbuf_getline(buffer, helper) == EOF) {
|
|
if (debug)
|
|
fprintf(stderr, "Debug: Remote helper quit.\n");
|
|
return 1;
|
|
}
|
|
|
|
if (debug)
|
|
fprintf(stderr, "Debug: Remote helper: <- %s\n", buffer->buf);
|
|
return 0;
|
|
}
|
|
|
|
static int recvline(struct helper_data *helper, struct strbuf *buffer)
|
|
{
|
|
return recvline_fh(helper->out, buffer);
|
|
}
|
|
|
|
static void write_constant(int fd, const char *str)
|
|
{
|
|
if (debug)
|
|
fprintf(stderr, "Debug: Remote helper: -> %s", str);
|
|
if (write_in_full(fd, str, strlen(str)) < 0)
|
|
die_errno(_("full write to remote helper failed"));
|
|
}
|
|
|
|
static const char *remove_ext_force(const char *url)
|
|
{
|
|
if (url) {
|
|
const char *colon = strchr(url, ':');
|
|
if (colon && colon[1] == ':')
|
|
return colon + 2;
|
|
}
|
|
return url;
|
|
}
|
|
|
|
static void do_take_over(struct transport *transport)
|
|
{
|
|
struct helper_data *data;
|
|
data = (struct helper_data *)transport->data;
|
|
transport_take_over(transport, data->helper);
|
|
fclose(data->out);
|
|
free(data);
|
|
}
|
|
|
|
static void standard_options(struct transport *t);
|
|
|
|
static struct child_process *get_helper(struct transport *transport)
|
|
{
|
|
struct helper_data *data = transport->data;
|
|
struct strbuf buf = STRBUF_INIT;
|
|
struct child_process *helper;
|
|
int duped;
|
|
int code;
|
|
|
|
if (data->helper)
|
|
return data->helper;
|
|
|
|
helper = xmalloc(sizeof(*helper));
|
|
child_process_init(helper);
|
|
helper->in = -1;
|
|
helper->out = -1;
|
|
helper->err = 0;
|
|
strvec_pushf(&helper->args, "remote-%s", data->name);
|
|
strvec_push(&helper->args, transport->remote->name);
|
|
strvec_push(&helper->args, remove_ext_force(transport->url));
|
|
helper->git_cmd = 1;
|
|
helper->silent_exec_failure = 1;
|
|
|
|
if (have_git_dir())
|
|
strvec_pushf(&helper->env_array, "%s=%s",
|
|
GIT_DIR_ENVIRONMENT, get_git_dir());
|
|
|
|
helper->trace2_child_class = helper->args.v[0]; /* "remote-<name>" */
|
|
|
|
code = start_command(helper);
|
|
if (code < 0 && errno == ENOENT)
|
|
die(_("unable to find remote helper for '%s'"), data->name);
|
|
else if (code != 0)
|
|
exit(code);
|
|
|
|
data->helper = helper;
|
|
data->no_disconnect_req = 0;
|
|
refspec_init(&data->rs, REFSPEC_FETCH);
|
|
|
|
/*
|
|
* Open the output as FILE* so strbuf_getline_*() family of
|
|
* functions can be used.
|
|
* Do this with duped fd because fclose() will close the fd,
|
|
* and stuff like taking over will require the fd to remain.
|
|
*/
|
|
duped = dup(helper->out);
|
|
if (duped < 0)
|
|
die_errno(_("can't dup helper output fd"));
|
|
data->out = xfdopen(duped, "r");
|
|
|
|
write_constant(helper->in, "capabilities\n");
|
|
|
|
while (1) {
|
|
const char *capname, *arg;
|
|
int mandatory = 0;
|
|
if (recvline(data, &buf))
|
|
exit(128);
|
|
|
|
if (!*buf.buf)
|
|
break;
|
|
|
|
if (*buf.buf == '*') {
|
|
capname = buf.buf + 1;
|
|
mandatory = 1;
|
|
} else
|
|
capname = buf.buf;
|
|
|
|
if (debug)
|
|
fprintf(stderr, "Debug: Got cap %s\n", capname);
|
|
if (!strcmp(capname, "fetch"))
|
|
data->fetch = 1;
|
|
else if (!strcmp(capname, "option"))
|
|
data->option = 1;
|
|
else if (!strcmp(capname, "push"))
|
|
data->push = 1;
|
|
else if (!strcmp(capname, "import"))
|
|
data->import = 1;
|
|
else if (!strcmp(capname, "bidi-import"))
|
|
data->bidi_import = 1;
|
|
else if (!strcmp(capname, "export"))
|
|
data->export = 1;
|
|
else if (!strcmp(capname, "check-connectivity"))
|
|
data->check_connectivity = 1;
|
|
else if (skip_prefix(capname, "refspec ", &arg)) {
|
|
refspec_append(&data->rs, arg);
|
|
} else if (!strcmp(capname, "connect")) {
|
|
data->connect = 1;
|
|
} else if (!strcmp(capname, "stateless-connect")) {
|
|
data->stateless_connect = 1;
|
|
} else if (!strcmp(capname, "signed-tags")) {
|
|
data->signed_tags = 1;
|
|
} else if (skip_prefix(capname, "export-marks ", &arg)) {
|
|
data->export_marks = xstrdup(arg);
|
|
} else if (skip_prefix(capname, "import-marks ", &arg)) {
|
|
data->import_marks = xstrdup(arg);
|
|
} else if (starts_with(capname, "no-private-update")) {
|
|
data->no_private_update = 1;
|
|
} else if (starts_with(capname, "object-format")) {
|
|
data->object_format = 1;
|
|
} else if (mandatory) {
|
|
die(_("unknown mandatory capability %s; this remote "
|
|
"helper probably needs newer version of Git"),
|
|
capname);
|
|
}
|
|
}
|
|
if (!data->rs.nr && (data->import || data->bidi_import || data->export)) {
|
|
warning(_("this remote helper should implement refspec capability"));
|
|
}
|
|
strbuf_release(&buf);
|
|
if (debug)
|
|
fprintf(stderr, "Debug: Capabilities complete.\n");
|
|
standard_options(transport);
|
|
return data->helper;
|
|
}
|
|
|
|
static int disconnect_helper(struct transport *transport)
|
|
{
|
|
struct helper_data *data = transport->data;
|
|
int res = 0;
|
|
|
|
if (data->helper) {
|
|
if (debug)
|
|
fprintf(stderr, "Debug: Disconnecting.\n");
|
|
if (!data->no_disconnect_req) {
|
|
/*
|
|
* Ignore write errors; there's nothing we can do,
|
|
* since we're about to close the pipe anyway. And the
|
|
* most likely error is EPIPE due to the helper dying
|
|
* to report an error itself.
|
|
*/
|
|
sigchain_push(SIGPIPE, SIG_IGN);
|
|
xwrite(data->helper->in, "\n", 1);
|
|
sigchain_pop(SIGPIPE);
|
|
}
|
|
close(data->helper->in);
|
|
close(data->helper->out);
|
|
fclose(data->out);
|
|
res = finish_command(data->helper);
|
|
FREE_AND_NULL(data->helper);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
static const char *unsupported_options[] = {
|
|
TRANS_OPT_UPLOADPACK,
|
|
TRANS_OPT_RECEIVEPACK,
|
|
TRANS_OPT_THIN,
|
|
TRANS_OPT_KEEP
|
|
};
|
|
|
|
static const char *boolean_options[] = {
|
|
TRANS_OPT_THIN,
|
|
TRANS_OPT_KEEP,
|
|
TRANS_OPT_FOLLOWTAGS,
|
|
TRANS_OPT_DEEPEN_RELATIVE
|
|
};
|
|
|
|
static int strbuf_set_helper_option(struct helper_data *data,
|
|
struct strbuf *buf)
|
|
{
|
|
int ret;
|
|
|
|
sendline(data, buf);
|
|
if (recvline(data, buf))
|
|
exit(128);
|
|
|
|
if (!strcmp(buf->buf, "ok"))
|
|
ret = 0;
|
|
else if (starts_with(buf->buf, "error"))
|
|
ret = -1;
|
|
else if (!strcmp(buf->buf, "unsupported"))
|
|
ret = 1;
|
|
else {
|
|
warning(_("%s unexpectedly said: '%s'"), data->name, buf->buf);
|
|
ret = 1;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int string_list_set_helper_option(struct helper_data *data,
|
|
const char *name,
|
|
struct string_list *list)
|
|
{
|
|
struct strbuf buf = STRBUF_INIT;
|
|
int i, ret = 0;
|
|
|
|
for (i = 0; i < list->nr; i++) {
|
|
strbuf_addf(&buf, "option %s ", name);
|
|
quote_c_style(list->items[i].string, &buf, NULL, 0);
|
|
strbuf_addch(&buf, '\n');
|
|
|
|
if ((ret = strbuf_set_helper_option(data, &buf)))
|
|
break;
|
|
strbuf_reset(&buf);
|
|
}
|
|
strbuf_release(&buf);
|
|
return ret;
|
|
}
|
|
|
|
static int set_helper_option(struct transport *transport,
|
|
const char *name, const char *value)
|
|
{
|
|
struct helper_data *data = transport->data;
|
|
struct strbuf buf = STRBUF_INIT;
|
|
int i, ret, is_bool = 0;
|
|
|
|
get_helper(transport);
|
|
|
|
if (!data->option)
|
|
return 1;
|
|
|
|
if (!strcmp(name, "deepen-not"))
|
|
return string_list_set_helper_option(data, name,
|
|
(struct string_list *)value);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(unsupported_options); i++) {
|
|
if (!strcmp(name, unsupported_options[i]))
|
|
return 1;
|
|
}
|
|
|
|
for (i = 0; i < ARRAY_SIZE(boolean_options); i++) {
|
|
if (!strcmp(name, boolean_options[i])) {
|
|
is_bool = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
strbuf_addf(&buf, "option %s ", name);
|
|
if (is_bool)
|
|
strbuf_addstr(&buf, value ? "true" : "false");
|
|
else
|
|
quote_c_style(value, &buf, NULL, 0);
|
|
strbuf_addch(&buf, '\n');
|
|
|
|
ret = strbuf_set_helper_option(data, &buf);
|
|
strbuf_release(&buf);
|
|
return ret;
|
|
}
|
|
|
|
static void standard_options(struct transport *t)
|
|
{
|
|
char buf[16];
|
|
int v = t->verbose;
|
|
|
|
set_helper_option(t, "progress", t->progress ? "true" : "false");
|
|
|
|
xsnprintf(buf, sizeof(buf), "%d", v + 1);
|
|
set_helper_option(t, "verbosity", buf);
|
|
|
|
switch (t->family) {
|
|
case TRANSPORT_FAMILY_ALL:
|
|
/*
|
|
* this is already the default,
|
|
* do not break old remote helpers by setting "all" here
|
|
*/
|
|
break;
|
|
case TRANSPORT_FAMILY_IPV4:
|
|
set_helper_option(t, "family", "ipv4");
|
|
break;
|
|
case TRANSPORT_FAMILY_IPV6:
|
|
set_helper_option(t, "family", "ipv6");
|
|
break;
|
|
}
|
|
}
|
|
|
|
static int release_helper(struct transport *transport)
|
|
{
|
|
int res = 0;
|
|
struct helper_data *data = transport->data;
|
|
refspec_clear(&data->rs);
|
|
res = disconnect_helper(transport);
|
|
free(transport->data);
|
|
return res;
|
|
}
|
|
|
|
static int fetch_with_fetch(struct transport *transport,
|
|
int nr_heads, struct ref **to_fetch)
|
|
{
|
|
struct helper_data *data = transport->data;
|
|
int i;
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
for (i = 0; i < nr_heads; i++) {
|
|
const struct ref *posn = to_fetch[i];
|
|
if (posn->status & REF_STATUS_UPTODATE)
|
|
continue;
|
|
|
|
strbuf_addf(&buf, "fetch %s %s\n",
|
|
oid_to_hex(&posn->old_oid),
|
|
posn->symref ? posn->symref : posn->name);
|
|
}
|
|
|
|
strbuf_addch(&buf, '\n');
|
|
sendline(data, &buf);
|
|
|
|
while (1) {
|
|
const char *name;
|
|
|
|
if (recvline(data, &buf))
|
|
exit(128);
|
|
|
|
if (skip_prefix(buf.buf, "lock ", &name)) {
|
|
if (transport->pack_lockfiles.nr)
|
|
warning(_("%s also locked %s"), data->name, name);
|
|
else
|
|
string_list_append(&transport->pack_lockfiles,
|
|
name);
|
|
}
|
|
else if (data->check_connectivity &&
|
|
data->transport_options.check_self_contained_and_connected &&
|
|
!strcmp(buf.buf, "connectivity-ok"))
|
|
data->transport_options.self_contained_and_connected = 1;
|
|
else if (!buf.len)
|
|
break;
|
|
else
|
|
warning(_("%s unexpectedly said: '%s'"), data->name, buf.buf);
|
|
}
|
|
strbuf_release(&buf);
|
|
return 0;
|
|
}
|
|
|
|
static int get_importer(struct transport *transport, struct child_process *fastimport)
|
|
{
|
|
struct child_process *helper = get_helper(transport);
|
|
struct helper_data *data = transport->data;
|
|
int cat_blob_fd, code;
|
|
child_process_init(fastimport);
|
|
fastimport->in = xdup(helper->out);
|
|
strvec_push(&fastimport->args, "fast-import");
|
|
strvec_push(&fastimport->args, "--allow-unsafe-features");
|
|
strvec_push(&fastimport->args, debug ? "--stats" : "--quiet");
|
|
|
|
if (data->bidi_import) {
|
|
cat_blob_fd = xdup(helper->in);
|
|
strvec_pushf(&fastimport->args, "--cat-blob-fd=%d", cat_blob_fd);
|
|
}
|
|
fastimport->git_cmd = 1;
|
|
|
|
code = start_command(fastimport);
|
|
return code;
|
|
}
|
|
|
|
static int get_exporter(struct transport *transport,
|
|
struct child_process *fastexport,
|
|
struct string_list *revlist_args)
|
|
{
|
|
struct helper_data *data = transport->data;
|
|
struct child_process *helper = get_helper(transport);
|
|
int i;
|
|
|
|
child_process_init(fastexport);
|
|
|
|
/* we need to duplicate helper->in because we want to use it after
|
|
* fastexport is done with it. */
|
|
fastexport->out = dup(helper->in);
|
|
strvec_push(&fastexport->args, "fast-export");
|
|
strvec_push(&fastexport->args, "--use-done-feature");
|
|
strvec_push(&fastexport->args, data->signed_tags ?
|
|
"--signed-tags=verbatim" : "--signed-tags=warn-strip");
|
|
if (data->export_marks)
|
|
strvec_pushf(&fastexport->args, "--export-marks=%s.tmp", data->export_marks);
|
|
if (data->import_marks)
|
|
strvec_pushf(&fastexport->args, "--import-marks=%s", data->import_marks);
|
|
|
|
for (i = 0; i < revlist_args->nr; i++)
|
|
strvec_push(&fastexport->args, revlist_args->items[i].string);
|
|
|
|
fastexport->git_cmd = 1;
|
|
return start_command(fastexport);
|
|
}
|
|
|
|
static int fetch_with_import(struct transport *transport,
|
|
int nr_heads, struct ref **to_fetch)
|
|
{
|
|
struct child_process fastimport;
|
|
struct helper_data *data = transport->data;
|
|
int i;
|
|
struct ref *posn;
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
get_helper(transport);
|
|
|
|
if (get_importer(transport, &fastimport))
|
|
die(_("couldn't run fast-import"));
|
|
|
|
for (i = 0; i < nr_heads; i++) {
|
|
posn = to_fetch[i];
|
|
if (posn->status & REF_STATUS_UPTODATE)
|
|
continue;
|
|
|
|
strbuf_addf(&buf, "import %s\n",
|
|
posn->symref ? posn->symref : posn->name);
|
|
sendline(data, &buf);
|
|
strbuf_reset(&buf);
|
|
}
|
|
|
|
write_constant(data->helper->in, "\n");
|
|
/*
|
|
* remote-helpers that advertise the bidi-import capability are required to
|
|
* buffer the complete batch of import commands until this newline before
|
|
* sending data to fast-import.
|
|
* These helpers read back data from fast-import on their stdin, which could
|
|
* be mixed with import commands, otherwise.
|
|
*/
|
|
|
|
if (finish_command(&fastimport))
|
|
die(_("error while running fast-import"));
|
|
|
|
/*
|
|
* The fast-import stream of a remote helper that advertises
|
|
* the "refspec" capability writes to the refs named after the
|
|
* right hand side of the first refspec matching each ref we
|
|
* were fetching.
|
|
*
|
|
* (If no "refspec" capability was specified, for historical
|
|
* reasons we default to the equivalent of *:*.)
|
|
*
|
|
* Store the result in to_fetch[i].old_sha1. Callers such
|
|
* as "git fetch" can use the value to write feedback to the
|
|
* terminal, populate FETCH_HEAD, and determine what new value
|
|
* should be written to peer_ref if the update is a
|
|
* fast-forward or this is a forced update.
|
|
*/
|
|
for (i = 0; i < nr_heads; i++) {
|
|
char *private, *name;
|
|
posn = to_fetch[i];
|
|
if (posn->status & REF_STATUS_UPTODATE)
|
|
continue;
|
|
name = posn->symref ? posn->symref : posn->name;
|
|
if (data->rs.nr)
|
|
private = apply_refspecs(&data->rs, name);
|
|
else
|
|
private = xstrdup(name);
|
|
if (private) {
|
|
if (read_ref(private, &posn->old_oid) < 0)
|
|
die(_("could not read ref %s"), private);
|
|
free(private);
|
|
}
|
|
}
|
|
strbuf_release(&buf);
|
|
return 0;
|
|
}
|
|
|
|
static int run_connect(struct transport *transport, struct strbuf *cmdbuf)
|
|
{
|
|
struct helper_data *data = transport->data;
|
|
int ret = 0;
|
|
int duped;
|
|
FILE *input;
|
|
struct child_process *helper;
|
|
|
|
helper = get_helper(transport);
|
|
|
|
/*
|
|
* Yes, dup the pipe another time, as we need unbuffered version
|
|
* of input pipe as FILE*. fclose() closes the underlying fd and
|
|
* stream buffering only can be changed before first I/O operation
|
|
* on it.
|
|
*/
|
|
duped = dup(helper->out);
|
|
if (duped < 0)
|
|
die_errno(_("can't dup helper output fd"));
|
|
input = xfdopen(duped, "r");
|
|
setvbuf(input, NULL, _IONBF, 0);
|
|
|
|
sendline(data, cmdbuf);
|
|
if (recvline_fh(input, cmdbuf))
|
|
exit(128);
|
|
|
|
if (!strcmp(cmdbuf->buf, "")) {
|
|
data->no_disconnect_req = 1;
|
|
if (debug)
|
|
fprintf(stderr, "Debug: Smart transport connection "
|
|
"ready.\n");
|
|
ret = 1;
|
|
} else if (!strcmp(cmdbuf->buf, "fallback")) {
|
|
if (debug)
|
|
fprintf(stderr, "Debug: Falling back to dumb "
|
|
"transport.\n");
|
|
} else {
|
|
die(_("unknown response to connect: %s"),
|
|
cmdbuf->buf);
|
|
}
|
|
|
|
fclose(input);
|
|
return ret;
|
|
}
|
|
|
|
static int process_connect_service(struct transport *transport,
|
|
const char *name, const char *exec)
|
|
{
|
|
struct helper_data *data = transport->data;
|
|
struct strbuf cmdbuf = STRBUF_INIT;
|
|
int ret = 0;
|
|
|
|
/*
|
|
* Handle --upload-pack and friends. This is fire and forget...
|
|
* just warn if it fails.
|
|
*/
|
|
if (strcmp(name, exec)) {
|
|
int r = set_helper_option(transport, "servpath", exec);
|
|
if (r > 0)
|
|
warning(_("setting remote service path not supported by protocol"));
|
|
else if (r < 0)
|
|
warning(_("invalid remote service path"));
|
|
}
|
|
|
|
if (data->connect) {
|
|
strbuf_addf(&cmdbuf, "connect %s\n", name);
|
|
ret = run_connect(transport, &cmdbuf);
|
|
} else if (data->stateless_connect &&
|
|
(get_protocol_version_config() == protocol_v2) &&
|
|
!strcmp("git-upload-pack", name)) {
|
|
strbuf_addf(&cmdbuf, "stateless-connect %s\n", name);
|
|
ret = run_connect(transport, &cmdbuf);
|
|
if (ret)
|
|
transport->stateless_rpc = 1;
|
|
}
|
|
|
|
strbuf_release(&cmdbuf);
|
|
return ret;
|
|
}
|
|
|
|
static int process_connect(struct transport *transport,
|
|
int for_push)
|
|
{
|
|
struct helper_data *data = transport->data;
|
|
const char *name;
|
|
const char *exec;
|
|
|
|
name = for_push ? "git-receive-pack" : "git-upload-pack";
|
|
if (for_push)
|
|
exec = data->transport_options.receivepack;
|
|
else
|
|
exec = data->transport_options.uploadpack;
|
|
|
|
return process_connect_service(transport, name, exec);
|
|
}
|
|
|
|
static int connect_helper(struct transport *transport, const char *name,
|
|
const char *exec, int fd[2])
|
|
{
|
|
struct helper_data *data = transport->data;
|
|
|
|
/* Get_helper so connect is inited. */
|
|
get_helper(transport);
|
|
if (!data->connect)
|
|
die(_("operation not supported by protocol"));
|
|
|
|
if (!process_connect_service(transport, name, exec))
|
|
die(_("can't connect to subservice %s"), name);
|
|
|
|
fd[0] = data->helper->out;
|
|
fd[1] = data->helper->in;
|
|
return 0;
|
|
}
|
|
|
|
static struct ref *get_refs_list_using_list(struct transport *transport,
|
|
int for_push);
|
|
|
|
static int fetch(struct transport *transport,
|
|
int nr_heads, struct ref **to_fetch)
|
|
{
|
|
struct helper_data *data = transport->data;
|
|
int i, count;
|
|
|
|
get_helper(transport);
|
|
|
|
if (process_connect(transport, 0)) {
|
|
do_take_over(transport);
|
|
return transport->vtable->fetch(transport, nr_heads, to_fetch);
|
|
}
|
|
|
|
/*
|
|
* If we reach here, then the server, the client, and/or the transport
|
|
* helper does not support protocol v2. --negotiate-only requires
|
|
* protocol v2.
|
|
*/
|
|
if (data->transport_options.acked_commits) {
|
|
warning(_("--negotiate-only requires protocol v2"));
|
|
return -1;
|
|
}
|
|
|
|
if (!data->get_refs_list_called)
|
|
get_refs_list_using_list(transport, 0);
|
|
|
|
count = 0;
|
|
for (i = 0; i < nr_heads; i++)
|
|
if (!(to_fetch[i]->status & REF_STATUS_UPTODATE))
|
|
count++;
|
|
|
|
if (!count)
|
|
return 0;
|
|
|
|
if (data->check_connectivity &&
|
|
data->transport_options.check_self_contained_and_connected)
|
|
set_helper_option(transport, "check-connectivity", "true");
|
|
|
|
if (transport->cloning)
|
|
set_helper_option(transport, "cloning", "true");
|
|
|
|
if (data->transport_options.update_shallow)
|
|
set_helper_option(transport, "update-shallow", "true");
|
|
|
|
if (data->transport_options.filter_options.choice) {
|
|
const char *spec = expand_list_objects_filter_spec(
|
|
&data->transport_options.filter_options);
|
|
set_helper_option(transport, "filter", spec);
|
|
}
|
|
|
|
if (data->transport_options.negotiation_tips)
|
|
warning("Ignoring --negotiation-tip because the protocol does not support it.");
|
|
|
|
if (data->fetch)
|
|
return fetch_with_fetch(transport, nr_heads, to_fetch);
|
|
|
|
if (data->import)
|
|
return fetch_with_import(transport, nr_heads, to_fetch);
|
|
|
|
return -1;
|
|
}
|
|
|
|
struct push_update_ref_state {
|
|
struct ref *hint;
|
|
struct ref_push_report *report;
|
|
int new_report;
|
|
};
|
|
|
|
static int push_update_ref_status(struct strbuf *buf,
|
|
struct push_update_ref_state *state,
|
|
struct ref *remote_refs)
|
|
{
|
|
char *refname, *msg;
|
|
int status, forced = 0;
|
|
|
|
if (starts_with(buf->buf, "option ")) {
|
|
struct object_id old_oid, new_oid;
|
|
const char *key, *val;
|
|
char *p;
|
|
|
|
if (!state->hint || !(state->report || state->new_report))
|
|
die(_("'option' without a matching 'ok/error' directive"));
|
|
if (state->new_report) {
|
|
if (!state->hint->report) {
|
|
CALLOC_ARRAY(state->hint->report, 1);
|
|
state->report = state->hint->report;
|
|
} else {
|
|
state->report = state->hint->report;
|
|
while (state->report->next)
|
|
state->report = state->report->next;
|
|
CALLOC_ARRAY(state->report->next, 1);
|
|
state->report = state->report->next;
|
|
}
|
|
state->new_report = 0;
|
|
}
|
|
key = buf->buf + 7;
|
|
p = strchr(key, ' ');
|
|
if (p)
|
|
*p++ = '\0';
|
|
val = p;
|
|
if (!strcmp(key, "refname"))
|
|
state->report->ref_name = xstrdup_or_null(val);
|
|
else if (!strcmp(key, "old-oid") && val &&
|
|
!parse_oid_hex(val, &old_oid, &val))
|
|
state->report->old_oid = oiddup(&old_oid);
|
|
else if (!strcmp(key, "new-oid") && val &&
|
|
!parse_oid_hex(val, &new_oid, &val))
|
|
state->report->new_oid = oiddup(&new_oid);
|
|
else if (!strcmp(key, "forced-update"))
|
|
state->report->forced_update = 1;
|
|
/* Not update remote namespace again. */
|
|
return 1;
|
|
}
|
|
|
|
state->report = NULL;
|
|
state->new_report = 0;
|
|
|
|
if (starts_with(buf->buf, "ok ")) {
|
|
status = REF_STATUS_OK;
|
|
refname = buf->buf + 3;
|
|
} else if (starts_with(buf->buf, "error ")) {
|
|
status = REF_STATUS_REMOTE_REJECT;
|
|
refname = buf->buf + 6;
|
|
} else
|
|
die(_("expected ok/error, helper said '%s'"), buf->buf);
|
|
|
|
msg = strchr(refname, ' ');
|
|
if (msg) {
|
|
struct strbuf msg_buf = STRBUF_INIT;
|
|
const char *end;
|
|
|
|
*msg++ = '\0';
|
|
if (!unquote_c_style(&msg_buf, msg, &end))
|
|
msg = strbuf_detach(&msg_buf, NULL);
|
|
else
|
|
msg = xstrdup(msg);
|
|
strbuf_release(&msg_buf);
|
|
|
|
if (!strcmp(msg, "no match")) {
|
|
status = REF_STATUS_NONE;
|
|
FREE_AND_NULL(msg);
|
|
}
|
|
else if (!strcmp(msg, "up to date")) {
|
|
status = REF_STATUS_UPTODATE;
|
|
FREE_AND_NULL(msg);
|
|
}
|
|
else if (!strcmp(msg, "non-fast forward")) {
|
|
status = REF_STATUS_REJECT_NONFASTFORWARD;
|
|
FREE_AND_NULL(msg);
|
|
}
|
|
else if (!strcmp(msg, "already exists")) {
|
|
status = REF_STATUS_REJECT_ALREADY_EXISTS;
|
|
FREE_AND_NULL(msg);
|
|
}
|
|
else if (!strcmp(msg, "fetch first")) {
|
|
status = REF_STATUS_REJECT_FETCH_FIRST;
|
|
FREE_AND_NULL(msg);
|
|
}
|
|
else if (!strcmp(msg, "needs force")) {
|
|
status = REF_STATUS_REJECT_NEEDS_FORCE;
|
|
FREE_AND_NULL(msg);
|
|
}
|
|
else if (!strcmp(msg, "stale info")) {
|
|
status = REF_STATUS_REJECT_STALE;
|
|
FREE_AND_NULL(msg);
|
|
}
|
|
else if (!strcmp(msg, "remote ref updated since checkout")) {
|
|
status = REF_STATUS_REJECT_REMOTE_UPDATED;
|
|
FREE_AND_NULL(msg);
|
|
}
|
|
else if (!strcmp(msg, "forced update")) {
|
|
forced = 1;
|
|
FREE_AND_NULL(msg);
|
|
}
|
|
}
|
|
|
|
if (state->hint)
|
|
state->hint = find_ref_by_name(state->hint, refname);
|
|
if (!state->hint)
|
|
state->hint = find_ref_by_name(remote_refs, refname);
|
|
if (!state->hint) {
|
|
warning(_("helper reported unexpected status of %s"), refname);
|
|
return 1;
|
|
}
|
|
|
|
if (state->hint->status != REF_STATUS_NONE) {
|
|
/*
|
|
* Earlier, the ref was marked not to be pushed, so ignore the ref
|
|
* status reported by the remote helper if the latter is 'no match'.
|
|
*/
|
|
if (status == REF_STATUS_NONE)
|
|
return 1;
|
|
}
|
|
|
|
if (status == REF_STATUS_OK)
|
|
state->new_report = 1;
|
|
state->hint->status = status;
|
|
state->hint->forced_update |= forced;
|
|
state->hint->remote_status = msg;
|
|
return !(status == REF_STATUS_OK);
|
|
}
|
|
|
|
static int push_update_refs_status(struct helper_data *data,
|
|
struct ref *remote_refs,
|
|
int flags)
|
|
{
|
|
struct ref *ref;
|
|
struct ref_push_report *report;
|
|
struct strbuf buf = STRBUF_INIT;
|
|
struct push_update_ref_state state = { remote_refs, NULL, 0 };
|
|
|
|
for (;;) {
|
|
if (recvline(data, &buf)) {
|
|
strbuf_release(&buf);
|
|
return 1;
|
|
}
|
|
if (!buf.len)
|
|
break;
|
|
push_update_ref_status(&buf, &state, remote_refs);
|
|
}
|
|
strbuf_release(&buf);
|
|
|
|
if (flags & TRANSPORT_PUSH_DRY_RUN || !data->rs.nr || data->no_private_update)
|
|
return 0;
|
|
|
|
/* propagate back the update to the remote namespace */
|
|
for (ref = remote_refs; ref; ref = ref->next) {
|
|
char *private;
|
|
|
|
if (ref->status != REF_STATUS_OK)
|
|
continue;
|
|
|
|
if (!ref->report) {
|
|
private = apply_refspecs(&data->rs, ref->name);
|
|
if (!private)
|
|
continue;
|
|
update_ref("update by helper", private, &(ref->new_oid),
|
|
NULL, 0, 0);
|
|
free(private);
|
|
} else {
|
|
for (report = ref->report; report; report = report->next) {
|
|
private = apply_refspecs(&data->rs,
|
|
report->ref_name
|
|
? report->ref_name
|
|
: ref->name);
|
|
if (!private)
|
|
continue;
|
|
update_ref("update by helper", private,
|
|
report->new_oid
|
|
? report->new_oid
|
|
: &(ref->new_oid),
|
|
NULL, 0, 0);
|
|
free(private);
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void set_common_push_options(struct transport *transport,
|
|
const char *name, int flags)
|
|
{
|
|
if (flags & TRANSPORT_PUSH_DRY_RUN) {
|
|
if (set_helper_option(transport, "dry-run", "true") != 0)
|
|
die(_("helper %s does not support dry-run"), name);
|
|
} else if (flags & TRANSPORT_PUSH_CERT_ALWAYS) {
|
|
if (set_helper_option(transport, TRANS_OPT_PUSH_CERT, "true") != 0)
|
|
die(_("helper %s does not support --signed"), name);
|
|
} else if (flags & TRANSPORT_PUSH_CERT_IF_ASKED) {
|
|
if (set_helper_option(transport, TRANS_OPT_PUSH_CERT, "if-asked") != 0)
|
|
die(_("helper %s does not support --signed=if-asked"), name);
|
|
}
|
|
|
|
if (flags & TRANSPORT_PUSH_ATOMIC)
|
|
if (set_helper_option(transport, TRANS_OPT_ATOMIC, "true") != 0)
|
|
die(_("helper %s does not support --atomic"), name);
|
|
|
|
if (flags & TRANSPORT_PUSH_FORCE_IF_INCLUDES)
|
|
if (set_helper_option(transport, TRANS_OPT_FORCE_IF_INCLUDES, "true") != 0)
|
|
die(_("helper %s does not support --%s"),
|
|
name, TRANS_OPT_FORCE_IF_INCLUDES);
|
|
|
|
if (flags & TRANSPORT_PUSH_OPTIONS) {
|
|
struct string_list_item *item;
|
|
for_each_string_list_item(item, transport->push_options)
|
|
if (set_helper_option(transport, "push-option", item->string) != 0)
|
|
die(_("helper %s does not support 'push-option'"), name);
|
|
}
|
|
}
|
|
|
|
static int push_refs_with_push(struct transport *transport,
|
|
struct ref *remote_refs, int flags)
|
|
{
|
|
int force_all = flags & TRANSPORT_PUSH_FORCE;
|
|
int mirror = flags & TRANSPORT_PUSH_MIRROR;
|
|
int atomic = flags & TRANSPORT_PUSH_ATOMIC;
|
|
struct helper_data *data = transport->data;
|
|
struct strbuf buf = STRBUF_INIT;
|
|
struct ref *ref;
|
|
struct string_list cas_options = STRING_LIST_INIT_DUP;
|
|
struct string_list_item *cas_option;
|
|
|
|
get_helper(transport);
|
|
if (!data->push)
|
|
return 1;
|
|
|
|
for (ref = remote_refs; ref; ref = ref->next) {
|
|
if (!ref->peer_ref && !mirror)
|
|
continue;
|
|
|
|
/* Check for statuses set by set_ref_status_for_push() */
|
|
switch (ref->status) {
|
|
case REF_STATUS_REJECT_NONFASTFORWARD:
|
|
case REF_STATUS_REJECT_STALE:
|
|
case REF_STATUS_REJECT_ALREADY_EXISTS:
|
|
case REF_STATUS_REJECT_REMOTE_UPDATED:
|
|
if (atomic) {
|
|
reject_atomic_push(remote_refs, mirror);
|
|
string_list_clear(&cas_options, 0);
|
|
return 0;
|
|
} else
|
|
continue;
|
|
case REF_STATUS_UPTODATE:
|
|
continue;
|
|
default:
|
|
; /* do nothing */
|
|
}
|
|
|
|
if (force_all)
|
|
ref->force = 1;
|
|
|
|
strbuf_addstr(&buf, "push ");
|
|
if (!ref->deletion) {
|
|
if (ref->force)
|
|
strbuf_addch(&buf, '+');
|
|
if (ref->peer_ref)
|
|
strbuf_addstr(&buf, ref->peer_ref->name);
|
|
else
|
|
strbuf_addstr(&buf, oid_to_hex(&ref->new_oid));
|
|
}
|
|
strbuf_addch(&buf, ':');
|
|
strbuf_addstr(&buf, ref->name);
|
|
strbuf_addch(&buf, '\n');
|
|
|
|
/*
|
|
* The "--force-with-lease" options without explicit
|
|
* values to expect have already been expanded into
|
|
* the ref->old_oid_expect[] field; we can ignore
|
|
* transport->smart_options->cas altogether and instead
|
|
* can enumerate them from the refs.
|
|
*/
|
|
if (ref->expect_old_sha1) {
|
|
struct strbuf cas = STRBUF_INIT;
|
|
strbuf_addf(&cas, "%s:%s",
|
|
ref->name, oid_to_hex(&ref->old_oid_expect));
|
|
string_list_append_nodup(&cas_options,
|
|
strbuf_detach(&cas, NULL));
|
|
}
|
|
}
|
|
if (buf.len == 0) {
|
|
string_list_clear(&cas_options, 0);
|
|
return 0;
|
|
}
|
|
|
|
for_each_string_list_item(cas_option, &cas_options)
|
|
set_helper_option(transport, "cas", cas_option->string);
|
|
set_common_push_options(transport, data->name, flags);
|
|
|
|
strbuf_addch(&buf, '\n');
|
|
sendline(data, &buf);
|
|
strbuf_release(&buf);
|
|
string_list_clear(&cas_options, 0);
|
|
|
|
return push_update_refs_status(data, remote_refs, flags);
|
|
}
|
|
|
|
static int push_refs_with_export(struct transport *transport,
|
|
struct ref *remote_refs, int flags)
|
|
{
|
|
struct ref *ref;
|
|
struct child_process *helper, exporter;
|
|
struct helper_data *data = transport->data;
|
|
struct string_list revlist_args = STRING_LIST_INIT_DUP;
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
if (!data->rs.nr)
|
|
die(_("remote-helper doesn't support push; refspec needed"));
|
|
|
|
set_common_push_options(transport, data->name, flags);
|
|
if (flags & TRANSPORT_PUSH_FORCE) {
|
|
if (set_helper_option(transport, "force", "true") != 0)
|
|
warning(_("helper %s does not support 'force'"), data->name);
|
|
}
|
|
|
|
helper = get_helper(transport);
|
|
|
|
write_constant(helper->in, "export\n");
|
|
|
|
for (ref = remote_refs; ref; ref = ref->next) {
|
|
char *private;
|
|
struct object_id oid;
|
|
|
|
private = apply_refspecs(&data->rs, ref->name);
|
|
if (private && !get_oid(private, &oid)) {
|
|
strbuf_addf(&buf, "^%s", private);
|
|
string_list_append_nodup(&revlist_args,
|
|
strbuf_detach(&buf, NULL));
|
|
oidcpy(&ref->old_oid, &oid);
|
|
}
|
|
free(private);
|
|
|
|
if (ref->peer_ref) {
|
|
if (strcmp(ref->name, ref->peer_ref->name)) {
|
|
if (!ref->deletion) {
|
|
const char *name;
|
|
int flag;
|
|
|
|
/* Follow symbolic refs (mainly for HEAD). */
|
|
name = resolve_ref_unsafe(ref->peer_ref->name,
|
|
RESOLVE_REF_READING,
|
|
&oid, &flag);
|
|
if (!name || !(flag & REF_ISSYMREF))
|
|
name = ref->peer_ref->name;
|
|
|
|
strbuf_addf(&buf, "%s:%s", name, ref->name);
|
|
} else
|
|
strbuf_addf(&buf, ":%s", ref->name);
|
|
|
|
string_list_append(&revlist_args, "--refspec");
|
|
string_list_append(&revlist_args, buf.buf);
|
|
strbuf_release(&buf);
|
|
}
|
|
if (!ref->deletion)
|
|
string_list_append(&revlist_args, ref->peer_ref->name);
|
|
}
|
|
}
|
|
|
|
if (get_exporter(transport, &exporter, &revlist_args))
|
|
die(_("couldn't run fast-export"));
|
|
|
|
string_list_clear(&revlist_args, 1);
|
|
|
|
if (finish_command(&exporter))
|
|
die(_("error while running fast-export"));
|
|
if (push_update_refs_status(data, remote_refs, flags))
|
|
return 1;
|
|
|
|
if (data->export_marks) {
|
|
strbuf_addf(&buf, "%s.tmp", data->export_marks);
|
|
rename(buf.buf, data->export_marks);
|
|
strbuf_release(&buf);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int push_refs(struct transport *transport,
|
|
struct ref *remote_refs, int flags)
|
|
{
|
|
struct helper_data *data = transport->data;
|
|
|
|
if (process_connect(transport, 1)) {
|
|
do_take_over(transport);
|
|
return transport->vtable->push_refs(transport, remote_refs, flags);
|
|
}
|
|
|
|
if (!remote_refs) {
|
|
fprintf(stderr,
|
|
_("No refs in common and none specified; doing nothing.\n"
|
|
"Perhaps you should specify a branch.\n"));
|
|
return 0;
|
|
}
|
|
|
|
if (data->push)
|
|
return push_refs_with_push(transport, remote_refs, flags);
|
|
|
|
if (data->export)
|
|
return push_refs_with_export(transport, remote_refs, flags);
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
static int has_attribute(const char *attrs, const char *attr)
|
|
{
|
|
int len;
|
|
if (!attrs)
|
|
return 0;
|
|
|
|
len = strlen(attr);
|
|
for (;;) {
|
|
const char *space = strchrnul(attrs, ' ');
|
|
if (len == space - attrs && !strncmp(attrs, attr, len))
|
|
return 1;
|
|
if (!*space)
|
|
return 0;
|
|
attrs = space + 1;
|
|
}
|
|
}
|
|
|
|
static struct ref *get_refs_list(struct transport *transport, int for_push,
|
|
struct transport_ls_refs_options *transport_options)
|
|
{
|
|
get_helper(transport);
|
|
|
|
if (process_connect(transport, for_push)) {
|
|
do_take_over(transport);
|
|
return transport->vtable->get_refs_list(transport, for_push,
|
|
transport_options);
|
|
}
|
|
|
|
return get_refs_list_using_list(transport, for_push);
|
|
}
|
|
|
|
static struct ref *get_refs_list_using_list(struct transport *transport,
|
|
int for_push)
|
|
{
|
|
struct helper_data *data = transport->data;
|
|
struct child_process *helper;
|
|
struct ref *ret = NULL;
|
|
struct ref **tail = &ret;
|
|
struct ref *posn;
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
data->get_refs_list_called = 1;
|
|
helper = get_helper(transport);
|
|
|
|
if (data->object_format) {
|
|
write_str_in_full(helper->in, "option object-format\n");
|
|
if (recvline(data, &buf) || strcmp(buf.buf, "ok"))
|
|
exit(128);
|
|
}
|
|
|
|
if (data->push && for_push)
|
|
write_str_in_full(helper->in, "list for-push\n");
|
|
else
|
|
write_str_in_full(helper->in, "list\n");
|
|
|
|
while (1) {
|
|
char *eov, *eon;
|
|
if (recvline(data, &buf))
|
|
exit(128);
|
|
|
|
if (!*buf.buf)
|
|
break;
|
|
else if (buf.buf[0] == ':') {
|
|
const char *value;
|
|
if (skip_prefix(buf.buf, ":object-format ", &value)) {
|
|
int algo = hash_algo_by_name(value);
|
|
if (algo == GIT_HASH_UNKNOWN)
|
|
die(_("unsupported object format '%s'"),
|
|
value);
|
|
transport->hash_algo = &hash_algos[algo];
|
|
}
|
|
continue;
|
|
}
|
|
|
|
eov = strchr(buf.buf, ' ');
|
|
if (!eov)
|
|
die(_("malformed response in ref list: %s"), buf.buf);
|
|
eon = strchr(eov + 1, ' ');
|
|
*eov = '\0';
|
|
if (eon)
|
|
*eon = '\0';
|
|
*tail = alloc_ref(eov + 1);
|
|
if (buf.buf[0] == '@')
|
|
(*tail)->symref = xstrdup(buf.buf + 1);
|
|
else if (buf.buf[0] != '?')
|
|
get_oid_hex_algop(buf.buf, &(*tail)->old_oid, transport->hash_algo);
|
|
if (eon) {
|
|
if (has_attribute(eon + 1, "unchanged")) {
|
|
(*tail)->status |= REF_STATUS_UPTODATE;
|
|
if (read_ref((*tail)->name, &(*tail)->old_oid) < 0)
|
|
die(_("could not read ref %s"),
|
|
(*tail)->name);
|
|
}
|
|
}
|
|
tail = &((*tail)->next);
|
|
}
|
|
if (debug)
|
|
fprintf(stderr, "Debug: Read ref listing.\n");
|
|
strbuf_release(&buf);
|
|
|
|
for (posn = ret; posn; posn = posn->next)
|
|
resolve_remote_symref(posn, ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static struct transport_vtable vtable = {
|
|
set_helper_option,
|
|
get_refs_list,
|
|
fetch,
|
|
push_refs,
|
|
connect_helper,
|
|
release_helper
|
|
};
|
|
|
|
int transport_helper_init(struct transport *transport, const char *name)
|
|
{
|
|
struct helper_data *data = xcalloc(1, sizeof(*data));
|
|
data->name = name;
|
|
|
|
transport_check_allowed(name);
|
|
|
|
if (getenv("GIT_TRANSPORT_HELPER_DEBUG"))
|
|
debug = 1;
|
|
|
|
transport->data = data;
|
|
transport->vtable = &vtable;
|
|
transport->smart_options = &(data->transport_options);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Linux pipes can buffer 65536 bytes at once (and most platforms can
|
|
* buffer less), so attempt reads and writes with up to that size.
|
|
*/
|
|
#define BUFFERSIZE 65536
|
|
/* This should be enough to hold debugging message. */
|
|
#define PBUFFERSIZE 8192
|
|
|
|
/* Print bidirectional transfer loop debug message. */
|
|
__attribute__((format (printf, 1, 2)))
|
|
static void transfer_debug(const char *fmt, ...)
|
|
{
|
|
/*
|
|
* NEEDSWORK: This function is sometimes used from multiple threads, and
|
|
* we end up using debug_enabled racily. That "should not matter" since
|
|
* we always write the same value, but it's still wrong. This function
|
|
* is listed in .tsan-suppressions for the time being.
|
|
*/
|
|
|
|
va_list args;
|
|
char msgbuf[PBUFFERSIZE];
|
|
static int debug_enabled = -1;
|
|
|
|
if (debug_enabled < 0)
|
|
debug_enabled = getenv("GIT_TRANSLOOP_DEBUG") ? 1 : 0;
|
|
if (!debug_enabled)
|
|
return;
|
|
|
|
va_start(args, fmt);
|
|
vsnprintf(msgbuf, PBUFFERSIZE, fmt, args);
|
|
va_end(args);
|
|
fprintf(stderr, "Transfer loop debugging: %s\n", msgbuf);
|
|
}
|
|
|
|
/* Stream state: More data may be coming in this direction. */
|
|
#define SSTATE_TRANSFERRING 0
|
|
/*
|
|
* Stream state: No more data coming in this direction, flushing rest of
|
|
* data.
|
|
*/
|
|
#define SSTATE_FLUSHING 1
|
|
/* Stream state: Transfer in this direction finished. */
|
|
#define SSTATE_FINISHED 2
|
|
|
|
#define STATE_NEEDS_READING(state) ((state) <= SSTATE_TRANSFERRING)
|
|
#define STATE_NEEDS_WRITING(state) ((state) <= SSTATE_FLUSHING)
|
|
#define STATE_NEEDS_CLOSING(state) ((state) == SSTATE_FLUSHING)
|
|
|
|
/* Unidirectional transfer. */
|
|
struct unidirectional_transfer {
|
|
/* Source */
|
|
int src;
|
|
/* Destination */
|
|
int dest;
|
|
/* Is source socket? */
|
|
int src_is_sock;
|
|
/* Is destination socket? */
|
|
int dest_is_sock;
|
|
/* Transfer state (TRANSFERRING/FLUSHING/FINISHED) */
|
|
int state;
|
|
/* Buffer. */
|
|
char buf[BUFFERSIZE];
|
|
/* Buffer used. */
|
|
size_t bufuse;
|
|
/* Name of source. */
|
|
const char *src_name;
|
|
/* Name of destination. */
|
|
const char *dest_name;
|
|
};
|
|
|
|
/* Closes the target (for writing) if transfer has finished. */
|
|
static void udt_close_if_finished(struct unidirectional_transfer *t)
|
|
{
|
|
if (STATE_NEEDS_CLOSING(t->state) && !t->bufuse) {
|
|
t->state = SSTATE_FINISHED;
|
|
if (t->dest_is_sock)
|
|
shutdown(t->dest, SHUT_WR);
|
|
else
|
|
close(t->dest);
|
|
transfer_debug("Closed %s.", t->dest_name);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Tries to read data from source into buffer. If buffer is full,
|
|
* no data is read. Returns 0 on success, -1 on error.
|
|
*/
|
|
static int udt_do_read(struct unidirectional_transfer *t)
|
|
{
|
|
ssize_t bytes;
|
|
|
|
if (t->bufuse == BUFFERSIZE)
|
|
return 0; /* No space for more. */
|
|
|
|
transfer_debug("%s is readable", t->src_name);
|
|
bytes = xread(t->src, t->buf + t->bufuse, BUFFERSIZE - t->bufuse);
|
|
if (bytes < 0) {
|
|
error_errno(_("read(%s) failed"), t->src_name);
|
|
return -1;
|
|
} else if (bytes == 0) {
|
|
transfer_debug("%s EOF (with %i bytes in buffer)",
|
|
t->src_name, (int)t->bufuse);
|
|
t->state = SSTATE_FLUSHING;
|
|
} else if (bytes > 0) {
|
|
t->bufuse += bytes;
|
|
transfer_debug("Read %i bytes from %s (buffer now at %i)",
|
|
(int)bytes, t->src_name, (int)t->bufuse);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Tries to write data from buffer into destination. If buffer is empty,
|
|
* no data is written. Returns 0 on success, -1 on error.
|
|
*/
|
|
static int udt_do_write(struct unidirectional_transfer *t)
|
|
{
|
|
ssize_t bytes;
|
|
|
|
if (t->bufuse == 0)
|
|
return 0; /* Nothing to write. */
|
|
|
|
transfer_debug("%s is writable", t->dest_name);
|
|
bytes = xwrite(t->dest, t->buf, t->bufuse);
|
|
if (bytes < 0) {
|
|
error_errno(_("write(%s) failed"), t->dest_name);
|
|
return -1;
|
|
} else if (bytes > 0) {
|
|
t->bufuse -= bytes;
|
|
if (t->bufuse)
|
|
memmove(t->buf, t->buf + bytes, t->bufuse);
|
|
transfer_debug("Wrote %i bytes to %s (buffer now at %i)",
|
|
(int)bytes, t->dest_name, (int)t->bufuse);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* State of bidirectional transfer loop. */
|
|
struct bidirectional_transfer_state {
|
|
/* Direction from program to git. */
|
|
struct unidirectional_transfer ptg;
|
|
/* Direction from git to program. */
|
|
struct unidirectional_transfer gtp;
|
|
};
|
|
|
|
static void *udt_copy_task_routine(void *udt)
|
|
{
|
|
struct unidirectional_transfer *t = (struct unidirectional_transfer *)udt;
|
|
while (t->state != SSTATE_FINISHED) {
|
|
if (STATE_NEEDS_READING(t->state))
|
|
if (udt_do_read(t))
|
|
return NULL;
|
|
if (STATE_NEEDS_WRITING(t->state))
|
|
if (udt_do_write(t))
|
|
return NULL;
|
|
if (STATE_NEEDS_CLOSING(t->state))
|
|
udt_close_if_finished(t);
|
|
}
|
|
return udt; /* Just some non-NULL value. */
|
|
}
|
|
|
|
#ifndef NO_PTHREADS
|
|
|
|
/*
|
|
* Join thread, with appropriate errors on failure. Name is name for the
|
|
* thread (for error messages). Returns 0 on success, 1 on failure.
|
|
*/
|
|
static int tloop_join(pthread_t thread, const char *name)
|
|
{
|
|
int err;
|
|
void *tret;
|
|
err = pthread_join(thread, &tret);
|
|
if (!tret) {
|
|
error(_("%s thread failed"), name);
|
|
return 1;
|
|
}
|
|
if (err) {
|
|
error(_("%s thread failed to join: %s"), name, strerror(err));
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Spawn the transfer tasks and then wait for them. Returns 0 on success,
|
|
* -1 on failure.
|
|
*/
|
|
static int tloop_spawnwait_tasks(struct bidirectional_transfer_state *s)
|
|
{
|
|
pthread_t gtp_thread;
|
|
pthread_t ptg_thread;
|
|
int err;
|
|
int ret = 0;
|
|
err = pthread_create(>p_thread, NULL, udt_copy_task_routine,
|
|
&s->gtp);
|
|
if (err)
|
|
die(_("can't start thread for copying data: %s"), strerror(err));
|
|
err = pthread_create(&ptg_thread, NULL, udt_copy_task_routine,
|
|
&s->ptg);
|
|
if (err)
|
|
die(_("can't start thread for copying data: %s"), strerror(err));
|
|
|
|
ret |= tloop_join(gtp_thread, "Git to program copy");
|
|
ret |= tloop_join(ptg_thread, "Program to git copy");
|
|
return ret;
|
|
}
|
|
#else
|
|
|
|
/* Close the source and target (for writing) for transfer. */
|
|
static void udt_kill_transfer(struct unidirectional_transfer *t)
|
|
{
|
|
t->state = SSTATE_FINISHED;
|
|
/*
|
|
* Socket read end left open isn't a disaster if nobody
|
|
* attempts to read from it (mingw compat headers do not
|
|
* have SHUT_RD)...
|
|
*
|
|
* We can't fully close the socket since otherwise gtp
|
|
* task would first close the socket it sends data to
|
|
* while closing the ptg file descriptors.
|
|
*/
|
|
if (!t->src_is_sock)
|
|
close(t->src);
|
|
if (t->dest_is_sock)
|
|
shutdown(t->dest, SHUT_WR);
|
|
else
|
|
close(t->dest);
|
|
}
|
|
|
|
/*
|
|
* Join process, with appropriate errors on failure. Name is name for the
|
|
* process (for error messages). Returns 0 on success, 1 on failure.
|
|
*/
|
|
static int tloop_join(pid_t pid, const char *name)
|
|
{
|
|
int tret;
|
|
if (waitpid(pid, &tret, 0) < 0) {
|
|
error_errno(_("%s process failed to wait"), name);
|
|
return 1;
|
|
}
|
|
if (!WIFEXITED(tret) || WEXITSTATUS(tret)) {
|
|
error(_("%s process failed"), name);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Spawn the transfer tasks and then wait for them. Returns 0 on success,
|
|
* -1 on failure.
|
|
*/
|
|
static int tloop_spawnwait_tasks(struct bidirectional_transfer_state *s)
|
|
{
|
|
pid_t pid1, pid2;
|
|
int ret = 0;
|
|
|
|
/* Fork thread #1: git to program. */
|
|
pid1 = fork();
|
|
if (pid1 < 0)
|
|
die_errno(_("can't start thread for copying data"));
|
|
else if (pid1 == 0) {
|
|
udt_kill_transfer(&s->ptg);
|
|
exit(udt_copy_task_routine(&s->gtp) ? 0 : 1);
|
|
}
|
|
|
|
/* Fork thread #2: program to git. */
|
|
pid2 = fork();
|
|
if (pid2 < 0)
|
|
die_errno(_("can't start thread for copying data"));
|
|
else if (pid2 == 0) {
|
|
udt_kill_transfer(&s->gtp);
|
|
exit(udt_copy_task_routine(&s->ptg) ? 0 : 1);
|
|
}
|
|
|
|
/*
|
|
* Close both streams in parent as to not interfere with
|
|
* end of file detection and wait for both tasks to finish.
|
|
*/
|
|
udt_kill_transfer(&s->gtp);
|
|
udt_kill_transfer(&s->ptg);
|
|
ret |= tloop_join(pid1, "Git to program copy");
|
|
ret |= tloop_join(pid2, "Program to git copy");
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Copies data from stdin to output and from input to stdout simultaneously.
|
|
* Additionally filtering through given filter. If filter is NULL, uses
|
|
* identity filter.
|
|
*/
|
|
int bidirectional_transfer_loop(int input, int output)
|
|
{
|
|
struct bidirectional_transfer_state state;
|
|
|
|
/* Fill the state fields. */
|
|
state.ptg.src = input;
|
|
state.ptg.dest = 1;
|
|
state.ptg.src_is_sock = (input == output);
|
|
state.ptg.dest_is_sock = 0;
|
|
state.ptg.state = SSTATE_TRANSFERRING;
|
|
state.ptg.bufuse = 0;
|
|
state.ptg.src_name = "remote input";
|
|
state.ptg.dest_name = "stdout";
|
|
|
|
state.gtp.src = 0;
|
|
state.gtp.dest = output;
|
|
state.gtp.src_is_sock = 0;
|
|
state.gtp.dest_is_sock = (input == output);
|
|
state.gtp.state = SSTATE_TRANSFERRING;
|
|
state.gtp.bufuse = 0;
|
|
state.gtp.src_name = "stdin";
|
|
state.gtp.dest_name = "remote output";
|
|
|
|
return tloop_spawnwait_tasks(&state);
|
|
}
|
|
|
|
void reject_atomic_push(struct ref *remote_refs, int mirror_mode)
|
|
{
|
|
struct ref *ref;
|
|
|
|
/* Mark other refs as failed */
|
|
for (ref = remote_refs; ref; ref = ref->next) {
|
|
if (!ref->peer_ref && !mirror_mode)
|
|
continue;
|
|
|
|
switch (ref->status) {
|
|
case REF_STATUS_NONE:
|
|
case REF_STATUS_OK:
|
|
case REF_STATUS_EXPECTING_REPORT:
|
|
ref->status = REF_STATUS_ATOMIC_PUSH_FAILED;
|
|
continue;
|
|
default:
|
|
break; /* do nothing */
|
|
}
|
|
}
|
|
return;
|
|
}
|