2005-06-30 02:09:05 +00:00
|
|
|
#include "cache.h"
|
2005-07-19 11:03:47 +00:00
|
|
|
#include "commit.h"
|
2005-07-08 20:58:40 +00:00
|
|
|
#include "refs.h"
|
2005-06-30 03:50:15 +00:00
|
|
|
#include "pkt-line.h"
|
2009-10-31 00:47:41 +00:00
|
|
|
#include "sideband.h"
|
2007-03-12 23:00:29 +00:00
|
|
|
#include "run-command.h"
|
2007-05-12 15:45:59 +00:00
|
|
|
#include "remote.h"
|
2007-10-30 02:03:39 +00:00
|
|
|
#include "send-pack.h"
|
2009-10-31 00:47:41 +00:00
|
|
|
#include "quote.h"
|
2005-06-30 02:09:05 +00:00
|
|
|
|
2005-07-14 07:10:05 +00:00
|
|
|
static const char send_pack_usage[] =
|
2008-07-13 13:36:15 +00:00
|
|
|
"git send-pack [--all | --mirror] [--dry-run] [--force] [--receive-pack=<git-receive-pack>] [--verbose] [--thin] [<host>:]<directory> [<ref>...]\n"
|
2007-01-19 12:43:00 +00:00
|
|
|
" --all and explicit <ref> specification are mutually exclusive.";
|
2007-10-30 02:03:39 +00:00
|
|
|
|
2009-03-27 02:37:53 +00:00
|
|
|
static struct send_pack_args args;
|
2005-06-30 02:09:05 +00:00
|
|
|
|
2009-01-28 04:21:31 +00:00
|
|
|
static int feed_object(const unsigned char *sha1, int fd, int negative)
|
|
|
|
{
|
|
|
|
char buf[42];
|
|
|
|
|
|
|
|
if (negative && !has_sha1_file(sha1))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
memcpy(buf + negative, sha1_to_hex(sha1), 40);
|
|
|
|
if (negative)
|
|
|
|
buf[0] = '^';
|
|
|
|
buf[40 + negative] = '\n';
|
|
|
|
return write_or_whine(fd, buf, 41 + negative, "send-pack: send refs");
|
|
|
|
}
|
|
|
|
|
2006-09-05 21:52:12 +00:00
|
|
|
/*
|
2006-12-31 09:26:53 +00:00
|
|
|
* Make a pack stream and spit it out into file descriptor fd
|
2006-09-05 21:52:12 +00:00
|
|
|
*/
|
2009-03-09 01:06:07 +00:00
|
|
|
static int pack_objects(int fd, struct ref *refs, struct extra_have_objects *extra, struct send_pack_args *args)
|
2006-09-05 21:52:12 +00:00
|
|
|
{
|
2007-03-12 23:00:29 +00:00
|
|
|
/*
|
|
|
|
* The child becomes pack-objects --revs; we feed
|
|
|
|
* the revision parameters to it via its stdin and
|
|
|
|
* let its stdout go back to the other end.
|
|
|
|
*/
|
2007-10-30 02:03:39 +00:00
|
|
|
const char *argv[] = {
|
2007-03-12 23:00:29 +00:00
|
|
|
"pack-objects",
|
2009-11-23 17:43:50 +00:00
|
|
|
"--all-progress-implied",
|
2007-03-12 23:00:29 +00:00
|
|
|
"--revs",
|
|
|
|
"--stdout",
|
|
|
|
NULL,
|
|
|
|
NULL,
|
2009-05-01 20:56:47 +00:00
|
|
|
NULL,
|
2009-08-05 20:22:36 +00:00
|
|
|
NULL,
|
2007-03-12 23:00:29 +00:00
|
|
|
};
|
|
|
|
struct child_process po;
|
2008-09-09 08:27:09 +00:00
|
|
|
int i;
|
2006-09-05 21:52:12 +00:00
|
|
|
|
2009-05-01 20:56:47 +00:00
|
|
|
i = 4;
|
2009-03-09 01:06:07 +00:00
|
|
|
if (args->use_thin_pack)
|
2009-05-01 20:56:47 +00:00
|
|
|
argv[i++] = "--thin";
|
|
|
|
if (args->use_ofs_delta)
|
|
|
|
argv[i++] = "--delta-base-offset";
|
2009-08-05 20:22:36 +00:00
|
|
|
if (args->quiet)
|
|
|
|
argv[i++] = "-q";
|
2007-03-12 23:00:29 +00:00
|
|
|
memset(&po, 0, sizeof(po));
|
2007-10-30 02:03:39 +00:00
|
|
|
po.argv = argv;
|
2007-03-12 23:00:29 +00:00
|
|
|
po.in = -1;
|
2009-10-31 00:47:41 +00:00
|
|
|
po.out = args->stateless_rpc ? -1 : fd;
|
2007-03-12 23:00:29 +00:00
|
|
|
po.git_cmd = 1;
|
|
|
|
if (start_command(&po))
|
2009-06-27 15:58:46 +00:00
|
|
|
die_errno("git pack-objects failed");
|
2006-09-05 21:52:12 +00:00
|
|
|
|
2006-12-31 09:26:53 +00:00
|
|
|
/*
|
|
|
|
* We feed the pack-objects we just spawned with revision
|
|
|
|
* parameters by writing to the pipe.
|
2006-09-05 21:52:12 +00:00
|
|
|
*/
|
2009-01-28 04:21:31 +00:00
|
|
|
for (i = 0; i < extra->nr; i++)
|
|
|
|
if (!feed_object(extra->array[i], po.in, 1))
|
2008-09-09 08:27:09 +00:00
|
|
|
break;
|
2006-09-05 21:52:12 +00:00
|
|
|
|
2008-09-09 08:27:09 +00:00
|
|
|
while (refs) {
|
2006-09-05 21:52:12 +00:00
|
|
|
if (!is_null_sha1(refs->old_sha1) &&
|
2009-01-28 04:21:31 +00:00
|
|
|
!feed_object(refs->old_sha1, po.in, 1))
|
|
|
|
break;
|
|
|
|
if (!is_null_sha1(refs->new_sha1) &&
|
|
|
|
!feed_object(refs->new_sha1, po.in, 0))
|
|
|
|
break;
|
2006-09-05 21:52:12 +00:00
|
|
|
refs = refs->next;
|
|
|
|
}
|
|
|
|
|
2008-02-16 17:36:38 +00:00
|
|
|
close(po.in);
|
2009-10-31 00:47:41 +00:00
|
|
|
|
|
|
|
if (args->stateless_rpc) {
|
|
|
|
char *buf = xmalloc(LARGE_PACKET_MAX);
|
|
|
|
while (1) {
|
|
|
|
ssize_t n = xread(po.out, buf, LARGE_PACKET_MAX);
|
|
|
|
if (n <= 0)
|
|
|
|
break;
|
|
|
|
send_sideband(fd, -1, buf, n, LARGE_PACKET_MAX);
|
|
|
|
}
|
|
|
|
free(buf);
|
|
|
|
close(po.out);
|
|
|
|
po.out = -1;
|
|
|
|
}
|
|
|
|
|
2007-03-12 23:00:29 +00:00
|
|
|
if (finish_command(&po))
|
|
|
|
return error("pack-objects died with strange error");
|
|
|
|
return 0;
|
2005-06-30 17:17:39 +00:00
|
|
|
}
|
2005-06-30 05:31:41 +00:00
|
|
|
|
2007-11-17 12:56:03 +00:00
|
|
|
static int receive_status(int in, struct ref *refs)
|
|
|
|
{
|
|
|
|
struct ref *hint;
|
2005-12-26 07:18:37 +00:00
|
|
|
char line[1000];
|
|
|
|
int ret = 0;
|
|
|
|
int len = packet_read_line(in, line, sizeof(line));
|
send-pack: tighten remote error reporting
Previously, we set all ref pushes to 'OK', and then marked
them as errors if the remote reported so. This has the
problem that if the remote dies or fails to report a ref, we
just assume it was OK.
Instead, we use a new non-OK state to indicate that we are
expecting status (if the remote doesn't support the
report-status feature, we fall back on the old behavior).
Thus we can flag refs for which we expected a status, but
got none (conversely, we now also print a warning for refs
for which we get a status, but weren't expecting one).
This also allows us to simplify the receive_status exit
code, since each ref is individually marked with failure
until we get a success response. We can just print the usual
status table, so the user still gets a sense of what we were
trying to do when the failure happened.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-18 07:16:52 +00:00
|
|
|
if (len < 10 || memcmp(line, "unpack ", 7))
|
|
|
|
return error("did not receive remote status");
|
2005-12-26 07:18:37 +00:00
|
|
|
if (memcmp(line, "unpack ok\n", 10)) {
|
send-pack: tighten remote error reporting
Previously, we set all ref pushes to 'OK', and then marked
them as errors if the remote reported so. This has the
problem that if the remote dies or fails to report a ref, we
just assume it was OK.
Instead, we use a new non-OK state to indicate that we are
expecting status (if the remote doesn't support the
report-status feature, we fall back on the old behavior).
Thus we can flag refs for which we expected a status, but
got none (conversely, we now also print a warning for refs
for which we get a status, but weren't expecting one).
This also allows us to simplify the receive_status exit
code, since each ref is individually marked with failure
until we get a success response. We can just print the usual
status table, so the user still gets a sense of what we were
trying to do when the failure happened.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-18 07:16:52 +00:00
|
|
|
char *p = line + strlen(line) - 1;
|
|
|
|
if (*p == '\n')
|
|
|
|
*p = '\0';
|
|
|
|
error("unpack failed: %s", line + 7);
|
2005-12-26 07:18:37 +00:00
|
|
|
ret = -1;
|
|
|
|
}
|
2007-11-17 12:56:03 +00:00
|
|
|
hint = NULL;
|
2005-12-26 07:18:37 +00:00
|
|
|
while (1) {
|
send-pack: tighten remote error reporting
Previously, we set all ref pushes to 'OK', and then marked
them as errors if the remote reported so. This has the
problem that if the remote dies or fails to report a ref, we
just assume it was OK.
Instead, we use a new non-OK state to indicate that we are
expecting status (if the remote doesn't support the
report-status feature, we fall back on the old behavior).
Thus we can flag refs for which we expected a status, but
got none (conversely, we now also print a warning for refs
for which we get a status, but weren't expecting one).
This also allows us to simplify the receive_status exit
code, since each ref is individually marked with failure
until we get a success response. We can just print the usual
status table, so the user still gets a sense of what we were
trying to do when the failure happened.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-18 07:16:52 +00:00
|
|
|
char *refname;
|
|
|
|
char *msg;
|
2005-12-26 07:18:37 +00:00
|
|
|
len = packet_read_line(in, line, sizeof(line));
|
|
|
|
if (!len)
|
|
|
|
break;
|
|
|
|
if (len < 3 ||
|
send-pack: tighten remote error reporting
Previously, we set all ref pushes to 'OK', and then marked
them as errors if the remote reported so. This has the
problem that if the remote dies or fails to report a ref, we
just assume it was OK.
Instead, we use a new non-OK state to indicate that we are
expecting status (if the remote doesn't support the
report-status feature, we fall back on the old behavior).
Thus we can flag refs for which we expected a status, but
got none (conversely, we now also print a warning for refs
for which we get a status, but weren't expecting one).
This also allows us to simplify the receive_status exit
code, since each ref is individually marked with failure
until we get a success response. We can just print the usual
status table, so the user still gets a sense of what we were
trying to do when the failure happened.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-18 07:16:52 +00:00
|
|
|
(memcmp(line, "ok ", 3) && memcmp(line, "ng ", 3))) {
|
2005-12-26 07:18:37 +00:00
|
|
|
fprintf(stderr, "protocol error: %s\n", line);
|
|
|
|
ret = -1;
|
|
|
|
break;
|
|
|
|
}
|
send-pack: tighten remote error reporting
Previously, we set all ref pushes to 'OK', and then marked
them as errors if the remote reported so. This has the
problem that if the remote dies or fails to report a ref, we
just assume it was OK.
Instead, we use a new non-OK state to indicate that we are
expecting status (if the remote doesn't support the
report-status feature, we fall back on the old behavior).
Thus we can flag refs for which we expected a status, but
got none (conversely, we now also print a warning for refs
for which we get a status, but weren't expecting one).
This also allows us to simplify the receive_status exit
code, since each ref is individually marked with failure
until we get a success response. We can just print the usual
status table, so the user still gets a sense of what we were
trying to do when the failure happened.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-18 07:16:52 +00:00
|
|
|
|
|
|
|
line[strlen(line)-1] = '\0';
|
|
|
|
refname = line + 3;
|
|
|
|
msg = strchr(refname, ' ');
|
|
|
|
if (msg)
|
|
|
|
*msg++ = '\0';
|
|
|
|
|
|
|
|
/* first try searching at our hint, falling back to all refs */
|
2007-11-17 12:56:03 +00:00
|
|
|
if (hint)
|
send-pack: tighten remote error reporting
Previously, we set all ref pushes to 'OK', and then marked
them as errors if the remote reported so. This has the
problem that if the remote dies or fails to report a ref, we
just assume it was OK.
Instead, we use a new non-OK state to indicate that we are
expecting status (if the remote doesn't support the
report-status feature, we fall back on the old behavior).
Thus we can flag refs for which we expected a status, but
got none (conversely, we now also print a warning for refs
for which we get a status, but weren't expecting one).
This also allows us to simplify the receive_status exit
code, since each ref is individually marked with failure
until we get a success response. We can just print the usual
status table, so the user still gets a sense of what we were
trying to do when the failure happened.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-18 07:16:52 +00:00
|
|
|
hint = find_ref_by_name(hint, refname);
|
2007-11-17 12:56:03 +00:00
|
|
|
if (!hint)
|
send-pack: tighten remote error reporting
Previously, we set all ref pushes to 'OK', and then marked
them as errors if the remote reported so. This has the
problem that if the remote dies or fails to report a ref, we
just assume it was OK.
Instead, we use a new non-OK state to indicate that we are
expecting status (if the remote doesn't support the
report-status feature, we fall back on the old behavior).
Thus we can flag refs for which we expected a status, but
got none (conversely, we now also print a warning for refs
for which we get a status, but weren't expecting one).
This also allows us to simplify the receive_status exit
code, since each ref is individually marked with failure
until we get a success response. We can just print the usual
status table, so the user still gets a sense of what we were
trying to do when the failure happened.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-18 07:16:52 +00:00
|
|
|
hint = find_ref_by_name(refs, refname);
|
|
|
|
if (!hint) {
|
|
|
|
warning("remote reported status on unknown ref: %s",
|
|
|
|
refname);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (hint->status != REF_STATUS_EXPECTING_REPORT) {
|
|
|
|
warning("remote reported status on unexpected ref: %s",
|
|
|
|
refname);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (line[0] == 'o' && line[1] == 'k')
|
|
|
|
hint->status = REF_STATUS_OK;
|
|
|
|
else {
|
|
|
|
hint->status = REF_STATUS_REMOTE_REJECT;
|
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
if (msg)
|
|
|
|
hint->remote_status = xstrdup(msg);
|
|
|
|
/* start our next search from the next ref */
|
|
|
|
hint = hint->next;
|
2005-12-26 07:18:37 +00:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-10-18 06:19:15 +00:00
|
|
|
static void update_tracking_ref(struct remote *remote, struct ref *ref)
|
|
|
|
{
|
|
|
|
struct refspec rs;
|
|
|
|
|
2008-11-05 20:55:54 +00:00
|
|
|
if (ref->status != REF_STATUS_OK && ref->status != REF_STATUS_UPTODATE)
|
2007-10-18 06:19:15 +00:00
|
|
|
return;
|
|
|
|
|
2007-11-17 12:55:15 +00:00
|
|
|
rs.src = ref->name;
|
|
|
|
rs.dst = NULL;
|
2007-10-18 06:19:15 +00:00
|
|
|
|
|
|
|
if (!remote_find_tracking(remote, &rs)) {
|
2007-11-05 05:12:18 +00:00
|
|
|
if (args.verbose)
|
|
|
|
fprintf(stderr, "updating local tracking ref '%s'\n", rs.dst);
|
2007-11-17 12:55:15 +00:00
|
|
|
if (ref->deletion) {
|
2008-10-26 02:33:56 +00:00
|
|
|
delete_ref(rs.dst, NULL, 0);
|
2007-10-18 06:19:15 +00:00
|
|
|
} else
|
|
|
|
update_ref("update by push", rs.dst,
|
|
|
|
ref->new_sha1, NULL, 0, 0);
|
|
|
|
free(rs.dst);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-11-05 05:11:15 +00:00
|
|
|
#define SUMMARY_WIDTH (2 * DEFAULT_ABBREV + 3)
|
|
|
|
|
2007-11-17 12:54:27 +00:00
|
|
|
static void print_ref_status(char flag, const char *summary, struct ref *to, struct ref *from, const char *msg)
|
|
|
|
{
|
|
|
|
fprintf(stderr, " %c %-*s ", flag, SUMMARY_WIDTH, summary);
|
|
|
|
if (from)
|
2009-05-13 21:22:04 +00:00
|
|
|
fprintf(stderr, "%s -> %s", prettify_refname(from->name), prettify_refname(to->name));
|
2007-11-17 12:54:27 +00:00
|
|
|
else
|
2009-05-13 21:22:04 +00:00
|
|
|
fputs(prettify_refname(to->name), stderr);
|
2007-11-17 12:54:27 +00:00
|
|
|
if (msg) {
|
|
|
|
fputs(" (", stderr);
|
|
|
|
fputs(msg, stderr);
|
|
|
|
fputc(')', stderr);
|
|
|
|
}
|
|
|
|
fputc('\n', stderr);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char *status_abbrev(unsigned char sha1[20])
|
|
|
|
{
|
2008-03-02 07:43:32 +00:00
|
|
|
return find_unique_abbrev(sha1, DEFAULT_ABBREV);
|
2007-11-17 12:54:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void print_ok_ref_status(struct ref *ref)
|
|
|
|
{
|
|
|
|
if (ref->deletion)
|
|
|
|
print_ref_status('-', "[deleted]", ref, NULL, NULL);
|
|
|
|
else if (is_null_sha1(ref->old_sha1))
|
|
|
|
print_ref_status('*',
|
|
|
|
(!prefixcmp(ref->name, "refs/tags/") ? "[new tag]" :
|
|
|
|
"[new branch]"),
|
|
|
|
ref, ref->peer_ref, NULL);
|
|
|
|
else {
|
|
|
|
char quickref[84];
|
|
|
|
char type;
|
|
|
|
const char *msg;
|
|
|
|
|
|
|
|
strcpy(quickref, status_abbrev(ref->old_sha1));
|
|
|
|
if (ref->nonfastforward) {
|
|
|
|
strcat(quickref, "...");
|
|
|
|
type = '+';
|
|
|
|
msg = "forced update";
|
|
|
|
} else {
|
|
|
|
strcat(quickref, "..");
|
|
|
|
type = ' ';
|
|
|
|
msg = NULL;
|
|
|
|
}
|
|
|
|
strcat(quickref, status_abbrev(ref->new_sha1));
|
|
|
|
|
|
|
|
print_ref_status(type, quickref, ref, ref->peer_ref, msg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-11-20 11:18:01 +00:00
|
|
|
static int print_one_push_status(struct ref *ref, const char *dest, int count)
|
|
|
|
{
|
|
|
|
if (!count)
|
|
|
|
fprintf(stderr, "To %s\n", dest);
|
|
|
|
|
|
|
|
switch(ref->status) {
|
|
|
|
case REF_STATUS_NONE:
|
|
|
|
print_ref_status('X', "[no match]", ref, NULL, NULL);
|
|
|
|
break;
|
|
|
|
case REF_STATUS_REJECT_NODELETE:
|
|
|
|
print_ref_status('!', "[rejected]", ref, NULL,
|
|
|
|
"remote does not support deleting refs");
|
|
|
|
break;
|
|
|
|
case REF_STATUS_UPTODATE:
|
|
|
|
print_ref_status('=', "[up to date]", ref,
|
|
|
|
ref->peer_ref, NULL);
|
|
|
|
break;
|
|
|
|
case REF_STATUS_REJECT_NONFASTFORWARD:
|
|
|
|
print_ref_status('!', "[rejected]", ref, ref->peer_ref,
|
2009-10-24 08:31:32 +00:00
|
|
|
"non-fast-forward");
|
2007-11-20 11:18:01 +00:00
|
|
|
break;
|
|
|
|
case REF_STATUS_REMOTE_REJECT:
|
|
|
|
print_ref_status('!', "[remote rejected]", ref,
|
|
|
|
ref->deletion ? NULL : ref->peer_ref,
|
|
|
|
ref->remote_status);
|
|
|
|
break;
|
|
|
|
case REF_STATUS_EXPECTING_REPORT:
|
|
|
|
print_ref_status('!', "[remote failure]", ref,
|
|
|
|
ref->deletion ? NULL : ref->peer_ref,
|
|
|
|
"remote failed to report status");
|
|
|
|
break;
|
|
|
|
case REF_STATUS_OK:
|
|
|
|
print_ok_ref_status(ref);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-11-17 12:54:27 +00:00
|
|
|
static void print_push_status(const char *dest, struct ref *refs)
|
|
|
|
{
|
|
|
|
struct ref *ref;
|
2007-11-20 11:18:01 +00:00
|
|
|
int n = 0;
|
2007-11-17 12:54:27 +00:00
|
|
|
|
2007-11-20 11:18:01 +00:00
|
|
|
if (args.verbose) {
|
|
|
|
for (ref = refs; ref; ref = ref->next)
|
|
|
|
if (ref->status == REF_STATUS_UPTODATE)
|
|
|
|
n += print_one_push_status(ref, dest, n);
|
|
|
|
}
|
2007-11-17 12:54:27 +00:00
|
|
|
|
2007-11-20 11:18:01 +00:00
|
|
|
for (ref = refs; ref; ref = ref->next)
|
|
|
|
if (ref->status == REF_STATUS_OK)
|
|
|
|
n += print_one_push_status(ref, dest, n);
|
2007-11-17 12:54:27 +00:00
|
|
|
|
2007-11-20 11:18:01 +00:00
|
|
|
for (ref = refs; ref; ref = ref->next) {
|
|
|
|
if (ref->status != REF_STATUS_NONE &&
|
|
|
|
ref->status != REF_STATUS_UPTODATE &&
|
|
|
|
ref->status != REF_STATUS_OK)
|
|
|
|
n += print_one_push_status(ref, dest, n);
|
2007-11-17 12:54:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-11-18 08:08:22 +00:00
|
|
|
static int refs_pushed(struct ref *ref)
|
|
|
|
{
|
|
|
|
for (; ref; ref = ref->next) {
|
|
|
|
switch(ref->status) {
|
|
|
|
case REF_STATUS_NONE:
|
|
|
|
case REF_STATUS_UPTODATE:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-10-31 00:47:41 +00:00
|
|
|
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_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');
|
|
|
|
|
|
|
|
safe_write(1, buf.buf, buf.len);
|
|
|
|
}
|
|
|
|
strbuf_release(&buf);
|
|
|
|
}
|
|
|
|
|
2009-03-09 01:06:07 +00:00
|
|
|
int send_pack(struct send_pack_args *args,
|
|
|
|
int fd[], struct child_process *conn,
|
|
|
|
struct ref *remote_refs,
|
|
|
|
struct extra_have_objects *extra_have)
|
2005-06-30 02:09:05 +00:00
|
|
|
{
|
2009-03-09 01:06:07 +00:00
|
|
|
int in = fd[0];
|
|
|
|
int out = fd[1];
|
2009-10-31 00:47:41 +00:00
|
|
|
struct strbuf req_buf = STRBUF_INIT;
|
2009-03-09 01:06:07 +00:00
|
|
|
struct ref *ref;
|
2005-07-08 20:58:40 +00:00
|
|
|
int new_refs;
|
2005-12-26 07:18:37 +00:00
|
|
|
int ask_for_status_report = 0;
|
2006-11-24 08:26:49 +00:00
|
|
|
int allow_deleting_refs = 0;
|
2005-12-26 07:18:37 +00:00
|
|
|
int expect_status_report = 0;
|
2007-11-17 12:56:03 +00:00
|
|
|
int ret;
|
2005-07-08 20:58:40 +00:00
|
|
|
|
2005-12-26 07:18:37 +00:00
|
|
|
/* Does the other end support the reporting? */
|
|
|
|
if (server_supports("report-status"))
|
|
|
|
ask_for_status_report = 1;
|
2006-11-24 08:26:49 +00:00
|
|
|
if (server_supports("delete-refs"))
|
|
|
|
allow_deleting_refs = 1;
|
2009-05-01 20:56:47 +00:00
|
|
|
if (server_supports("ofs-delta"))
|
|
|
|
args->use_ofs_delta = 1;
|
2005-12-26 07:18:37 +00:00
|
|
|
|
2005-12-04 16:59:37 +00:00
|
|
|
if (!remote_refs) {
|
2007-10-16 21:16:05 +00:00
|
|
|
fprintf(stderr, "No refs in common and none specified; doing nothing.\n"
|
|
|
|
"Perhaps you should specify a branch such as 'master'.\n");
|
2005-12-04 16:59:37 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-07-08 20:58:40 +00:00
|
|
|
/*
|
2005-08-03 23:35:29 +00:00
|
|
|
* Finally, tell the other end!
|
2005-07-08 20:58:40 +00:00
|
|
|
*/
|
2005-08-03 23:35:29 +00:00
|
|
|
new_refs = 0;
|
|
|
|
for (ref = remote_refs; ref; ref = ref->next) {
|
2006-11-24 08:26:49 +00:00
|
|
|
|
2008-11-05 20:55:54 +00:00
|
|
|
if (ref->peer_ref)
|
|
|
|
hashcpy(ref->new_sha1, ref->peer_ref->new_sha1);
|
2009-03-09 01:06:07 +00:00
|
|
|
else if (!args->send_mirror)
|
2008-11-05 20:55:54 +00:00
|
|
|
continue;
|
2007-11-09 23:32:10 +00:00
|
|
|
|
2008-11-05 20:55:54 +00:00
|
|
|
ref->deletion = is_null_sha1(ref->new_sha1);
|
2007-11-17 12:54:27 +00:00
|
|
|
if (ref->deletion && !allow_deleting_refs) {
|
|
|
|
ref->status = REF_STATUS_REJECT_NODELETE;
|
2006-11-24 08:26:49 +00:00
|
|
|
continue;
|
|
|
|
}
|
2007-11-17 12:54:27 +00:00
|
|
|
if (!ref->deletion &&
|
2008-11-05 20:55:54 +00:00
|
|
|
!hashcmp(ref->old_sha1, ref->new_sha1)) {
|
2007-11-17 12:54:27 +00:00
|
|
|
ref->status = REF_STATUS_UPTODATE;
|
2005-08-05 07:47:56 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This part determines what can overwrite what.
|
|
|
|
* The rules are:
|
|
|
|
*
|
2005-08-24 07:40:14 +00:00
|
|
|
* (0) you can always use --force or +A:B notation to
|
|
|
|
* selectively force individual ref pairs.
|
2005-08-05 07:47:56 +00:00
|
|
|
*
|
|
|
|
* (1) if the old thing does not exist, it is OK.
|
|
|
|
*
|
|
|
|
* (2) if you do not have the old thing, you are not allowed
|
|
|
|
* to overwrite it; you would not know what you are losing
|
|
|
|
* otherwise.
|
|
|
|
*
|
|
|
|
* (3) if both new and old are commit-ish, and new is a
|
|
|
|
* descendant of old, it is OK.
|
2006-11-24 08:26:49 +00:00
|
|
|
*
|
|
|
|
* (4) regardless of all of the above, removing :B is
|
|
|
|
* always allowed.
|
2005-08-05 07:47:56 +00:00
|
|
|
*/
|
|
|
|
|
2007-11-17 12:54:27 +00:00
|
|
|
ref->nonfastforward =
|
|
|
|
!ref->deletion &&
|
2006-12-31 08:59:53 +00:00
|
|
|
!is_null_sha1(ref->old_sha1) &&
|
2007-11-17 12:54:27 +00:00
|
|
|
(!has_sha1_file(ref->old_sha1)
|
2008-11-05 20:55:54 +00:00
|
|
|
|| !ref_newer(ref->new_sha1, ref->old_sha1));
|
2007-11-17 12:54:27 +00:00
|
|
|
|
2009-03-09 01:06:07 +00:00
|
|
|
if (ref->nonfastforward && !ref->force && !args->force_update) {
|
2007-11-17 12:54:27 +00:00
|
|
|
ref->status = REF_STATUS_REJECT_NONFASTFORWARD;
|
|
|
|
continue;
|
2005-06-30 05:31:41 +00:00
|
|
|
}
|
2007-11-17 12:54:27 +00:00
|
|
|
|
|
|
|
if (!ref->deletion)
|
2006-11-24 08:26:49 +00:00
|
|
|
new_refs++;
|
2005-12-26 07:18:37 +00:00
|
|
|
|
2009-03-09 01:06:07 +00:00
|
|
|
if (!args->dry_run) {
|
2007-11-17 12:54:27 +00:00
|
|
|
char *old_hex = sha1_to_hex(ref->old_sha1);
|
|
|
|
char *new_hex = sha1_to_hex(ref->new_sha1);
|
|
|
|
|
2007-10-11 19:32:26 +00:00
|
|
|
if (ask_for_status_report) {
|
2009-10-31 00:47:41 +00:00
|
|
|
packet_buf_write(&req_buf, "%s %s %s%c%s",
|
2007-10-11 19:32:26 +00:00
|
|
|
old_hex, new_hex, ref->name, 0,
|
|
|
|
"report-status");
|
|
|
|
ask_for_status_report = 0;
|
|
|
|
expect_status_report = 1;
|
|
|
|
}
|
|
|
|
else
|
2009-10-31 00:47:41 +00:00
|
|
|
packet_buf_write(&req_buf, "%s %s %s",
|
2007-10-11 19:32:26 +00:00
|
|
|
old_hex, new_hex, ref->name);
|
2005-12-26 07:18:37 +00:00
|
|
|
}
|
send-pack: tighten remote error reporting
Previously, we set all ref pushes to 'OK', and then marked
them as errors if the remote reported so. This has the
problem that if the remote dies or fails to report a ref, we
just assume it was OK.
Instead, we use a new non-OK state to indicate that we are
expecting status (if the remote doesn't support the
report-status feature, we fall back on the old behavior).
Thus we can flag refs for which we expected a status, but
got none (conversely, we now also print a warning for refs
for which we get a status, but weren't expecting one).
This also allows us to simplify the receive_status exit
code, since each ref is individually marked with failure
until we get a success response. We can just print the usual
status table, so the user still gets a sense of what we were
trying to do when the failure happened.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-18 07:16:52 +00:00
|
|
|
ref->status = expect_status_report ?
|
|
|
|
REF_STATUS_EXPECTING_REPORT :
|
|
|
|
REF_STATUS_OK;
|
2005-06-30 02:09:05 +00:00
|
|
|
}
|
2005-08-03 23:35:29 +00:00
|
|
|
|
2009-10-31 00:47:41 +00:00
|
|
|
if (args->stateless_rpc) {
|
|
|
|
if (!args->dry_run) {
|
|
|
|
packet_buf_flush(&req_buf);
|
|
|
|
send_sideband(out, -1, req_buf.buf, req_buf.len, LARGE_PACKET_MAX);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
safe_write(out, req_buf.buf, req_buf.len);
|
|
|
|
packet_flush(out);
|
|
|
|
}
|
|
|
|
strbuf_release(&req_buf);
|
|
|
|
|
2009-03-09 01:06:07 +00:00
|
|
|
if (new_refs && !args->dry_run) {
|
|
|
|
if (pack_objects(out, remote_refs, extra_have, args) < 0) {
|
|
|
|
for (ref = remote_refs; ref; ref = ref->next)
|
|
|
|
ref->status = REF_STATUS_NONE;
|
2007-11-17 12:54:27 +00:00
|
|
|
return -1;
|
2009-03-09 01:06:07 +00:00
|
|
|
}
|
2007-11-17 12:54:27 +00:00
|
|
|
}
|
2009-10-31 00:47:41 +00:00
|
|
|
if (args->stateless_rpc && !args->dry_run)
|
|
|
|
packet_flush(out);
|
2005-12-26 07:18:37 +00:00
|
|
|
|
send-pack: tighten remote error reporting
Previously, we set all ref pushes to 'OK', and then marked
them as errors if the remote reported so. This has the
problem that if the remote dies or fails to report a ref, we
just assume it was OK.
Instead, we use a new non-OK state to indicate that we are
expecting status (if the remote doesn't support the
report-status feature, we fall back on the old behavior).
Thus we can flag refs for which we expected a status, but
got none (conversely, we now also print a warning for refs
for which we get a status, but weren't expecting one).
This also allows us to simplify the receive_status exit
code, since each ref is individually marked with failure
until we get a success response. We can just print the usual
status table, so the user still gets a sense of what we were
trying to do when the failure happened.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-18 07:16:52 +00:00
|
|
|
if (expect_status_report)
|
2007-11-17 12:56:03 +00:00
|
|
|
ret = receive_status(in, remote_refs);
|
|
|
|
else
|
|
|
|
ret = 0;
|
2009-10-31 00:47:41 +00:00
|
|
|
if (args->stateless_rpc)
|
|
|
|
packet_flush(out);
|
2007-11-17 12:56:03 +00:00
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2007-11-17 12:54:27 +00:00
|
|
|
for (ref = remote_refs; ref; ref = ref->next) {
|
|
|
|
switch (ref->status) {
|
|
|
|
case REF_STATUS_NONE:
|
|
|
|
case REF_STATUS_UPTODATE:
|
|
|
|
case REF_STATUS_OK:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
2005-06-30 02:09:05 +00:00
|
|
|
}
|
|
|
|
|
2007-10-30 01:05:40 +00:00
|
|
|
static void verify_remote_names(int nr_heads, const char **heads)
|
2006-12-13 18:30:11 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < nr_heads; i++) {
|
2008-04-28 15:32:12 +00:00
|
|
|
const char *local = heads[i];
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 06:34:37 +00:00
|
|
|
const char *remote = strrchr(heads[i], ':');
|
2006-12-13 18:30:11 +00:00
|
|
|
|
2008-04-28 15:32:12 +00:00
|
|
|
if (*local == '+')
|
|
|
|
local++;
|
|
|
|
|
|
|
|
/* A matching refspec is okay. */
|
|
|
|
if (remote == local && remote[1] == '\0')
|
|
|
|
continue;
|
|
|
|
|
|
|
|
remote = remote ? (remote + 1) : local;
|
2006-12-13 18:30:11 +00:00
|
|
|
switch (check_ref_format(remote)) {
|
|
|
|
case 0: /* ok */
|
2008-01-02 19:14:40 +00:00
|
|
|
case CHECK_REF_FORMAT_ONELEVEL:
|
|
|
|
/* ok but a single level -- that is fine for
|
|
|
|
* a match pattern.
|
|
|
|
*/
|
|
|
|
case CHECK_REF_FORMAT_WILDCARD:
|
|
|
|
/* ok but ends with a pattern-match character */
|
2006-12-13 18:30:11 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
die("remote part of refspec is not a valid name in %s",
|
|
|
|
heads[i]);
|
|
|
|
}
|
|
|
|
}
|
2005-08-03 23:35:29 +00:00
|
|
|
|
2007-10-30 02:03:39 +00:00
|
|
|
int cmd_send_pack(int argc, const char **argv, const char *prefix)
|
2005-06-30 02:09:05 +00:00
|
|
|
{
|
2009-03-09 01:06:07 +00:00
|
|
|
int i, nr_refspecs = 0;
|
|
|
|
const char **refspecs = NULL;
|
2007-10-30 02:03:39 +00:00
|
|
|
const char *remote_name = NULL;
|
2007-05-16 02:50:19 +00:00
|
|
|
struct remote *remote = NULL;
|
2007-10-30 02:03:39 +00:00
|
|
|
const char *dest = NULL;
|
2009-03-09 01:06:07 +00:00
|
|
|
int fd[2];
|
|
|
|
struct child_process *conn;
|
|
|
|
struct extra_have_objects extra_have;
|
2009-05-31 14:26:48 +00:00
|
|
|
struct ref *remote_refs, *local_refs;
|
2009-03-09 01:06:07 +00:00
|
|
|
int ret;
|
2009-10-31 00:47:41 +00:00
|
|
|
int helper_status = 0;
|
2009-03-09 01:06:07 +00:00
|
|
|
int send_all = 0;
|
|
|
|
const char *receivepack = "git-receive-pack";
|
|
|
|
int flags;
|
2006-03-24 07:41:18 +00:00
|
|
|
|
2005-06-30 02:09:05 +00:00
|
|
|
argv++;
|
2005-07-16 20:26:33 +00:00
|
|
|
for (i = 1; i < argc; i++, argv++) {
|
2007-10-30 02:03:39 +00:00
|
|
|
const char *arg = *argv;
|
2005-06-30 02:09:05 +00:00
|
|
|
|
|
|
|
if (*arg == '-') {
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
if (!prefixcmp(arg, "--receive-pack=")) {
|
2009-03-09 01:06:07 +00:00
|
|
|
receivepack = arg + 15;
|
2007-01-19 12:49:27 +00:00
|
|
|
continue;
|
|
|
|
}
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
if (!prefixcmp(arg, "--exec=")) {
|
2009-03-09 01:06:07 +00:00
|
|
|
receivepack = arg + 7;
|
2005-06-30 02:09:05 +00:00
|
|
|
continue;
|
|
|
|
}
|
2007-05-16 02:50:19 +00:00
|
|
|
if (!prefixcmp(arg, "--remote=")) {
|
|
|
|
remote_name = arg + 9;
|
|
|
|
continue;
|
|
|
|
}
|
2005-07-16 20:26:33 +00:00
|
|
|
if (!strcmp(arg, "--all")) {
|
2009-03-09 01:06:07 +00:00
|
|
|
send_all = 1;
|
2005-07-16 20:26:33 +00:00
|
|
|
continue;
|
|
|
|
}
|
2007-10-11 19:32:26 +00:00
|
|
|
if (!strcmp(arg, "--dry-run")) {
|
2007-10-30 02:03:39 +00:00
|
|
|
args.dry_run = 1;
|
2007-10-11 19:32:26 +00:00
|
|
|
continue;
|
|
|
|
}
|
2007-11-09 23:32:10 +00:00
|
|
|
if (!strcmp(arg, "--mirror")) {
|
|
|
|
args.send_mirror = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-07-19 11:03:47 +00:00
|
|
|
if (!strcmp(arg, "--force")) {
|
2007-10-30 02:03:39 +00:00
|
|
|
args.force_update = 1;
|
2005-07-19 11:03:47 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-12-21 02:13:02 +00:00
|
|
|
if (!strcmp(arg, "--verbose")) {
|
2007-10-30 02:03:39 +00:00
|
|
|
args.verbose = 1;
|
2005-12-21 02:13:02 +00:00
|
|
|
continue;
|
|
|
|
}
|
2006-02-19 23:03:49 +00:00
|
|
|
if (!strcmp(arg, "--thin")) {
|
2007-10-30 02:03:39 +00:00
|
|
|
args.use_thin_pack = 1;
|
2006-02-19 23:03:49 +00:00
|
|
|
continue;
|
|
|
|
}
|
2009-10-31 00:47:41 +00:00
|
|
|
if (!strcmp(arg, "--stateless-rpc")) {
|
|
|
|
args.stateless_rpc = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!strcmp(arg, "--helper-status")) {
|
|
|
|
helper_status = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-06-30 02:09:05 +00:00
|
|
|
usage(send_pack_usage);
|
|
|
|
}
|
2005-07-16 20:26:33 +00:00
|
|
|
if (!dest) {
|
|
|
|
dest = arg;
|
|
|
|
continue;
|
|
|
|
}
|
2009-03-09 01:06:07 +00:00
|
|
|
refspecs = (const char **) argv;
|
|
|
|
nr_refspecs = argc - i;
|
2005-06-30 02:09:05 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!dest)
|
|
|
|
usage(send_pack_usage);
|
2007-11-09 23:32:10 +00:00
|
|
|
/*
|
|
|
|
* --all and --mirror are incompatible; neither makes sense
|
|
|
|
* with any refspecs.
|
|
|
|
*/
|
2009-03-09 01:06:07 +00:00
|
|
|
if ((refspecs && (send_all || args.send_mirror)) ||
|
|
|
|
(send_all && args.send_mirror))
|
2005-08-02 19:20:27 +00:00
|
|
|
usage(send_pack_usage);
|
2006-12-13 18:30:11 +00:00
|
|
|
|
2007-05-16 02:50:19 +00:00
|
|
|
if (remote_name) {
|
|
|
|
remote = remote_get(remote_name);
|
2007-09-19 04:49:27 +00:00
|
|
|
if (!remote_has_url(remote, dest)) {
|
2007-05-16 02:50:19 +00:00
|
|
|
die("Destination %s is not a uri for %s",
|
|
|
|
dest, remote_name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-31 00:47:41 +00:00
|
|
|
if (args.stateless_rpc) {
|
|
|
|
conn = NULL;
|
|
|
|
fd[0] = 0;
|
|
|
|
fd[1] = 1;
|
|
|
|
} else {
|
|
|
|
conn = git_connect(fd, dest, receivepack,
|
|
|
|
args.verbose ? CONNECT_VERBOSE : 0);
|
|
|
|
}
|
2007-10-30 02:03:39 +00:00
|
|
|
|
2009-03-09 01:06:07 +00:00
|
|
|
memset(&extra_have, 0, sizeof(extra_have));
|
|
|
|
|
|
|
|
get_remote_heads(fd[0], &remote_refs, 0, NULL, REF_NORMAL,
|
|
|
|
&extra_have);
|
|
|
|
|
|
|
|
verify_remote_names(nr_refspecs, refspecs);
|
|
|
|
|
|
|
|
local_refs = get_local_heads();
|
2007-10-30 02:03:39 +00:00
|
|
|
|
2009-03-09 01:06:07 +00:00
|
|
|
flags = MATCH_REFS_NONE;
|
|
|
|
|
|
|
|
if (send_all)
|
|
|
|
flags |= MATCH_REFS_ALL;
|
|
|
|
if (args.send_mirror)
|
|
|
|
flags |= MATCH_REFS_MIRROR;
|
|
|
|
|
|
|
|
/* match them up */
|
2009-05-31 14:26:48 +00:00
|
|
|
if (match_refs(local_refs, &remote_refs, nr_refspecs, refspecs, flags))
|
2009-03-09 01:06:07 +00:00
|
|
|
return -1;
|
2007-10-30 02:03:39 +00:00
|
|
|
|
2009-03-09 01:06:07 +00:00
|
|
|
ret = send_pack(&args, fd, conn, remote_refs, &extra_have);
|
2007-10-30 02:03:39 +00:00
|
|
|
|
2009-10-31 00:47:41 +00:00
|
|
|
if (helper_status)
|
|
|
|
print_helper_status(remote_refs);
|
|
|
|
|
2009-03-09 01:06:07 +00:00
|
|
|
close(fd[1]);
|
2005-06-30 05:50:48 +00:00
|
|
|
close(fd[0]);
|
2009-03-09 01:06:07 +00:00
|
|
|
|
2007-10-19 19:47:53 +00:00
|
|
|
ret |= finish_connect(conn);
|
2009-03-09 01:06:07 +00:00
|
|
|
|
2009-10-31 00:47:41 +00:00
|
|
|
if (!helper_status)
|
|
|
|
print_push_status(dest, remote_refs);
|
2009-03-09 01:06:07 +00:00
|
|
|
|
|
|
|
if (!args.dry_run && remote) {
|
|
|
|
struct ref *ref;
|
|
|
|
for (ref = remote_refs; ref; ref = ref->next)
|
|
|
|
update_tracking_ref(remote, ref);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ret && !refs_pushed(remote_refs))
|
|
|
|
fprintf(stderr, "Everything up-to-date\n");
|
|
|
|
|
|
|
|
return ret;
|
2005-06-30 02:09:05 +00:00
|
|
|
}
|