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"
|
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;
|
|
|
|
|
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;
|
|
|
|
struct extra_have_objects extra_have;
|
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;
|
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 == '-') {
|
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 10:53:29 +01:00
|
|
|
if (!prefixcmp(arg, "--receive-pack=")) {
|
2009-03-09 02:06:07 +01:00
|
|
|
receivepack = arg + 15;
|
2007-01-19 13:49:27 +01: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 10:53:29 +01:00
|
|
|
if (!prefixcmp(arg, "--exec=")) {
|
2009-03-09 02:06:07 +01:00
|
|
|
receivepack = arg + 7;
|
2005-06-30 04:09:05 +02:00
|
|
|
continue;
|
|
|
|
}
|
2007-05-16 04:50:19 +02:00
|
|
|
if (!prefixcmp(arg, "--remote=")) {
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
if (!strcmp(arg, "--helper-status")) {
|
|
|
|
helper_status = 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);
|
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
|
|
|
|
2009-03-09 02:06:07 +01:00
|
|
|
memset(&extra_have, 0, sizeof(extra_have));
|
|
|
|
|
2013-02-20 21:06:45 +01:00
|
|
|
get_remote_heads(fd[0], NULL, 0, &remote_refs, REF_NORMAL, &extra_have);
|
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
|
|
|
|
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
|
|
|
}
|