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 08:51:05 +01:00
|
|
|
#include "builtin.h"
|
2005-07-19 13:03:47 +02:00
|
|
|
#include "commit.h"
|
2005-07-08 22:58:40 +02:00
|
|
|
#include "refs.h"
|
2005-06-30 05:50:15 +02:00
|
|
|
#include "pkt-line.h"
|
2009-10-31 01:47:41 +01:00
|
|
|
#include "sideband.h"
|
2007-03-13 00:00:29 +01:00
|
|
|
#include "run-command.h"
|
2007-05-12 17:45:59 +02:00
|
|
|
#include "remote.h"
|
2013-07-08 22:56:53 +02:00
|
|
|
#include "connect.h"
|
2007-10-30 03:03:39 +01:00
|
|
|
#include "send-pack.h"
|
2009-10-31 01:47:41 +01:00
|
|
|
#include "quote.h"
|
2010-02-17 00:42:52 +01:00
|
|
|
#include "transport.h"
|
2012-08-03 18:19:16 +02:00
|
|
|
#include "version.h"
|
2013-12-05 14:02:29 +01:00
|
|
|
#include "sha1-array.h"
|
2005-06-30 04:09:05 +02:00
|
|
|
|
2005-07-14 09:10:05 +02:00
|
|
|
static const char send_pack_usage[] =
|
2008-07-13 15:36:15 +02:00
|
|
|
"git send-pack [--all | --mirror] [--dry-run] [--force] [--receive-pack=<git-receive-pack>] [--verbose] [--thin] [<host>:]<directory> [<ref>...]\n"
|
2007-01-19 13:43:00 +01:00
|
|
|
" --all and explicit <ref> specification are mutually exclusive.";
|
2007-10-30 03:03:39 +01:00
|
|
|
|
2009-03-27 03:37:53 +01:00
|
|
|
static struct send_pack_args args;
|
2005-06-30 04:09:05 +02:00
|
|
|
|
2009-10-31 01:47:41 +01: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";
|
2012-11-30 02:41:37 +01:00
|
|
|
break;
|
|
|
|
|
|
push: introduce REJECT_FETCH_FIRST and REJECT_NEEDS_FORCE
When we push to update an existing ref, if:
* the object at the tip of the remote is not a commit; or
* the object we are pushing is not a commit,
it won't be correct to suggest to fetch, integrate and push again,
as the old and new objects will not "merge". We should explain that
the push must be forced when there is a non-committish object is
involved in such a case.
If we do not have the current object at the tip of the remote, we do
not even know that object, when fetched, is something that can be
merged. In such a case, suggesting to pull first just like
non-fast-forward case may not be technically correct, but in
practice, most such failures are seen when you try to push your work
to a branch without knowing that somebody else already pushed to
update the same branch since you forked, so "pull first" would work
as a suggestion most of the time. And if the object at the tip is
not a commit, "pull first" will fail, without making any permanent
damage. As a side effect, it also makes the error message the user
will get during the next "push" attempt easier to understand, now
the user is aware that a non-commit object is involved.
In these cases, the current code already rejects such a push on the
client end, but we used the same error and advice messages as the
ones used when rejecting a non-fast-forward push, i.e. pull from
there and integrate before pushing again.
Introduce new rejection reasons and reword the messages
appropriately.
[jc: with help by Peff on message details]
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-23 22:55:30 +01:00
|
|
|
case REF_STATUS_REJECT_FETCH_FIRST:
|
|
|
|
|
res = "error";
|
|
|
|
|
msg = "fetch first";
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case REF_STATUS_REJECT_NEEDS_FORCE:
|
|
|
|
|
res = "error";
|
|
|
|
|
msg = "needs force";
|
|
|
|
|
break;
|
|
|
|
|
|
2013-07-08 23:42:40 +02:00
|
|
|
case REF_STATUS_REJECT_STALE:
|
|
|
|
|
res = "error";
|
|
|
|
|
msg = "stale info";
|
|
|
|
|
break;
|
|
|
|
|
|
2012-11-30 02:41:37 +01:00
|
|
|
case REF_STATUS_REJECT_ALREADY_EXISTS:
|
|
|
|
|
res = "error";
|
|
|
|
|
msg = "already exists";
|
2009-10-31 01:47:41 +01:00
|
|
|
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');
|
|
|
|
|
|
2013-02-20 21:01:56 +01:00
|
|
|
write_or_die(1, buf.buf, buf.len);
|
2009-10-31 01:47:41 +01:00
|
|
|
}
|
|
|
|
|
strbuf_release(&buf);
|
|
|
|
|
}
|
|
|
|
|
|
2007-10-30 03:03:39 +01:00
|
|
|
int cmd_send_pack(int argc, const char **argv, const char *prefix)
|
2005-06-30 04:09:05 +02:00
|
|
|
{
|
2009-03-09 02:06:07 +01:00
|
|
|
int i, nr_refspecs = 0;
|
|
|
|
|
const char **refspecs = NULL;
|
2007-10-30 03:03:39 +01:00
|
|
|
const char *remote_name = NULL;
|
2007-05-16 04:50:19 +02:00
|
|
|
struct remote *remote = NULL;
|
2007-10-30 03:03:39 +01:00
|
|
|
const char *dest = NULL;
|
2009-03-09 02:06:07 +01:00
|
|
|
int fd[2];
|
|
|
|
|
struct child_process *conn;
|
2013-12-05 14:02:29 +01:00
|
|
|
struct sha1_array extra_have = SHA1_ARRAY_INIT;
|
2013-12-05 14:02:48 +01:00
|
|
|
struct sha1_array shallow = SHA1_ARRAY_INIT;
|
2009-05-31 16:26:48 +02:00
|
|
|
struct ref *remote_refs, *local_refs;
|
2009-03-09 02:06:07 +01:00
|
|
|
int ret;
|
2009-10-31 01:47:41 +01:00
|
|
|
int helper_status = 0;
|
2009-03-09 02:06:07 +01:00
|
|
|
int send_all = 0;
|
|
|
|
|
const char *receivepack = "git-receive-pack";
|
|
|
|
|
int flags;
|
2012-11-30 02:41:33 +01:00
|
|
|
unsigned int reject_reasons;
|
2012-05-01 10:42:24 +02:00
|
|
|
int progress = -1;
|
2014-08-21 14:21:20 +02:00
|
|
|
int from_stdin = 0;
|
remote.c: add command line option parser for "--force-with-lease"
Update "git push" and "git send-pack" to parse this commnd line
option.
The intended sematics is:
* "--force-with-lease" alone, without specifying the details, will
protect _all_ remote refs that are going to be updated by
requiring their current value to be the same as some reasonable
default, unless otherwise specified;
* "--force-with-lease=refname", without specifying the expected
value, will protect that refname, if it is going to be updated,
by requiring its current value to be the same as some reasonable
default.
* "--force-with-lease=refname:value" will protect that refname, if
it is going to be updated, by requiring its current value to be
the same as the specified value; and
* "--no-force-with-lease" will cancel all the previous --force-with-lease on the
command line.
For now, "some reasonable default" is tentatively defined as "the
value of the remote-tracking branch we have for the ref of the
remote being updated", and it is an error if we do not have such a
remote-tracking branch. But this is known to be fragile, its use is
not yet recommended, and hopefully we will find more reasonable
default as we gain experience with this feature. The manual marks
the feature as experimental unless the expected value is specified
explicitly for this reason.
Because the command line options are parsed _before_ we know which
remote we are pushing to, there needs further processing to the
parsed data after we instantiate the transport object to:
* expand "refname" given by the user to a full refname to be
matched with the list of "struct ref" used in match_push_refs()
and set_ref_status_for_push(); and
* learning the actual local ref that is the remote-tracking branch
for the specified remote ref.
Further, some processing need to be deferred until we find the set
of remote refs and match_push_refs() returns in order to find the
ones that need to be checked after explicit ones have been processed
for "--force-with-lease" (no specific details).
These post-processing will be the topic of the next patch.
This option was originally called "cas" (for "compare and swap"),
the name which nobody liked because it was too technical. The
second attempt called it "lockref" (because it is conceptually like
pushing after taking a lock) but the word "lock" was hated because
it implied that it may reject push by others, which is not the way
this option works. This round calls it "force-with-lease". You
assume you took the lease on the ref when you fetched to decide what
the rebased history should be, and you can push back only if the
lease has not been broken.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-09 00:34:36 +02:00
|
|
|
struct push_cas_option cas = {0};
|
2006-03-24 08:41:18 +01:00
|
|
|
|
2005-06-30 04:09:05 +02:00
|
|
|
argv++;
|
2005-07-16 22:26:33 +02:00
|
|
|
for (i = 1; i < argc; i++, argv++) {
|
2007-10-30 03:03:39 +01:00
|
|
|
const char *arg = *argv;
|
2005-06-30 04:09:05 +02:00
|
|
|
|
|
|
|
|
if (*arg == '-') {
|
2013-11-30 21:55:40 +01:00
|
|
|
if (starts_with(arg, "--receive-pack=")) {
|
2009-03-09 02:06:07 +01:00
|
|
|
receivepack = arg + 15;
|
2007-01-19 13:49:27 +01:00
|
|
|
continue;
|
|
|
|
|
}
|
2013-11-30 21:55:40 +01:00
|
|
|
if (starts_with(arg, "--exec=")) {
|
2009-03-09 02:06:07 +01:00
|
|
|
receivepack = arg + 7;
|
2005-06-30 04:09:05 +02:00
|
|
|
continue;
|
|
|
|
|
}
|
2013-11-30 21:55:40 +01:00
|
|
|
if (starts_with(arg, "--remote=")) {
|
2007-05-16 04:50:19 +02:00
|
|
|
remote_name = arg + 9;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2005-07-16 22:26:33 +02:00
|
|
|
if (!strcmp(arg, "--all")) {
|
2009-03-09 02:06:07 +01:00
|
|
|
send_all = 1;
|
2005-07-16 22:26:33 +02:00
|
|
|
continue;
|
|
|
|
|
}
|
2007-10-11 21:32:26 +02:00
|
|
|
if (!strcmp(arg, "--dry-run")) {
|
2007-10-30 03:03:39 +01:00
|
|
|
args.dry_run = 1;
|
2007-10-11 21:32:26 +02:00
|
|
|
continue;
|
|
|
|
|
}
|
2007-11-10 00:32:10 +01:00
|
|
|
if (!strcmp(arg, "--mirror")) {
|
|
|
|
|
args.send_mirror = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2005-07-19 13:03:47 +02:00
|
|
|
if (!strcmp(arg, "--force")) {
|
2007-10-30 03:03:39 +01:00
|
|
|
args.force_update = 1;
|
2005-07-19 13:03:47 +02:00
|
|
|
continue;
|
|
|
|
|
}
|
2012-01-08 22:06:20 +01:00
|
|
|
if (!strcmp(arg, "--quiet")) {
|
|
|
|
|
args.quiet = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2005-12-21 03:13:02 +01:00
|
|
|
if (!strcmp(arg, "--verbose")) {
|
2007-10-30 03:03:39 +01:00
|
|
|
args.verbose = 1;
|
2005-12-21 03:13:02 +01:00
|
|
|
continue;
|
|
|
|
|
}
|
2012-05-01 10:42:24 +02:00
|
|
|
if (!strcmp(arg, "--progress")) {
|
|
|
|
|
progress = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (!strcmp(arg, "--no-progress")) {
|
|
|
|
|
progress = 0;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2006-02-20 00:03:49 +01:00
|
|
|
if (!strcmp(arg, "--thin")) {
|
2007-10-30 03:03:39 +01:00
|
|
|
args.use_thin_pack = 1;
|
2006-02-20 00:03:49 +01:00
|
|
|
continue;
|
|
|
|
|
}
|
2009-10-31 01:47:41 +01:00
|
|
|
if (!strcmp(arg, "--stateless-rpc")) {
|
|
|
|
|
args.stateless_rpc = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2014-08-21 14:21:20 +02:00
|
|
|
if (!strcmp(arg, "--stdin")) {
|
|
|
|
|
from_stdin = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2009-10-31 01:47:41 +01:00
|
|
|
if (!strcmp(arg, "--helper-status")) {
|
|
|
|
|
helper_status = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
remote.c: add command line option parser for "--force-with-lease"
Update "git push" and "git send-pack" to parse this commnd line
option.
The intended sematics is:
* "--force-with-lease" alone, without specifying the details, will
protect _all_ remote refs that are going to be updated by
requiring their current value to be the same as some reasonable
default, unless otherwise specified;
* "--force-with-lease=refname", without specifying the expected
value, will protect that refname, if it is going to be updated,
by requiring its current value to be the same as some reasonable
default.
* "--force-with-lease=refname:value" will protect that refname, if
it is going to be updated, by requiring its current value to be
the same as the specified value; and
* "--no-force-with-lease" will cancel all the previous --force-with-lease on the
command line.
For now, "some reasonable default" is tentatively defined as "the
value of the remote-tracking branch we have for the ref of the
remote being updated", and it is an error if we do not have such a
remote-tracking branch. But this is known to be fragile, its use is
not yet recommended, and hopefully we will find more reasonable
default as we gain experience with this feature. The manual marks
the feature as experimental unless the expected value is specified
explicitly for this reason.
Because the command line options are parsed _before_ we know which
remote we are pushing to, there needs further processing to the
parsed data after we instantiate the transport object to:
* expand "refname" given by the user to a full refname to be
matched with the list of "struct ref" used in match_push_refs()
and set_ref_status_for_push(); and
* learning the actual local ref that is the remote-tracking branch
for the specified remote ref.
Further, some processing need to be deferred until we find the set
of remote refs and match_push_refs() returns in order to find the
ones that need to be checked after explicit ones have been processed
for "--force-with-lease" (no specific details).
These post-processing will be the topic of the next patch.
This option was originally called "cas" (for "compare and swap"),
the name which nobody liked because it was too technical. The
second attempt called it "lockref" (because it is conceptually like
pushing after taking a lock) but the word "lock" was hated because
it implied that it may reject push by others, which is not the way
this option works. This round calls it "force-with-lease". You
assume you took the lease on the ref when you fetched to decide what
the rebased history should be, and you can push back only if the
lease has not been broken.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-09 00:34:36 +02:00
|
|
|
if (!strcmp(arg, "--" CAS_OPT_NAME)) {
|
|
|
|
|
if (parse_push_cas_option(&cas, NULL, 0) < 0)
|
|
|
|
|
exit(1);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (!strcmp(arg, "--no-" CAS_OPT_NAME)) {
|
|
|
|
|
if (parse_push_cas_option(&cas, NULL, 1) < 0)
|
|
|
|
|
exit(1);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2013-11-30 21:55:40 +01:00
|
|
|
if (starts_with(arg, "--" CAS_OPT_NAME "=")) {
|
remote.c: add command line option parser for "--force-with-lease"
Update "git push" and "git send-pack" to parse this commnd line
option.
The intended sematics is:
* "--force-with-lease" alone, without specifying the details, will
protect _all_ remote refs that are going to be updated by
requiring their current value to be the same as some reasonable
default, unless otherwise specified;
* "--force-with-lease=refname", without specifying the expected
value, will protect that refname, if it is going to be updated,
by requiring its current value to be the same as some reasonable
default.
* "--force-with-lease=refname:value" will protect that refname, if
it is going to be updated, by requiring its current value to be
the same as the specified value; and
* "--no-force-with-lease" will cancel all the previous --force-with-lease on the
command line.
For now, "some reasonable default" is tentatively defined as "the
value of the remote-tracking branch we have for the ref of the
remote being updated", and it is an error if we do not have such a
remote-tracking branch. But this is known to be fragile, its use is
not yet recommended, and hopefully we will find more reasonable
default as we gain experience with this feature. The manual marks
the feature as experimental unless the expected value is specified
explicitly for this reason.
Because the command line options are parsed _before_ we know which
remote we are pushing to, there needs further processing to the
parsed data after we instantiate the transport object to:
* expand "refname" given by the user to a full refname to be
matched with the list of "struct ref" used in match_push_refs()
and set_ref_status_for_push(); and
* learning the actual local ref that is the remote-tracking branch
for the specified remote ref.
Further, some processing need to be deferred until we find the set
of remote refs and match_push_refs() returns in order to find the
ones that need to be checked after explicit ones have been processed
for "--force-with-lease" (no specific details).
These post-processing will be the topic of the next patch.
This option was originally called "cas" (for "compare and swap"),
the name which nobody liked because it was too technical. The
second attempt called it "lockref" (because it is conceptually like
pushing after taking a lock) but the word "lock" was hated because
it implied that it may reject push by others, which is not the way
this option works. This round calls it "force-with-lease". You
assume you took the lease on the ref when you fetched to decide what
the rebased history should be, and you can push back only if the
lease has not been broken.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-09 00:34:36 +02:00
|
|
|
if (parse_push_cas_option(&cas,
|
2013-08-03 01:06:29 +02:00
|
|
|
strchr(arg, '=') + 1, 0) < 0)
|
remote.c: add command line option parser for "--force-with-lease"
Update "git push" and "git send-pack" to parse this commnd line
option.
The intended sematics is:
* "--force-with-lease" alone, without specifying the details, will
protect _all_ remote refs that are going to be updated by
requiring their current value to be the same as some reasonable
default, unless otherwise specified;
* "--force-with-lease=refname", without specifying the expected
value, will protect that refname, if it is going to be updated,
by requiring its current value to be the same as some reasonable
default.
* "--force-with-lease=refname:value" will protect that refname, if
it is going to be updated, by requiring its current value to be
the same as the specified value; and
* "--no-force-with-lease" will cancel all the previous --force-with-lease on the
command line.
For now, "some reasonable default" is tentatively defined as "the
value of the remote-tracking branch we have for the ref of the
remote being updated", and it is an error if we do not have such a
remote-tracking branch. But this is known to be fragile, its use is
not yet recommended, and hopefully we will find more reasonable
default as we gain experience with this feature. The manual marks
the feature as experimental unless the expected value is specified
explicitly for this reason.
Because the command line options are parsed _before_ we know which
remote we are pushing to, there needs further processing to the
parsed data after we instantiate the transport object to:
* expand "refname" given by the user to a full refname to be
matched with the list of "struct ref" used in match_push_refs()
and set_ref_status_for_push(); and
* learning the actual local ref that is the remote-tracking branch
for the specified remote ref.
Further, some processing need to be deferred until we find the set
of remote refs and match_push_refs() returns in order to find the
ones that need to be checked after explicit ones have been processed
for "--force-with-lease" (no specific details).
These post-processing will be the topic of the next patch.
This option was originally called "cas" (for "compare and swap"),
the name which nobody liked because it was too technical. The
second attempt called it "lockref" (because it is conceptually like
pushing after taking a lock) but the word "lock" was hated because
it implied that it may reject push by others, which is not the way
this option works. This round calls it "force-with-lease". You
assume you took the lease on the ref when you fetched to decide what
the rebased history should be, and you can push back only if the
lease has not been broken.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-09 00:34:36 +02:00
|
|
|
exit(1);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2005-06-30 04:09:05 +02:00
|
|
|
usage(send_pack_usage);
|
|
|
|
|
}
|
2005-07-16 22:26:33 +02:00
|
|
|
if (!dest) {
|
|
|
|
|
dest = arg;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2009-03-09 02:06:07 +01:00
|
|
|
refspecs = (const char **) argv;
|
|
|
|
|
nr_refspecs = argc - i;
|
2005-06-30 04:09:05 +02:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (!dest)
|
|
|
|
|
usage(send_pack_usage);
|
2014-08-21 14:21:20 +02:00
|
|
|
|
|
|
|
|
if (from_stdin) {
|
|
|
|
|
struct argv_array all_refspecs = ARGV_ARRAY_INIT;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < nr_refspecs; i++)
|
|
|
|
|
argv_array_push(&all_refspecs, refspecs[i]);
|
|
|
|
|
|
|
|
|
|
if (args.stateless_rpc) {
|
|
|
|
|
const char *buf;
|
|
|
|
|
while ((buf = packet_read_line(0, NULL)))
|
|
|
|
|
argv_array_push(&all_refspecs, buf);
|
|
|
|
|
} else {
|
|
|
|
|
struct strbuf line = STRBUF_INIT;
|
|
|
|
|
while (strbuf_getline(&line, stdin, '\n') != EOF)
|
|
|
|
|
argv_array_push(&all_refspecs, line.buf);
|
|
|
|
|
strbuf_release(&line);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
refspecs = all_refspecs.argv;
|
|
|
|
|
nr_refspecs = all_refspecs.argc;
|
|
|
|
|
}
|
|
|
|
|
|
2007-11-10 00:32:10 +01:00
|
|
|
/*
|
|
|
|
|
* --all and --mirror are incompatible; neither makes sense
|
|
|
|
|
* with any refspecs.
|
|
|
|
|
*/
|
2009-03-09 02:06:07 +01:00
|
|
|
if ((refspecs && (send_all || args.send_mirror)) ||
|
|
|
|
|
(send_all && args.send_mirror))
|
2005-08-02 21:20:27 +02:00
|
|
|
usage(send_pack_usage);
|
2006-12-13 19:30:11 +01:00
|
|
|
|
2007-05-16 04:50:19 +02:00
|
|
|
if (remote_name) {
|
|
|
|
|
remote = remote_get(remote_name);
|
2007-09-19 06:49:27 +02:00
|
|
|
if (!remote_has_url(remote, dest)) {
|
2007-05-16 04:50:19 +02:00
|
|
|
die("Destination %s is not a uri for %s",
|
|
|
|
|
dest, remote_name);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-05-01 10:42:24 +02:00
|
|
|
if (progress == -1)
|
|
|
|
|
progress = !args.quiet && isatty(2);
|
|
|
|
|
args.progress = progress;
|
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 10:41:42 +02:00
|
|
|
|
2009-10-31 01:47:41 +01:00
|
|
|
if (args.stateless_rpc) {
|
|
|
|
|
conn = NULL;
|
|
|
|
|
fd[0] = 0;
|
|
|
|
|
fd[1] = 1;
|
|
|
|
|
} else {
|
2011-09-06 20:06:32 +02:00
|
|
|
conn = git_connect(fd, dest, receivepack,
|
2009-10-31 01:47:41 +01:00
|
|
|
args.verbose ? CONNECT_VERBOSE : 0);
|
|
|
|
|
}
|
2007-10-30 03:03:39 +01:00
|
|
|
|
2013-12-05 14:02:48 +01:00
|
|
|
get_remote_heads(fd[0], NULL, 0, &remote_refs, REF_NORMAL,
|
|
|
|
|
&extra_have, &shallow);
|
2009-03-09 02:06:07 +01:00
|
|
|
|
2010-02-17 00:42:52 +01:00
|
|
|
transport_verify_remote_names(nr_refspecs, refspecs);
|
2009-03-09 02:06:07 +01:00
|
|
|
|
|
|
|
|
local_refs = get_local_heads();
|
2007-10-30 03:03:39 +01:00
|
|
|
|
2009-03-09 02:06:07 +01: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 20:54:58 +02:00
|
|
|
if (match_push_refs(local_refs, &remote_refs, nr_refspecs, refspecs, flags))
|
2009-03-09 02:06:07 +01:00
|
|
|
return -1;
|
2007-10-30 03:03:39 +01:00
|
|
|
|
2013-07-09 20:01:06 +02:00
|
|
|
if (!is_empty_cas(&cas))
|
|
|
|
|
apply_push_cas(&cas, remote, remote_refs);
|
|
|
|
|
|
2010-01-08 03:12:42 +01:00
|
|
|
set_ref_status_for_push(remote_refs, args.send_mirror,
|
|
|
|
|
args.force_update);
|
|
|
|
|
|
2009-03-09 02:06:07 +01:00
|
|
|
ret = send_pack(&args, fd, conn, remote_refs, &extra_have);
|
2007-10-30 03:03:39 +01:00
|
|
|
|
2009-10-31 01:47:41 +01:00
|
|
|
if (helper_status)
|
|
|
|
|
print_helper_status(remote_refs);
|
|
|
|
|
|
2009-03-09 02:06:07 +01:00
|
|
|
close(fd[1]);
|
2005-06-30 07:50:48 +02:00
|
|
|
close(fd[0]);
|
2009-03-09 02:06:07 +01:00
|
|
|
|
2007-10-19 21:47:53 +02:00
|
|
|
ret |= finish_connect(conn);
|
2009-03-09 02:06:07 +01:00
|
|
|
|
2009-10-31 01:47:41 +01:00
|
|
|
if (!helper_status)
|
2012-11-30 02:41:33 +01:00
|
|
|
transport_print_push_status(dest, remote_refs, args.verbose, 0, &reject_reasons);
|
2009-03-09 02:06:07 +01:00
|
|
|
|
|
|
|
|
if (!args.dry_run && remote) {
|
|
|
|
|
struct ref *ref;
|
|
|
|
|
for (ref = remote_refs; ref; ref = ref->next)
|
2010-02-17 00:42:52 +01:00
|
|
|
transport_update_tracking_ref(remote, ref, args.verbose);
|
2009-03-09 02:06:07 +01:00
|
|
|
}
|
|
|
|
|
|
2010-02-17 00:42:52 +01:00
|
|
|
if (!ret && !transport_refs_pushed(remote_refs))
|
2009-03-09 02:06:07 +01:00
|
|
|
fprintf(stderr, "Everything up-to-date\n");
|
|
|
|
|
|
|
|
|
|
return ret;
|
2005-06-30 04:09:05 +02:00
|
|
|
}
|