"git-send-pack [--all] [--exec=git-receive-pack] <remote> [<head>...]\n"
" --all and explicit <head> specification are mutually exclusive.";
static const char *exec = "git-receive-pack";
+static int verbose = 0;
static int send_all = 0;
static int force_update = 0;
return 0;
}
+static void unmark_and_free(struct commit_list *list, unsigned int mark)
+{
+ while (list) {
+ struct commit_list *temp = list;
+ temp->item->object.flags &= ~mark;
+ list = temp->next;
+ free(temp);
+ }
+}
+
static int ref_newer(const unsigned char *new_sha1,
const unsigned char *old_sha1)
{
struct object *o;
struct commit *old, *new;
- struct commit_list *list;
+ struct commit_list *list, *used;
+ int found = 0;
/* Both new and old must be commit-ish and new is descendant of
* old. Otherwise we require --force.
*/
- o = deref_tag(parse_object(old_sha1));
+ o = deref_tag(parse_object(old_sha1), NULL, 0);
if (!o || o->type != commit_type)
return 0;
old = (struct commit *) o;
- o = deref_tag(parse_object(new_sha1));
+ o = deref_tag(parse_object(new_sha1), NULL, 0);
if (!o || o->type != commit_type)
return 0;
new = (struct commit *) o;
if (parse_commit(new) < 0)
return 0;
- list = NULL;
+
+ used = list = NULL;
commit_list_insert(new, &list);
while (list) {
new = pop_most_recent_commit(&list, 1);
- if (new == old)
- return 1;
+ commit_list_insert(new, &used);
+ if (new == old) {
+ found = 1;
+ break;
+ }
}
- return 0;
+ unmark_and_free(list, 1);
+ unmark_and_free(used, 1);
+ return found;
}
static struct ref *local_refs, **local_tail;
{
struct ref *ref;
int new_refs;
+ int ret = 0;
/* No funny business with the matcher */
- remote_tail = get_remote_heads(in, &remote_refs, 0, NULL);
+ remote_tail = get_remote_heads(in, &remote_refs, 0, NULL, 1);
get_local_heads();
/* match them up */
if (match_refs(local_refs, remote_refs, &remote_tail,
nr_refspec, refspec, send_all))
return -1;
+
+ if (!remote_refs) {
+ fprintf(stderr, "No refs in common and none specified; doing nothing.\n");
+ return 0;
+ }
+
/*
* Finally, tell the other end!
*/
if (!ref->peer_ref)
continue;
if (!memcmp(ref->old_sha1, ref->peer_ref->new_sha1, 20)) {
- fprintf(stderr, "'%s': up-to-date\n", ref->name);
+ if (verbose)
+ fprintf(stderr, "'%s': up-to-date\n", ref->name);
continue;
}
/* This part determines what can overwrite what.
* The rules are:
*
- * (0) you can always use --force.
+ * (0) you can always use --force or +A:B notation to
+ * selectively force individual ref pairs.
*
* (1) if the old thing does not exist, it is OK.
*
* descendant of old, it is OK.
*/
- if (!force_update && !is_zero_sha1(ref->old_sha1)) {
+ if (!force_update &&
+ !is_zero_sha1(ref->old_sha1) &&
+ !ref->force) {
if (!has_sha1_file(ref->old_sha1)) {
error("remote '%s' object %s does not "
"exist on local",
ref->name, sha1_to_hex(ref->old_sha1));
+ ret = -2;
continue;
}
+
/* We assume that local is fsck-clean. Otherwise
- * you _could_ have a old tag which points at
- * something you do not have which may or may not
+ * you _could_ have an old tag which points at
+ * something you do not have, which may or may not
* be a commit.
*/
if (!ref_newer(ref->peer_ref->new_sha1,
error("remote ref '%s' is not a strict "
"subset of local ref '%s'.", ref->name,
ref->peer_ref->name);
+ ret = -2;
continue;
}
}
memcpy(ref->new_sha1, ref->peer_ref->new_sha1, 20);
if (is_zero_sha1(ref->new_sha1)) {
error("cannot happen anymore");
+ ret = -3;
continue;
}
new_refs++;
packet_flush(out);
if (new_refs)
pack_objects(out, remote_refs);
+ else if (ret == 0)
+ fprintf(stderr, "Everything up-to-date\n");
close(out);
- return 0;
+ return ret;
}
int fd[2], ret;
pid_t pid;
+ setup_git_directory();
argv++;
for (i = 1; i < argc; i++, argv++) {
char *arg = *argv;
force_update = 1;
continue;
}
+ if (!strcmp(arg, "--verbose")) {
+ verbose = 1;
+ continue;
+ }
usage(send_pack_usage);
}
if (!dest) {