Fix sparse warnings
Fix warnings from 'make check'.
- These files don't include 'builtin.h' causing sparse to complain that
cmd_* isn't declared:
builtin/clone.c:364, builtin/fetch-pack.c:797,
builtin/fmt-merge-msg.c:34, builtin/hash-object.c:78,
builtin/merge-index.c:69, builtin/merge-recursive.c:22
builtin/merge-tree.c:341, builtin/mktag.c:156, builtin/notes.c:426
builtin/notes.c:822, builtin/pack-redundant.c:596,
builtin/pack-refs.c:10, builtin/patch-id.c:60, builtin/patch-id.c:149,
builtin/remote.c:1512, builtin/remote-ext.c:240,
builtin/remote-fd.c:53, builtin/reset.c:236, builtin/send-pack.c:384,
builtin/unpack-file.c:25, builtin/var.c:75
- These files have symbols which should be marked static since they're
only file scope:
submodule.c:12, diff.c:631, replace_object.c:92, submodule.c:13,
submodule.c:14, trace.c:78, transport.c:195, transport-helper.c:79,
unpack-trees.c:19, url.c:3, url.c:18, url.c:104, url.c:117, url.c:123,
url.c:129, url.c:136, thread-utils.c:21, thread-utils.c:48
- These files redeclare symbols to be different types:
builtin/index-pack.c:210, parse-options.c:564, parse-options.c:571,
usage.c:49, usage.c:58, usage.c:63, usage.c:72
- These files use a literal integer 0 when they really should use a NULL
pointer:
daemon.c:663, fast-import.c:2942, imap-send.c:1072, notes-merge.c:362
While we're in the area, clean up some unused #includes in builtin files
(mostly exec_cmd.h).
Signed-off-by: Stephen Boyd <bebarino@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-03-22 07:51:05 +00:00
|
|
|
#include "builtin.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"
|
2010-02-16 23:42:52 +00:00
|
|
|
#include "transport.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,
|
2010-10-16 18:37:03 +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";
|
2012-02-13 20:17:15 +00:00
|
|
|
if (args->quiet || !args->progress)
|
2009-08-05 20:22:36 +00:00
|
|
|
argv[i++] = "-q";
|
2010-10-16 18:37:03 +00:00
|
|
|
if (args->progress)
|
|
|
|
argv[i++] = "--progress";
|
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))
|
2010-10-16 17:09:54 +00:00
|
|
|
return -1;
|
2007-03-12 23:00:29 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2010-02-05 20:57:39 +00:00
|
|
|
static int sideband_demux(int in, int out, void *data)
|
|
|
|
{
|
2011-05-16 23:19:49 +00:00
|
|
|
int *fd = data, ret;
|
2011-04-25 22:20:39 +00:00
|
|
|
#ifdef NO_PTHREADS
|
send-pack: avoid deadlock when pack-object dies early
Send-pack deadlocks in two ways when pack-object dies early (for example,
because there is some repo corruption).
The first deadlock happens with the smart push protocol (--stateless-rpc).
After the initial rev-exchange, the remote is waiting for the pack data
to arrive, and the sideband demuxer at the local side continues trying to
stream data from the remote repository until it gets EOF. Meanwhile,
send-pack (in function pack_objects()) has noticed that pack-objects did
not produce output and died. Back in send_pack(), it now tries to clean
up the sideband demuxer using finish_async(). The demuxer, however, waits
for the remote end to close down, the remote waits for pack data, and
the reason that it still waits is that send-pack forgot to close the
outgoing channel. Add the missing close() in pack_objects().
The second deadlock happens in a similar constellation when the sideband
demuxer runs in a forked process (rather than in a thread). Again, the
remote end waits for pack data to arrive, the sideband demuxer waits for
the remote to shut down, and send-pack (in the regular clean-up) waits for
the demuxer to terminate. This time, the send-pack parent process closes
the writable end of the outgoing channel (in start_command() that spawned
pack-objects) so that after the death of the pack-objects process all
writable ends should have been closed and the remote repo should see EOF.
This does not happen, however, because when the sideband demuxer was forked
earlier, it also inherited a writable end; it remains open and keeps the
remote repo from seeing EOF. To break this deadlock, close the writable end
in the demuxer.
Analyzed-by: Jeff King <peff@peff.net>
Signed-off-by: Johannes Sixt <j6t@kdbg.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-04-25 21:04:10 +00:00
|
|
|
close(fd[1]);
|
|
|
|
#endif
|
2011-05-16 23:19:49 +00:00
|
|
|
ret = recv_sideband("send-pack", fd[0], out);
|
2010-02-05 20:57:39 +00:00
|
|
|
close(out);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
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;
|
2006-11-24 08:26:49 +00:00
|
|
|
int allow_deleting_refs = 0;
|
2010-02-05 20:57:39 +00:00
|
|
|
int status_report = 0;
|
|
|
|
int use_sideband = 0;
|
2012-02-13 20:17:15 +00:00
|
|
|
int quiet_supported = 0;
|
2010-02-05 20:57:39 +00:00
|
|
|
unsigned cmds_sent = 0;
|
2007-11-17 12:56:03 +00:00
|
|
|
int ret;
|
2010-02-05 20:57:39 +00:00
|
|
|
struct async demux;
|
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"))
|
2010-02-05 20:57:39 +00:00
|
|
|
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;
|
2010-02-05 20:57:39 +00:00
|
|
|
if (server_supports("side-band-64k"))
|
|
|
|
use_sideband = 1;
|
2012-02-13 20:17:15 +00:00
|
|
|
if (server_supports("quiet"))
|
|
|
|
quiet_supported = 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) {
|
2010-01-08 02:12:42 +00:00
|
|
|
if (!ref->peer_ref && !args->send_mirror)
|
2008-11-05 20:55:54 +00:00
|
|
|
continue;
|
2007-11-09 23:32:10 +00:00
|
|
|
|
2010-01-08 02:12:42 +00:00
|
|
|
/* Check for statuses set by set_ref_status_for_push() */
|
|
|
|
switch (ref->status) {
|
|
|
|
case REF_STATUS_REJECT_NONFASTFORWARD:
|
|
|
|
case REF_STATUS_UPTODATE:
|
2005-08-05 07:47:56 +00:00
|
|
|
continue;
|
2010-01-08 02:12:42 +00:00
|
|
|
default:
|
|
|
|
; /* do nothing */
|
2005-08-05 07:47:56 +00:00
|
|
|
}
|
|
|
|
|
2010-01-08 02:12:42 +00:00
|
|
|
if (ref->deletion && !allow_deleting_refs) {
|
|
|
|
ref->status = REF_STATUS_REJECT_NODELETE;
|
2007-11-17 12:54:27 +00:00
|
|
|
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
|
|
|
|
2010-02-05 20:57:39 +00:00
|
|
|
if (args->dry_run) {
|
|
|
|
ref->status = REF_STATUS_OK;
|
|
|
|
} else {
|
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);
|
2012-02-13 20:17:15 +00:00
|
|
|
int quiet = quiet_supported && (args->quiet || !args->progress);
|
2007-11-17 12:54:27 +00:00
|
|
|
|
2012-01-08 21:06:20 +00:00
|
|
|
if (!cmds_sent && (status_report || use_sideband || args->quiet)) {
|
|
|
|
packet_buf_write(&req_buf, "%s %s %s%c%s%s%s",
|
2012-02-13 20:17:15 +00:00
|
|
|
old_hex, new_hex, ref->name, 0,
|
|
|
|
status_report ? " report-status" : "",
|
|
|
|
use_sideband ? " side-band-64k" : "",
|
|
|
|
quiet ? " quiet" : "");
|
2007-10-11 19:32:26 +00:00
|
|
|
}
|
|
|
|
else
|
2009-10-31 00:47:41 +00:00
|
|
|
packet_buf_write(&req_buf, "%s %s %s",
|
2012-02-13 20:17:15 +00:00
|
|
|
old_hex, new_hex, ref->name);
|
2010-02-05 20:57:39 +00:00
|
|
|
ref->status = status_report ?
|
|
|
|
REF_STATUS_EXPECTING_REPORT :
|
|
|
|
REF_STATUS_OK;
|
|
|
|
cmds_sent++;
|
2005-12-26 07:18:37 +00:00
|
|
|
}
|
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) {
|
2010-02-05 20:57:39 +00:00
|
|
|
if (!args->dry_run && cmds_sent) {
|
2009-10-31 00:47:41 +00:00
|
|
|
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);
|
|
|
|
|
2010-02-05 20:57:39 +00:00
|
|
|
if (use_sideband && cmds_sent) {
|
|
|
|
memset(&demux, 0, sizeof(demux));
|
|
|
|
demux.proc = sideband_demux;
|
|
|
|
demux.data = fd;
|
|
|
|
demux.out = -1;
|
|
|
|
if (start_async(&demux))
|
2011-09-07 20:56:38 +00:00
|
|
|
die("send-pack: unable to fork off sideband demultiplexer");
|
2010-02-05 20:57:39 +00:00
|
|
|
in = demux.out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (new_refs && cmds_sent) {
|
2009-03-09 01:06:07 +00:00
|
|
|
if (pack_objects(out, remote_refs, extra_have, args) < 0) {
|
|
|
|
for (ref = remote_refs; ref; ref = ref->next)
|
|
|
|
ref->status = REF_STATUS_NONE;
|
send-pack: unbreak push over stateless rpc
Commit 09c9957 (send-pack: avoid deadlock when pack-object
dies early, 2011-04-25) attempted to fix a hang in the
stateless rpc case by closing a file descriptor early, but
we still need that descriptor.
Basically the deadlock can happen when pack-objects fails,
and the descriptor to upstream is left open. We never send
the pack, so the upstream is left waiting for us to say
something, and we are left waiting for upstream to close the
connection.
In the non-rpc case, our descriptor points straight to the
upstream. We hand it off to run-command, which takes
ownership and closes the descriptor after pack-objects
finishes (whether it succeeds or not).
Commit 09c9957 tried to emulate that in the rpc case. That
isn't right, though. We actually have a descriptor going
back to the remote-helper, and we need to keep using it
after pack-objects is finished. Closing it early completely
breaks pushing via smart-http.
We still need to do something on error to signal the
remote-helper that we won't be sending any pack data
(otherwise we get the deadlock). In an ideal world, we
would send a special packet back that says "Sorry, there was
an error". But the remote-helper doesn't understand any such
packet, so the best we can do is close the descriptor and
let it report that we hung up unexpectedly.
Signed-off-by: Jeff King <peff@peff.net>
Acked-by: Johannes Sixt <j6t@kdbg.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-05-05 06:18:45 +00:00
|
|
|
if (args->stateless_rpc)
|
|
|
|
close(out);
|
2011-05-16 06:52:57 +00:00
|
|
|
if (git_connection_is_socket(conn))
|
|
|
|
shutdown(fd[0], SHUT_WR);
|
2010-02-05 20:57:39 +00:00
|
|
|
if (use_sideband)
|
|
|
|
finish_async(&demux);
|
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
|
|
|
}
|
2010-02-05 20:57:39 +00:00
|
|
|
if (args->stateless_rpc && cmds_sent)
|
2009-10-31 00:47:41 +00:00
|
|
|
packet_flush(out);
|
2005-12-26 07:18:37 +00:00
|
|
|
|
2010-02-05 20:57:39 +00:00
|
|
|
if (status_report && cmds_sent)
|
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
|
|
|
|
2010-02-05 20:57:39 +00:00
|
|
|
if (use_sideband && cmds_sent) {
|
|
|
|
if (finish_async(&demux)) {
|
|
|
|
error("error in sideband demultiplexer");
|
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
close(demux.out);
|
|
|
|
}
|
|
|
|
|
2007-11-17 12:56:03 +00:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2010-02-27 04:52:15 +00:00
|
|
|
|
|
|
|
if (args->porcelain)
|
|
|
|
return 0;
|
|
|
|
|
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 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;
|
2010-02-16 23:42:52 +00:00
|
|
|
int nonfastforward = 0;
|
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;
|
|
|
|
}
|
2012-01-08 21:06:20 +00:00
|
|
|
if (!strcmp(arg, "--quiet")) {
|
|
|
|
args.quiet = 1;
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
send-pack: show progress when isatty(2)
The send_pack_args struct has two verbosity flags: "quiet"
and "progress". Originally, if "quiet" was set, we would
tell pack-objects explicitly to be quiet, and if "progress"
was set, we would tell it to show progress. Otherwise, we
told it neither, and it relied on isatty(2) to make the
decision itself.
However, commit 01fdc21 changed the meaning of these
variables. Now both "quiet" and "!progress" instruct us to
tell pack-objects to be quiet (and a non-zero "progress"
means the same as before). This works well for transports
which call send_pack directly, as the transport code copies
transport->progress into send_pack_args->progress, and they
both have the same meaning.
However, the code path of calling "git send-pack" was left
behind. It always sets "progress" to 0, and thus always
tells pack-objects to be quiet. We can work around this by
checking isatty(2) ourselves in the cmd_send_pack code path,
restoring the original behavior of the send-pack command.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-05-01 08:41:42 +00:00
|
|
|
if (!args.quiet)
|
|
|
|
args.progress = isatty(2);
|
|
|
|
|
2009-10-31 00:47:41 +00:00
|
|
|
if (args.stateless_rpc) {
|
|
|
|
conn = NULL;
|
|
|
|
fd[0] = 0;
|
|
|
|
fd[1] = 1;
|
|
|
|
} else {
|
2011-09-06 18:06:32 +00:00
|
|
|
conn = git_connect(fd, dest, receivepack,
|
2009-10-31 00:47:41 +00:00
|
|
|
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));
|
|
|
|
|
2011-12-13 00:41:37 +00:00
|
|
|
get_remote_heads(fd[0], &remote_refs, REF_NORMAL, &extra_have);
|
2009-03-09 01:06:07 +00:00
|
|
|
|
2010-02-16 23:42:52 +00:00
|
|
|
transport_verify_remote_names(nr_refspecs, refspecs);
|
2009-03-09 01:06:07 +00:00
|
|
|
|
|
|
|
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 */
|
2011-09-09 18:54:58 +00:00
|
|
|
if (match_push_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
|
|
|
|
2010-01-08 02:12:42 +00:00
|
|
|
set_ref_status_for_push(remote_refs, args.send_mirror,
|
|
|
|
args.force_update);
|
|
|
|
|
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)
|
2010-02-16 23:42:52 +00:00
|
|
|
transport_print_push_status(dest, remote_refs, args.verbose, 0, &nonfastforward);
|
2009-03-09 01:06:07 +00:00
|
|
|
|
|
|
|
if (!args.dry_run && remote) {
|
|
|
|
struct ref *ref;
|
|
|
|
for (ref = remote_refs; ref; ref = ref->next)
|
2010-02-16 23:42:52 +00:00
|
|
|
transport_update_tracking_ref(remote, ref, args.verbose);
|
2009-03-09 01:06:07 +00:00
|
|
|
}
|
|
|
|
|
2010-02-16 23:42:52 +00:00
|
|
|
if (!ret && !transport_refs_pushed(remote_refs))
|
2009-03-09 01:06:07 +00:00
|
|
|
fprintf(stderr, "Everything up-to-date\n");
|
|
|
|
|
|
|
|
return ret;
|
2005-06-30 02:09:05 +00:00
|
|
|
}
|