X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=read-cache.c;h=693273620370e0500bc9ea2adba98a88cafc39cd;hb=6d0de319d6249096fe934317e937177d07b1b84f;hp=9b6ce46b9fa57e85b5c9e6bf552dc27f40f6e5c5;hpb=2160a025d2a20202e323d33d879521d23e28b709;p=git.git

diff --git a/read-cache.c b/read-cache.c
index 9b6ce46b..69327362 100644
--- a/read-cache.c
+++ b/read-cache.c
@@ -35,8 +35,11 @@ int ce_match_stat(struct cache_entry *ce, struct stat *st)
 	switch (ntohl(ce->ce_mode) & S_IFMT) {
 	case S_IFREG:
 		changed |= !S_ISREG(st->st_mode) ? TYPE_CHANGED : 0;
-		/* We consider only the owner x bit to be relevant for "mode changes" */
-		if (0100 & (ntohl(ce->ce_mode) ^ st->st_mode))
+		/* We consider only the owner x bit to be relevant for
+		 * "mode changes"
+		 */
+		if (trust_executable_bit &&
+		    (0100 & (ntohl(ce->ce_mode) ^ st->st_mode)))
 			changed |= MODE_CHANGED;
 		break;
 	case S_IFLNK:
@@ -83,6 +86,83 @@ int ce_match_stat(struct cache_entry *ce, struct stat *st)
 	return changed;
 }
 
+static int ce_compare_data(struct cache_entry *ce, struct stat *st)
+{
+	int match = -1;
+	int fd = open(ce->name, O_RDONLY);
+
+	if (fd >= 0) {
+		unsigned char sha1[20];
+		if (!index_fd(sha1, fd, st, 0, NULL))
+			match = memcmp(sha1, ce->sha1, 20);
+		close(fd);
+	}
+	return match;
+}
+
+static int ce_compare_link(struct cache_entry *ce, unsigned long expected_size)
+{
+	int match = -1;
+	char *target;
+	void *buffer;
+	unsigned long size;
+	char type[10];
+	int len;
+
+	target = xmalloc(expected_size);
+	len = readlink(ce->name, target, expected_size);
+	if (len != expected_size) {
+		free(target);
+		return -1;
+	}
+	buffer = read_sha1_file(ce->sha1, type, &size);
+	if (!buffer) {
+		free(target);
+		return -1;
+	}
+	if (size == expected_size)
+		match = memcmp(buffer, target, size);
+	free(buffer);
+	free(target);
+	return match;
+}
+
+int ce_modified(struct cache_entry *ce, struct stat *st)
+{
+	int changed;
+	changed = ce_match_stat(ce, st);
+	if (!changed)
+		return 0;
+
+	/*
+	 * If the mode or type has changed, there's no point in trying
+	 * to refresh the entry - it's not going to match
+	 */
+	if (changed & (MODE_CHANGED | TYPE_CHANGED))
+		return changed;
+
+	/* Immediately after read-tree or update-index --cacheinfo,
+	 * the length field is zero.  For other cases the ce_size
+	 * should match the SHA1 recorded in the index entry.
+	 */
+	if ((changed & DATA_CHANGED) && ce->ce_size != htonl(0))
+		return changed;
+
+	switch (st->st_mode & S_IFMT) {
+	case S_IFREG:
+		if (ce_compare_data(ce, st))
+			return changed | DATA_CHANGED;
+		break;
+	case S_IFLNK:
+		if (ce_compare_link(ce, st->st_size))
+			return changed | DATA_CHANGED;
+		break;
+	default:
+		return changed | TYPE_CHANGED;
+	}
+	return 0;
+}
+
 int base_name_compare(const char *name1, int len1, int mode1,
 		      const char *name2, int len2, int mode2)
 {
@@ -155,7 +235,7 @@ int remove_cache_entry_at(int pos)
 	return 1;
 }
 
-int remove_file_from_cache(char *path)
+int remove_file_from_cache(const char *path)
 {
 	int pos = cache_name_pos(path, strlen(path));
 	if (pos < 0)
@@ -171,6 +251,32 @@ int ce_same_name(struct cache_entry *a, struct cache_entry *b)
 	return ce_namelen(b) == len && !memcmp(a->name, b->name, len);
 }
 
+int ce_path_match(const struct cache_entry *ce, const char **pathspec)
+{
+	const char *match, *name;
+	int len;
+
+	if (!pathspec)
+		return 1;
+
+	len = ce_namelen(ce);
+	name = ce->name;
+	while ((match = *pathspec++) != NULL) {
+		int matchlen = strlen(match);
+		if (matchlen > len)
+			continue;
+		if (memcmp(name, match, matchlen))
+			continue;
+		if (matchlen && name[matchlen-1] == '/')
+			return 1;
+		if (name[matchlen] == '/' || !name[matchlen])
+			return 1;
+		if (!matchlen)
+			return 1;
+	}
+	return 0;
+}
+
 /*
  * Do we have another file that has the beginning components being a
  * proper superset of the name we're trying to add?
@@ -179,6 +285,7 @@ static int has_file_name(const struct cache_entry *ce, int pos, int ok_to_replac
 {
 	int retval = 0;
 	int len = ce_namelen(ce);
+	int stage = ce_stage(ce);
 	const char *name = ce->name;
 
 	while (pos < active_nr) {
@@ -188,6 +295,8 @@ static int has_file_name(const struct cache_entry *ce, int pos, int ok_to_replac
 			break;
 		if (memcmp(name, p->name, len))
 			break;
+		if (ce_stage(p) != stage)
+			continue;
 		if (p->name[len] != '/')
 			continue;
 		retval = -1;
@@ -205,6 +314,7 @@ static int has_file_name(const struct cache_entry *ce, int pos, int ok_to_replac
 static int has_dir_name(const struct cache_entry *ce, int pos, int ok_to_replace)
 {
 	int retval = 0;
+	int stage = ce_stage(ce);
 	const char *name = ce->name;
 	const char *slash = name + ce_namelen(ce);
 
@@ -219,7 +329,7 @@ static int has_dir_name(const struct cache_entry *ce, int pos, int ok_to_replace
 		}
 		len = slash - name;
 
-		pos = cache_name_pos(name, len);
+		pos = cache_name_pos(name, ntohs(create_ce_flags(len, stage)));
 		if (pos >= 0) {
 			retval = -1;
 			if (ok_to_replace)
@@ -231,18 +341,23 @@ static int has_dir_name(const struct cache_entry *ce, int pos, int ok_to_replace
 		/*
 		 * Trivial optimization: if we find an entry that
 		 * already matches the sub-directory, then we know
-		 * we're ok, and we can exit
+		 * we're ok, and we can exit.
 		 */
 		pos = -pos-1;
-		if (pos < active_nr) {
+		while (pos < active_nr) {
 			struct cache_entry *p = active_cache[pos];
-			if (ce_namelen(p) <= len)
-				continue;
-			if (p->name[len] != '/')
-				continue;
-			if (memcmp(p->name, name, len))
-				continue;
-			break;
+			if ((ce_namelen(p) <= len) ||
+			    (p->name[len] != '/') ||
+			    memcmp(p->name, name, len))
+				break; /* not our subdirectory */
+			if (ce_stage(p) == stage)
+				/* p is at the same stage as our entry, and
+				 * is a subdirectory of what we are looking
+				 * at, so we cannot have conflicts at our
+				 * level or anything shorter.
+				 */
+				return retval;
+			pos++;
 		}
 	}
 	return retval;
@@ -277,9 +392,10 @@ int add_cache_entry(struct cache_entry *ce, int option)
 	int pos;
 	int ok_to_add = option & ADD_CACHE_OK_TO_ADD;
 	int ok_to_replace = option & ADD_CACHE_OK_TO_REPLACE;
+	int skip_df_check = option & ADD_CACHE_SKIP_DFCHECK;
 	pos = cache_name_pos(ce->name, ntohs(ce->ce_flags));
 
-	/* existing match? Just replace it */
+	/* existing match? Just replace it. */
 	if (pos >= 0) {
 		active_cache_changed = 1;
 		active_cache[pos] = ce;
@@ -302,7 +418,8 @@ int add_cache_entry(struct cache_entry *ce, int option)
 	if (!ok_to_add)
 		return -1;
 
-	if (!ce_stage(ce) && check_file_directory_conflict(ce, pos, ok_to_replace)) {
+	if (!skip_df_check &&
+	    check_file_directory_conflict(ce, pos, ok_to_replace)) {
 		if (!ok_to_replace)
 			return -1;
 		pos = cache_name_pos(ce->name, ntohs(ce->ce_flags));
@@ -351,14 +468,18 @@ int read_cache(void)
 
 	errno = EBUSY;
 	if (active_cache)
-		return error("more than one cachefile");
+		return active_nr;
+
 	errno = ENOENT;
 	fd = open(get_index_file(), O_RDONLY);
-	if (fd < 0)
-		return (errno == ENOENT) ? 0 : error("open failed");
+	if (fd < 0) {
+		if (errno == ENOENT)
+			return 0;
+		die("index file open failed (%s)", strerror(errno));
+	}
 
 	size = 0; // avoid gcc warning
-	map = (void *)-1;
+	map = MAP_FAILED;
 	if (!fstat(fd, &st)) {
 		size = st.st_size;
 		errno = EINVAL;
@@ -366,8 +487,8 @@ int read_cache(void)
 			map = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
 	}
 	close(fd);
-	if (-1 == (int)(long)map)
-		return error("mmap failed");
+	if (map == MAP_FAILED)
+		die("index file mmap failed (%s)", strerror(errno));
 
 	hdr = map;
 	if (verify_hdr(hdr, size) < 0)
@@ -388,7 +509,7 @@ int read_cache(void)
 unmap:
 	munmap(map, size);
 	errno = EINVAL;
-	return error("verify header failed");
+	die("index file corrupt");
 }
 
 #define WRITE_BUFFER_SIZE 8192
@@ -426,6 +547,13 @@ static int ce_flush(SHA_CTX *context, int fd)
 		SHA1_Update(context, write_buffer, left);
 	}
 
+	/* Flush first if not enough space for SHA1 signature */
+	if (left + 20 > WRITE_BUFFER_SIZE) {
+		if (write(fd, write_buffer, left) != left)
+			return -1;
+		left = 0;
+	}
+
 	/* Append the SHA1 signature at the end */
 	SHA1_Final(write_buffer + left, context);
 	left += 20;