Start of "git-send-pack", the local part of sending off a pack

[git.git] / sha1_file.c

diff --git a/sha1_file.c b/sha1_file.c
index 25208d2..63cbdde 100644 (file)
--- a/sha1_file.c
+++ b/sha1_file.c
@@ -302,7 +302,7 @@ static int check_packed_git_idx(const char *path, unsigned long *idx_size_,
        index = idx_map;
 
        /* check index map */
-       if (idx_size < 4*256 + 20)
+       if (idx_size < 4*256 + 20 + 20)
                return error("index file too small");
        nr = 0;
        for (i = 0; i < 256; i++) {
@@ -327,12 +327,29 @@ static int check_packed_git_idx(const char *path, unsigned long *idx_size_,
        return 0;
 }
 
-static void unuse_one_packed_git(void)
+static int unuse_one_packed_git(void)
 {
-       /* NOTYET */
+       struct packed_git *p, *lru = NULL;
+
+       for (p = packed_git; p; p = p->next) {
+               if (p->pack_use_cnt || !p->pack_base)
+                       continue;
+               if (!lru || p->pack_last_used < lru->pack_last_used)
+                       lru = p;
+       }
+       if (!lru)
+               return 0;
+       munmap(lru->pack_base, lru->pack_size);
+       lru->pack_base = NULL;
+       return 1;
 }
 
-static int use_packed_git(struct packed_git *p)
+void unuse_packed_git(struct packed_git *p)
+{
+       p->pack_use_cnt--;
+}
+
+int use_packed_git(struct packed_git *p)
 {
        if (!p->pack_base) {
                int fd;
@@ -340,28 +357,36 @@ static int use_packed_git(struct packed_git *p)
                void *map;
 
                pack_mapped += p->pack_size;
-               while (PACK_MAX_SZ < pack_mapped)
-                       unuse_one_packed_git();
+               while (PACK_MAX_SZ < pack_mapped && unuse_one_packed_git())
+                       ; /* nothing */
                fd = open(p->pack_name, O_RDONLY);
                if (fd < 0)
-                       return -1;
+                       die("packfile %s cannot be opened", p->pack_name);
                if (fstat(fd, &st)) {
                        close(fd);
-                       return -1;
+                       die("packfile %s cannot be opened", p->pack_name);
                }
                if (st.st_size != p->pack_size)
-                       return -1;
+                       die("packfile %s size mismatch.", p->pack_name);
                map = mmap(NULL, p->pack_size, PROT_READ, MAP_PRIVATE, fd, 0);
                close(fd);
                if (map == MAP_FAILED)
-                       return -1;
+                       die("packfile %s cannot be mapped.", p->pack_name);
                p->pack_base = map;
+
+               /* Check if the pack file matches with the index file.
+                * this is cheap.
+                */
+               if (memcmp((char*)(p->index_base) + p->index_size - 40,
+                          p->pack_base + p->pack_size - 20, 20))
+                       die("packfile %s does not match index.", p->pack_name);
        }
        p->pack_last_used = pack_used_ctr++;
+       p->pack_use_cnt++;
        return 0;
 }
 
-static struct packed_git *add_packed_git(char *path, int path_len)
+struct packed_git *add_packed_git(char *path, int path_len)
 {
        struct stat st;
        struct packed_git *p;
@@ -388,6 +413,7 @@ static struct packed_git *add_packed_git(char *path, int path_len)
        p->next = NULL;
        p->pack_base = NULL;
        p->pack_last_used = 0;
+       p->pack_use_cnt = 0;
        return p;
 }
 
@@ -598,11 +624,9 @@ static int packed_delta_info(unsigned char *base_sha1,
                             char *type,
                             unsigned long *sizep)
 {
-       unsigned char *data;
+       const unsigned char *data;
        unsigned char delta_head[64];
-       int i;
-       unsigned char cmd;
-       unsigned long data_size, result_size, base_size, verify_base_size;
+       unsigned long result_size, base_size, verify_base_size;
        z_stream stream;
        int st;
 
@@ -611,13 +635,10 @@ static int packed_delta_info(unsigned char *base_sha1,
        if (sha1_object_info(base_sha1, type, &base_size))
                die("cannot get info for delta-pack base");
 
-       data = base_sha1 + 20;
-       data_size = left - 20;
-
        memset(&stream, 0, sizeof(stream));
 
-       stream.next_in = data;
-       stream.avail_in = data_size;
+       data = stream.next_in = base_sha1 + 20;
+       stream.avail_in = left - 20;
        stream.next_out = delta_head;
        stream.avail_out = sizeof(delta_head);
 
@@ -631,27 +652,12 @@ static int packed_delta_info(unsigned char *base_sha1,
         * the result size.  Verify the base size while we are at it.
         */
        data = delta_head;
-       verify_base_size = i = 0;
-       cmd = *data++;
-       while (cmd) {
-               if (cmd & 1)
-                       verify_base_size |= *data++ << i;
-               i += 8;
-               cmd >>= 1;
-       }
-
-       /* Read the result size */
-       result_size = i = 0;
-       cmd = *data++;
-       while (cmd) {
-               if (cmd & 1)
-                       result_size |= *data++ << i;
-               i += 8;
-               cmd >>= 1;
-       }
+       verify_base_size = get_delta_hdr_size(&data);
        if (verify_base_size != base_size)
                die("delta base size mismatch");
 
+       /* Read the result size */
+       result_size = get_delta_hdr_size(&data);
        *sizep = result_size;
        return 0;
 }
@@ -659,6 +665,7 @@ static int packed_delta_info(unsigned char *base_sha1,
 static unsigned long unpack_object_header(struct packed_git *p, unsigned long offset,
        enum object_type *type, unsigned long *sizep)
 {
+       unsigned shift;
        unsigned char *pack, c;
        unsigned long size;
 
@@ -670,12 +677,14 @@ static unsigned long unpack_object_header(struct packed_git *p, unsigned long of
        offset++;
        *type = (c >> 4) & 7;
        size = c & 15;
+       shift = 4;
        while (c & 0x80) {
                if (offset >= p->pack_size)
                        die("object offset outside of pack file");
                c = *pack++;
                offset++;
-               size = (size << 7) | (c & 0x7f);
+               size += (c & 0x7f) << shift;
+               shift += 7;
        }
        *sizep = size;
        return offset;
@@ -688,6 +697,7 @@ static int packed_object_info(struct pack_entry *entry,
        unsigned long offset, size, left;
        unsigned char *pack;
        enum object_type kind;
+       int retval;
 
        if (use_packed_git(p))
                die("cannot map packed file");
@@ -698,8 +708,9 @@ static int packed_object_info(struct pack_entry *entry,
 
        switch (kind) {
        case OBJ_DELTA:
-               return packed_delta_info(pack, size, left, type, sizep);
-               break;
+               retval = packed_delta_info(pack, size, left, type, sizep);
+               unuse_packed_git(p);
+               return retval;
        case OBJ_COMMIT:
                strcpy(type, "commit");
                break;
@@ -716,6 +727,7 @@ static int packed_object_info(struct pack_entry *entry,
                die("corrupted pack file");
        }
        *sizep = size;
+       unuse_packed_git(p);
        return 0;
 }
 
@@ -802,6 +814,7 @@ static void *unpack_entry(struct pack_entry *entry,
        unsigned long offset, size, left;
        unsigned char *pack;
        enum object_type kind;
+       void *retval;
 
        if (use_packed_git(p))
                die("cannot map packed file");
@@ -811,7 +824,9 @@ static void *unpack_entry(struct pack_entry *entry,
        left = p->pack_size - offset;
        switch (kind) {
        case OBJ_DELTA:
-               return unpack_delta_entry(pack, size, left, type, sizep);
+               retval = unpack_delta_entry(pack, size, left, type, sizep);
+               unuse_packed_git(p);
+               return retval;
        case OBJ_COMMIT:
                strcpy(type, "commit");
                break;
@@ -828,12 +843,14 @@ static void *unpack_entry(struct pack_entry *entry,
                die("corrupted pack file");
        }
        *sizep = size;
-       return unpack_non_delta_entry(pack, size, left);
+       retval = unpack_non_delta_entry(pack, size, left);
+       unuse_packed_git(p);
+       return retval;
 }
 
 int num_packed_objects(const struct packed_git *p)
 {
-       /* See check_packed_git_idx and pack-objects.c */
+       /* See check_packed_git_idx() */
        return (p->index_size - 20 - 20 - 4*256) / 24;
 }