rugged 0.17.0b2 → 0.17.0.b6

data/{ext/rugged/vendor/libgit2-dist → vendor/libgit2}/src/transports/local.c

@@ -15,11 +15,11 @@
 #include "posix.h"
 #include "path.h"
 #include "buffer.h"
+#include "pkt.h"
 
 typedef struct {
 	git_transport parent;
 	git_repository *repo;
-	git_vector refs;
 } transport_local;
 
 static int add_ref(transport_local *t, const char *name)
@@ -27,19 +27,32 @@ static int add_ref(transport_local *t, const char *name)
 	const char peeled[] = "^{}";
 	git_remote_head *head;
 	git_object *obj = NULL, *target = NULL;
+	git_transport *transport = (git_transport *) t;
 	git_buf buf = GIT_BUF_INIT;
+	git_pkt_ref *pkt;
 
 	head = git__malloc(sizeof(git_remote_head));
 	GITERR_CHECK_ALLOC(head);
+	pkt = git__malloc(sizeof(git_pkt_ref));
+	GITERR_CHECK_ALLOC(pkt);
 
 	head->name = git__strdup(name);
 	GITERR_CHECK_ALLOC(head->name);
 
-	if (git_reference_name_to_oid(&head->oid, t->repo, name) < 0 ||
-		git_vector_insert(&t->refs, head) < 0)
-	{
-		git__free(head->name);
+	if (git_reference_name_to_oid(&head->oid, t->repo, name) < 0) {
 		git__free(head);
+		git__free(pkt->head.name);
+		git__free(pkt);
+	}
+
+	pkt->type = GIT_PKT_REF;
+	memcpy(&pkt->head, head, sizeof(git_remote_head));
+	git__free(head);
+
+	if (git_vector_insert(&transport->refs, pkt) < 0)
+	{
+		git__free(pkt->head.name);
+		git__free(pkt);
 		return -1;
 	}
 
@@ -47,7 +60,7 @@ static int add_ref(transport_local *t, const char *name)
 	if (git__prefixcmp(name, GIT_REFS_TAGS_DIR))
 		return 0;
 
-	if (git_object_lookup(&obj, t->repo, &head->oid, GIT_OBJ_ANY) < 0)
+	if (git_object_lookup(&obj, t->repo, &pkt->head.oid, GIT_OBJ_ANY) < 0)
 		return -1;
 
 	head = NULL;
@@ -66,14 +79,20 @@ static int add_ref(transport_local *t, const char *name)
 
 	head->name = git_buf_detach(&buf);
 
+	pkt = git__malloc(sizeof(git_pkt_ref));
+	GITERR_CHECK_ALLOC(pkt);
+	pkt->type = GIT_PKT_REF;
+
 	if (git_tag_peel(&target, (git_tag *) obj) < 0)
 		goto on_error;
 
 	git_oid_cpy(&head->oid, git_object_id(target));
 	git_object_free(obj);
 	git_object_free(target);
+	memcpy(&pkt->head, head, sizeof(git_remote_head));
+	git__free(head);
 
-	if (git_vector_insert(&t->refs, head) < 0)
+	if (git_vector_insert(&transport->refs, pkt) < 0)
 		return -1;
 
 	return 0;
@@ -88,11 +107,12 @@ static int store_refs(transport_local *t)
 {
 	unsigned int i;
 	git_strarray ref_names = {0};
+	git_transport *transport = (git_transport *) t;
 
 	assert(t);
 
 	if (git_reference_list(&ref_names, t->repo, GIT_REF_LISTALL) < 0 ||
-		git_vector_init(&t->refs, (unsigned int)ref_names.count, NULL) < 0)
+		git_vector_init(&transport->refs, (unsigned int)ref_names.count, NULL) < 0)
 		goto on_error;
 
 	/* Sort the references first */
@@ -111,28 +131,11 @@ static int store_refs(transport_local *t)
 	return 0;
 
 on_error:
-	git_vector_free(&t->refs);
+	git_vector_free(&transport->refs);
 	git_strarray_free(&ref_names);
 	return -1;
 }
 
-static int local_ls(git_transport *transport, git_headlist_cb list_cb, void *payload)
-{
-	transport_local  *t = (transport_local *) transport;
-	git_vector *refs = &t->refs;
-	unsigned int i;
-	git_remote_head *h;
-
-	assert(transport && transport->connected);
-
-	git_vector_foreach(refs, i, h) {
-		if (list_cb(h, payload) < 0)
-			return -1;
-	}
-
-	return 0;
-}
-
 /*
  * Try to open the url as a git directory. The direction doesn't
  * matter in this case because we're calulating the heads ourselves.
@@ -201,14 +204,14 @@ static void local_free(git_transport *transport)
 {
 	unsigned int i;
 	transport_local *t = (transport_local *) transport;
-	git_vector *vec = &t->refs;
-	git_remote_head *h;
+	git_vector *vec = &transport->refs;
+	git_pkt_ref *pkt;
 
 	assert(transport);
 
-	git_vector_foreach (vec, i, h) {
-		git__free(h->name);
-		git__free(h);
+	git_vector_foreach (vec, i, pkt) {
+		git__free(pkt->head.name);
+		git__free(pkt);
 	}
 	git_vector_free(vec);
 
@@ -229,8 +232,8 @@ int git_transport_local(git_transport **out)
 
 	memset(t, 0x0, sizeof(transport_local));
 
+	t->parent.own_logic = 1;
 	t->parent.connect = local_connect;
-	t->parent.ls = local_ls;
 	t->parent.negotiate_fetch = local_negotiate_fetch;
 	t->parent.close = local_close;
 	t->parent.free = local_free;

data/{ext/rugged/vendor/libgit2-dist → vendor/libgit2}/src/tree.c

@@ -12,12 +12,16 @@
 #include "git2/object.h"
 
 #define DEFAULT_TREE_SIZE 16
-#define MAX_FILEMODE 0777777
 #define MAX_FILEMODE_BYTES 6
 
-static int valid_attributes(const int attributes)
+static bool valid_filemode(const int filemode)
 {
-	return attributes >= 0 && attributes <= MAX_FILEMODE;
+	return (filemode == GIT_FILEMODE_TREE
+		|| filemode == GIT_FILEMODE_BLOB
+		|| filemode == GIT_FILEMODE_BLOB_GROUP_WRITABLE
+		|| filemode == GIT_FILEMODE_BLOB_EXECUTABLE
+		|| filemode == GIT_FILEMODE_LINK
+		|| filemode == GIT_FILEMODE_COMMIT);
 }
 
 static int valid_entry_name(const char *filename)
@@ -35,6 +39,22 @@ static int entry_sort_cmp(const void *a, const void *b)
 		entry_b->filename, entry_b->filename_len, git_tree_entry__is_tree(entry_b));
 }
 
+static git_tree_entry *alloc_entry(const char *filename)
+{
+	git_tree_entry *entry = NULL;
+	size_t filename_len = strlen(filename);
+
+	entry = git__malloc(sizeof(git_tree_entry) + filename_len + 1);
+	if (!entry)
+		return NULL;
+
+	memset(entry, 0x0, sizeof(git_tree_entry));
+	memcpy(entry->filename, filename, filename_len);
+	entry->filename[filename_len] = 0;
+	entry->filename_len = filename_len;
+
+	return entry;
+}
 
 struct tree_key_search {
 	const char *filename;
@@ -76,7 +96,7 @@ static int homing_search_cmp(const void *key, const void *array_member)
  * ambiguous because of folder vs file sorting, we look linearly
  * around the area for our target file.
  */
-static int tree_key_search(git_vector *entries, const char *filename)
+static int tree_key_search(git_vector *entries, const char *filename, size_t filename_len)
 {
 	struct tree_key_search ksearch;
 	const git_tree_entry *entry;
@@ -84,7 +104,7 @@ static int tree_key_search(git_vector *entries, const char *filename)
 	int homing, i;
 
 	ksearch.filename = filename;
-	ksearch.filename_len = strlen(filename);
+	ksearch.filename_len = filename_len;
 
 	/* Initial homing search; find an entry on the tree with
 	 * the same prefix as the filename we're looking for */
@@ -100,7 +120,8 @@ static int tree_key_search(git_vector *entries, const char *filename)
 		if (homing_search_cmp(&ksearch, entry) < 0)
 			break;
 
-		if (strcmp(filename, entry->filename) == 0)
+		if (entry->filename_len == filename_len &&
+			memcmp(filename, entry->filename, filename_len) == 0)
 			return i;
 	}
 
@@ -112,7 +133,8 @@ static int tree_key_search(git_vector *entries, const char *filename)
 		if (homing_search_cmp(&ksearch, entry) > 0)
 			break;
 
-		if (strcmp(filename, entry->filename) == 0)
+		if (entry->filename_len == filename_len &&
+			memcmp(filename, entry->filename, filename_len) == 0)
 			return i;
 	}
 
@@ -120,16 +142,38 @@ static int tree_key_search(git_vector *entries, const char *filename)
 	return GIT_ENOTFOUND;
 }
 
+void git_tree_entry_free(git_tree_entry *entry)
+{
+	if (entry == NULL)
+		return;
+
+	git__free(entry);
+}
+
+git_tree_entry *git_tree_entry_dup(const git_tree_entry *entry)
+{
+	size_t total_size;
+	git_tree_entry *copy;
+
+	assert(entry);
+
+	total_size = sizeof(git_tree_entry) + entry->filename_len + 1;
+
+	copy = git__malloc(total_size);
+	if (!copy)
+		return NULL;
+
+	memcpy(copy, entry, total_size);
+	return copy;
+}
+
 void git_tree__free(git_tree *tree)
 {
 	unsigned int i;
 
 	for (i = 0; i < tree->entries.length; ++i) {
-		git_tree_entry *e;
-		e = git_vector_get(&tree->entries, i);
-
-		git__free(e->filename);
-		git__free(e);
+		git_tree_entry *e = git_vector_get(&tree->entries, i);
+		git_tree_entry_free(e);
 	}
 
 	git_vector_free(&tree->entries);
@@ -141,9 +185,9 @@ const git_oid *git_tree_id(git_tree *c)
 	return git_object_id((git_object *)c);
 }
 
-unsigned int git_tree_entry_attributes(const git_tree_entry *entry)
+git_filemode_t git_tree_entry_filemode(const git_tree_entry *entry)
 {
-	return entry->attr;
+	return (git_filemode_t)entry->attr;
 }
 
 const char *git_tree_entry_name(const git_tree_entry *entry)
@@ -179,25 +223,42 @@ int git_tree_entry_to_object(
 	return git_object_lookup(object_out, repo, &entry->oid, GIT_OBJ_ANY);
 }
 
-const git_tree_entry *git_tree_entry_byname(git_tree *tree, const char *filename)
+static git_tree_entry *entry_fromname(git_tree *tree, const char *name, size_t name_len)
 {
-	int idx;
-
-	assert(tree && filename);
-
-	idx = tree_key_search(&tree->entries, filename);
-	if (idx == GIT_ENOTFOUND)
+	int idx = tree_key_search(&tree->entries, name, name_len);
+	if (idx < 0)
 		return NULL;
 
 	return git_vector_get(&tree->entries, idx);
 }
 
-const git_tree_entry *git_tree_entry_byindex(git_tree *tree, unsigned int idx)
+const git_tree_entry *git_tree_entry_byname(git_tree *tree, const char *filename)
+{
+	assert(tree && filename);
+	return entry_fromname(tree, filename, strlen(filename));
+}
+
+const git_tree_entry *git_tree_entry_byindex(git_tree *tree, size_t idx)
 {
 	assert(tree);
 	return git_vector_get(&tree->entries, idx);
 }
 
+const git_tree_entry *git_tree_entry_byoid(git_tree *tree, const git_oid *oid)
+{
+	unsigned int i;
+	git_tree_entry *e;
+
+	assert(tree);
+
+	git_vector_foreach(&tree->entries, i, e) {
+		if (memcmp(&e->oid.id, &oid->id, sizeof(oid->id)) == 0)
+			return e;
+	}
+
+	return NULL;
+}
+
 int git_tree__prefix_position(git_tree *tree, const char *path)
 {
 	git_vector *entries = &tree->entries;
@@ -228,7 +289,7 @@ int git_tree__prefix_position(git_tree *tree, const char *path)
 unsigned int git_tree_entrycount(git_tree *tree)
 {
 	assert(tree);
-	return tree->entries.length;
+	return (unsigned int)tree->entries.length;
 }
 
 static int tree_error(const char *str)
@@ -244,19 +305,11 @@ static int tree_parse_buffer(git_tree *tree, const char *buffer, const char *buf
 
 	while (buffer < buffer_end) {
 		git_tree_entry *entry;
-		int tmp;
-
-		entry = git__calloc(1, sizeof(git_tree_entry));
-		GITERR_CHECK_ALLOC(entry);
-
-		if (git_vector_insert(&tree->entries, entry) < 0)
-			return -1;
-
-		if (git__strtol32(&tmp, buffer, &buffer, 8) < 0 ||
-			!buffer || !valid_attributes(tmp))
-			return tree_error("Failed to parse tree. Can't parse attributes");
+		int attr;
 
-		entry->attr = tmp;
+		if (git__strtol32(&attr, buffer, &buffer, 8) < 0 ||
+			!buffer || !valid_filemode(attr))
+			return tree_error("Failed to parse tree. Can't parse filemode");
 
 		if (*buffer++ != ' ')
 			return tree_error("Failed to parse tree. Object is corrupted");
@@ -264,8 +317,16 @@ static int tree_parse_buffer(git_tree *tree, const char *buffer, const char *buf
 		if (memchr(buffer, 0, buffer_end - buffer) == NULL)
 			return tree_error("Failed to parse tree. Object is corrupted");
 
-		entry->filename = git__strdup(buffer);
-		entry->filename_len = strlen(buffer);
+		/** Allocate the entry and store it in the entries vector */
+		{
+			entry = alloc_entry(buffer);
+			GITERR_CHECK_ALLOC(entry);
+
+			if (git_vector_insert(&tree->entries, entry) < 0)
+				return -1;
+
+			entry->attr = attr;
+		}
 
 		while (buffer < buffer_end && *buffer != 0)
 			buffer++;
@@ -303,18 +364,19 @@ static unsigned int find_next_dir(const char *dirname, git_index *index, unsigne
 	return i;
 }
 
-static int append_entry(git_treebuilder *bld, const char *filename, const git_oid *id, unsigned int attributes)
+static int append_entry(
+	git_treebuilder *bld,
+	const char *filename,
+	const git_oid *id,
+	git_filemode_t filemode)
 {
 	git_tree_entry *entry;
 
-	entry = git__calloc(1, sizeof(git_tree_entry));
+	entry = alloc_entry(filename);
 	GITERR_CHECK_ALLOC(entry);
 
-	entry->filename = git__strdup(filename);
-	entry->filename_len = strlen(entry->filename);
-
 	git_oid_cpy(&entry->oid, id);
-	entry->attr = attributes;
+	entry->attr = (uint16_t)filemode;
 
 	if (git_vector_insert(&bld->entries, entry) < 0)
 		return -1;
@@ -455,10 +517,23 @@ static void sort_entries(git_treebuilder *bld)
 	git_vector_sort(&bld->entries);
 }
 
+GIT_INLINE(git_filemode_t) normalize_filemode(git_filemode_t filemode)
+{
+	/* 100664 mode is an early design mistake. Tree entries may bear
+	 * this mode in some old git repositories, but it's now deprecated.
+	 * We silently normalize while inserting new entries in a tree 
+	 * being built.
+	 */
+	if (filemode == GIT_FILEMODE_BLOB_GROUP_WRITABLE)
+		return GIT_FILEMODE_BLOB;
+
+	return filemode;
+}
+
 int git_treebuilder_create(git_treebuilder **builder_p, const git_tree *source)
 {
 	git_treebuilder *bld;
-	unsigned int i, source_entries = DEFAULT_TREE_SIZE;
+	size_t i, source_entries = DEFAULT_TREE_SIZE;
 
 	assert(builder_p);
 
@@ -475,7 +550,10 @@ int git_treebuilder_create(git_treebuilder **builder_p, const git_tree *source)
 		for (i = 0; i < source->entries.length; ++i) {
 			git_tree_entry *entry_src = source->entries.contents[i];
 
-			if (append_entry(bld, entry_src->filename, &entry_src->oid, entry_src->attr) < 0)
+			if (append_entry(
+				bld, entry_src->filename,
+				&entry_src->oid,
+				normalize_filemode((git_filemode_t)entry_src->attr)) < 0)
 				goto on_error;
 		}
 	}
@@ -488,43 +566,48 @@ on_error:
 	return -1;
 }
 
-int git_treebuilder_insert(git_tree_entry **entry_out, git_treebuilder *bld, const char *filename, const git_oid *id, unsigned int attributes)
+int git_treebuilder_insert(
+	const git_tree_entry **entry_out,
+	git_treebuilder *bld,
+	const char *filename,
+	const git_oid *id,
+	git_filemode_t filemode)
 {
 	git_tree_entry *entry;
 	int pos;
 
 	assert(bld && id && filename);
 
-	if (!valid_attributes(attributes))
-		return tree_error("Failed to insert entry. Invalid attributes");
+	if (!valid_filemode(filemode))
+		return tree_error("Failed to insert entry. Invalid filemode");
+
+	filemode = normalize_filemode(filemode);
 
 	if (!valid_entry_name(filename))
 		return tree_error("Failed to insert entry. Invalid name for a tree entry");
 
-	pos = tree_key_search(&bld->entries, filename);
+	pos = tree_key_search(&bld->entries, filename, strlen(filename));
 
 	if (pos >= 0) {
 		entry = git_vector_get(&bld->entries, pos);
 		if (entry->removed)
 			entry->removed = 0;
 	} else {
-		entry = git__calloc(1, sizeof(git_tree_entry));
+		entry = alloc_entry(filename);
 		GITERR_CHECK_ALLOC(entry);
-
-		entry->filename = git__strdup(filename);
-		entry->filename_len = strlen(entry->filename);
 	}
 
 	git_oid_cpy(&entry->oid, id);
-	entry->attr = attributes;
+	entry->attr = filemode;
 
-	if (pos == GIT_ENOTFOUND) {
+	if (pos < 0) {
 		if (git_vector_insert(&bld->entries, entry) < 0)
 			return -1;
 	}
 
-	if (entry_out != NULL)
+	if (entry_out != NULL) {
 		*entry_out = entry;
+	}
 
 	return 0;
 }
@@ -536,7 +619,7 @@ static git_tree_entry *treebuilder_get(git_treebuilder *bld, const char *filenam
 
 	assert(bld && filename);
 
-	idx = tree_key_search(&bld->entries, filename);
+	idx = tree_key_search(&bld->entries, filename, strlen(filename));
 	if (idx < 0)
 		return NULL;
 
@@ -625,8 +708,7 @@ void git_treebuilder_clear(git_treebuilder *bld)
 
 	for (i = 0; i < bld->entries.length; ++i) {
 		git_tree_entry *e = bld->entries.contents[i];
-		git__free(e->filename);
-		git__free(e);
+		git_tree_entry_free(e);
 	}
 
 	git_vector_clear(&bld->entries);
@@ -634,95 +716,92 @@ void git_treebuilder_clear(git_treebuilder *bld)
 
 void git_treebuilder_free(git_treebuilder *bld)
 {
+	if (bld == NULL)
+		return;
+
 	git_treebuilder_clear(bld);
 	git_vector_free(&bld->entries);
 	git__free(bld);
 }
 
-static int tree_frompath(
-	git_tree **parent_out,
+static size_t subpath_len(const char *path)
+{
+	const char *slash_pos = strchr(path, '/');
+	if (slash_pos == NULL)
+		return strlen(path);
+
+	return slash_pos - path;
+}
+
+int git_tree_entry_bypath(
+	git_tree_entry **entry_out,
 	git_tree *root,
-	git_buf *treeentry_path,
-	size_t offset)
+	const char *path)
 {
-	char *slash_pos = NULL;
-	const git_tree_entry* entry;
 	int error = 0;
 	git_tree *subtree;
+	const git_tree_entry *entry;
+	size_t filename_len;
 
-	if (!*(treeentry_path->ptr + offset)) {
-		giterr_set(GITERR_INVALID,
-			"Invalid relative path to a tree entry '%s'.", treeentry_path->ptr);
-		return -1;
-	}
-
-	slash_pos = (char *)strchr(treeentry_path->ptr + offset, '/');
+	/* Find how long is the current path component (i.e.
+	 * the filename between two slashes */
+	filename_len = subpath_len(path);
 
-	if (slash_pos == NULL)
-		return git_tree_lookup(
-			parent_out,
-			root->object.repo,
-			git_object_id((const git_object *)root)
-		);
-
-	if (slash_pos == treeentry_path->ptr + offset) {
-		giterr_set(GITERR_INVALID,
-			"Invalid relative path to a tree entry '%s'.", treeentry_path->ptr);
-		return -1;
+	if (filename_len == 0) {
+		giterr_set(GITERR_TREE, "Invalid tree path given");
+		return GIT_ENOTFOUND;
 	}
 
-	*slash_pos = '\0';
-
-	entry = git_tree_entry_byname(root, treeentry_path->ptr + offset);
-
-	if (slash_pos != NULL)
-		*slash_pos = '/';
+	entry = entry_fromname(root, path, filename_len);
 
 	if (entry == NULL) {
 		giterr_set(GITERR_TREE,
-			"No tree entry can be found from "
-			"the given tree and relative path '%s'.", treeentry_path->ptr);
+			"The path '%s' does not exist in the given tree", path);
 		return GIT_ENOTFOUND;
 	}
 
+	switch (path[filename_len]) {
+	case '/':
+		/* If there are more components in the path...
+		 * then this entry *must* be a tree */
+		if (!git_tree_entry__is_tree(entry)) {
+			giterr_set(GITERR_TREE,
+				"The path '%s' does not exist in the given tree", path);
+			return GIT_ENOTFOUND;
+		}
+
+		/* If there's only a slash left in the path, we 
+		 * return the current entry; otherwise, we keep
+		 * walking down the path */
+		if (path[filename_len + 1] != '\0')
+			break;
+
+	case '\0':
+		/* If there are no more components in the path, return
+		 * this entry */
+		*entry_out = git_tree_entry_dup(entry);
+		return 0;
+	}
 
 	if (git_tree_lookup(&subtree, root->object.repo, &entry->oid) < 0)
-		return error;
+		return -1;
 
-	error = tree_frompath(
-		parent_out,
+	error = git_tree_entry_bypath(
+		entry_out,
 		subtree,
-		treeentry_path,
-		(slash_pos - treeentry_path->ptr) + 1
+		path + filename_len + 1
 	);
 
 	git_tree_free(subtree);
 	return error;
 }
 
-int git_tree_get_subtree(
-	git_tree **subtree,
-	git_tree *root,
-	const char *subtree_path)
-{
-	int error;
-	git_buf buffer = GIT_BUF_INIT;
-
-	assert(subtree && root && subtree_path);
-
-	if ((error = git_buf_sets(&buffer, subtree_path)) == 0)
-		error = tree_frompath(subtree, root, &buffer, 0);
-
-	git_buf_free(&buffer);
-
-	return error;
-}
-
-static int tree_walk_post(
+static int tree_walk(
 	git_tree *tree,
 	git_treewalk_cb callback,
 	git_buf *path,
-	void *payload)
+	void *payload,
+	bool preorder)
 {
 	int error = 0;
 	unsigned int i;
@@ -730,8 +809,13 @@ static int tree_walk_post(
 	for (i = 0; i < tree->entries.length; ++i) {
 		git_tree_entry *entry = tree->entries.contents[i];
 
-		if (callback(path->ptr, entry, payload) < 0)
-			continue;
+		if (preorder) {
+			error = callback(path->ptr, entry, payload);
+			if (error > 0)
+				continue;
+			if (error < 0)
+				return GIT_EUSER;
+		}
 
 		if (git_tree_entry__is_tree(entry)) {
 			git_tree *subtree;
@@ -748,15 +832,21 @@ static int tree_walk_post(
 			if (git_buf_oom(path))
 				return -1;
 
-			if (tree_walk_post(subtree, callback, path, payload) < 0)
-				return -1;
+			error = tree_walk(subtree, callback, path, payload, preorder);
+			if (error != 0)
+				break;
 
 			git_buf_truncate(path, path_len);
 			git_tree_free(subtree);
 		}
+
+		if (!preorder && callback(path->ptr, entry, payload) < 0) {
+			error = GIT_EUSER;
+			break;
+		}
 	}
 
-	return 0;
+	return error;
 }
 
 int git_tree_walk(git_tree *tree, git_treewalk_cb callback, int mode, void *payload)
@@ -766,12 +856,12 @@ int git_tree_walk(git_tree *tree, git_treewalk_cb callback, int mode, void *payl
 
 	switch (mode) {
 		case GIT_TREEWALK_POST:
-			error = tree_walk_post(tree, callback, &root_path, payload);
+			error = tree_walk(tree, callback, &root_path, payload, false);
 			break;
 
 		case GIT_TREEWALK_PRE:
-			tree_error("Preorder tree walking is still not implemented");
-			return -1;
+			error = tree_walk(tree, callback, &root_path, payload, true);
+			break;
 
 		default:
 			giterr_set(GITERR_INVALID, "Invalid walking mode for tree walk");