Make fsck-cache warn about old-style tree objects that have full

[git.git] / read-cache.c

diff --git a/read-cache.c b/read-cache.c
index 4d75050..ac8375a 100644 (file)
--- a/read-cache.c
+++ b/read-cache.c
@@ -26,7 +26,7 @@ static unsigned hexval(char c)
        return ~0;
 }
 
-int get_sha1_hex(char *hex, unsigned char *sha1)
+int get_sha1_hex(const char *hex, unsigned char *sha1)
 {
        int i;
        for (i = 0; i < 20; i++) {
@@ -39,7 +39,7 @@ int get_sha1_hex(char *hex, unsigned char *sha1)
        return 0;
 }
 
-char * sha1_to_hex(unsigned char *sha1)
+char * sha1_to_hex(const unsigned char *sha1)
 {
        static char buffer[50];
        static const char hex[] = "0123456789abcdef";
@@ -84,6 +84,17 @@ char *sha1_file_name(unsigned char *sha1)
        return base;
 }
 
+int check_sha1_signature(unsigned char *sha1, void *map, unsigned long size)
+{
+       unsigned char real_sha1[20];
+       SHA_CTX c;
+
+       SHA1_Init(&c);
+       SHA1_Update(&c, map, size);
+       SHA1_Final(real_sha1, &c);
+       return memcmp(sha1, real_sha1, 20) ? -1 : 0;
+}
+
 void *map_sha1_file(unsigned char *sha1, unsigned long *size)
 {
        char *filename = sha1_file_name(sha1);
@@ -211,6 +222,103 @@ static int error(const char * string)
        return -1;
 }
 
+int cache_match_stat(struct cache_entry *ce, struct stat *st)
+{
+       unsigned int changed = 0;
+
+       if (ce->mtime.sec  != (unsigned int)st->st_mtim.tv_sec ||
+           ce->mtime.nsec != (unsigned int)st->st_mtim.tv_nsec)
+               changed |= MTIME_CHANGED;
+       if (ce->ctime.sec  != (unsigned int)st->st_ctim.tv_sec ||
+           ce->ctime.nsec != (unsigned int)st->st_ctim.tv_nsec)
+               changed |= CTIME_CHANGED;
+       if (ce->st_uid != (unsigned int)st->st_uid ||
+           ce->st_gid != (unsigned int)st->st_gid)
+               changed |= OWNER_CHANGED;
+       if (ce->st_mode != (unsigned int)st->st_mode)
+               changed |= MODE_CHANGED;
+       if (ce->st_dev != (unsigned int)st->st_dev ||
+           ce->st_ino != (unsigned int)st->st_ino)
+               changed |= INODE_CHANGED;
+       if (ce->st_size != (unsigned int)st->st_size)
+               changed |= DATA_CHANGED;
+       return changed;
+}
+
+int cache_name_compare(const char *name1, int len1, const char *name2, int len2)
+{
+       int len = len1 < len2 ? len1 : len2;
+       int cmp;
+
+       cmp = memcmp(name1, name2, len);
+       if (cmp)
+               return cmp;
+       if (len1 < len2)
+               return -1;
+       if (len1 > len2)
+               return 1;
+       return 0;
+}
+
+int cache_name_pos(const char *name, int namelen)
+{
+       int first, last;
+
+       first = 0;
+       last = active_nr;
+       while (last > first) {
+               int next = (last + first) >> 1;
+               struct cache_entry *ce = active_cache[next];
+               int cmp = cache_name_compare(name, namelen, ce->name, ce->namelen);
+               if (!cmp)
+                       return -next-1;
+               if (cmp < 0) {
+                       last = next;
+                       continue;
+               }
+               first = next+1;
+       }
+       return first;
+}
+
+int remove_file_from_cache(char *path)
+{
+       int pos = cache_name_pos(path, strlen(path));
+       if (pos < 0) {
+               pos = -pos-1;
+               active_nr--;
+               if (pos < active_nr)
+                       memmove(active_cache + pos, active_cache + pos + 1, (active_nr - pos - 1) * sizeof(struct cache_entry *));
+       }
+       return 0;
+}
+
+int add_cache_entry(struct cache_entry *ce)
+{
+       int pos;
+
+       pos = cache_name_pos(ce->name, ce->namelen);
+
+       /* existing match? Just replace it */
+       if (pos < 0) {
+               active_cache[-pos-1] = ce;
+               return 0;
+       }
+
+       /* Make sure the array is big enough .. */
+       if (active_nr == active_alloc) {
+               active_alloc = alloc_nr(active_alloc);
+               active_cache = realloc(active_cache, active_alloc * sizeof(struct cache_entry *));
+       }
+
+       /* Add it in.. */
+       active_nr++;
+       if (active_nr > pos)
+               memmove(active_cache + pos + 1, active_cache + pos, (active_nr - pos - 1) * sizeof(ce));
+       active_cache[pos] = ce;
+       return 0;
+}
+
 static int verify_hdr(struct cache_header *hdr, unsigned long size)
 {
        SHA_CTX c;
@@ -253,10 +361,9 @@ int read_cache(void)
        size = 0; // avoid gcc warning
        map = (void *)-1;
        if (!fstat(fd, &st)) {
-               map = NULL;
                size = st.st_size;
                errno = EINVAL;
-               if (size > sizeof(struct cache_header))
+               if (size >= sizeof(struct cache_header))
                        map = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
        }
        close(fd);
@@ -285,3 +392,33 @@ unmap:
        return error("verify header failed");
 }
 
+int write_cache(int newfd, struct cache_entry **cache, int entries)
+{
+       SHA_CTX c;
+       struct cache_header hdr;
+       int i;
+
+       hdr.signature = CACHE_SIGNATURE;
+       hdr.version = 1;
+       hdr.entries = entries;
+
+       SHA1_Init(&c);
+       SHA1_Update(&c, &hdr, offsetof(struct cache_header, sha1));
+       for (i = 0; i < entries; i++) {
+               struct cache_entry *ce = cache[i];
+               int size = ce_size(ce);
+               SHA1_Update(&c, ce, size);
+       }
+       SHA1_Final(hdr.sha1, &c);
+
+       if (write(newfd, &hdr, sizeof(hdr)) != sizeof(hdr))
+               return -1;
+
+       for (i = 0; i < entries; i++) {
+               struct cache_entry *ce = cache[i];
+               int size = ce_size(ce);
+               if (write(newfd, ce, size) != size)
+                       return -1;
+       }
+       return 0;
+}