rugged 0.24.6.1 → 0.25.0b1

data/vendor/libgit2/src/tag.c

@@ -137,14 +137,8 @@ static int tag_parse(git_tag *tag, const char *buffer, const char *buffer_end)
 
 	tag->message = NULL;
 	if (buffer < buffer_end) {
-		/* If we're not at the end of the header, search for it */
-		if( *buffer != '\n' ) {
-			search = strstr(buffer, "\n\n");
-			if (search)
-				buffer = search + 1;
-			else
-				return tag_error("tag contains no message");
-		}
+		if( *buffer != '\n' )
+			return tag_error("No new line before message");
 
 		text_len = buffer_end - ++buffer;
 

data/vendor/libgit2/src/thread-utils.h

@@ -40,12 +40,58 @@ typedef git_atomic git_atomic_ssize;
 
 #ifdef GIT_THREADS
 
-#ifdef GIT_WIN32
-#   include "win32/thread.h"
-#else
-#   include "unix/pthread.h"
+#if !defined(GIT_WIN32)
+
+typedef struct {
+	pthread_t thread;
+} git_thread;
+
+#define git_thread_create(git_thread_ptr, attr, start_routine, arg) \
+	pthread_create(&(git_thread_ptr)->thread, attr, start_routine, arg)
+#define git_thread_join(git_thread_ptr, status) \
+	pthread_join((git_thread_ptr)->thread, status)
+
 #endif
 
+/* Pthreads Mutex */
+#define git_mutex pthread_mutex_t
+#define git_mutex_init(a)	pthread_mutex_init(a, NULL)
+#define git_mutex_lock(a)	pthread_mutex_lock(a)
+#define git_mutex_unlock(a) pthread_mutex_unlock(a)
+#define git_mutex_free(a)	pthread_mutex_destroy(a)
+
+/* Pthreads condition vars */
+#define git_cond pthread_cond_t
+#define git_cond_init(c)	pthread_cond_init(c, NULL)
+#define git_cond_free(c) 	pthread_cond_destroy(c)
+#define git_cond_wait(c, l)	pthread_cond_wait(c, l)
+#define git_cond_signal(c)	pthread_cond_signal(c)
+#define git_cond_broadcast(c)	pthread_cond_broadcast(c)
+
+/* Pthread (-ish) rwlock
+ *
+ * This differs from normal pthreads rwlocks in two ways:
+ * 1. Separate APIs for releasing read locks and write locks (as
+ *    opposed to the pure POSIX API which only has one unlock fn)
+ * 2. You should not use recursive read locks (i.e. grabbing a read
+ *    lock in a thread that already holds a read lock) because the
+ *    Windows implementation doesn't support it
+ */
+#define git_rwlock pthread_rwlock_t
+#define git_rwlock_init(a)		pthread_rwlock_init(a, NULL)
+#define git_rwlock_rdlock(a)	pthread_rwlock_rdlock(a)
+#define git_rwlock_rdunlock(a)	pthread_rwlock_rdunlock(a)
+#define git_rwlock_wrlock(a)	pthread_rwlock_wrlock(a)
+#define git_rwlock_wrunlock(a)	pthread_rwlock_wrunlock(a)
+#define git_rwlock_free(a)		pthread_rwlock_destroy(a)
+#define GIT_RWLOCK_STATIC_INIT	PTHREAD_RWLOCK_INITIALIZER
+
+#ifndef GIT_WIN32
+#define pthread_rwlock_rdunlock pthread_rwlock_unlock
+#define pthread_rwlock_wrunlock pthread_rwlock_unlock
+#endif
+
+
 GIT_INLINE(void) git_atomic_set(git_atomic *a, int val)
 {
 #if defined(GIT_WIN32)
@@ -132,7 +178,7 @@ GIT_INLINE(int64_t) git_atomic64_add(git_atomic64 *a, int64_t addend)
 #else
 
 #define git_thread unsigned int
-#define git_thread_create(thread, start_routine, arg) 0
+#define git_thread_create(thread, attr, start_routine, arg) 0
 #define git_thread_join(id, status) (void)0
 
 /* Pthreads Mutex */

data/vendor/libgit2/src/transports/http.c

@@ -114,7 +114,7 @@ static bool challenge_match(git_http_auth_scheme *scheme, void *data)
 	size_t scheme_len;
 
 	scheme_len = strlen(scheme_name);
-	return (strncasecmp(challenge, scheme_name, scheme_len) == 0 &&
+	return (strncmp(challenge, scheme_name, scheme_len) == 0 &&
 		(challenge[scheme_len] == '\0' || challenge[scheme_len] == ' '));
 }
 
@@ -569,7 +569,6 @@ static int http_connect(http_subtransport *t)
 		git_stream_close(t->io);
 		git_stream_free(t->io);
 		t->io = NULL;
-		t->connected = 0;
 	}
 
 	if (t->connection_data.use_ssl) {
@@ -602,12 +601,13 @@ static int http_connect(http_subtransport *t)
 	if ((!error || error == GIT_ECERTIFICATE) && t->owner->certificate_check_cb != NULL &&
 	    git_stream_is_encrypted(t->io)) {
 		git_cert *cert;
-		int is_valid = (error == GIT_OK);
+		int is_valid;
 
 		if ((error = git_stream_certificate(&cert, t->io)) < 0)
 			return error;
 
 		giterr_clear();
+		is_valid = error != GIT_ECERTIFICATE;
 		error = t->owner->certificate_check_cb(cert, is_valid, t->connection_data.host, t->owner->message_cb_payload);
 
 		if (error < 0) {

data/vendor/libgit2/src/transports/smart_pkt.c

@@ -427,23 +427,14 @@ int git_pkt_parse_line(
 	if (bufflen > 0 && bufflen < (size_t)len)
 		return GIT_EBUFS;
 
-	/*
-	 * The length has to be exactly 0 in case of a flush
-	 * packet or greater than PKT_LEN_SIZE, as the decoded
-	 * length includes its own encoded length of four bytes.
-	 */
-	if (len != 0 && len < PKT_LEN_SIZE)
-		return GIT_ERROR;
-
 	line += PKT_LEN_SIZE;
 	/*
-	 * The Git protocol does not specify empty lines as part
-	 * of the protocol. Not knowing what to do with an empty
-	 * line, we should return an error upon hitting one.
+	 * TODO: How do we deal with empty lines? Try again? with the next
+	 * line?
 	 */
 	if (len == PKT_LEN_SIZE) {
-		giterr_set_str(GITERR_NET, "Invalid empty packet");
-		return GIT_ERROR;
+		*out = line;
+		return 0;
 	}
 
 	if (len == 0) { /* Flush pkt */

data/vendor/libgit2/src/transports/smart_protocol.c

@@ -721,39 +721,18 @@ static int add_push_report_pkt(git_push *push, git_pkt *pkt)
 	return 0;
 }
 
-static int add_push_report_sideband_pkt(git_push *push, git_pkt_data *data_pkt, git_buf *data_pkt_buf)
+static int add_push_report_sideband_pkt(git_push *push, git_pkt_data *data_pkt)
 {
 	git_pkt *pkt;
-	const char *line, *line_end;
-	size_t line_len;
+	const char *line = data_pkt->data, *line_end;
+	size_t line_len = data_pkt->len;
 	int error;
-	int reading_from_buf = data_pkt_buf->size > 0;
-
-	if (reading_from_buf) {
-		/* We had an existing partial packet, so add the new
-		 * packet to the buffer and parse the whole thing */
-		git_buf_put(data_pkt_buf, data_pkt->data, data_pkt->len);
-		line = data_pkt_buf->ptr;
-		line_len = data_pkt_buf->size;
-	}
-	else {
-		line = data_pkt->data;
-		line_len = data_pkt->len;
-	}
 
 	while (line_len > 0) {
 		error = git_pkt_parse_line(&pkt, line, &line_end, line_len);
 
-		if (error == GIT_EBUFS) {
-			/* Buffer the data when the inner packet is split
-			 * across multiple sideband packets */
-			if (!reading_from_buf)
-				git_buf_put(data_pkt_buf, line, line_len);
-			error = 0;
-			goto done;
-		}
-		else if (error < 0)
-			goto done;
+		if (error < 0)
+			return error;
 
 		/* Advance in the buffer */
 		line_len -= (line_end - line);
@@ -764,15 +743,10 @@ static int add_push_report_sideband_pkt(git_push *push, git_pkt_data *data_pkt,
 		git_pkt_free(pkt);
 
 		if (error < 0 && error != GIT_ITEROVER)
-			goto done;
+			return error;
 	}
 
-	error = 0;
-
-done:
-	if (reading_from_buf)
-		git_buf_consume(data_pkt_buf, line_end);
-	return error;
+	return 0;
 }
 
 static int parse_report(transport_smart *transport, git_push *push)
@@ -781,7 +755,6 @@ static int parse_report(transport_smart *transport, git_push *push)
 	const char *line_end = NULL;
 	gitno_buffer *buf = &transport->buffer;
 	int error, recvd;
-	git_buf data_pkt_buf = GIT_BUF_INIT;
 
 	for (;;) {
 		if (buf->offset > 0)
@@ -790,21 +763,16 @@ static int parse_report(transport_smart *transport, git_push *push)
 		else
 			error = GIT_EBUFS;
 
-		if (error < 0 && error != GIT_EBUFS) {
-			error = -1;
-			goto done;
-		}
+		if (error < 0 && error != GIT_EBUFS)
+			return -1;
 
 		if (error == GIT_EBUFS) {
-			if ((recvd = gitno_recv(buf)) < 0) {
-				error = recvd;
-				goto done;
-			}
+			if ((recvd = gitno_recv(buf)) < 0)
+				return recvd;
 
 			if (recvd == 0) {
 				giterr_set(GITERR_NET, "early EOF");
-				error = GIT_EEOF;
-				goto done;
+				return GIT_EEOF;
 			}
 			continue;
 		}
@@ -816,7 +784,7 @@ static int parse_report(transport_smart *transport, git_push *push)
 		switch (pkt->type) {
 			case GIT_PKT_DATA:
 				/* This is a sideband packet which contains other packets */
-				error = add_push_report_sideband_pkt(push, (git_pkt_data *)pkt, &data_pkt_buf);
+				error = add_push_report_sideband_pkt(push, (git_pkt_data *)pkt);
 				break;
 			case GIT_PKT_ERR:
 				giterr_set(GITERR_NET, "report-status: Error reported: %s",
@@ -837,24 +805,12 @@ static int parse_report(transport_smart *transport, git_push *push)
 		git_pkt_free(pkt);
 
 		/* add_push_report_pkt returns GIT_ITEROVER when it receives a flush */
-		if (error == GIT_ITEROVER) {
-			error = 0;
-			if (data_pkt_buf.size > 0) {
-				/* If there was data remaining in the pack data buffer,
-				 * then the server sent a partial pkt-line */
-				giterr_set(GITERR_NET, "Incomplete pack data pkt-line");
-				error = GIT_ERROR;
-			}
-			goto done;
-		}
+		if (error == GIT_ITEROVER)
+			return 0;
 
-		if (error < 0) {
-			goto done;
-		}
+		if (error < 0)
+			return error;
 	}
-done:
-	git_buf_free(&data_pkt_buf);
-	return error;
 }
 
 static int add_ref_from_push_spec(git_vector *refs, push_spec *push_spec)

data/vendor/libgit2/src/tree.c

@@ -45,7 +45,7 @@ GIT_INLINE(git_filemode_t) normalize_filemode(git_filemode_t filemode)
 	if (GIT_MODE_TYPE(filemode) == GIT_FILEMODE_COMMIT)
 		return GIT_FILEMODE_COMMIT;
 
-	/* 12XXXX means symlink */
+	/* 12XXXX means commit */
 	if (GIT_MODE_TYPE(filemode) == GIT_FILEMODE_LINK)
 		return GIT_FILEMODE_LINK;
 
@@ -85,10 +85,9 @@ int git_tree_entry_icmp(const git_tree_entry *e1, const git_tree_entry *e2)
 }
 
 /**
- * Allocate a new self-contained entry, with enough space after it to
- * store the filename and the id.
+ * Allocate either from the pool or from the system allocator
  */
-static git_tree_entry *alloc_entry(const char *filename, size_t filename_len, const git_oid *id)
+static git_tree_entry *alloc_entry_base(git_pool *pool, const char *filename, size_t filename_len)
 {
 	git_tree_entry *entry = NULL;
 	size_t tree_len;
@@ -96,32 +95,44 @@ static git_tree_entry *alloc_entry(const char *filename, size_t filename_len, co
 	TREE_ENTRY_CHECK_NAMELEN(filename_len);
 
 	if (GIT_ADD_SIZET_OVERFLOW(&tree_len, sizeof(git_tree_entry), filename_len) ||
-	    GIT_ADD_SIZET_OVERFLOW(&tree_len, tree_len, 1) ||
-	    GIT_ADD_SIZET_OVERFLOW(&tree_len, tree_len, GIT_OID_RAWSZ))
+	    GIT_ADD_SIZET_OVERFLOW(&tree_len, tree_len, 1))
 		return NULL;
 
-	entry = git__calloc(1, tree_len);
+	entry = pool ? git_pool_malloc(pool, tree_len) :
+		       git__malloc(tree_len);
 	if (!entry)
 		return NULL;
 
-	{
-		char *filename_ptr;
-		void *id_ptr;
+	memset(entry, 0x0, sizeof(git_tree_entry));
+	memcpy(entry->filename, filename, filename_len);
+	entry->filename[filename_len] = 0;
+	entry->filename_len = (uint16_t)filename_len;
 
-		filename_ptr = ((char *) entry) + sizeof(git_tree_entry);
-		memcpy(filename_ptr, filename, filename_len);
-		entry->filename = filename_ptr;
+	return entry;
+}
 
-		id_ptr = filename_ptr + filename_len + 1;
-		git_oid_cpy(id_ptr, id);
-		entry->oid = id_ptr;
-	}
+/**
+ * Allocate a tree entry, using the poolin the tree which owns
+ * it. This is useful when reading trees, so we don't allocate a ton
+ * of small strings but can use the pool.
+ */
+static git_tree_entry *alloc_entry_pooled(git_pool *pool, const char *filename, size_t filename_len)
+{
+	git_tree_entry *entry = NULL;
 
-	entry->filename_len = (uint16_t)filename_len;
+	if (!(entry = alloc_entry_base(pool, filename, filename_len)))
+		return NULL;
+
+	entry->pooled = true;
 
 	return entry;
 }
 
+static git_tree_entry *alloc_entry(const char *filename)
+{
+	return alloc_entry_base(NULL, filename, strlen(filename));
+}
+
 struct tree_key_search {
 	const char *filename;
 	uint16_t filename_len;
@@ -163,10 +174,7 @@ static int homing_search_cmp(const void *key, const void *array_member)
  * around the area for our target file.
  */
 static int tree_key_search(
-	size_t *at_pos,
-	const git_tree *tree,
-	const char *filename,
-	size_t filename_len)
+	size_t *at_pos, git_vector *entries, const char *filename, size_t filename_len)
 {
 	struct tree_key_search ksearch;
 	const git_tree_entry *entry;
@@ -179,15 +187,13 @@ static int tree_key_search(
 
 	/* Initial homing search; find an entry on the tree with
 	 * the same prefix as the filename we're looking for */
-
-	if (git_array_search(&homing,
-		tree->entries, &homing_search_cmp, &ksearch) < 0)
+	if (git_vector_bsearch2(&homing, entries, &homing_search_cmp, &ksearch) < 0)
 		return GIT_ENOTFOUND; /* just a signal error; not passed back to user */
 
 	/* We found a common prefix. Look forward as long as
 	 * there are entries that share the common prefix */
-	for (i = homing; i < tree->entries.size; ++i) {
-		entry = git_array_get(tree->entries, i);
+	for (i = homing; i < entries->length; ++i) {
+		entry = entries->contents[i];
 
 		if (homing_search_cmp(&ksearch, entry) < 0)
 			break;
@@ -207,7 +213,7 @@ static int tree_key_search(
 		i = homing - 1;
 
 		do {
-			entry = git_array_get(tree->entries, i);
+			entry = entries->contents[i];
 
 			if (homing_search_cmp(&ksearch, entry) > 0)
 				break;
@@ -228,7 +234,7 @@ static int tree_key_search(
 
 void git_tree_entry_free(git_tree_entry *entry)
 {
-	if (entry == NULL)
+	if (entry == NULL || entry->pooled)
 		return;
 
 	git__free(entry);
@@ -236,26 +242,36 @@ void git_tree_entry_free(git_tree_entry *entry)
 
 int git_tree_entry_dup(git_tree_entry **dest, const git_tree_entry *source)
 {
-	git_tree_entry *cpy;
+	size_t total_size;
+	git_tree_entry *copy;
 
 	assert(source);
 
-	cpy = alloc_entry(source->filename, source->filename_len, source->oid);
-	if (cpy == NULL)
-		return -1;
+	GITERR_CHECK_ALLOC_ADD(&total_size, sizeof(git_tree_entry), source->filename_len);
+	GITERR_CHECK_ALLOC_ADD(&total_size, total_size, 1);
 
-	cpy->attr = source->attr;
+	copy = git__malloc(total_size);
+	GITERR_CHECK_ALLOC(copy);
 
-	*dest = cpy;
+	memcpy(copy, source, total_size);
+
+	copy->pooled = 0;
+
+	*dest = copy;
 	return 0;
 }
 
 void git_tree__free(void *_tree)
 {
 	git_tree *tree = _tree;
+	size_t i;
+	git_tree_entry *e;
+
+	git_vector_foreach(&tree->entries, i, e)
+		git_tree_entry_free(e);
 
-	git_odb_object_free(tree->odb_obj);
-	git_array_clear(tree->entries);
+	git_vector_free(&tree->entries);
+	git_pool_clear(&tree->pool);
 	git__free(tree);
 }
 
@@ -278,7 +294,7 @@ const char *git_tree_entry_name(const git_tree_entry *entry)
 const git_oid *git_tree_entry_id(const git_tree_entry *entry)
 {
 	assert(entry);
-	return entry->oid;
+	return &entry->oid;
 }
 
 git_otype git_tree_entry_type(const git_tree_entry *entry)
@@ -299,7 +315,7 @@ int git_tree_entry_to_object(
 	const git_tree_entry *entry)
 {
 	assert(entry && object_out);
-	return git_object_lookup(object_out, repo, entry->oid, GIT_OBJ_ANY);
+	return git_object_lookup(object_out, repo, &entry->oid, GIT_OBJ_ANY);
 }
 
 static const git_tree_entry *entry_fromname(
@@ -307,10 +323,13 @@ static const git_tree_entry *entry_fromname(
 {
 	size_t idx;
 
-	if (tree_key_search(&idx, tree, name, name_len) < 0)
+	/* be safe when we cast away constness - i.e. don't trigger a sort */
+	assert(git_vector_is_sorted(&tree->entries));
+
+	if (tree_key_search(&idx, (git_vector *)&tree->entries, name, name_len) < 0)
 		return NULL;
 
-	return git_array_get(tree->entries, idx);
+	return git_vector_get(&tree->entries, idx);
 }
 
 const git_tree_entry *git_tree_entry_byname(
@@ -325,7 +344,7 @@ const git_tree_entry *git_tree_entry_byindex(
 	const git_tree *tree, size_t idx)
 {
 	assert(tree);
-	return git_array_get(tree->entries, idx);
+	return git_vector_get(&tree->entries, idx);
 }
 
 const git_tree_entry *git_tree_entry_byid(
@@ -336,8 +355,8 @@ const git_tree_entry *git_tree_entry_byid(
 
 	assert(tree);
 
-	git_array_foreach(tree->entries, i, e) {
-		if (memcmp(&e->oid->id, &id->id, sizeof(id->id)) == 0)
+	git_vector_foreach(&tree->entries, i, e) {
+		if (memcmp(&e->oid.id, &id->id, sizeof(id->id)) == 0)
 			return e;
 	}
 
@@ -346,6 +365,7 @@ const git_tree_entry *git_tree_entry_byid(
 
 int git_tree__prefix_position(const git_tree *tree, const char *path)
 {
+	const git_vector *entries = &tree->entries;
 	struct tree_key_search ksearch;
 	size_t at_pos, path_len;
 
@@ -358,20 +378,21 @@ int git_tree__prefix_position(const git_tree *tree, const char *path)
 	ksearch.filename = path;
 	ksearch.filename_len = (uint16_t)path_len;
 
+	/* be safe when we cast away constness - i.e. don't trigger a sort */
+	assert(git_vector_is_sorted(&tree->entries));
+
 	/* Find tree entry with appropriate prefix */
-	git_array_search(
-		&at_pos, tree->entries, &homing_search_cmp, &ksearch);
+	git_vector_bsearch2(
+		&at_pos, (git_vector *)entries, &homing_search_cmp, &ksearch);
 
-	for (; at_pos < tree->entries.size; ++at_pos) {
-		const git_tree_entry *entry = git_array_get(tree->entries, at_pos);
+	for (; at_pos < entries->length; ++at_pos) {
+		const git_tree_entry *entry = entries->contents[at_pos];
 		if (homing_search_cmp(&ksearch, entry) < 0)
 			break;
 	}
 
 	for (; at_pos > 0; --at_pos) {
-		const git_tree_entry *entry =
-			git_array_get(tree->entries, at_pos - 1);
-
+		const git_tree_entry *entry = entries->contents[at_pos - 1];
 		if (homing_search_cmp(&ksearch, entry) > 0)
 			break;
 	}
@@ -382,7 +403,7 @@ int git_tree__prefix_position(const git_tree *tree, const char *path)
 size_t git_tree_entrycount(const git_tree *tree)
 {
 	assert(tree);
-	return tree->entries.size;
+	return tree->entries.length;
 }
 
 unsigned int git_treebuilder_entrycount(git_treebuilder *bld)
@@ -423,18 +444,13 @@ static int parse_mode(unsigned int *modep, const char *buffer, const char **buff
 int git_tree__parse(void *_tree, git_odb_object *odb_obj)
 {
 	git_tree *tree = _tree;
-	const char *buffer;
-	const char *buffer_end;
+	const char *buffer = git_odb_object_data(odb_obj);
+	const char *buffer_end = buffer + git_odb_object_size(odb_obj);
 
-	if (git_odb_object_dup(&tree->odb_obj, odb_obj) < 0)
+	git_pool_init(&tree->pool, 1);
+	if (git_vector_init(&tree->entries, DEFAULT_TREE_SIZE, entry_sort_cmp) < 0)
 		return -1;
 
-	buffer = git_odb_object_data(tree->odb_obj);
-	buffer_end = buffer + git_odb_object_size(tree->odb_obj);
-
-	git_array_init_to_size(tree->entries, DEFAULT_TREE_SIZE);
-	GITERR_CHECK_ARRAY(tree->entries);
-
 	while (buffer < buffer_end) {
 		git_tree_entry *entry;
 		size_t filename_len;
@@ -447,27 +463,28 @@ int git_tree__parse(void *_tree, git_odb_object *odb_obj)
 		if ((nul = memchr(buffer, 0, buffer_end - buffer)) == NULL)
 			return tree_error("Failed to parse tree. Object is corrupted", NULL);
 
-		if ((filename_len = nul - buffer) == 0)
-			return tree_error("Failed to parse tree. Can't parse filename", NULL);
-
-		if ((buffer_end - (nul + 1)) < GIT_OID_RAWSZ)
-			return tree_error("Failed to parse tree. Can't parse OID", NULL);
-
-		/* Allocate the entry */
+		filename_len = nul - buffer;
+		/** Allocate the entry and store it in the entries vector */
 		{
-			entry = git_array_alloc(tree->entries);
+			entry = alloc_entry_pooled(&tree->pool, buffer, filename_len);
 			GITERR_CHECK_ALLOC(entry);
 
+			if (git_vector_insert(&tree->entries, entry) < 0)
+				return -1;
+
 			entry->attr = attr;
-			entry->filename_len = filename_len;
-			entry->filename = buffer;
-			entry->oid = (git_oid *) ((char *) buffer + filename_len + 1);
 		}
 
+		/* Advance to the ID just after the path */
 		buffer += filename_len + 1;
+
+		git_oid_fromraw(&entry->oid, (const unsigned char *)buffer);
 		buffer += GIT_OID_RAWSZ;
 	}
 
+	/* The tree is sorted by definition. Bad inputs give bad outputs */
+	tree->entries.flags |= GIT_VECTOR_SORTED;
+
 	return 0;
 }
 
@@ -500,9 +517,10 @@ static int append_entry(
 	if (!valid_entry_name(bld->repo, filename))
 		return tree_error("Failed to insert entry. Invalid name for a tree entry", filename);
 
-	entry = alloc_entry(filename, strlen(filename), id);
+	entry = alloc_entry(filename);
 	GITERR_CHECK_ALLOC(entry);
 
+	git_oid_cpy(&entry->oid, id);
 	entry->attr = (uint16_t)filemode;
 
 	git_strmap_insert(bld->map, entry->filename, entry, error);
@@ -691,10 +709,10 @@ int git_treebuilder_new(
 	if (source != NULL) {
 		git_tree_entry *entry_src;
 
-		git_array_foreach(source->entries, i, entry_src) {
+		git_vector_foreach(&source->entries, i, entry_src) {
 			if (append_entry(
 				bld, entry_src->filename,
-				entry_src->oid,
+				&entry_src->oid,
 				entry_src->attr) < 0)
 				goto on_error;
 		}
@@ -746,9 +764,8 @@ int git_treebuilder_insert(
 	pos = git_strmap_lookup_index(bld->map, filename);
 	if (git_strmap_valid_index(bld->map, pos)) {
 		entry = git_strmap_value_at(bld->map, pos);
-		git_oid_cpy((git_oid *) entry->oid, id);
 	} else {
-		entry = alloc_entry(filename, strlen(filename), id);
+		entry = alloc_entry(filename);
 		GITERR_CHECK_ALLOC(entry);
 
 		git_strmap_insert(bld->map, entry->filename, entry, error);
@@ -760,6 +777,7 @@ int git_treebuilder_insert(
 		}
 	}
 
+	git_oid_cpy(&entry->oid, id);
 	entry->attr = filemode;
 
 	if (entry_out)
@@ -830,20 +848,19 @@ int git_treebuilder_write(git_oid *oid, git_treebuilder *bld)
 
 		git_buf_printf(&tree, "%o ", entry->attr);
 		git_buf_put(&tree, entry->filename, entry->filename_len + 1);
-		git_buf_put(&tree, (char *)entry->oid->id, GIT_OID_RAWSZ);
+		git_buf_put(&tree, (char *)entry->oid.id, GIT_OID_RAWSZ);
 
 		if (git_buf_oom(&tree))
 			error = -1;
 	}
 
+	git_vector_free(&entries);
 
 	if (!error &&
 		!(error = git_repository_odb__weakptr(&odb, bld->repo)))
 		error = git_odb_write(oid, odb, tree.ptr, tree.size, GIT_OBJ_TREE);
 
 	git_buf_free(&tree);
-	git_vector_free(&entries);
-
 	return error;
 }
 
@@ -943,7 +960,7 @@ int git_tree_entry_bypath(
 		return git_tree_entry_dup(entry_out, entry);
 	}
 
-	if (git_tree_lookup(&subtree, root->object.repo, entry->oid) < 0)
+	if (git_tree_lookup(&subtree, root->object.repo, &entry->oid) < 0)
 		return -1;
 
 	error = git_tree_entry_bypath(
@@ -967,7 +984,7 @@ static int tree_walk(
 	size_t i;
 	const git_tree_entry *entry;
 
-	git_array_foreach(tree->entries, i, entry) {
+	git_vector_foreach(&tree->entries, i, entry) {
 		if (preorder) {
 			error = callback(path->ptr, entry, payload);
 			if (error < 0) { /* negative value stops iteration */
@@ -984,7 +1001,7 @@ static int tree_walk(
 			git_tree *subtree;
 			size_t path_len = git_buf_len(path);
 
-			error = git_tree_lookup(&subtree, tree->object.repo, entry->oid);
+			error = git_tree_lookup(&subtree, tree->object.repo, &entry->oid);
 			if (error < 0)
 				break;