From 37fde874c2448ae2cd98abe24df2bd2a50aa2cda Mon Sep 17 00:00:00 2001
From: Junio C Hamano <junkio@cox.net>
Date: Fri, 5 Aug 2005 00:47:56 -0700
Subject: Fix send-pack for non-commitish tags.

Again I left the v2.6.11-tree tag behind.  My bad.

This commit makes sure that we do not barf when pushing a ref
that is a non-commitish tag.  You can update a remote ref under
the following conditions:

 * You can always use --force.
 * Creating a brand new ref is OK.
 * If the remote ref is exactly the same as what you are
   pushing, it is OK (nothing is pushed).
 * You can replace a commitish with another commitish which is a
   descendant of it, if you can verify the ancestry between them;
   this and the above means you have to have what you are replacing.
 * Otherwise you cannot update; you need to use --force.

Signed-off-by: Junio C Hamano <junkio@cox.net>
---
 commit.c    |  5 +----
 send-pack.c | 55 ++++++++++++++++++++++++++++++++++++++++++-------------
 tag.c       |  7 +++++++
 tag.h       |  1 +
 4 files changed, 51 insertions(+), 17 deletions(-)

diff --git a/commit.c b/commit.c
index 6db31651c2..3ac421ac34 100644
--- a/commit.c
+++ b/commit.c
@@ -48,13 +48,10 @@ static struct commit *check_commit(struct object *obj, const unsigned char *sha1
 
 struct commit *lookup_commit_reference(const unsigned char *sha1)
 {
-	struct object *obj = parse_object(sha1);
+	struct object *obj = deref_tag(parse_object(sha1));
 
 	if (!obj)
 		return NULL;
-	while (obj->type == tag_type)
-		obj = parse_object(((struct tag *)obj)->tagged->sha1);
-
 	return check_commit(obj, sha1);
 }
 
diff --git a/send-pack.c b/send-pack.c
index 633fc471af..4d015fd6e4 100644
--- a/send-pack.c
+++ b/send-pack.c
@@ -1,5 +1,6 @@
 #include "cache.h"
 #include "commit.h"
+#include "tag.h"
 #include "refs.h"
 #include "pkt-line.h"
 
@@ -104,19 +105,26 @@ static int pack_objects(int fd, struct ref *refs)
 	return 0;
 }
 
-static int ref_newer(const unsigned char *new_sha1, const unsigned char *old_sha1)
+static int ref_newer(const unsigned char *new_sha1,
+		     const unsigned char *old_sha1)
 {
-	struct commit *new, *old;
+	struct object *o;
+	struct commit *old, *new;
 	struct commit_list *list;
 
-	if (force_update)
-		return 1;
-	old = lookup_commit_reference(old_sha1);
-	if (!old)
+	/* 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));
+	if (!o || o->type != commit_type)
 		return 0;
-	new = lookup_commit_reference(new_sha1);
-	if (!new)
+	old = (struct commit *) o;
+
+	o = deref_tag(parse_object(new_sha1));
+	if (!o || o->type != commit_type)
 		return 0;
+	new = (struct commit *) o;
+
 	if (parse_commit(new) < 0)
 		return 0;
 	list = NULL;
@@ -173,13 +181,38 @@ static int send_pack(int in, int out, int nr_refspec, char **refspec)
 		char old_hex[60], *new_hex;
 		if (!ref->peer_ref)
 			continue;
-		if (!is_zero_sha1(ref->old_sha1)) {
+		if (!memcmp(ref->old_sha1, ref->peer_ref->new_sha1, 20)) {
+			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.
+		 *
+		 * (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.
+		 */
+
+		if (!force_update && !is_zero_sha1(ref->old_sha1)) {
 			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));
 				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
+			 * be a commit.
+			 */
 			if (!ref_newer(ref->peer_ref->new_sha1,
 				       ref->old_sha1)) {
 				error("remote ref '%s' is not a strict "
@@ -188,10 +221,6 @@ static int send_pack(int in, int out, int nr_refspec, char **refspec)
 				continue;
 			}
 		}
-		if (!memcmp(ref->old_sha1, ref->peer_ref->new_sha1, 20)) {
-			fprintf(stderr, "'%s': up-to-date\n", ref->name);
-			continue;
-		}
 		memcpy(ref->new_sha1, ref->peer_ref->new_sha1, 20);
 		if (is_zero_sha1(ref->new_sha1)) {
 			error("cannot happen anymore");
diff --git a/tag.c b/tag.c
index 2b25fc0e1d..b1ab75ff01 100644
--- a/tag.c
+++ b/tag.c
@@ -3,6 +3,13 @@
 
 const char *tag_type = "tag";
 
+struct object *deref_tag(struct object *o)
+{
+	while (o && o->type == tag_type)
+		o = parse_object(((struct tag *)o)->tagged->sha1);
+	return o;
+}
+
 struct tag *lookup_tag(const unsigned char *sha1)
 {
         struct object *obj = lookup_object(sha1);
diff --git a/tag.h b/tag.h
index 3e8c32d738..36e532401f 100644
--- a/tag.h
+++ b/tag.h
@@ -15,5 +15,6 @@ struct tag {
 extern struct tag *lookup_tag(const unsigned char *sha1);
 extern int parse_tag_buffer(struct tag *item, void *data, unsigned long size);
 extern int parse_tag(struct tag *item);
+extern struct object *deref_tag(struct object *);
 
 #endif /* TAG_H */
-- 
cgit v1.2.3