Initial revision of "git", the information manager from hell

11 files changed, 1244 insertions, 0 deletions

diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..a6bba79
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,40 @@
+CFLAGS=-g
+CC=gcc
+
+PROG=update-cache show-diff init-db write-tree read-tree commit-tree cat-file
+
+all: $(PROG)
+
+install: $(PROG)
+	install $(PROG) $(HOME)/bin/
+
+LIBS= -lssl
+
+init-db: init-db.o
+
+update-cache: update-cache.o read-cache.o
+	$(CC) $(CFLAGS) -o update-cache update-cache.o read-cache.o $(LIBS)
+
+show-diff: show-diff.o read-cache.o
+	$(CC) $(CFLAGS) -o show-diff show-diff.o read-cache.o $(LIBS)
+
+write-tree: write-tree.o read-cache.o
+	$(CC) $(CFLAGS) -o write-tree write-tree.o read-cache.o $(LIBS)
+
+read-tree: read-tree.o read-cache.o
+	$(CC) $(CFLAGS) -o read-tree read-tree.o read-cache.o $(LIBS)
+
+commit-tree: commit-tree.o read-cache.o
+	$(CC) $(CFLAGS) -o commit-tree commit-tree.o read-cache.o $(LIBS)
+
+cat-file: cat-file.o read-cache.o
+	$(CC) $(CFLAGS) -o cat-file cat-file.o read-cache.o $(LIBS)
+
+read-cache.o: cache.h
+show-diff.o: cache.h
+
+clean:
+	rm -f *.o $(PROG) temp_git_file_*
+
+backup: clean
+	cd .. ; tar czvf dircache.tar.gz dir-cache
diff --git a/README b/README
new file mode 100644
index 0000000..27577f7
--- /dev/null
+++ b/README
@@ -0,0 +1,168 @@
+
+	GIT - the stupid content tracker
+
+"git" can mean anything, depending on your mood.
+
+ - random three-letter combination that is pronounceable, and not
+   actually used by any common UNIX command.  The fact that it is a
+   mispronounciation of "get" may or may not be relevant.
+ - stupid. contemptible and despicable. simple. Take your pick from the
+   dictionary of slang.
+ - "global information tracker": you're in a good mood, and it actually
+   works for you. Angels sing, and a light suddenly fills the room. 
+ - "goddamn idiotic truckload of sh*t": when it breaks
+
+This is a stupid (but extremely fast) directory content manager.  It
+doesn't do a whole lot, but what it _does_ do is track directory
+contents efficiently. 
+
+There are two object abstractions: the "object database", and the
+"current directory cache".
+
+	The Object Database (SHA1_FILE_DIRECTORY)
+
+The object database is literally just a content-addressable collection
+of objects.  All objects are named by their content, which is
+approximated by the SHA1 hash of the object itself.  Objects may refer
+to other objects (by referencing their SHA1 hash), and so you can build
+up a hierarchy of objects. 
+
+There are several kinds of objects in the content-addressable collection
+database.  They are all in deflated with zlib, and start off with a tag
+of their type, and size information about the data.  The SHA1 hash is
+always the hash of the _compressed_ object, not the original one.
+
+In particular, the consistency of an object can always be tested
+independently of the contents or the type of the object: all objects can
+be validated by verifying that (a) their hashes match the content of the
+file and (b) the object successfully inflates to a stream of bytes that
+forms a sequence of <ascii tag without space> + <space> + <ascii decimal
+size> + <byte\0> + <binary object data>. 
+
+BLOB: A "blob" object is nothing but a binary blob of data, and doesn't
+refer to anything else.  There is no signature or any other verification
+of the data, so while the object is consistent (it _is_ indexed by its
+sha1 hash, so the data itself is certainly correct), it has absolutely
+no other attributes.  No name associations, no permissions.  It is
+purely a blob of data (ie normally "file contents"). 
+
+TREE: The next hierarchical object type is the "tree" object.  A tree
+object is a list of permission/name/blob data, sorted by name.  In other
+words the tree object is uniquely determined by the set contents, and so
+two separate but identical trees will always share the exact same
+object. 
+
+Again, a "tree" object is just a pure data abstraction: it has no
+history, no signatures, no verification of validity, except that the
+contents are again protected by the hash itself.  So you can trust the
+contents of a tree, the same way you can trust the contents of a blob,
+but you don't know where those contents _came_ from. 
+
+Side note on trees: since a "tree" object is a sorted list of
+"filename+content", you can create a diff between two trees without
+actually having to unpack two trees.  Just ignore all common parts, and
+your diff will look right.  In other words, you can effectively (and
+efficiently) tell the difference between any two random trees by O(n)
+where "n" is the size of the difference, rather than the size of the
+tree. 
+
+Side note 2 on trees: since the name of a "blob" depends entirely and
+exclusively on its contents (ie there are no names or permissions
+involved), you can see trivial renames or permission changes by noticing
+that the blob stayed the same.  However, renames with data changes need
+a smarter "diff" implementation. 
+
+CHANGESET: The "changeset" object is an object that introduces the
+notion of history into the picture.  In contrast to the other objects,
+it doesn't just describe the physical state of a tree, it describes how
+we got there, and why. 
+
+A "changeset" is defined by the tree-object that it results in, the
+parent changesets (zero, one or more) that led up to that point, and a
+comment on what happened. Again, a changeset is not trusted per se:
+the contents are well-defined and "safe" due to the cryptographically
+strong signatures at all levels, but there is no reason to believe that
+the tree is "good" or that the merge information makes sense. The
+parents do not have to actually have any relationship with the result,
+for example.
+
+Note on changesets: unlike real SCM's, changesets do not contain rename
+information or file mode chane information.  All of that is implicit in
+the trees involved (the result tree, and the result trees of the
+parents), and describing that makes no sense in this idiotic file
+manager.
+
+TRUST: The notion of "trust" is really outside the scope of "git", but
+it's worth noting a few things. First off, since everything is hashed
+with SHA1, you _can_ trust that an object is intact and has not been
+messed with by external sources. So the name of an object uniquely
+identifies a known state - just not a state that you may want to trust.
+
+Furthermore, since the SHA1 signature of a changeset refers to the
+SHA1 signatures of the tree it is associated with and the signatures
+of the parent, a single named changeset specifies uniquely a whole
+set of history, with full contents. You can't later fake any step of
+the way once you have the name of a changeset.
+
+So to introduce some real trust in the system, the only thing you need
+to do is to digitally sign just _one_ special note, which includes the
+name of a top-level changeset.  Your digital signature shows others that
+you trust that changeset, and the immutability of the history of
+changesets tells others that they can trust the whole history.
+
+In other words, you can easily validate a whole archive by just sending
+out a single email that tells the people the name (SHA1 hash) of the top
+changeset, and digitally sign that email using something like GPG/PGP.
+
+In particular, you can also have a separate archive of "trust points" or
+tags, which document your (and other peoples) trust.  You may, of
+course, archive these "certificates of trust" using "git" itself, but
+it's not something "git" does for you. 
+
+Another way of saying the same thing: "git" itself only handles content
+integrity, the trust has to come from outside. 
+
+	Current Directory Cache (".dircache/index")
+
+The "current directory cache" is a simple binary file, which contains an
+efficient representation of a virtual directory content at some random
+time.  It does so by a simple array that associates a set of names,
+dates, permissions and content (aka "blob") objects together.  The cache
+is always kept ordered by name, and names are unique at any point in
+time, but the cache has no long-term meaning, and can be partially
+updated at any time. 
+
+In particular, the "current directory cache" certainly does not need to
+be consistent with the current directory contents, but it has two very
+important attributes:
+
+ (a) it can re-generate the full state it caches (not just the directory
+     structure: through the "blob" object it can regenerate the data too)
+
+     As a special case, there is a clear and unambiguous one-way mapping
+     from a current directory cache to a "tree object", which can be
+     efficiently created from just the current directory cache without
+     actually looking at any other data.  So a directory cache at any
+     one time uniquely specifies one and only one "tree" object (but
+     has additional data to make it easy to match up that tree object
+     with what has happened in the directory)
+    
+
+and
+
+ (b) it has efficient methods for finding inconsistencies between that
+     cached state ("tree object waiting to be instantiated") and the
+     current state. 
+
+Those are the two ONLY things that the directory cache does.  It's a
+cache, and the normal operation is to re-generate it completely from a
+known tree object, or update/compare it with a live tree that is being
+developed.  If you blow the directory cache away entirely, you haven't
+lost any information as long as you have the name of the tree that it
+described. 
+
+(But directory caches can also have real information in them: in
+particular, they can have the representation of an intermediate tree
+that has not yet been instantiated.  So they do have meaning and usage
+outside of caching - in one sense you can think of the current directory
+cache as being the "work in progress" towards a tree commit).
diff --git a/cache.h b/cache.h
new file mode 100644
index 0000000..98a32a9
--- /dev/null
+++ b/cache.h
@@ -0,0 +1,93 @@
+#ifndef CACHE_H
+#define CACHE_H
+
+#include <stdio.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <errno.h>
+#include <sys/mman.h>
+
+#include <openssl/sha.h>
+#include <zlib.h>
+
+/*
+ * Basic data structures for the directory cache
+ *
+ * NOTE NOTE NOTE! This is all in the native CPU byte format. It's
+ * not even trying to be portable. It's trying to be efficient. It's
+ * just a cache, after all.
+ */
+
+#define CACHE_SIGNATURE 0x44495243	/* "DIRC" */
+struct cache_header {
+	unsigned int signature;
+	unsigned int version;
+	unsigned int entries;
+	unsigned char sha1[20];
+};
+
+/*
+ * The "cache_time" is just the low 32 bits of the
+ * time. It doesn't matter if it overflows - we only
+ * check it for equality in the 32 bits we save.
+ */
+struct cache_time {
+	unsigned int sec;
+	unsigned int nsec;
+};
+
+/*
+ * dev/ino/uid/gid/size are also just tracked to the low 32 bits
+ * Again - this is just a (very strong in practice) heuristic that
+ * the inode hasn't changed.
+ */
+struct cache_entry {
+	struct cache_time ctime;
+	struct cache_time mtime;
+	unsigned int st_dev;
+	unsigned int st_ino;
+	unsigned int st_mode;
+	unsigned int st_uid;
+	unsigned int st_gid;
+	unsigned int st_size;
+	unsigned char sha1[20];
+	unsigned short namelen;
+	unsigned char name[0];
+};
+
+const char *sha1_file_directory;
+struct cache_entry **active_cache;
+unsigned int active_nr, active_alloc;
+
+#define DB_ENVIRONMENT "SHA1_FILE_DIRECTORY"
+#define DEFAULT_DB_ENVIRONMENT ".dircache/objects"
+
+#define cache_entry_size(len) ((offsetof(struct cache_entry,name) + (len) + 8) & ~7)
+#define ce_size(ce) cache_entry_size((ce)->namelen)
+
+#define alloc_nr(x) (((x)+16)*3/2)
+
+/* Initialize the cache information */
+extern int read_cache(void);
+
+/* Return a statically allocated filename matching the sha1 signature */
+extern char *sha1_file_name(unsigned char *sha1);
+
+/* Write a memory buffer out to the sha file */
+extern int write_sha1_buffer(unsigned char *sha1, void *buf, unsigned int size);
+
+/* Read and unpack a sha1 file into memory, write memory to a sha1 file */
+extern void * read_sha1_file(unsigned char *sha1, char *type, unsigned long *size);
+extern int write_sha1_file(char *buf, unsigned len);
+
+/* Convert to/from hex/sha1 representation */
+extern int get_sha1_hex(char *hex, unsigned char *sha1);
+extern char *sha1_to_hex(unsigned char *sha1);	/* static buffer! */
+
+/* General helper functions */
+extern void usage(const char *err);
+
+#endif /* CACHE_H */
diff --git a/cat-file.c b/cat-file.c
new file mode 100644
index 0000000..74a0a23
--- /dev/null
+++ b/cat-file.c
@@ -0,0 +1,23 @@
+#include "cache.h"
+
+int main(int argc, char **argv)
+{
+	unsigned char sha1[20];
+	char type[20];
+	void *buf;
+	unsigned long size;
+	char template[] = "temp_git_file_XXXXXX";
+	int fd;
+
+	if (argc != 2 || get_sha1_hex(argv[1], sha1))
+		usage("cat-file: cat-file <sha1>");
+	buf = read_sha1_file(sha1, type, &size);
+	if (!buf)
+		exit(1);
+	fd = mkstemp(template);
+	if (fd < 0)
+		usage("unable to create tempfile");
+	if (write(fd, buf, size) != size)
+		strcpy(type, "bad");
+	printf("%s: %s\n", template, type);
+}
diff --git a/commit-tree.c b/commit-tree.c
new file mode 100644
index 0000000..840307a
--- /dev/null
+++ b/commit-tree.c
@@ -0,0 +1,172 @@
+#include "cache.h"
+
+#include <pwd.h>
+#include <time.h>
+
+#define BLOCKING (1ul << 14)
+#define ORIG_OFFSET (40)
+
+/*
+ * Leave space at the beginning to insert the tag
+ * once we know how big things are.
+ *
+ * FIXME! Share the code with "write-tree.c"
+ */
+static void init_buffer(char **bufp, unsigned int *sizep)
+{
+	char *buf = malloc(BLOCKING);
+	memset(buf, 0, ORIG_OFFSET);
+	*sizep = ORIG_OFFSET;
+	*bufp = buf;
+}
+
+static void add_buffer(char **bufp, unsigned int *sizep, const char *fmt, ...)
+{
+	char one_line[2048];
+	va_list args;
+	int len;
+	unsigned long alloc, size, newsize;
+	char *buf;
+
+	va_start(args, fmt);
+	len = vsnprintf(one_line, sizeof(one_line), fmt, args);
+	va_end(args);
+	size = *sizep;
+	newsize = size + len;
+	alloc = (size + 32767) & ~32767;
+	buf = *bufp;
+	if (newsize > alloc) {
+		alloc = (newsize + 32767) & ~32767;   
+		buf = realloc(buf, alloc);
+		*bufp = buf;
+	}
+	*sizep = newsize;
+	memcpy(buf + size, one_line, len);
+}
+
+static int prepend_integer(char *buffer, unsigned val, int i)
+{
+	buffer[--i] = '\0';
+	do {
+		buffer[--i] = '0' + (val % 10);
+		val /= 10;
+	} while (val);
+	return i;
+}
+
+static void finish_buffer(char *tag, char **bufp, unsigned int *sizep)
+{
+	int taglen;
+	int offset;
+	char *buf = *bufp;
+	unsigned int size = *sizep;
+
+	offset = prepend_integer(buf, size - ORIG_OFFSET, ORIG_OFFSET);
+	taglen = strlen(tag);
+	offset -= taglen;
+	buf += offset;
+	size -= offset;
+	memcpy(buf, tag, taglen);
+
+	*bufp = buf;
+	*sizep = size;
+}
+
+static void remove_special(char *p)
+{
+	char c;
+	char *dst = p;
+
+	for (;;) {
+		c = *p;
+		p++;
+		switch(c) {
+		case '\n': case '<': case '>':
+			continue;
+		}
+		*dst++ = c;
+		if (!c)
+			break;
+	}
+}
+
+/*
+ * Having more than two parents may be strange, but hey, there's
+ * no conceptual reason why the file format couldn't accept multi-way
+ * merges. It might be the "union" of several packages, for example.
+ *
+ * I don't really expect that to happen, but this is here to make
+ * it clear that _conceptually_ it's ok..
+ */
+#define MAXPARENT (16)
+
+int main(int argc, char **argv)
+{
+	int i, len;
+	int parents = 0;
+	unsigned char tree_sha1[20];
+	unsigned char parent_sha1[MAXPARENT][20];
+	char *gecos, *realgecos;
+	char *email, realemail[1000];
+	char *date, *realdate;
+	char comment[1000];
+	struct passwd *pw;
+	time_t now;
+	char *buffer;
+	unsigned int size;
+
+	if (argc < 2 || get_sha1_hex(argv[1], tree_sha1) < 0)
+		usage("commit-tree <sha1> [-p <sha1>]* < changelog");
+
+	for (i = 2; i < argc; i += 2) {
+		char *a, *b;
+		a = argv[i]; b = argv[i+1];
+		if (!b || strcmp(a, "-p") || get_sha1_hex(b, parent_sha1[parents]))
+			usage("commit-tree <sha1> [-p <sha1>]* < changelog");
+		parents++;
+	}
+	if (!parents)
+		fprintf(stderr, "Committing initial tree %s\n", argv[1]);
+	pw = getpwuid(getuid());
+	if (!pw)
+		usage("You don't exist. Go away!");
+	realgecos = pw->pw_gecos;
+	len = strlen(pw->pw_name);
+	memcpy(realemail, pw->pw_name, len);
+	realemail[len] = '@';
+	gethostname(realemail+len+1, sizeof(realemail)-len-1);
+	time(&now);
+	realdate = ctime(&now);
+
+	gecos = getenv("COMMITTER_NAME") ? : realgecos;
+	email = getenv("COMMITTER_EMAIL") ? : realemail;
+	date = getenv("COMMITTER_DATE") ? : realdate;
+
+	remove_special(gecos); remove_special(realgecos);
+	remove_special(email); remove_special(realemail);
+	remove_special(date); remove_special(realdate);
+
+	init_buffer(&buffer, &size);
+	add_buffer(&buffer, &size, "tree %s\n", sha1_to_hex(tree_sha1));
+
+	/*
+	 * NOTE! This ordering means that the same exact tree merged with a
+	 * different order of parents will be a _different_ changeset even
+	 * if everything else stays the same.
+	 */
+	for (i = 0; i < parents; i++)
+		add_buffer(&buffer, &size, "parent %s\n", sha1_to_hex(parent_sha1[i]));
+
+	/* Person/date information */
+	add_buffer(&buffer, &size, "author %s <%s> %s\n", gecos, email, date);
+	add_buffer(&buffer, &size, "committer %s <%s> %s\n\n", realgecos, realemail, realdate);
+
+	/* And add the comment */
+	while (fgets(comment, sizeof(comment), stdin) != NULL)
+		add_buffer(&buffer, &size, "%s", comment);
+
+	finish_buffer("commit ", &buffer, &size);
+
+	write_sha1_file(buffer, size);
+	return 0;
+}
diff --git a/init-db.c b/init-db.c
new file mode 100644
index 0000000..25dc13f
--- /dev/null
+++ b/init-db.c
@@ -0,0 +1,51 @@
+#include "cache.h"
+
+int main(int argc, char **argv)
+{
+	char *sha1_dir = getenv(DB_ENVIRONMENT), *path;
+	int len, i, fd;
+
+	if (mkdir(".dircache", 0700) < 0) {
+		perror("unable to create .dircache");
+		exit(1);
+	}
+
+	/*
+	 * If you want to, you can share the DB area with any number of branches.
+	 * That has advantages: you can save space by sharing all the SHA1 objects.
+	 * On the other hand, it might just make lookup slower and messier. You
+	 * be the judge.
+	 */
+	sha1_dir = getenv(DB_ENVIRONMENT);
+	if (sha1_dir) {
+		struct stat st;
+		if (!stat(sha1_dir, &st) < 0 && S_ISDIR(st.st_mode))
+			return;
+		fprintf(stderr, "DB_ENVIRONMENT set to bad directory %s: ", sha1_dir);
+	}
+
+	/*
+	 * The default case is to have a DB per managed directory. 
+	 */
+	sha1_dir = DEFAULT_DB_ENVIRONMENT;
+	fprintf(stderr, "defaulting to private storage area\n");
+	len = strlen(sha1_dir);
+	if (mkdir(sha1_dir, 0700) < 0) {
+		if (errno != EEXIST) {
+			perror(sha1_dir);
+			exit(1);
+		}
+	}
+	path = malloc(len + 40);
+	memcpy(path, sha1_dir, len);
+	for (i = 0; i < 256; i++) {
+		sprintf(path+len, "/%02x", i);
+		if (mkdir(path, 0700) < 0) {
+			if (errno != EEXIST) {
+				perror(path);
+				exit(1);
+			}
+		}
+	}
+	return 0;
+}
diff --git a/read-cache.c b/read-cache.c
new file mode 100644
index 0000000..c924a6e
--- /dev/null
+++ b/read-cache.c
@@ -0,0 +1,259 @@
+#include "cache.h"
+
+const char *sha1_file_directory = NULL;
+struct cache_entry **active_cache = NULL;
+unsigned int active_nr = 0, active_alloc = 0;
+
+void usage(const char *err)
+{
+	fprintf(stderr, "read-tree: %s\n", err);
+	exit(1);
+}
+
+static unsigned hexval(char c)
+{
+	if (c >= '0' && c <= '9')
+		return c - '0';
+	if (c >= 'a' && c <= 'f')
+		return c - 'a' + 10;
+	if (c >= 'A' && c <= 'F')
+		return c - 'A' + 10;
+	return ~0;
+}
+
+int get_sha1_hex(char *hex, unsigned char *sha1)
+{
+	int i;
+	for (i = 0; i < 20; i++) {
+		unsigned int val = (hexval(hex[0]) << 4) | hexval(hex[1]);
+		if (val & ~0xff)
+			return -1;
+		*sha1++ = val;
+		hex += 2;
+	}
+	return 0;
+}
+
+char * sha1_to_hex(unsigned char *sha1)
+{
+	static char buffer[50];
+	static const char hex[] = "0123456789abcdef";
+	char *buf = buffer;
+	int i;
+
+	for (i = 0; i < 20; i++) {
+		unsigned int val = *sha1++;
+		*buf++ = hex[val >> 4];
+		*buf++ = hex[val & 0xf];
+	}
+	return buffer;
+}
+
+/*
+ * NOTE! This returns a statically allocated buffer, so you have to be
+ * careful about using it. Do a "strdup()" if you need to save the
+ * filename.
+ */
+char *sha1_file_name(unsigned char *sha1)
+{
+	int i;
+	static char *name, *base;
+
+	if (!base) {
+		char *sha1_file_directory = getenv(DB_ENVIRONMENT) ? : DEFAULT_DB_ENVIRONMENT;
+		int len = strlen(sha1_file_directory);
+		base = malloc(len + 60);
+		memcpy(base, sha1_file_directory, len);
+		memset(base+len, 0, 60);
+		base[len] = '/';
+		base[len+3] = '/';
+		name = base + len + 1;
+	}
+	for (i = 0; i < 20; i++) {
+		static char hex[] = "0123456789abcdef";
+		unsigned int val = sha1[i];
+		char *pos = name + i*2 + (i > 0);
+		*pos++ = hex[val >> 4];
+		*pos = hex[val & 0xf];
+	}
+	return base;
+}
+
+void * read_sha1_file(unsigned char *sha1, char *type, 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);
+
+	fd = open(filename, O_RDONLY);
+	if (fd < 0) {
+		perror(filename);
+		return NULL;
+	}
+	if (fstat(fd, &st) < 0) {
+		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;
+
+	/* Get the data stream */
+	memset(&stream, 0, sizeof(stream));
+	stream.next_in = map;
+	stream.avail_in = st.st_size;
+	stream.next_out = buffer;
+	stream.avail_out = sizeof(buffer);
+
+	inflateInit(&stream);
+	ret = inflate(&stream, 0);
+	if (sscanf(buffer, "%10s %lu", type, size) != 2)
+		return NULL;
+	bytes = strlen(buffer) + 1;
+	buf = malloc(*size);
+	if (!buf)
+		return NULL;
+
+	memcpy(buf, buffer + bytes, stream.total_out - bytes);
+	bytes = stream.total_out - bytes;
+	if (bytes < *size && ret == Z_OK) {
+		stream.next_out = buf + bytes;
+		stream.avail_out = *size - bytes;
+		while (inflate(&stream, Z_FINISH) == Z_OK)
+			/* nothing */;
+	}
+	inflateEnd(&stream);
+	return buf;
+}
+
+int write_sha1_file(char *buf, unsigned len)
+{
+	int size;
+	char *compressed;
+	z_stream stream;
+	unsigned char sha1[20];
+	SHA_CTX c;
+
+	/* Set it up */
+	memset(&stream, 0, sizeof(stream));
+	deflateInit(&stream, Z_BEST_COMPRESSION);
+	size = deflateBound(&stream, len);
+	compressed = malloc(size);
+
+	/* Compress it */
+	stream.next_in = buf;
+	stream.avail_in = len;
+	stream.next_out = compressed;
+	stream.avail_out = size;
+	while (deflate(&stream, Z_FINISH) == Z_OK)
+		/* nothing */;
+	deflateEnd(&stream);
+	size = stream.total_out;
+
+	/* Sha1.. */
+	SHA1_Init(&c);
+	SHA1_Update(&c, compressed, size);
+	SHA1_Final(sha1, &c);
+
+	if (write_sha1_buffer(sha1, compressed, size) < 0)
+		return -1;
+	printf("%s\n", sha1_to_hex(sha1));
+	return 0;
+}
+
+int write_sha1_buffer(unsigned char *sha1, void *buf, unsigned int size)
+{
+	char *filename = sha1_file_name(sha1);
+	int i, fd;
+
+	fd = open(filename, O_WRONLY | O_CREAT | O_EXCL, 0666);
+	if (fd < 0)
+		return (errno == EEXIST) ? 0 : -1;
+	write(fd, buf, size);
+	close(fd);
+	return 0;
+}
+
+static int error(const char * string)
+{
+	fprintf(stderr, "error: %s\n", string);
+	return -1;
+}
+
+static int verify_hdr(struct cache_header *hdr, unsigned long size)
+{
+	SHA_CTX c;
+	unsigned char sha1[20];
+
+	if (hdr->signature != CACHE_SIGNATURE)
+		return error("bad signature");
+	if (hdr->version != 1)
+		return error("bad version");
+	SHA1_Init(&c);
+	SHA1_Update(&c, hdr, offsetof(struct cache_header, sha1));
+	SHA1_Update(&c, hdr+1, size - sizeof(*hdr));
+	SHA1_Final(sha1, &c);
+	if (memcmp(sha1, hdr->sha1, 20))
+		return error("bad header sha1");
+	return 0;
+}
+
+int read_cache(void)
+{
+	int fd, i;
+	struct stat st;
+	unsigned long size, offset;
+	void *map;
+	struct cache_header *hdr;
+
+	errno = EBUSY;
+	if (active_cache)
+		return error("more than one cachefile");
+	errno = ENOENT;
+	sha1_file_directory = getenv(DB_ENVIRONMENT);
+	if (!sha1_file_directory)
+		sha1_file_directory = DEFAULT_DB_ENVIRONMENT;
+	if (access(sha1_file_directory, X_OK) < 0)
+		return error("no access to SHA1 file directory");
+	fd = open(".dircache/index", O_RDONLY);
+	if (fd < 0)
+		return (errno == ENOENT) ? 0 : error("open failed");
+
+	map = (void *)-1;
+	if (!fstat(fd, &st)) {
+		map = NULL;
+		size = st.st_size;
+		errno = EINVAL;
+		if (size > sizeof(struct cache_header))
+			map = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
+	}
+	close(fd);
+	if (-1 == (int)(long)map)
+		return error("mmap failed");
+
+	hdr = map;
+	if (verify_hdr(hdr, size) < 0)
+		goto unmap;
+
+	active_nr = hdr->entries;
+	active_alloc = alloc_nr(active_nr);
+	active_cache = calloc(active_alloc, sizeof(struct cache_entry *));
+
+	offset = sizeof(*hdr);
+	for (i = 0; i < hdr->entries; i++) {
+		struct cache_entry *ce = map + offset;
+		offset = offset + ce_size(ce);
+		active_cache[i] = ce;
+	}
+	return active_nr;
+
+unmap:
+	munmap(map, size);
+	errno = EINVAL;
+	return error("verify header failed");
+}
+
diff --git a/read-tree.c b/read-tree.c
new file mode 100644
index 0000000..1b47742
--- /dev/null
+++ b/read-tree.c
@@ -0,0 +1,43 @@
+#include "cache.h"
+
+static int unpack(unsigned char *sha1)
+{
+	void *buffer;
+	unsigned long size;
+	char type[20];
+
+	buffer = read_sha1_file(sha1, type, &size);
+	if (!buffer)
+		usage("unable to read sha1 file");
+	if (strcmp(type, "tree"))
+		usage("expected a 'tree' node");
+	while (size) {
+		int len = strlen(buffer)+1;
+		unsigned char *sha1 = buffer + len;
+		char *path = strchr(buffer, ' ')+1;
+		unsigned int mode;
+		if (size < len + 20 || sscanf(buffer, "%o", &mode) != 1)
+			usage("corrupt 'tree' file");
+		buffer = sha1 + 20;
+		size -= len + 20;
+		printf("%o %s (%s)\n", mode, path, sha1_to_hex(sha1));
+	}
+	return 0;
+}
+
+int main(int argc, char **argv)
+{
+	int fd;
+	unsigned char sha1[20];
+
+	if (argc != 2)
+		usage("read-tree <key>");
+	if (get_sha1_hex(argv[1], sha1) < 0)
+		usage("read-tree <key>");
+	sha1_file_directory = getenv(DB_ENVIRONMENT);
+	if (!sha1_file_directory)
+		sha1_file_directory = DEFAULT_DB_ENVIRONMENT;
+	if (unpack(sha1) < 0)
+		usage("unpack failed");
+	return 0;
+}
diff --git a/show-diff.c b/show-diff.c
new file mode 100644
index 0000000..b852288
--- /dev/null
+++ b/show-diff.c
@@ -0,0 +1,81 @@
+#include "cache.h"
+
+#define MTIME_CHANGED	0x0001
+#define CTIME_CHANGED	0x0002
+#define OWNER_CHANGED	0x0004
+#define MODE_CHANGED    0x0008
+#define INODE_CHANGED   0x0010
+#define DATA_CHANGED    0x0020
+
+static int 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 void show_differences(struct cache_entry *ce, struct stat *cur,
+	void *old_contents, unsigned long long old_size)
+{
+	static char cmd[1000];
+	FILE *f;
+
+	snprintf(cmd, sizeof(cmd), "diff -u - %s", ce->name);
+	f = popen(cmd, "w");
+	fwrite(old_contents, old_size, 1, f);
+	pclose(f);
+}
+
+int main(int argc, char **argv)
+{
+	int entries = read_cache();
+	int i;
+
+	if (entries < 0) {
+		perror("read_cache");
+		exit(1);
+	}
+	for (i = 0; i < entries; i++) {
+		struct stat st;
+		struct cache_entry *ce = active_cache[i];
+		int n, changed;
+		unsigned int mode;
+		unsigned long size;
+		char type[20];
+		void *new;
+
+		if (stat(ce->name, &st) < 0) {
+			printf("%s: %s\n", ce->name, strerror(errno));
+			continue;
+		}
+		changed = match_stat(ce, &st);
+		if (!changed) {
+			printf("%s: ok\n", ce->name);
+			continue;
+		}
+		printf("%.*s:  ", ce->namelen, ce->name);
+		for (n = 0; n < 20; n++)
+			printf("%02x", ce->sha1[n]);
+		printf("\n");
+		new = read_sha1_file(ce->sha1, type, &size);
+		show_differences(ce, &st, new, size);
+		free(new);
+	}
+	return 0;
+}
diff --git a/update-cache.c b/update-cache.c
new file mode 100644
index 0000000..5085a5c
--- /dev/null
+++ b/update-cache.c
@@ -0,0 +1,248 @@
+#include "cache.h"
+
+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;
+}
+
+static 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 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 *));
+	}
+}
+
+static 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 index_fd(const char *path, int namelen, struct cache_entry *ce, int fd, struct stat *st)
+{
+	z_stream stream;
+	int max_out_bytes = namelen + st->st_size + 200;
+	void *out = malloc(max_out_bytes);
+	void *metadata = malloc(namelen + 200);
+	void *in = mmap(NULL, st->st_size, PROT_READ, MAP_PRIVATE, fd, 0);
+	SHA_CTX c;
+
+	close(fd);
+	if (!out || (int)(long)in == -1)
+		return -1;
+
+	memset(&stream, 0, sizeof(stream));
+	deflateInit(&stream, Z_BEST_COMPRESSION);
+
+	/*
+	 * ASCII size + nul byte
+	 */	
+	stream.next_in = metadata;
+	stream.avail_in = 1+sprintf(metadata, "blob %lu", (unsigned long) st->st_size);
+	stream.next_out = out;
+	stream.avail_out = max_out_bytes;
+	while (deflate(&stream, 0) == Z_OK)
+		/* nothing */;
+
+	/*
+	 * File content
+	 */
+	stream.next_in = in;
+	stream.avail_in = st->st_size;
+	while (deflate(&stream, Z_FINISH) == Z_OK)
+		/*nothing */;
+
+	deflateEnd(&stream);
+	
+	SHA1_Init(&c);
+	SHA1_Update(&c, out, stream.total_out);
+	SHA1_Final(ce->sha1, &c);
+
+	return write_sha1_buffer(ce->sha1, out, stream.total_out);
+}
+
+static int add_file_to_cache(char *path)
+{
+	int size, namelen;
+	struct cache_entry *ce;
+	struct stat st;
+	int fd;
+
+	fd = open(path, O_RDONLY);
+	if (fd < 0) {
+		if (errno == ENOENT)
+			return remove_file_from_cache(path);
+		return -1;
+	}
+	if (fstat(fd, &st) < 0) {
+		close(fd);
+		return -1;
+	}
+	namelen = strlen(path);
+	size = cache_entry_size(namelen);
+	ce = malloc(size);
+	memset(ce, 0, size);
+	memcpy(ce->name, path, namelen);
+	ce->ctime.sec = st.st_ctime;
+	ce->ctime.nsec = st.st_ctim.tv_nsec;
+	ce->mtime.sec = st.st_mtime;
+	ce->mtime.nsec = st.st_mtim.tv_nsec;
+	ce->st_dev = st.st_dev;
+	ce->st_ino = st.st_ino;
+	ce->st_mode = st.st_mode;
+	ce->st_uid = st.st_uid;
+	ce->st_gid = st.st_gid;
+	ce->st_size = st.st_size;
+	ce->namelen = namelen;
+
+	if (index_fd(path, namelen, ce, fd, &st) < 0)
+		return -1;
+
+	return add_cache_entry(ce);
+}
+
+static 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;
+}		
+
+/*
+ * We fundamentally don't like some paths: we don't want
+ * dot or dot-dot anywhere, and in fact, we don't even want
+ * any other dot-files (.dircache or anything else). They
+ * are hidden, for chist sake.
+ *
+ * Also, we don't want double slashes or slashes at the
+ * end that can make pathnames ambiguous. 
+ */
+static int verify_path(char *path)
+{
+	char c;
+
+	goto inside;
+	for (;;) {
+		if (!c)
+			return 1;
+		if (c == '/') {
+inside:
+			c = *path++;
+			if (c != '/' && c != '.' && c != '\0')
+				continue;
+			return 0;
+		}
+		c = *path++;
+	}
+}
+
+int main(int argc, char **argv)
+{
+	int i, newfd, entries;
+
+	entries = read_cache();
+	if (entries < 0) {
+		perror("cache corrupted");
+		return -1;
+	}
+
+	newfd = open(".dircache/index.lock", O_RDWR | O_CREAT | O_EXCL, 0600);
+	if (newfd < 0) {
+		perror("unable to create new cachefile");
+		return -1;
+	}
+	for (i = 1 ; i < argc; i++) {
+		char *path = argv[i];
+		if (!verify_path(path)) {
+			fprintf(stderr, "Ignoring path %s\n", argv[i]);
+			continue;
+		}
+		if (add_file_to_cache(path)) {
+			fprintf(stderr, "Unable to add %s to database\n", path);
+			goto out;
+		}
+	}
+	if (!write_cache(newfd, active_cache, active_nr) && !rename(".dircache/index.lock", ".dircache/index"))
+		return 0;
+out:
+	unlink(".dircache/index.lock");
+}
diff --git a/write-tree.c b/write-tree.c
new file mode 100644
index 0000000..921f981
--- /dev/null
+++ b/write-tree.c
@@ -0,0 +1,66 @@
+#include "cache.h"
+
+static int check_valid_sha1(unsigned char *sha1)
+{
+	char *filename = sha1_file_name(sha1);
+	int ret;
+
+	/* If we were anal, we'd check that the sha1 of the contents actually matches */
+	ret = access(filename, R_OK);
+	if (ret)
+		perror(filename);
+	return ret;
+}
+
+static int prepend_integer(char *buffer, unsigned val, int i)
+{
+	buffer[--i] = '\0';
+	do {
+		buffer[--i] = '0' + (val % 10);
+		val /= 10;
+	} while (val);
+	return i;
+}
+
+#define ORIG_OFFSET (40)	/* Enough space to add the header of "tree <size>\0" */
+
+int main(int argc, char **argv)
+{
+	unsigned long size, offset, val;
+	int i, entries = read_cache();
+	char *buffer;
+
+	if (entries <= 0) {
+		fprintf(stderr, "No file-cache to create a tree of\n");
+		exit(1);
+	}
+
+	/* Guess at an initial size */
+	size = entries * 40 + 400;
+	buffer = malloc(size);
+	offset = ORIG_OFFSET;
+
+	for (i = 0; i < entries; i++) {
+		struct cache_entry *ce = active_cache[i];
+		if (check_valid_sha1(ce->sha1) < 0)
+			exit(1);
+		if (offset + ce->namelen + 60 > size) {
+			size = alloc_nr(offset + ce->namelen + 60);
+			buffer = realloc(buffer, size);
+		}
+		offset += sprintf(buffer + offset, "%o %s", ce->st_mode, ce->name);
+		buffer[offset++] = 0;
+		memcpy(buffer + offset, ce->sha1, 20);
+		offset += 20;
+	}
+
+	i = prepend_integer(buffer, offset - ORIG_OFFSET, ORIG_OFFSET);
+	i -= 5;
+	memcpy(buffer+i, "tree ", 5);
+
+	buffer += i;
+	offset -= i;
+
+	write_sha1_file(buffer, offset);
+	return 0;
+}