bash: Support git-bisect and its subcommands.
[gitweb.git] / sha1_file.c
index 1b1c0f7b4dc814764ead5ba1af77070ed381110c..1526a28095bdb161fd60554a994aefd7cebee27c 100644 (file)
@@ -435,7 +435,7 @@ static int check_packed_git_idx(const char *path, unsigned long *idx_size_,
                                void **idx_map_)
 {
        void *idx_map;
-       unsigned int *index;
+       uint32_t *index;
        unsigned long idx_size;
        int nr, i;
        int fd = open(path, O_RDONLY);
@@ -456,12 +456,23 @@ static int check_packed_git_idx(const char *path, unsigned long *idx_size_,
 
        /* check index map */
        if (idx_size < 4*256 + 20 + 20)
-               return error("index file too small");
+               return error("index file %s is too small", path);
+
+       /* a future index format would start with this, as older git
+        * binaries would fail the non-monotonic index check below.
+        * give a nicer warning to the user if we can.
+        */
+       if (index[0] == htonl(PACK_IDX_SIGNATURE))
+               return error("index file %s is a newer version"
+                       " and is not supported by this binary"
+                       " (try upgrading GIT to a newer version)",
+                       path);
+
        nr = 0;
        for (i = 0; i < 256; i++) {
                unsigned int n = ntohl(index[i]);
                if (n < nr)
-                       return error("non-monotonic index");
+                       return error("non-monotonic index %s", path);
                nr = n;
        }
 
@@ -473,7 +484,7 @@ static int check_packed_git_idx(const char *path, unsigned long *idx_size_,
         *  - 20-byte SHA1 file checksum
         */
        if (idx_size != 4*256 + nr * 24 + 20 + 20)
-               return error("wrong index file size");
+               return error("wrong index file size in %s", path);
 
        return 0;
 }
@@ -541,7 +552,11 @@ void unuse_pack(struct pack_window **w_cursor)
        }
 }
 
-static void open_packed_git(struct packed_git *p)
+/*
+ * Do not call this directly as this leaks p->pack_fd on error return;
+ * call open_packed_git() instead.
+ */
+static int open_packed_git_1(struct packed_git *p)
 {
        struct stat st;
        struct pack_header hdr;
@@ -551,49 +566,61 @@ static void open_packed_git(struct packed_git *p)
 
        p->pack_fd = open(p->pack_name, O_RDONLY);
        if (p->pack_fd < 0 || fstat(p->pack_fd, &st))
-               die("packfile %s cannot be opened", p->pack_name);
+               return -1;
 
        /* If we created the struct before we had the pack we lack size. */
        if (!p->pack_size) {
                if (!S_ISREG(st.st_mode))
-                       die("packfile %s not a regular file", p->pack_name);
+                       return error("packfile %s not a regular file", p->pack_name);
                p->pack_size = st.st_size;
        } else if (p->pack_size != st.st_size)
-               die("packfile %s size changed", p->pack_name);
+               return error("packfile %s size changed", p->pack_name);
 
        /* We leave these file descriptors open with sliding mmap;
         * there is no point keeping them open across exec(), though.
         */
        fd_flag = fcntl(p->pack_fd, F_GETFD, 0);
        if (fd_flag < 0)
-               die("cannot determine file descriptor flags");
+               return error("cannot determine file descriptor flags");
        fd_flag |= FD_CLOEXEC;
        if (fcntl(p->pack_fd, F_SETFD, fd_flag) == -1)
-               die("cannot set FD_CLOEXEC");
+               return error("cannot set FD_CLOEXEC");
 
        /* Verify we recognize this pack file format. */
        if (read_in_full(p->pack_fd, &hdr, sizeof(hdr)) != sizeof(hdr))
-               die("file %s is far too short to be a packfile", p->pack_name);
+               return error("file %s is far too short to be a packfile", p->pack_name);
        if (hdr.hdr_signature != htonl(PACK_SIGNATURE))
-               die("file %s is not a GIT packfile", p->pack_name);
+               return error("file %s is not a GIT packfile", p->pack_name);
        if (!pack_version_ok(hdr.hdr_version))
-               die("packfile %s is version %u and not supported"
+               return error("packfile %s is version %u and not supported"
                        " (try upgrading GIT to a newer version)",
                        p->pack_name, ntohl(hdr.hdr_version));
 
        /* Verify the pack matches its index. */
        if (num_packed_objects(p) != ntohl(hdr.hdr_entries))
-               die("packfile %s claims to have %u objects"
+               return error("packfile %s claims to have %u objects"
                        " while index size indicates %u objects",
                        p->pack_name, ntohl(hdr.hdr_entries),
                        num_packed_objects(p));
        if (lseek(p->pack_fd, p->pack_size - sizeof(sha1), SEEK_SET) == -1)
-               die("end of packfile %s is unavailable", p->pack_name);
+               return error("end of packfile %s is unavailable", p->pack_name);
        if (read_in_full(p->pack_fd, sha1, sizeof(sha1)) != sizeof(sha1))
-               die("packfile %s signature is unavailable", p->pack_name);
+               return error("packfile %s signature is unavailable", p->pack_name);
        idx_sha1 = ((unsigned char *)p->index_base) + p->index_size - 40;
        if (hashcmp(sha1, idx_sha1))
-               die("packfile %s does not match index", p->pack_name);
+               return error("packfile %s does not match index", p->pack_name);
+       return 0;
+}
+
+static int open_packed_git(struct packed_git *p)
+{
+       if (!open_packed_git_1(p))
+               return 0;
+       if (p->pack_fd != -1) {
+               close(p->pack_fd);
+               p->pack_fd = -1;
+       }
+       return -1;
 }
 
 static int in_window(struct pack_window *win, unsigned long offset)
@@ -616,8 +643,8 @@ unsigned char* use_pack(struct packed_git *p,
 {
        struct pack_window *win = *w_cursor;
 
-       if (p->pack_fd == -1)
-               open_packed_git(p);
+       if (p->pack_fd == -1 && open_packed_git(p))
+               die("packfile %s cannot be accessed", p->pack_name);
 
        /* Since packfiles end in a hash of their content and its
         * pointless to ask for an offset into the middle of that
@@ -768,7 +795,7 @@ static void prepare_packed_git_one(char *objdir, int local)
                if (!has_extension(de->d_name, ".idx"))
                        continue;
 
-               /* we have .idx.  Is it a file we can map? */
+               /* Don't reopen a pack we already have. */
                strcpy(path + len, de->d_name);
                for (p = packed_git; p; p = p->next) {
                        if (!memcmp(path, p->pack_name, len + namelen - 4))
@@ -776,11 +803,13 @@ static void prepare_packed_git_one(char *objdir, int local)
                }
                if (p)
                        continue;
+               /* See if it really is a valid .idx file with corresponding
+                * .pack file that we can map.
+                */
                p = add_packed_git(path, len + namelen, local);
                if (!p)
                        continue;
-               p->next = packed_git;
-               packed_git = p;
+               install_packed_git(p);
        }
        closedir(dir);
 }
@@ -1134,7 +1163,7 @@ static unsigned long unpack_object_header(struct packed_git *p,
 
        /* use_pack() assures us we have [base, base + 20) available
         * as a range that we can look at at.  (Its actually the hash
-        * size that is assurred.)  With our object header encoding
+        * size that is assured.)  With our object header encoding
         * the maximum deflated object size is 2^137, which is just
         * insane, so we know won't exceed what we have been given.
         */
@@ -1340,7 +1369,7 @@ int nth_packed_object_sha1(const struct packed_git *p, int n,
 unsigned long find_pack_entry_one(const unsigned char *sha1,
                                  struct packed_git *p)
 {
-       unsigned int *level1_ofs = p->index_base;
+       uint32_t *level1_ofs = p->index_base;
        int hi = ntohl(level1_ofs[*sha1]);
        int lo = ((*sha1 == 0x0) ? 0 : ntohl(level1_ofs[*sha1 - 1]));
        void *index = p->index_base + 256;
@@ -1349,7 +1378,7 @@ unsigned long find_pack_entry_one(const unsigned char *sha1,
                int mi = (lo + hi) / 2;
                int cmp = hashcmp((unsigned char *)index + (24 * mi) + 4, sha1);
                if (!cmp)
-                       return ntohl(*((unsigned int *) ((char *) index + (24 * mi))));
+                       return ntohl(*((uint32_t *)((char *)index + (24 * mi))));
                if (cmp > 0)
                        hi = mi;
                else
@@ -1394,6 +1423,18 @@ static int find_pack_entry(const unsigned char *sha1, struct pack_entry *e, cons
                }
                offset = find_pack_entry_one(sha1, p);
                if (offset) {
+                       /*
+                        * We are about to tell the caller where they can
+                        * locate the requested object.  We better make
+                        * sure the packfile is still here and can be
+                        * accessed before supplying that answer, as
+                        * it may have been deleted since the index
+                        * was loaded!
+                        */
+                       if (p->pack_fd == -1 && open_packed_git(p)) {
+                               error("packfile %s cannot be accessed", p->pack_name);
+                               continue;
+                       }
                        e->offset = offset;
                        e->p = p;
                        hashcpy(e->sha1, sha1);
@@ -1458,21 +1499,20 @@ static void *read_packed_sha1(const unsigned char *sha1, char *type, unsigned lo
 {
        struct pack_entry e;
 
-       if (!find_pack_entry(sha1, &e, NULL)) {
-               error("cannot read sha1_file for %s", sha1_to_hex(sha1));
+       if (!find_pack_entry(sha1, &e, NULL))
                return NULL;
-       }
-       return unpack_entry(e.p, e.offset, type, size);
+       else
+               return unpack_entry(e.p, e.offset, type, size);
 }
 
 void * read_sha1_file(const unsigned char *sha1, char *type, unsigned long *size)
 {
        unsigned long mapsize;
        void *map, *buf;
-       struct pack_entry e;
 
-       if (find_pack_entry(sha1, &e, NULL))
-               return read_packed_sha1(sha1, type, size);
+       buf = read_packed_sha1(sha1, type, size);
+       if (buf)
+               return buf;
        map = map_sha1_file(sha1, &mapsize);
        if (map) {
                buf = unpack_sha1_file(map, mapsize, type, size);
@@ -1480,9 +1520,7 @@ void * read_sha1_file(const unsigned char *sha1, char *type, unsigned long *size
                return buf;
        }
        reprepare_packed_git();
-       if (find_pack_entry(sha1, &e, NULL))
-               return read_packed_sha1(sha1, type, size);
-       return NULL;
+       return read_packed_sha1(sha1, type, size);
 }
 
 void *read_object_with_reference(const unsigned char *sha1,
@@ -1770,6 +1808,8 @@ static void *repack_object(const unsigned char *sha1, unsigned long *objsize)
 
        /* need to unpack and recompress it by itself */
        unpacked = read_packed_sha1(sha1, type, &len);
+       if (!unpacked)
+               error("cannot read sha1_file for %s", sha1_to_hex(sha1));
 
        hdrlen = sprintf(hdr, "%s %lu", type, len) + 1;
 
@@ -2038,3 +2078,24 @@ int index_path(unsigned char *sha1, const char *path, struct stat *st, int write
        }
        return 0;
 }
+
+int read_pack_header(int fd, struct pack_header *header)
+{
+       char *c = (char*)header;
+       ssize_t remaining = sizeof(struct pack_header);
+       do {
+               ssize_t r = xread(fd, c, remaining);
+               if (r <= 0)
+                       /* "eof before pack header was fully read" */
+                       return PH_ERROR_EOF;
+               remaining -= r;
+               c += r;
+       } while (remaining > 0);
+       if (header->hdr_signature != htonl(PACK_SIGNATURE))
+               /* "protocol error (pack signature mismatch detected)" */
+               return PH_ERROR_PACK_SIGNATURE;
+       if (!pack_version_ok(header->hdr_version))
+               /* "protocol error (pack version unsupported)" */
+               return PH_ERROR_PROTOCOL;
+       return 0;
+}