From ff9e25d40ff1f2a2942eac7b3dd108ca739f362a Mon Sep 17 00:00:00 2001

From: Jeff King <peff@peff.net>

Date: Fri, 13 Jan 2017 12:58:16 -0500

Subject: [PATCH 01/11] sha1_file: add read_loose_object() function

commit f6371f9210418f1beabc85b097e2a3470aeeb54d upstream.

It's surprisingly hard to ask the sha1_file code to open a

_specific_ incarnation of a loose object. Most of the

functions take a sha1, and loop over the various object

types (packed versus loose) and locations (local versus

alternates) at a low level.

However, some tools like fsck need to look at a specific

file. This patch gives them a function they can use to open

the loose object at a given path.

The implementation unfortunately ends up repeating bits of

related functions, but there's not a good way around it

without some major refactoring of the whole sha1_file stack.

We need to mmap the specific file, then partially read the

zlib stream to know whether we're streaming or not, and then

finally either stream it or copy the data to a buffer.

We can do that by assembling some of the more arcane

internal sha1_file functions, but we end up having to

essentially reimplement unpack_sha1_file(), along with the

streaming bits of check_sha1_signature().

Still, most of the ugliness is contained in the new

function, and the interface is clean enough that it may be

reusable (though it seems unlikely anything but git-fsck

would care about opening a specific file).

Signed-off-by: Jeff King <peff@peff.net>

Signed-off-by: Junio C Hamano <gitster@pobox.com>

Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>

---

 cache.h     |  13 ++++++

 sha1_file.c | 132 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-

 2 files changed, 143 insertions(+), 2 deletions(-)

diff --git a/cache.h b/cache.h

index 61d43c6..fa53623 100644

--- a/cache.h

+++ b/cache.h

@@ -1113,6 +1113,19 @@ extern int finalize_object_file(const char *tmpfile, const char *filename);

 extern int has_sha1_pack(const unsigned char *sha1);

+/*

+ * Open the loose object at path, check its sha1, and return the contents,

+ * type, and size. If the object is a blob, then "contents" may return NULL,

+ * to allow streaming of large blobs.

+ *

+ * Returns 0 on success, negative on error (details may be written to stderr).

+ */

+int read_loose_object(const char *path,

+		      const unsigned char *expected_sha1,

+		      enum object_type *type,

+		      unsigned long *size,

+		      void **contents);

+

 /*

  * Return true iff we have an object named sha1, whether local or in

  * an alternate object database, and whether packed or loose.  This

diff --git a/sha1_file.c b/sha1_file.c

index cb571ac..6d29840 100644

--- a/sha1_file.c

+++ b/sha1_file.c

@@ -1547,12 +1547,21 @@ static int open_sha1_file(const unsigned char *sha1)

 	return -1;

 }

-void *map_sha1_file(const unsigned char *sha1, unsigned long *size)

+/*

+ * Map the loose object at "path" if it is not NULL, or the path found by

+ * searching for a loose object named "sha1".

+ */

+static void *map_sha1_file_1(const char *path,

+			     const unsigned char *sha1,

+			     unsigned long *size)

 {

 	void *map;

 	int fd;

-	fd = open_sha1_file(sha1);

+	if (path)

+		fd = git_open_noatime(path);

+	else

+		fd = open_sha1_file(sha1);

 	map = NULL;

 	if (fd >= 0) {

 		struct stat st;

@@ -1571,6 +1580,11 @@ void *map_sha1_file(const unsigned char *sha1, unsigned long *size)

 	return map;

 }

+void *map_sha1_file(const unsigned char *sha1, unsigned long *size)

+{

+	return map_sha1_file_1(NULL, sha1, size);

+}

+

 unsigned long unpack_object_header_buffer(const unsigned char *buf,

 		unsigned long len, enum object_type *type, unsigned long *sizep)

 {

@@ -3644,3 +3658,117 @@ int for_each_packed_object(each_packed_object_fn cb, void *data, unsigned flags)

 	}

 	return r ? r : pack_errors;

 }

+

+static int check_stream_sha1(git_zstream *stream,

+			     const char *hdr,

+			     unsigned long size,

+			     const char *path,

+			     const unsigned char *expected_sha1)

+{

+	git_SHA_CTX c;

+	unsigned char real_sha1[GIT_SHA1_RAWSZ];

+	unsigned char buf[4096];

+	unsigned long total_read;

+	int status = Z_OK;

+

+	git_SHA1_Init(&c);

+	git_SHA1_Update(&c, hdr, stream->total_out);

+

+	/*

+	 * We already read some bytes into hdr, but the ones up to the NUL

+	 * do not count against the object's content size.

+	 */

+	total_read = stream->total_out - strlen(hdr) - 1;

+

+	/*

+	 * This size comparison must be "<=" to read the final zlib packets;

+	 * see the comment in unpack_sha1_rest for details.

+	 */

+	while (total_read <= size &&

+	       (status == Z_OK || status == Z_BUF_ERROR)) {

+		stream->next_out = buf;

+		stream->avail_out = sizeof(buf);

+		if (size - total_read < stream->avail_out)

+			stream->avail_out = size - total_read;

+		status = git_inflate(stream, Z_FINISH);

+		git_SHA1_Update(&c, buf, stream->next_out - buf);

+		total_read += stream->next_out - buf;

+	}

+	git_inflate_end(stream);

+

+	if (status != Z_STREAM_END) {

+		error("corrupt loose object '%s'", sha1_to_hex(expected_sha1));

+		return -1;

+	}

+

+	git_SHA1_Final(real_sha1, &c);

+	if (hashcmp(expected_sha1, real_sha1)) {

+		error("sha1 mismatch for %s (expected %s)", path,

+		      sha1_to_hex(expected_sha1));

+		return -1;

+	}

+

+	return 0;

+}

+

+int read_loose_object(const char *path,

+		      const unsigned char *expected_sha1,

+		      enum object_type *type,

+		      unsigned long *size,

+		      void **contents)

+{

+	int ret = -1;

+	int fd = -1;

+	void *map = NULL;

+	unsigned long mapsize;

+	git_zstream stream;

+	char hdr[32];

+

+	*contents = NULL;

+

+	map = map_sha1_file_1(path, NULL, &mapsize);

+	if (!map) {

+		error_errno("unable to mmap %s", path);

+		goto out;

+	}

+

+	if (unpack_sha1_header(&stream, map, mapsize, hdr, sizeof(hdr)) < 0) {

+		error("unable to unpack header of %s", path);

+		goto out;

+	}

+

+	*type = parse_sha1_header(hdr, size);

+	if (*type < 0) {

+		error("unable to parse header of %s", path);

+		git_inflate_end(&stream);

+		goto out;

+	}

+

+	if (*type == OBJ_BLOB) {

+		if (check_stream_sha1(&stream, hdr, *size, path, expected_sha1) < 0)

+			goto out;

+	} else {

+		*contents = unpack_sha1_rest(&stream, hdr, *size, expected_sha1);

+		if (!*contents) {

+			error("unable to unpack contents of %s", path);

+			git_inflate_end(&stream);

+			goto out;

+		}

+		if (check_sha1_signature(expected_sha1, *contents,

+					 *size, typename(*type))) {

+			error("sha1 mismatch for %s (expected %s)", path,

+			      sha1_to_hex(expected_sha1));

+			free(*contents);

+			goto out;

+		}

+	}

+

+	ret = 0; /* everything checks out */

+

+out:

+	if (map)

+		munmap(map, mapsize);

+	if (fd >= 0)

+		close(fd);

+	return ret;

+}

-- 

2.14.4

From 65074f3eda3338445c7674b7d5b176844970b5de Mon Sep 17 00:00:00 2001

From: Jeff King <peff@peff.net>

Date: Fri, 13 Jan 2017 12:59:44 -0500

Subject: [PATCH 02/11] fsck: parse loose object paths directly

commit c68b489e56431cf27f7719913ab09ddc62f95912 upstream.

When we iterate over the list of loose objects to check, we

get the actual path of each object. But we then throw it

away and pass just the sha1 to fsck_sha1(), which will do a

fresh lookup. Usually it would find the same object, but it

may not if an object exists both as a loose and a packed

object. We may end up checking the packed object twice, and

never look at the loose one.

In practice this isn't too terrible, because if fsck doesn't

complain, it means you have at least one good copy. But

since the point of fsck is to look for corruption, we should

be thorough.

The new read_loose_object() interface can help us get the

data from disk, and then we replace parse_object() with

parse_object_buffer(). As a bonus, our error messages now

mention the path to a corrupted object, which should make it

easier to track down errors when they do happen.

Signed-off-by: Jeff King <peff@peff.net>

Signed-off-by: Junio C Hamano <gitster@pobox.com>

Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>

---

 builtin/fsck.c  | 46 +++++++++++++++++++++++++++++++++-------------

 t/t1450-fsck.sh | 16 ++++++++++++++++

 2 files changed, 49 insertions(+), 13 deletions(-)

diff --git a/builtin/fsck.c b/builtin/fsck.c

index 9923b10..150597c 100644

--- a/builtin/fsck.c

+++ b/builtin/fsck.c

@@ -341,18 +341,6 @@ static int fsck_obj(struct object *obj)

 	return 0;

 }

-static int fsck_sha1(const unsigned char *sha1)

-{

-	struct object *obj = parse_object(sha1);

-	if (!obj) {

-		errors_found |= ERROR_OBJECT;

-		return error("%s: object corrupt or missing",

-			     sha1_to_hex(sha1));

-	}

-	obj->flags |= HAS_OBJ;

-	return fsck_obj(obj);

-}

-

 static int fsck_obj_buffer(const unsigned char *sha1, enum object_type type,

 			   unsigned long size, void *buffer, int *eaten)

 {

@@ -459,9 +447,41 @@ static void get_default_heads(void)

 	}

 }

+static struct object *parse_loose_object(const unsigned char *sha1,

+					 const char *path)

+{

+	struct object *obj;

+	void *contents;

+	enum object_type type;

+	unsigned long size;

+	int eaten;

+

+	if (read_loose_object(path, sha1, &type, &size, &contents) < 0)

+		return NULL;

+

+	if (!contents && type != OBJ_BLOB)

+		die("BUG: read_loose_object streamed a non-blob");

+

+	obj = parse_object_buffer(sha1, type, size, contents, &eaten);

+

+	if (!eaten)

+		free(contents);

+	return obj;

+}

+

 static int fsck_loose(const unsigned char *sha1, const char *path, void *data)

 {

-	if (fsck_sha1(sha1))

+	struct object *obj = parse_loose_object(sha1, path);

+

+	if (!obj) {

+		errors_found |= ERROR_OBJECT;

+		error("%s: object corrupt or missing: %s",

+		      sha1_to_hex(sha1), path);

+		return 0; /* keep checking other objects */

+	}

+

+	obj->flags = HAS_OBJ;

+	if (fsck_obj(obj))

 		errors_found |= ERROR_OBJECT;

 	return 0;

 }

diff --git a/t/t1450-fsck.sh b/t/t1450-fsck.sh

index 7ee8ea0..17c4c77 100755

--- a/t/t1450-fsck.sh

+++ b/t/t1450-fsck.sh

@@ -523,4 +523,20 @@ test_expect_success 'fsck --connectivity-only' '

 	)

 '

+test_expect_success 'fsck finds problems in duplicate loose objects' '

+	rm -rf broken-duplicate &&

+	git init broken-duplicate &&

+	(

+		cd broken-duplicate &&

+		test_commit duplicate &&

+		# no "-d" here, so we end up with duplicates

+		git repack &&

+		# now corrupt the loose copy

+		file=$(sha1_file "$(git rev-parse HEAD)") &&

+		rm "$file" &&

+		echo broken >"$file" &&

+		test_must_fail git fsck

+	)

+'

+

 test_done

-- 

2.14.4

From 6a26b1fcf92a6c825eb72c1a55399f38af5b7b79 Mon Sep 17 00:00:00 2001

From: Jeff King <peff@peff.net>

Date: Wed, 2 May 2018 16:37:09 -0400

Subject: [PATCH 03/11] index-pack: make fsck error message more specific

commit db5a58c1bda5b20169b9958af1e8b05ddd178b01 upstream.

If fsck reports an error, we say only "Error in object".

This isn't quite as bad as it might seem, since the fsck

code would have dumped some errors to stderr already. But it

might help to give a little more context. The earlier output

would not have even mentioned "fsck", and that may be a clue

that the "fsck.*" or "*.fsckObjects" config may be relevant.

Signed-off-by: Jeff King <peff@peff.net>

Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>

---

 builtin/index-pack.c     | 2 +-

 builtin/unpack-objects.c | 2 +-

 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/builtin/index-pack.c b/builtin/index-pack.c

index 1008d7f..81f3bc7 100644

--- a/builtin/index-pack.c

+++ b/builtin/index-pack.c

@@ -841,7 +841,7 @@ static void sha1_object(const void *data, struct object_entry *obj_entry,

 				die(_("invalid %s"), typename(type));

 			if (do_fsck_object &&

 			    fsck_object(obj, buf, size, &fsck_options))

-				die(_("Error in object"));

+				die(_("fsck error in packed object"));

 			if (fsck_walk(obj, NULL, &fsck_options))

 				die(_("Not all child objects of %s are reachable"), oid_to_hex(&obj->oid));

diff --git a/builtin/unpack-objects.c b/builtin/unpack-objects.c

index 875e7ed..7018829 100644

--- a/builtin/unpack-objects.c

+++ b/builtin/unpack-objects.c

@@ -205,7 +205,7 @@ static int check_object(struct object *obj, int type, void *data, struct fsck_op

 	if (!obj_buf)

 		die("Whoops! Cannot find object '%s'", oid_to_hex(&obj->oid));

 	if (fsck_object(obj, obj_buf->buffer, obj_buf->size, &fsck_options))

-		die("Error in object");

+		die("fsck error in packed object");

 	fsck_options.walk = check_object;

 	if (fsck_walk(obj, NULL, &fsck_options))

 		die("Error on reachable objects of %s", oid_to_hex(&obj->oid));

-- 

2.14.4

From 8ac12a6cd60b74748494beadd7750de39f727ff3 Mon Sep 17 00:00:00 2001

From: Jeff King <peff@peff.net>

Date: Sun, 13 May 2018 12:35:37 -0400

Subject: [PATCH 04/11] fsck: simplify ".git" check

commit ed9c3220621d634d543bc4dd998d12167dfc57d4 upstream.

There's no need for us to manually check for ".git"; it's a

subset of the other filesystem-specific tests. Dropping it

makes our code slightly shorter. More importantly, the

existing code may make a reader wonder why ".GIT" is not

covered here, and whether that is a bug (it isn't, as it's

also covered in the filesystem-specific tests).

Signed-off-by: Jeff King <peff@peff.net>

Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>

---

 fsck.c | 4 +---

 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/fsck.c b/fsck.c

index 0531545..c807b7f 100644

--- a/fsck.c

+++ b/fsck.c

@@ -460,9 +460,7 @@ static int fsck_tree(struct tree *item, struct fsck_options *options)

 		has_empty_name |= !*name;

 		has_dot |= !strcmp(name, ".");

 		has_dotdot |= !strcmp(name, "..");

-		has_dotgit |= (!strcmp(name, ".git") ||

-			       is_hfs_dotgit(name) ||

-			       is_ntfs_dotgit(name));

+		has_dotgit |= is_hfs_dotgit(name) || is_ntfs_dotgit(name);

 		has_zero_pad |= *(char *)desc.buffer == '0';

 		update_tree_entry(&desc);

-- 

2.14.4

From 27d0f7bf0b6ba57e849353a65ff73887088b6d7b Mon Sep 17 00:00:00 2001

From: Jeff King <peff@peff.net>

Date: Wed, 2 May 2018 15:44:51 -0400

Subject: [PATCH 05/11] fsck: actually fsck blob data

commit 7ac4f3a007e2567f9d2492806186aa063f9a08d6 upstream.

Because fscking a blob has always been a noop, we didn't

bother passing around the blob data. In preparation for

content-level checks, let's fix up a few things:

  1. The fsck_object() function just returns success for any

     blob. Let's a noop fsck_blob(), which we can fill in

     with actual logic later.

  2. The fsck_loose() function in builtin/fsck.c

     just threw away blob content after loading it. Let's

     hold onto it until after we've called fsck_object().

     The easiest way to do this is to just drop the

     parse_loose_object() helper entirely. Incidentally,

     this also fixes a memory leak: if we successfully

     loaded the object data but did not parse it, we would

     have left the function without freeing it.

  3. When fsck_loose() loads the object data, it

     does so with a custom read_loose_object() helper. This

     function streams any blobs, regardless of size, under

     the assumption that we're only checking the sha1.

     Instead, let's actually load blobs smaller than

     big_file_threshold, as the normal object-reading

     code-paths would do. This lets us fsck small files, and

     a NULL return is an indication that the blob was so big

     that it needed to be streamed, and we can pass that

     information along to fsck_blob().

Signed-off-by: Jeff King <peff@peff.net>

Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>

---

 builtin/fsck.c | 39 +++++++++++++++++++--------------------

 fsck.c         |  8 +++++++-

 sha1_file.c    |  2 +-

 3 files changed, 27 insertions(+), 22 deletions(-)

diff --git a/builtin/fsck.c b/builtin/fsck.c

index 150597c..61ab1cd 100644

--- a/builtin/fsck.c

+++ b/builtin/fsck.c

@@ -299,7 +299,7 @@ static void check_connectivity(void)

 	}

 }

-static int fsck_obj(struct object *obj)

+static int fsck_obj(struct object *obj, void *buffer, unsigned long size)

 {

 	if (obj->flags & SEEN)

 		return 0;

@@ -311,7 +311,7 @@ static int fsck_obj(struct object *obj)

 	if (fsck_walk(obj, NULL, &fsck_obj_options))

 		objerror(obj, "broken links");

-	if (fsck_object(obj, NULL, 0, &fsck_obj_options))

+	if (fsck_object(obj, buffer, size, &fsck_obj_options))

 		return -1;

 	if (obj->type == OBJ_TREE) {

@@ -355,7 +355,7 @@ static int fsck_obj_buffer(const unsigned char *sha1, enum object_type type,

 		return error("%s: object corrupt or missing", sha1_to_hex(sha1));

 	}

 	obj->flags = HAS_OBJ;

-	return fsck_obj(obj);

+	return fsck_obj(obj, buffer, size);

 }

 static int default_refs;

@@ -447,43 +447,42 @@ static void get_default_heads(void)

 	}

 }

-static struct object *parse_loose_object(const unsigned char *sha1,

-					 const char *path)

+static int fsck_loose(const unsigned char *sha1, const char *path, void *data)

 {

 	struct object *obj;

-	void *contents;

 	enum object_type type;

 	unsigned long size;

+	void *contents;

 	int eaten;

-	if (read_loose_object(path, sha1, &type, &size, &contents) < 0)

-		return NULL;

+	if (read_loose_object(path, sha1, &type, &size, &contents) < 0) {

+		errors_found |= ERROR_OBJECT;

+		error("%s: object corrupt or missing: %s",

+		      sha1_to_hex(sha1), path);

+		return 0; /* keep checking other objects */

+	}

 	if (!contents && type != OBJ_BLOB)

 		die("BUG: read_loose_object streamed a non-blob");

 	obj = parse_object_buffer(sha1, type, size, contents, &eaten);

-	if (!eaten)

-		free(contents);

-	return obj;

-}

-

-static int fsck_loose(const unsigned char *sha1, const char *path, void *data)

-{

-	struct object *obj = parse_loose_object(sha1, path);

-

 	if (!obj) {

 		errors_found |= ERROR_OBJECT;

-		error("%s: object corrupt or missing: %s",

+		error("%s: object could not be parsed: %s",

 		      sha1_to_hex(sha1), path);

+		if (!eaten)

+			free(contents);

 		return 0; /* keep checking other objects */

 	}

 	obj->flags = HAS_OBJ;

-	if (fsck_obj(obj))

+	if (fsck_obj(obj, contents, size))

 		errors_found |= ERROR_OBJECT;

-	return 0;

+

+	if (!eaten)

+		free(contents);

+	return 0; /* keep checking other objects, even if we saw an error */

 }

 static int fsck_cruft(const char *basename, const char *path, void *data)

diff --git a/fsck.c b/fsck.c

index c807b7f..a520290 100644

--- a/fsck.c

+++ b/fsck.c

@@ -795,6 +795,12 @@ static int fsck_tag(struct tag *tag, const char *data,

 	return fsck_tag_buffer(tag, data, size, options);

 }

+static int fsck_blob(struct blob *blob, const char *buf,

+		     unsigned long size, struct fsck_options *options)

+{

+	return 0;

+}

+

 int fsck_object(struct object *obj, void *data, unsigned long size,

 	struct fsck_options *options)

 {

@@ -802,7 +808,7 @@ int fsck_object(struct object *obj, void *data, unsigned long size,

 		return report(options, obj, FSCK_MSG_BAD_OBJECT_SHA1, "no valid object to fsck");

 	if (obj->type == OBJ_BLOB)

-		return 0;

+		return fsck_blob((struct blob *)obj, data, size, options);

 	if (obj->type == OBJ_TREE)

 		return fsck_tree((struct tree *) obj, options);

 	if (obj->type == OBJ_COMMIT)

diff --git a/sha1_file.c b/sha1_file.c

index 6d29840..a091644 100644

--- a/sha1_file.c

+++ b/sha1_file.c

@@ -3744,7 +3744,7 @@ int read_loose_object(const char *path,

 		goto out;

 	}

-	if (*type == OBJ_BLOB) {

+	if (*type == OBJ_BLOB && *size > big_file_threshold) {

 		if (check_stream_sha1(&stream, hdr, *size, path, expected_sha1) < 0)

 			goto out;

 	} else {

-- 

2.14.4

From d393612c63e6bdfd7ab54139c229be3db89c550d Mon Sep 17 00:00:00 2001

From: Jeff King <peff@peff.net>

Date: Wed, 2 May 2018 17:20:08 -0400

Subject: [PATCH 06/11] fsck: detect gitmodules files

commit 159e7b080bfa5d34559467cacaa79df89a01afc0 upstream.

In preparation for performing fsck checks on .gitmodules

files, this commit plumbs in the actual detection of the

files. Note that unlike most other fsck checks, this cannot

be a property of a single object: we must know that the

object is found at a ".gitmodules" path at the root tree of

a commit.

Since the fsck code only sees one object at a time, we have

to mark the related objects to fit the puzzle together. When

we see a commit we mark its tree as a root tree, and when

we see a root tree with a .gitmodules file, we mark the

corresponding blob to be checked.

In an ideal world, we'd check the objects in topological

order: commits followed by trees followed by blobs. In that

case we can avoid ever loading an object twice, since all

markings would be complete by the time we get to the marked

objects. And indeed, if we are checking a single packfile,

this is the order in which Git will generally write the

objects. But we can't count on that:

  1. git-fsck may show us the objects in arbitrary order

     (loose objects are fed in sha1 order, but we may also

     have multiple packs, and we process each pack fully in

     sequence).

  2. The type ordering is just what git-pack-objects happens

     to write now. The pack format does not require a

     specific order, and it's possible that future versions

     of Git (or a custom version trying to fool official

     Git's fsck checks!) may order it differently.

  3. We may not even be fscking all of the relevant objects

     at once. Consider pushing with transfer.fsckObjects,

     where one push adds a blob at path "foo", and then a

     second push adds the same blob at path ".gitmodules".

     The blob is not part of the second push at all, but we

     need to mark and check it.

So in the general case, we need to make up to three passes

over the objects: once to make sure we've seen all commits,

then once to cover any trees we might have missed, and then

a final pass to cover any .gitmodules blobs we found in the

second pass.

We can simplify things a bit by loosening the requirement

that we find .gitmodules only at root trees. Technically

a file like "subdir/.gitmodules" is not parsed by Git, but

it's not unreasonable for us to declare that Git is aware of

all ".gitmodules" files and make them eligible for checking.

That lets us drop the root-tree requirement, which

eliminates one pass entirely. And it makes our worst case

much better: instead of potentially queueing every root tree

to be re-examined, the worst case is that we queue each

unique .gitmodules blob for a second look.

This patch just adds the boilerplate to find .gitmodules

files. The actual content checks will come in a subsequent

commit.

[jn: backported to 2.11.y:

 - passing oid->hash instead of oid to lookup_blob

 - using "struct hashmap" directly since "struct oidset" isn't

   available]

Signed-off-by: Jeff King <peff@peff.net>

Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>

---

 fsck.c | 91 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 fsck.h |  7 ++++++

 2 files changed, 98 insertions(+)

diff --git a/fsck.c b/fsck.c

index a520290..f0a566a 100644

--- a/fsck.c

+++ b/fsck.c

@@ -9,6 +9,42 @@

 #include "refs.h"

 #include "utf8.h"

 #include "sha1-array.h"

+#include "hashmap.h"

+

+struct oidhash_entry {

+	struct hashmap_entry ent;

+	struct object_id oid;

+};

+