mirror of
https://github.com/git/git
synced 2024-08-27 19:49:21 +00:00
![Masaya Suzuki](/assets/img/avatar_default.png)
In the Git pack protocol definition, an error packet may appear only in a certain context. However, servers can face a runtime error (e.g. I/O error) at an arbitrary timing. This patch changes the protocol to allow an error packet to be sent instead of any packet. Without this protocol spec change, when a server cannot process a request, there's no way to tell that to a client. Since the server cannot produce a valid response, it would be forced to cut a connection without telling why. With this protocol spec change, the server can be more gentle in this situation. An old client may see these error packets as an unexpected packet, but this is not worse than having an unexpected EOF. Following this protocol spec change, the error packet handling code is moved to pkt-line.c. Implementation wise, this implementation uses pkt-line to communicate with a subprocess. Since this is not a part of Git protocol, it's possible that a packet that is not supposed to be an error packet is mistakenly parsed as an error packet. This error packet handling is enabled only for the Git pack protocol parsing code considering this. Signed-off-by: Masaya Suzuki <masayasuzuki@google.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
312 lines
7.8 KiB
C
312 lines
7.8 KiB
C
#include "builtin.h"
|
|
#include "config.h"
|
|
#include "commit.h"
|
|
#include "refs.h"
|
|
#include "pkt-line.h"
|
|
#include "sideband.h"
|
|
#include "run-command.h"
|
|
#include "remote.h"
|
|
#include "connect.h"
|
|
#include "send-pack.h"
|
|
#include "quote.h"
|
|
#include "transport.h"
|
|
#include "version.h"
|
|
#include "sha1-array.h"
|
|
#include "gpg-interface.h"
|
|
#include "gettext.h"
|
|
#include "protocol.h"
|
|
|
|
static const char * const send_pack_usage[] = {
|
|
N_("git send-pack [--all | --mirror] [--dry-run] [--force] "
|
|
"[--receive-pack=<git-receive-pack>] [--verbose] [--thin] [--atomic] "
|
|
"[<host>:]<directory> [<ref>...]\n"
|
|
" --all and explicit <ref> specification are mutually exclusive."),
|
|
NULL,
|
|
};
|
|
|
|
static struct send_pack_args args;
|
|
|
|
static void print_helper_status(struct ref *ref)
|
|
{
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
for (; ref; ref = ref->next) {
|
|
const char *msg = NULL;
|
|
const char *res;
|
|
|
|
switch(ref->status) {
|
|
case REF_STATUS_NONE:
|
|
res = "error";
|
|
msg = "no match";
|
|
break;
|
|
|
|
case REF_STATUS_OK:
|
|
res = "ok";
|
|
break;
|
|
|
|
case REF_STATUS_UPTODATE:
|
|
res = "ok";
|
|
msg = "up to date";
|
|
break;
|
|
|
|
case REF_STATUS_REJECT_NONFASTFORWARD:
|
|
res = "error";
|
|
msg = "non-fast forward";
|
|
break;
|
|
|
|
case REF_STATUS_REJECT_FETCH_FIRST:
|
|
res = "error";
|
|
msg = "fetch first";
|
|
break;
|
|
|
|
case REF_STATUS_REJECT_NEEDS_FORCE:
|
|
res = "error";
|
|
msg = "needs force";
|
|
break;
|
|
|
|
case REF_STATUS_REJECT_STALE:
|
|
res = "error";
|
|
msg = "stale info";
|
|
break;
|
|
|
|
case REF_STATUS_REJECT_ALREADY_EXISTS:
|
|
res = "error";
|
|
msg = "already exists";
|
|
break;
|
|
|
|
case REF_STATUS_REJECT_NODELETE:
|
|
case REF_STATUS_REMOTE_REJECT:
|
|
res = "error";
|
|
break;
|
|
|
|
case REF_STATUS_EXPECTING_REPORT:
|
|
default:
|
|
continue;
|
|
}
|
|
|
|
strbuf_reset(&buf);
|
|
strbuf_addf(&buf, "%s %s", res, ref->name);
|
|
if (ref->remote_status)
|
|
msg = ref->remote_status;
|
|
if (msg) {
|
|
strbuf_addch(&buf, ' ');
|
|
quote_two_c_style(&buf, "", msg, 0);
|
|
}
|
|
strbuf_addch(&buf, '\n');
|
|
|
|
write_or_die(1, buf.buf, buf.len);
|
|
}
|
|
strbuf_release(&buf);
|
|
}
|
|
|
|
static int send_pack_config(const char *k, const char *v, void *cb)
|
|
{
|
|
git_gpg_config(k, v, NULL);
|
|
|
|
if (!strcmp(k, "push.gpgsign")) {
|
|
const char *value;
|
|
if (!git_config_get_value("push.gpgsign", &value)) {
|
|
switch (git_parse_maybe_bool(value)) {
|
|
case 0:
|
|
args.push_cert = SEND_PACK_PUSH_CERT_NEVER;
|
|
break;
|
|
case 1:
|
|
args.push_cert = SEND_PACK_PUSH_CERT_ALWAYS;
|
|
break;
|
|
default:
|
|
if (value && !strcasecmp(value, "if-asked"))
|
|
args.push_cert = SEND_PACK_PUSH_CERT_IF_ASKED;
|
|
else
|
|
return error("Invalid value for '%s'", k);
|
|
}
|
|
}
|
|
}
|
|
return git_default_config(k, v, cb);
|
|
}
|
|
|
|
int cmd_send_pack(int argc, const char **argv, const char *prefix)
|
|
{
|
|
struct refspec rs = REFSPEC_INIT_PUSH;
|
|
const char *remote_name = NULL;
|
|
struct remote *remote = NULL;
|
|
const char *dest = NULL;
|
|
int fd[2];
|
|
struct child_process *conn;
|
|
struct oid_array extra_have = OID_ARRAY_INIT;
|
|
struct oid_array shallow = OID_ARRAY_INIT;
|
|
struct ref *remote_refs, *local_refs;
|
|
int ret;
|
|
int helper_status = 0;
|
|
int send_all = 0;
|
|
int verbose = 0;
|
|
const char *receivepack = "git-receive-pack";
|
|
unsigned dry_run = 0;
|
|
unsigned send_mirror = 0;
|
|
unsigned force_update = 0;
|
|
unsigned quiet = 0;
|
|
int push_cert = 0;
|
|
struct string_list push_options = STRING_LIST_INIT_NODUP;
|
|
unsigned use_thin_pack = 0;
|
|
unsigned atomic = 0;
|
|
unsigned stateless_rpc = 0;
|
|
int flags;
|
|
unsigned int reject_reasons;
|
|
int progress = -1;
|
|
int from_stdin = 0;
|
|
struct push_cas_option cas = {0};
|
|
struct packet_reader reader;
|
|
|
|
struct option options[] = {
|
|
OPT__VERBOSITY(&verbose),
|
|
OPT_STRING(0, "receive-pack", &receivepack, "receive-pack", N_("receive pack program")),
|
|
OPT_STRING(0, "exec", &receivepack, "receive-pack", N_("receive pack program")),
|
|
OPT_STRING(0, "remote", &remote_name, "remote", N_("remote name")),
|
|
OPT_BOOL(0, "all", &send_all, N_("push all refs")),
|
|
OPT_BOOL('n' , "dry-run", &dry_run, N_("dry run")),
|
|
OPT_BOOL(0, "mirror", &send_mirror, N_("mirror all refs")),
|
|
OPT_BOOL('f', "force", &force_update, N_("force updates")),
|
|
{ OPTION_CALLBACK,
|
|
0, "signed", &push_cert, "(yes|no|if-asked)", N_("GPG sign the push"),
|
|
PARSE_OPT_OPTARG, option_parse_push_signed },
|
|
OPT_STRING_LIST(0, "push-option", &push_options,
|
|
N_("server-specific"),
|
|
N_("option to transmit")),
|
|
OPT_BOOL(0, "progress", &progress, N_("force progress reporting")),
|
|
OPT_BOOL(0, "thin", &use_thin_pack, N_("use thin pack")),
|
|
OPT_BOOL(0, "atomic", &atomic, N_("request atomic transaction on remote side")),
|
|
OPT_BOOL(0, "stateless-rpc", &stateless_rpc, N_("use stateless RPC protocol")),
|
|
OPT_BOOL(0, "stdin", &from_stdin, N_("read refs from stdin")),
|
|
OPT_BOOL(0, "helper-status", &helper_status, N_("print status from remote helper")),
|
|
{ OPTION_CALLBACK,
|
|
0, CAS_OPT_NAME, &cas, N_("<refname>:<expect>"),
|
|
N_("require old value of ref to be at this value"),
|
|
PARSE_OPT_OPTARG, parseopt_push_cas_option },
|
|
OPT_END()
|
|
};
|
|
|
|
git_config(send_pack_config, NULL);
|
|
argc = parse_options(argc, argv, prefix, options, send_pack_usage, 0);
|
|
if (argc > 0) {
|
|
dest = argv[0];
|
|
refspec_appendn(&rs, argv + 1, argc - 1);
|
|
}
|
|
|
|
if (!dest)
|
|
usage_with_options(send_pack_usage, options);
|
|
|
|
args.verbose = verbose;
|
|
args.dry_run = dry_run;
|
|
args.send_mirror = send_mirror;
|
|
args.force_update = force_update;
|
|
args.quiet = quiet;
|
|
args.push_cert = push_cert;
|
|
args.progress = progress;
|
|
args.use_thin_pack = use_thin_pack;
|
|
args.atomic = atomic;
|
|
args.stateless_rpc = stateless_rpc;
|
|
args.push_options = push_options.nr ? &push_options : NULL;
|
|
|
|
if (from_stdin) {
|
|
if (args.stateless_rpc) {
|
|
const char *buf;
|
|
while ((buf = packet_read_line(0, NULL)))
|
|
refspec_append(&rs, buf);
|
|
} else {
|
|
struct strbuf line = STRBUF_INIT;
|
|
while (strbuf_getline(&line, stdin) != EOF)
|
|
refspec_append(&rs, line.buf);
|
|
strbuf_release(&line);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* --all and --mirror are incompatible; neither makes sense
|
|
* with any refspecs.
|
|
*/
|
|
if ((rs.nr > 0 && (send_all || args.send_mirror)) ||
|
|
(send_all && args.send_mirror))
|
|
usage_with_options(send_pack_usage, options);
|
|
|
|
if (remote_name) {
|
|
remote = remote_get(remote_name);
|
|
if (!remote_has_url(remote, dest)) {
|
|
die("Destination %s is not a uri for %s",
|
|
dest, remote_name);
|
|
}
|
|
}
|
|
|
|
if (progress == -1)
|
|
progress = !args.quiet && isatty(2);
|
|
args.progress = progress;
|
|
|
|
if (args.stateless_rpc) {
|
|
conn = NULL;
|
|
fd[0] = 0;
|
|
fd[1] = 1;
|
|
} else {
|
|
conn = git_connect(fd, dest, receivepack,
|
|
args.verbose ? CONNECT_VERBOSE : 0);
|
|
}
|
|
|
|
packet_reader_init(&reader, fd[0], NULL, 0,
|
|
PACKET_READ_CHOMP_NEWLINE |
|
|
PACKET_READ_GENTLE_ON_EOF |
|
|
PACKET_READ_DIE_ON_ERR_PACKET);
|
|
|
|
switch (discover_version(&reader)) {
|
|
case protocol_v2:
|
|
die("support for protocol v2 not implemented yet");
|
|
break;
|
|
case protocol_v1:
|
|
case protocol_v0:
|
|
get_remote_heads(&reader, &remote_refs, REF_NORMAL,
|
|
&extra_have, &shallow);
|
|
break;
|
|
case protocol_unknown_version:
|
|
BUG("unknown protocol version");
|
|
}
|
|
|
|
local_refs = get_local_heads();
|
|
|
|
flags = MATCH_REFS_NONE;
|
|
|
|
if (send_all)
|
|
flags |= MATCH_REFS_ALL;
|
|
if (args.send_mirror)
|
|
flags |= MATCH_REFS_MIRROR;
|
|
|
|
/* match them up */
|
|
if (match_push_refs(local_refs, &remote_refs, &rs, flags))
|
|
return -1;
|
|
|
|
if (!is_empty_cas(&cas))
|
|
apply_push_cas(&cas, remote, remote_refs);
|
|
|
|
set_ref_status_for_push(remote_refs, args.send_mirror,
|
|
args.force_update);
|
|
|
|
ret = send_pack(&args, fd, conn, remote_refs, &extra_have);
|
|
|
|
if (helper_status)
|
|
print_helper_status(remote_refs);
|
|
|
|
close(fd[1]);
|
|
close(fd[0]);
|
|
|
|
ret |= finish_connect(conn);
|
|
|
|
if (!helper_status)
|
|
transport_print_push_status(dest, remote_refs, args.verbose, 0, &reject_reasons);
|
|
|
|
if (!args.dry_run && remote) {
|
|
struct ref *ref;
|
|
for (ref = remote_refs; ref; ref = ref->next)
|
|
transport_update_tracking_ref(remote, ref, args.verbose);
|
|
}
|
|
|
|
if (!ret && !transport_refs_pushed(remote_refs))
|
|
fprintf(stderr, "Everything up-to-date\n");
|
|
|
|
return ret;
|
|
}
|