Add a "checkout-cache" command which does what the name suggests.

diff --git a/read-cache.c b/read-cache.c
index b151981c1b3d15da75411c2af856958d06138c30..c42d2de330d20b599527547b1c7f130e8ec530c9 100644 (file)
--- a/read-cache.c
+++ b/read-cache.c
@@ -84,33 +84,51 @@ char *sha1_file_name(unsigned char *sha1)
        return base;
 }
 
-void * read_sha1_file(unsigned char *sha1, char *type, unsigned long *size)
+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)
 {
-       z_stream stream;
-       char buffer[8192];
-       struct stat st;
-       int i, fd, ret, bytes;
-       void *map, *buf;
        char *filename = sha1_file_name(sha1);
+       int fd = open(filename, O_RDONLY);
+       struct stat st;
+       void *map;
 
-       fd = open(filename, O_RDONLY);
        if (fd < 0) {
                perror(filename);
                return NULL;
        }
        if (fstat(fd, &st) < 0) {
-               close(fd);
+               close(fd);  
                return NULL;
        }
        map = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
        close(fd);
        if (-1 == (int)(long)map)
                return NULL;
+       *size = st.st_size;
+       return map;
+}
+
+void * unpack_sha1_file(void *map, unsigned long mapsize, char *type, unsigned long *size)
+{
+       int ret, bytes;
+       z_stream stream;
+       char buffer[8192];
+       char *buf;
 
        /* Get the data stream */
        memset(&stream, 0, sizeof(stream));
        stream.next_in = map;
-       stream.avail_in = st.st_size;
+       stream.avail_in = mapsize;
        stream.next_out = buffer;
        stream.avail_out = sizeof(buffer);
 
@@ -118,6 +136,7 @@ void * read_sha1_file(unsigned char *sha1, char *type, unsigned long *size)
        ret = inflate(&stream, 0);
        if (sscanf(buffer, "%10s %lu", type, size) != 2)
                return NULL;
+
        bytes = strlen(buffer) + 1;
        buf = malloc(*size);
        if (!buf)
@@ -135,6 +154,20 @@ void * read_sha1_file(unsigned char *sha1, char *type, unsigned long *size)
        return buf;
 }
 
+void * read_sha1_file(unsigned char *sha1, char *type, unsigned long *size)
+{
+       unsigned long mapsize;
+       void *map, *buf;
+
+       map = map_sha1_file(sha1, &mapsize);
+       if (map) {
+               buf = unpack_sha1_file(map, mapsize, type, size);
+               munmap(map, mapsize);
+               return buf;
+       }
+       return NULL;
+}
+
 int write_sha1_file(char *buf, unsigned len)
 {
        int size;
@@ -173,7 +206,7 @@ int write_sha1_file(char *buf, unsigned len)
 int write_sha1_buffer(unsigned char *sha1, void *buf, unsigned int size)
 {
        char *filename = sha1_file_name(sha1);
-       int i, fd;
+       int fd;
 
        fd = open(filename, O_WRONLY | O_CREAT | O_EXCL, 0666);
        if (fd < 0)
@@ -189,6 +222,65 @@ 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;
+}
+
+static 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;
+}
+
 static int verify_hdr(struct cache_header *hdr, unsigned long size)
 {
        SHA_CTX c;
@@ -228,12 +320,12 @@ int read_cache(void)
        if (fd < 0)
                return (errno == ENOENT) ? 0 : error("open failed");
 
+       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);