rugged 1.1.1 → 1.4.3

data/vendor/libgit2/src/oid.c

@@ -9,10 +9,17 @@
 
 #include "git2/oid.h"
 #include "repository.h"
-#include "global.h"
+#include "threadstate.h"
 #include <string.h>
 #include <limits.h>
 
+const git_oid git_oid__empty_blob_sha1 =
+	{{ 0xe6, 0x9d, 0xe2, 0x9b, 0xb2, 0xd1, 0xd6, 0x43, 0x4b, 0x8b,
+	   0x29, 0xae, 0x77, 0x5a, 0xd8, 0xc2, 0xe4, 0x8c, 0x53, 0x91 }};
+const git_oid git_oid__empty_tree_sha1 =
+	{{ 0x4b, 0x82, 0x5d, 0xc6, 0x42, 0xcb, 0x6e, 0xb9, 0xa0, 0x60,
+	   0xe5, 0x4b, 0xf8, 0xd6, 0x92, 0x88, 0xfb, 0xee, 0x49, 0x04 }};
+
 static char to_hex[] = "0123456789abcdef";
 
 static int oid_error_invalid(const char *msg)
@@ -26,7 +33,8 @@ int git_oid_fromstrn(git_oid *out, const char *str, size_t length)
 	size_t p;
 	int v;
 
-	assert(out && str);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(str);
 
 	if (!length)
 		return oid_error_invalid("too short");
@@ -107,7 +115,7 @@ int git_oid_pathfmt(char *str, const git_oid *oid)
 
 char *git_oid_tostr_s(const git_oid *oid)
 {
-	char *str = GIT_GLOBAL->oid_fmt;
+	char *str = GIT_THREADSTATE->oid_fmt;
 	git_oid_nfmt(str, GIT_OID_HEXSZ + 1, oid);
 	return str;
 }
@@ -161,14 +169,14 @@ int git_oid__parse(
 	return 0;
 }
 
-void git_oid__writebuf(git_buf *buf, const char *header, const git_oid *oid)
+void git_oid__writebuf(git_str *buf, const char *header, const git_oid *oid)
 {
 	char hex_oid[GIT_OID_HEXSZ];
 
 	git_oid_fmt(hex_oid, oid);
-	git_buf_puts(buf, header);
-	git_buf_put(buf, hex_oid, GIT_OID_HEXSZ);
-	git_buf_putc(buf, '\n');
+	git_str_puts(buf, header);
+	git_str_put(buf, hex_oid, GIT_OID_HEXSZ);
+	git_str_putc(buf, '\n');
 }
 
 int git_oid_fromraw(git_oid *out, const unsigned char *raw)
@@ -316,7 +324,7 @@ git_oid_shorten *git_oid_shorten_new(size_t min_length)
 {
 	git_oid_shorten *os;
 
-	assert((size_t)((int)min_length) == min_length);
+	GIT_ASSERT_ARG_WITH_RETVAL((size_t)((int)min_length) == min_length, NULL);
 
 	os = git__calloc(1, sizeof(git_oid_shorten));
 	if (os == NULL)

data/vendor/libgit2/src/oid.h

@@ -11,6 +11,9 @@
 
 #include "git2/oid.h"
 
+extern const git_oid git_oid__empty_blob_sha1;
+extern const git_oid git_oid__empty_tree_sha1;
+
 /**
  * Format a git_oid into a newly allocated c-string.
  *
@@ -48,4 +51,16 @@ GIT_INLINE(void) git_oid__cpy_prefix(
 		out->id[len / 2] &= 0xF0;
 }
 
+GIT_INLINE(bool) git_oid__is_hexstr(const char *str)
+{
+	size_t i;
+
+	for (i = 0; str[i] != '\0'; i++) {
+		if (git__fromhex(str[i]) < 0)
+			return false;
+	}
+
+	return (i == GIT_OID_HEXSZ);
+}
+
 #endif

data/vendor/libgit2/src/oidarray.c

@@ -10,7 +10,7 @@
 #include "git2/oidarray.h"
 #include "array.h"
 
-void git_oidarray_free(git_oidarray *arr)
+void git_oidarray_dispose(git_oidarray *arr)
 {
 	git__free(arr->ids);
 }
@@ -32,3 +32,12 @@ void git_oidarray__reverse(git_oidarray *arr)
 		git_oid_cpy(&arr->ids[(arr->count-1)-i], &tmp);
 	}
 }
+
+#ifndef GIT_DEPRECATE_HARD
+
+void git_oidarray_free(git_oidarray *arr)
+{
+	git_oidarray_dispose(arr);
+}
+
+#endif

data/vendor/libgit2/src/pack-objects.c

@@ -7,12 +7,13 @@
 
 #include "pack-objects.h"
 
+#include "buf.h"
 #include "zstream.h"
 #include "delta.h"
 #include "iterator.h"
 #include "netops.h"
 #include "pack.h"
-#include "thread-utils.h"
+#include "thread.h"
 #include "tree.h"
 #include "util.h"
 #include "revwalk.h"
@@ -33,7 +34,7 @@ struct unpacked {
 
 struct tree_walk_context {
 	git_packbuilder *pb;
-	git_buf buf;
+	git_str buf;
 };
 
 struct pack_write_context {
@@ -48,18 +49,10 @@ struct walk_object {
 };
 
 #ifdef GIT_THREADS
-
-#define GIT_PACKBUILDER__MUTEX_OP(pb, mtx, op) do { \
-		int result = git_mutex_##op(&(pb)->mtx); \
-		assert(!result); \
-		GIT_UNUSED(result); \
-	} while (0)
-
+# define GIT_PACKBUILDER__MUTEX_OP(pb, mtx, op) git_mutex_##op(&(pb)->mtx)
 #else
-
-#define GIT_PACKBUILDER__MUTEX_OP(pb,mtx,op) GIT_UNUSED(pb)
-
-#endif /* GIT_THREADS */
+# define GIT_PACKBUILDER__MUTEX_OP(pb, mtx, op) git__noop()
+#endif
 
 #define git_packbuilder__cache_lock(pb) GIT_PACKBUILDER__MUTEX_OP(pb, cache_mutex, lock)
 #define git_packbuilder__cache_unlock(pb) GIT_PACKBUILDER__MUTEX_OP(pb, cache_mutex, unlock)
@@ -149,7 +142,7 @@ int git_packbuilder_new(git_packbuilder **out, git_repository *repo)
 	pb->repo = repo;
 	pb->nr_threads = 1; /* do not spawn any thread by default */
 
-	if (git_hash_ctx_init(&pb->ctx) < 0 ||
+	if (git_hash_ctx_init(&pb->ctx, GIT_HASH_ALGORITHM_SHA1) < 0 ||
 		git_zstream_init(&pb->zstream, GIT_ZSTREAM_DEFLATE) < 0 ||
 		git_repository_odb(&pb->odb, repo) < 0 ||
 		packbuilder_config(pb) < 0)
@@ -177,13 +170,13 @@ on_error:
 
 unsigned int git_packbuilder_set_threads(git_packbuilder *pb, unsigned int n)
 {
-	assert(pb);
+	GIT_ASSERT_ARG(pb);
 
 #ifdef GIT_THREADS
 	pb->nr_threads = n;
 #else
 	GIT_UNUSED(n);
-	assert(1 == pb->nr_threads);
+	GIT_ASSERT(pb->nr_threads == 1);
 #endif
 
 	return pb->nr_threads;
@@ -211,7 +204,8 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 	size_t newsize;
 	int ret;
 
-	assert(pb && oid);
+	GIT_ASSERT_ARG(pb);
+	GIT_ASSERT_ARG(oid);
 
 	/* If the object already exists in the hash table, then we don't
 	 * have any work to do */
@@ -258,7 +252,7 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 		double current_time = git__timer();
 		double elapsed = current_time - pb->last_progress_report_time;
 
-		if (elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) {
+		if (elapsed < 0 || elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) {
 			pb->last_progress_report_time = current_time;
 
 			ret = pb->progress_cb(
@@ -347,10 +341,9 @@ static int write_object(
 	}
 
 	/* Write header */
-	hdr_len = git_packfile__object_header(hdr, data_len, type);
-
-	if ((error = write_cb(hdr, hdr_len, cb_data)) < 0 ||
-		(error = git_hash_update(&pb->ctx, hdr, hdr_len)) < 0)
+	if ((error = git_packfile__object_header(&hdr_len, hdr, data_len, type)) < 0 ||
+	    (error = write_cb(hdr, hdr_len, cb_data)) < 0 ||
+	    (error = git_hash_update(&pb->ctx, hdr, hdr_len)) < 0)
 		goto done;
 
 	if (type == GIT_OBJECT_REF_DELTA) {
@@ -525,13 +518,18 @@ static int cb_tag_foreach(const char *name, git_oid *oid, void *data)
 	return 0;
 }
 
-static git_pobject **compute_write_order(git_packbuilder *pb)
+static int compute_write_order(git_pobject ***out, git_packbuilder *pb)
 {
 	size_t i, wo_end, last_untagged;
 	git_pobject **wo;
 
+	*out = NULL;
+
+	if (!pb->nr_objects)
+		return 0;
+
 	if ((wo = git__mallocarray(pb->nr_objects, sizeof(*wo))) == NULL)
-		return NULL;
+		return -1;
 
 	for (i = 0; i < pb->nr_objects; i++) {
 		git_pobject *po = pb->object_list + i;
@@ -560,7 +558,7 @@ static git_pobject **compute_write_order(git_packbuilder *pb)
 	 */
 	if (git_tag_foreach(pb->repo, &cb_tag_foreach, pb) < 0) {
 		git__free(wo);
-		return NULL;
+		return -1;
 	}
 
 	/*
@@ -617,10 +615,11 @@ static git_pobject **compute_write_order(git_packbuilder *pb)
 	if (wo_end != pb->nr_objects) {
 		git__free(wo);
 		git_error_set(GIT_ERROR_INVALID, "invalid write order");
-		return NULL;
+		return -1;
 	}
 
-	return wo;
+	*out = wo;
+	return 0;
 }
 
 static int write_pack(git_packbuilder *pb,
@@ -633,15 +632,15 @@ static int write_pack(git_packbuilder *pb,
 	struct git_pack_header ph;
 	git_oid entry_oid;
 	size_t i = 0;
-	int error = 0;
+	int error;
 
-	write_order = compute_write_order(pb);
-	if (write_order == NULL)
-		return -1;
+	if ((error = compute_write_order(&write_order, pb)) < 0)
+		return error;
 
 	if (!git__is_uint32(pb->nr_objects)) {
 		git_error_set(GIT_ERROR_INVALID, "too many objects");
-		return -1;
+		error = -1;
+		goto done;
 	}
 
 	/* Write pack header */
@@ -666,7 +665,7 @@ static int write_pack(git_packbuilder *pb,
 		pb->nr_remaining -= pb->nr_written;
 	} while (pb->nr_remaining && i < pb->nr_objects);
 
-	if ((error = git_hash_final(&entry_oid, &pb->ctx)) < 0)
+	if ((error = git_hash_final(entry_oid.id, &pb->ctx)) < 0)
 		goto done;
 
 	error = write_cb(entry_oid.id, GIT_OID_RAWSZ, cb_data);
@@ -687,8 +686,8 @@ done:
 
 static int write_pack_buf(void *buf, size_t size, void *data)
 {
-	git_buf *b = (git_buf *)data;
-	return git_buf_put(b, buf, size);
+	git_str *b = (git_str *)data;
+	return git_str_put(b, buf, size);
 }
 
 static int type_size_sort(const void *_a, const void *_b)
@@ -852,10 +851,11 @@ static int try_delta(git_packbuilder *pb, struct unpacked *trg,
 		}
 	}
 
-	git_packbuilder__cache_lock(pb);
+	GIT_ASSERT(git_packbuilder__cache_lock(pb) == 0);
+
 	if (trg_object->delta_data) {
 		git__free(trg_object->delta_data);
-		assert(pb->delta_cache_size >= trg_object->delta_size);
+		GIT_ASSERT(pb->delta_cache_size >= trg_object->delta_size);
 		pb->delta_cache_size -= trg_object->delta_size;
 		trg_object->delta_data = NULL;
 	}
@@ -863,7 +863,7 @@ static int try_delta(git_packbuilder *pb, struct unpacked *trg,
 		bool overflow = git__add_sizet_overflow(
 			&pb->delta_cache_size, pb->delta_cache_size, delta_size);
 
-		git_packbuilder__cache_unlock(pb);
+		GIT_ASSERT(git_packbuilder__cache_unlock(pb) == 0);
 
 		if (overflow) {
 			git__free(delta_buf);
@@ -874,7 +874,7 @@ static int try_delta(git_packbuilder *pb, struct unpacked *trg,
 		GIT_ERROR_CHECK_ALLOC(trg_object->delta_data);
 	} else {
 		/* create delta when writing the pack */
-		git_packbuilder__cache_unlock(pb);
+		GIT_ASSERT(git_packbuilder__cache_unlock(pb) == 0);
 		git__free(delta_buf);
 	}
 
@@ -929,7 +929,7 @@ static int report_delta_progress(
 		double current_time = git__timer();
 		double elapsed = current_time - pb->last_progress_report_time;
 
-		if (force || elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) {
+		if (force || elapsed < 0 || elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) {
 			pb->last_progress_report_time = current_time;
 
 			ret = pb->progress_cb(
@@ -948,7 +948,7 @@ static int find_deltas(git_packbuilder *pb, git_pobject **list,
 	size_t *list_size, size_t window, size_t depth)
 {
 	git_pobject *po;
-	git_buf zbuf = GIT_BUF_INIT;
+	git_str zbuf = GIT_STR_INIT;
 	struct unpacked *array;
 	size_t idx = 0, count = 0;
 	size_t mem_usage = 0;
@@ -962,9 +962,9 @@ static int find_deltas(git_packbuilder *pb, git_pobject **list,
 		struct unpacked *n = array + idx;
 		size_t max_depth, j, best_base = SIZE_MAX;
 
-		git_packbuilder__progress_lock(pb);
+		GIT_ASSERT(git_packbuilder__progress_lock(pb) == 0);
 		if (!*list_size) {
-			git_packbuilder__progress_unlock(pb);
+			GIT_ASSERT(git_packbuilder__progress_unlock(pb) == 0);
 			break;
 		}
 
@@ -973,7 +973,7 @@ static int find_deltas(git_packbuilder *pb, git_pobject **list,
 
 		po = *list++;
 		(*list_size)--;
-		git_packbuilder__progress_unlock(pb);
+		GIT_ASSERT(git_packbuilder__progress_unlock(pb) == 0);
 
 		mem_usage -= free_unpacked(n);
 		n->object = po;
@@ -1046,12 +1046,12 @@ static int find_deltas(git_packbuilder *pb, git_pobject **list,
 
 			memcpy(po->delta_data, zbuf.ptr, zbuf.size);
 			po->z_delta_size = zbuf.size;
-			git_buf_clear(&zbuf);
+			git_str_clear(&zbuf);
 
-			git_packbuilder__cache_lock(pb);
+			GIT_ASSERT(git_packbuilder__cache_lock(pb) == 0);
 			pb->delta_cache_size -= po->delta_size;
 			pb->delta_cache_size += po->z_delta_size;
-			git_packbuilder__cache_unlock(pb);
+			GIT_ASSERT(git_packbuilder__cache_unlock(pb) == 0);
 		}
 
 		/*
@@ -1094,7 +1094,7 @@ on_error:
 		git__free(array[i].data);
 	}
 	git__free(array);
-	git_buf_dispose(&zbuf);
+	git_str_dispose(&zbuf);
 
 	return error;
 }
@@ -1129,10 +1129,10 @@ static void *threaded_find_deltas(void *arg)
 			; /* TODO */
 		}
 
-		git_packbuilder__progress_lock(me->pb);
+		GIT_ASSERT_WITH_RETVAL(git_packbuilder__progress_lock(me->pb) == 0, NULL);
 		me->working = 0;
 		git_cond_signal(&me->pb->progress_cond);
-		git_packbuilder__progress_unlock(me->pb);
+		GIT_ASSERT_WITH_RETVAL(git_packbuilder__progress_unlock(me->pb) == 0, NULL);
 
 		if (git_mutex_lock(&me->mutex)) {
 			git_error_set(GIT_ERROR_THREAD, "unable to lock packfile condition mutex");
@@ -1165,7 +1165,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 	int ret, active_threads = 0;
 
 	if (!pb->nr_threads)
-		pb->nr_threads = git_online_cpus();
+		pb->nr_threads = git__online_cpus();
 
 	if (pb->nr_threads <= 1) {
 		find_deltas(pb, list, &list_size, window, depth);
@@ -1237,7 +1237,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 		 * 'working' flag from 1 -> 0. This indicates that it is
 		 * ready to receive more work using our work-stealing
 		 * algorithm. */
-		git_packbuilder__progress_lock(pb);
+		GIT_ASSERT(git_packbuilder__progress_lock(pb) == 0);
 		for (;;) {
 			for (i = 0; !target && i < pb->nr_threads; i++)
 				if (!p[i].working)
@@ -1280,7 +1280,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 		target->list_size = sub_size;
 		target->remaining = sub_size;
 		target->working = 1;
-		git_packbuilder__progress_unlock(pb);
+		GIT_ASSERT(git_packbuilder__progress_unlock(pb) == 0);
 
 		if (git_mutex_lock(&target->mutex)) {
 			git_error_set(GIT_ERROR_THREAD, "unable to lock packfile condition mutex");
@@ -1308,7 +1308,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 #define ll_find_deltas(pb, l, ls, w, d) find_deltas(pb, l, &ls, w, d)
 #endif
 
-static int prepare_pack(git_packbuilder *pb)
+int git_packbuilder__prepare(git_packbuilder *pb)
 {
 	git_pobject **delta_list;
 	size_t i, n = 0;
@@ -1353,7 +1353,7 @@ static int prepare_pack(git_packbuilder *pb)
 	return 0;
 }
 
-#define PREPARE_PACK if (prepare_pack(pb) < 0) { return -1; }
+#define PREPARE_PACK if (git_packbuilder__prepare(pb) < 0) { return -1; }
 
 int git_packbuilder_foreach(git_packbuilder *pb, int (*cb)(void *buf, size_t size, void *payload), void *payload)
 {
@@ -1361,13 +1361,18 @@ int git_packbuilder_foreach(git_packbuilder *pb, int (*cb)(void *buf, size_t siz
 	return write_pack(pb, cb, payload);
 }
 
-int git_packbuilder_write_buf(git_buf *buf, git_packbuilder *pb)
+int git_packbuilder__write_buf(git_str *buf, git_packbuilder *pb)
 {
 	PREPARE_PACK;
-	git_buf_sanitize(buf);
+
 	return write_pack(pb, &write_pack_buf, buf);
 }
 
+int git_packbuilder_write_buf(git_buf *buf, git_packbuilder *pb)
+{
+	GIT_BUF_WRAP_PRIVATE(buf, git_packbuilder__write_buf, pb);
+}
+
 static int write_cb(void *buf, size_t len, void *payload)
 {
 	struct pack_write_context *ctx = payload;
@@ -1382,7 +1387,7 @@ int git_packbuilder_write(
 	void *progress_cb_payload)
 {
 	int error = -1;
-	git_buf object_path = GIT_BUF_INIT;
+	git_str object_path = GIT_STR_INIT;
 	git_indexer_options opts = GIT_INDEXER_OPTIONS_INIT;
 	git_indexer *indexer = NULL;
 	git_indexer_progress stats;
@@ -1392,11 +1397,11 @@ int git_packbuilder_write(
 	PREPARE_PACK;
 
 	if (path == NULL) {
-		if ((error = git_repository_item_path(&object_path, pb->repo, GIT_REPOSITORY_ITEM_OBJECTS)) < 0)
+		if ((error = git_repository__item_path(&object_path, pb->repo, GIT_REPOSITORY_ITEM_OBJECTS)) < 0)
 			goto cleanup;
-		if ((error = git_buf_joinpath(&object_path, git_buf_cstr(&object_path), "pack")) < 0)
+		if ((error = git_str_joinpath(&object_path, git_str_cstr(&object_path), "pack")) < 0)
 			goto cleanup;
-		path = git_buf_cstr(&object_path);
+		path = git_str_cstr(&object_path);
 	}
 
 	opts.progress_cb = progress_cb;
@@ -1417,20 +1422,32 @@ int git_packbuilder_write(
 	if ((error = git_indexer_commit(indexer, &stats)) < 0)
 		goto cleanup;
 
+#ifndef GIT_DEPRECATE_HARD
 	git_oid_cpy(&pb->pack_oid, git_indexer_hash(indexer));
+#endif
+
+	pb->pack_name = git__strdup(git_indexer_name(indexer));
+	GIT_ERROR_CHECK_ALLOC(pb->pack_name);
 
 cleanup:
 	git_indexer_free(indexer);
-	git_buf_dispose(&object_path);
+	git_str_dispose(&object_path);
 	return error;
 }
 
 #undef PREPARE_PACK
 
+#ifndef GIT_DEPRECATE_HARD
 const git_oid *git_packbuilder_hash(git_packbuilder *pb)
 {
 	return &pb->pack_oid;
 }
+#endif
+
+const char *git_packbuilder_name(git_packbuilder *pb)
+{
+	return pb->pack_name;
+}
 
 
 static int cb_tree_walk(
@@ -1443,10 +1460,10 @@ static int cb_tree_walk(
 	if (git_tree_entry_type(entry) == GIT_OBJECT_COMMIT)
 		return 0;
 
-	if (!(error = git_buf_sets(&ctx->buf, root)) &&
-		!(error = git_buf_puts(&ctx->buf, git_tree_entry_name(entry))))
+	if (!(error = git_str_sets(&ctx->buf, root)) &&
+		!(error = git_str_puts(&ctx->buf, git_tree_entry_name(entry))))
 		error = git_packbuilder_insert(
-			ctx->pb, git_tree_entry_id(entry), git_buf_cstr(&ctx->buf));
+			ctx->pb, git_tree_entry_id(entry), git_str_cstr(&ctx->buf));
 
 	return error;
 }
@@ -1470,14 +1487,14 @@ int git_packbuilder_insert_tree(git_packbuilder *pb, const git_oid *oid)
 {
 	int error;
 	git_tree *tree = NULL;
-	struct tree_walk_context context = { pb, GIT_BUF_INIT };
+	struct tree_walk_context context = { pb, GIT_STR_INIT };
 
 	if (!(error = git_tree_lookup(&tree, pb->repo, oid)) &&
 	    !(error = git_packbuilder_insert(pb, oid, NULL)))
 		error = git_tree_walk(tree, GIT_TREEWALK_PRE, cb_tree_walk, &context);
 
 	git_tree_free(tree);
-	git_buf_dispose(&context.buf);
+	git_str_dispose(&context.buf);
 	return error;
 }
 
@@ -1486,7 +1503,8 @@ int git_packbuilder_insert_recur(git_packbuilder *pb, const git_oid *id, const c
 	git_object *obj;
 	int error;
 
-	assert(pb && id);
+	GIT_ASSERT_ARG(pb);
+	GIT_ASSERT_ARG(id);
 
 	if ((error = git_object_lookup(&obj, pb->repo, id, GIT_OBJECT_ANY)) < 0)
 		return error;
@@ -1727,7 +1745,8 @@ int git_packbuilder_insert_walk(git_packbuilder *pb, git_revwalk *walk)
 	git_oid id;
 	struct walk_object *obj;
 
-	assert(pb && walk);
+	GIT_ASSERT_ARG(pb);
+	GIT_ASSERT_ARG(walk);
 
 	if ((error = mark_edges_uninteresting(pb, walk->user_input)) < 0)
 		return error;
@@ -1796,5 +1815,7 @@ void git_packbuilder_free(git_packbuilder *pb)
 	git_hash_ctx_cleanup(&pb->ctx);
 	git_zstream_free(&pb->zstream);
 
+	git__free(pb->pack_name);
+
 	git__free(pb);
 }

data/vendor/libgit2/src/pack-objects.h

@@ -10,7 +10,7 @@
 
 #include "common.h"
 
-#include "buffer.h"
+#include "str.h"
 #include "hash.h"
 #include "oidmap.h"
 #include "netops.h"
@@ -46,10 +46,10 @@ typedef struct git_pobject {
 	size_t delta_size;
 	size_t z_delta_size;
 
-	int written:1,
-	    recursing:1,
-	    tagged:1,
-	    filled:1;
+	unsigned int written:1,
+	             recursing:1,
+	             tagged:1,
+	             filled:1;
 } git_pobject;
 
 struct git_packbuilder {
@@ -73,7 +73,10 @@ struct git_packbuilder {
 	git_oidmap *walk_objects;
 	git_pool object_pool;
 
+#ifndef GIT_DEPRECATE_HARD
 	git_oid pack_oid; /* hash of written pack */
+#endif
+	char *pack_name; /* name of written pack */
 
 	/* synchronization objects */
 	git_mutex cache_mutex;
@@ -96,6 +99,8 @@ struct git_packbuilder {
 	bool done;
 };
 
-int git_packbuilder_write_buf(git_buf *buf, git_packbuilder *pb);
+int git_packbuilder__write_buf(git_str *buf, git_packbuilder *pb);
+int git_packbuilder__prepare(git_packbuilder *pb);
+
 
 #endif