rugged 0.1.2 → 0.16.0b1

data/ext/rugged/vendor/libgit2-dist/src/netops.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2009-2011 the libgit2 contributors
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_netops_h__
+#define INCLUDE_netops_h__
+
+#ifndef GIT_WIN32
+typedef int GIT_SOCKET;
+#else
+typedef SOCKET GIT_SOCKET;
+#endif
+
+typedef struct gitno_buffer {
+	char *data;
+	size_t len;
+	size_t offset;
+	GIT_SOCKET fd;
+} gitno_buffer;
+
+void gitno_buffer_setup(gitno_buffer *buf, char *data, unsigned int len, int fd);
+int gitno_recv(gitno_buffer *buf);
+void gitno_consume(gitno_buffer *buf, const char *ptr);
+void gitno_consume_n(gitno_buffer *buf, size_t cons);
+
+int gitno_connect(const char *host, const char *port);
+int gitno_send(GIT_SOCKET s, const char *msg, size_t len, int flags);
+int gitno_close(GIT_SOCKET s);
+int gitno_send_chunk_size(int s, size_t len);
+int gitno_select_in(gitno_buffer *buf, long int sec, long int usec);
+
+int gitno_extract_host_and_port(char **host, char **port, const char *url, const char *default_port);
+
+#endif

data/ext/rugged/vendor/libgit2-dist/src/object.c

@@ -0,0 +1,295 @@
+/*
+ * Copyright (C) 2009-2011 the libgit2 contributors
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#include <stdarg.h>
+
+#include "git2/object.h"
+
+#include "common.h"
+#include "repository.h"
+
+#include "commit.h"
+#include "tree.h"
+#include "blob.h"
+#include "tag.h"
+
+static const int OBJECT_BASE_SIZE = 4096;
+
+static struct {
+	const char	*str;	/* type name string */
+	int			loose; /* valid loose object type flag */
+	size_t		size;	/* size in bytes of the object structure */
+} git_objects_table[] = {
+	/* 0 = GIT_OBJ__EXT1 */
+	{ "", 0, 0},
+
+	/* 1 = GIT_OBJ_COMMIT */
+	{ "commit", 1, sizeof(struct git_commit)},
+
+	/* 2 = GIT_OBJ_TREE */
+	{ "tree", 1, sizeof(struct git_tree) },
+
+	/* 3 = GIT_OBJ_BLOB */
+	{ "blob", 1, sizeof(struct git_blob) },
+
+	/* 4 = GIT_OBJ_TAG */
+	{ "tag", 1, sizeof(struct git_tag) },
+
+	/* 5 = GIT_OBJ__EXT2 */
+	{ "", 0, 0 },
+
+	/* 6 = GIT_OBJ_OFS_DELTA */
+	{ "OFS_DELTA", 0, 0 },
+
+	/* 7 = GIT_OBJ_REF_DELTA */
+	{ "REF_DELTA", 0, 0	}
+};
+
+static int create_object(git_object **object_out, git_otype type)
+{
+	git_object *object = NULL;
+
+	assert(object_out);
+
+	*object_out = NULL;
+
+	switch (type) {
+	case GIT_OBJ_COMMIT:
+	case GIT_OBJ_TAG:
+	case GIT_OBJ_BLOB:
+	case GIT_OBJ_TREE:
+		object = git__malloc(git_object__size(type));
+		if (object == NULL)
+			return GIT_ENOMEM;
+		memset(object, 0x0, git_object__size(type));
+		break;
+
+	default:
+		return git__throw(GIT_EINVALIDTYPE, "The given type is invalid");
+	}
+
+	object->type = type;
+
+	*object_out = object;
+	return GIT_SUCCESS;
+}
+
+int git_object_lookup_prefix(
+	git_object **object_out,
+	git_repository *repo,
+	const git_oid *id,
+	unsigned int len,
+	git_otype type)
+{
+	git_object *object = NULL;
+	git_odb *odb = NULL;
+	git_odb_object *odb_obj;
+	int error = GIT_SUCCESS;
+
+	assert(repo && object_out && id);
+
+	if (len < GIT_OID_MINPREFIXLEN)
+		return git__throw(GIT_EAMBIGUOUSOIDPREFIX,
+			"Failed to lookup object. Prefix length is lower than %d.", GIT_OID_MINPREFIXLEN);
+
+	error = git_repository_odb__weakptr(&odb, repo);
+	if (error < GIT_SUCCESS)
+		return error;
+
+	if (len > GIT_OID_HEXSZ)
+		len = GIT_OID_HEXSZ;
+
+	if (len == GIT_OID_HEXSZ) {
+		/* We want to match the full id : we can first look up in the cache,
+		 * since there is no need to check for non ambiguousity
+		 */
+		object = git_cache_get(&repo->objects, id);
+		if (object != NULL) {
+			if (type != GIT_OBJ_ANY && type != object->type) {
+				git_object_free(object);
+				return git__throw(GIT_EINVALIDTYPE,
+					"Failed to lookup object. "
+					"The given type does not match the type on the ODB");
+			}
+
+			*object_out = object;
+			return GIT_SUCCESS;
+		}
+
+		/* Object was not found in the cache, let's explore the backends.
+		 * We could just use git_odb_read_unique_short_oid,
+		 * it is the same cost for packed and loose object backends,
+		 * but it may be much more costly for sqlite and hiredis.
+		 */
+		error = git_odb_read(&odb_obj, odb, id);
+	} else {
+		git_oid short_oid;
+
+		/* We copy the first len*4 bits from id and fill the remaining with 0s */
+		memcpy(short_oid.id, id->id, (len + 1) / 2);
+		if (len % 2)
+			short_oid.id[len / 2] &= 0xF0;
+		memset(short_oid.id + (len + 1) / 2, 0, (GIT_OID_HEXSZ - len) / 2);
+
+		/* If len < GIT_OID_HEXSZ (a strict short oid was given), we have
+		 * 2 options :
+		 * - We always search in the cache first. If we find that short oid is
+		 *	ambiguous, we can stop. But in all the other cases, we must then
+		 *	explore all the backends (to find an object if there was match,
+		 *	or to check that oid is not ambiguous if we have found 1 match in
+		 *	the cache)
+		 * - We never explore the cache, go right to exploring the backends
+		 * We chose the latter : we explore directly the backends.
+		 */
+		error = git_odb_read_prefix(&odb_obj, odb, &short_oid, len);
+	}
+
+	if (error < GIT_SUCCESS)
+		return git__rethrow(error, "Failed to lookup object");
+
+	if (type != GIT_OBJ_ANY && type != odb_obj->raw.type) {
+		git_odb_object_free(odb_obj);
+		return git__throw(GIT_EINVALIDTYPE, "Failed to lookup object. The given type does not match the type on the ODB");
+	}
+
+	type = odb_obj->raw.type;
+
+	if ((error = create_object(&object, type)) < GIT_SUCCESS)
+		return git__rethrow(error, "Failed to lookup object");
+
+	/* Initialize parent object */
+	git_oid_cpy(&object->cached.oid, &odb_obj->cached.oid);
+	object->repo = repo;
+
+	switch (type) {
+	case GIT_OBJ_COMMIT:
+		error = git_commit__parse((git_commit *)object, odb_obj);
+		break;
+
+	case GIT_OBJ_TREE:
+		error = git_tree__parse((git_tree *)object, odb_obj);
+		break;
+
+	case GIT_OBJ_TAG:
+		error = git_tag__parse((git_tag *)object, odb_obj);
+		break;
+
+	case GIT_OBJ_BLOB:
+		error = git_blob__parse((git_blob *)object, odb_obj);
+		break;
+
+	default:
+		break;
+	}
+
+	git_odb_object_free(odb_obj);
+
+	if (error < GIT_SUCCESS) {
+		git_object__free(object);
+		return git__rethrow(error, "Failed to lookup object");
+	}
+
+	*object_out = git_cache_try_store(&repo->objects, object);
+	return GIT_SUCCESS;
+}
+
+int git_object_lookup(git_object **object_out, git_repository *repo, const git_oid *id, git_otype type) {
+	return git_object_lookup_prefix(object_out, repo, id, GIT_OID_HEXSZ, type);
+}
+
+void git_object__free(void *_obj)
+{
+	git_object *object = (git_object *)_obj;
+
+	assert(object);
+
+	switch (object->type) {
+	case GIT_OBJ_COMMIT:
+		git_commit__free((git_commit *)object);
+		break;
+
+	case GIT_OBJ_TREE:
+		git_tree__free((git_tree *)object);
+		break;
+
+	case GIT_OBJ_TAG:
+		git_tag__free((git_tag *)object);
+		break;
+
+	case GIT_OBJ_BLOB:
+		git_blob__free((git_blob *)object);
+		break;
+
+	default:
+		git__free(object);
+		break;
+	}
+}
+
+void git_object_free(git_object *object)
+{
+	if (object == NULL)
+		return;
+
+	git_cached_obj_decref((git_cached_obj *)object, git_object__free);
+}
+
+const git_oid *git_object_id(const git_object *obj)
+{
+	assert(obj);
+	return &obj->cached.oid;
+}
+
+git_otype git_object_type(const git_object *obj)
+{
+	assert(obj);
+	return obj->type;
+}
+
+git_repository *git_object_owner(const git_object *obj)
+{
+	assert(obj);
+	return obj->repo;
+}
+
+const char *git_object_type2string(git_otype type)
+{
+	if (type < 0 || ((size_t) type) >= ARRAY_SIZE(git_objects_table))
+		return "";
+
+	return git_objects_table[type].str;
+}
+
+git_otype git_object_string2type(const char *str)
+{
+	size_t i;
+
+	if (!str || !*str)
+		return GIT_OBJ_BAD;
+
+	for (i = 0; i < ARRAY_SIZE(git_objects_table); i++)
+		if (!strcmp(str, git_objects_table[i].str))
+			return (git_otype)i;
+
+	return GIT_OBJ_BAD;
+}
+
+int git_object_typeisloose(git_otype type)
+{
+	if (type < 0 || ((size_t) type) >= ARRAY_SIZE(git_objects_table))
+		return 0;
+
+	return git_objects_table[type].loose;
+}
+
+size_t git_object__size(git_otype type)
+{
+	if (type < 0 || ((size_t) type) >= ARRAY_SIZE(git_objects_table))
+		return 0;
+
+	return git_objects_table[type].size;
+}
+

data/ext/rugged/vendor/libgit2-dist/src/odb.c

@@ -0,0 +1,672 @@
+/*
+ * Copyright (C) 2009-2011 the libgit2 contributors
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "common.h"
+#include "git2/zlib.h"
+#include "git2/object.h"
+#include "fileops.h"
+#include "hash.h"
+#include "odb.h"
+#include "delta-apply.h"
+
+#include "git2/odb_backend.h"
+
+#define GIT_ALTERNATES_FILE "info/alternates"
+
+/* TODO: is this correct? */
+#define GIT_LOOSE_PRIORITY 2
+#define GIT_PACKED_PRIORITY 1
+
+typedef struct
+{
+	git_odb_backend *backend;
+	int priority;
+	int is_alternate;
+} backend_internal;
+
+static int format_object_header(char *hdr, size_t n, size_t obj_len, git_otype obj_type)
+{
+	const char *type_str = git_object_type2string(obj_type);
+	int len = p_snprintf(hdr, n, "%s %"PRIuZ, type_str, obj_len);
+
+	if (len < 0 || ((size_t) len) >= n)
+		return git__throw(GIT_ERROR, "Cannot format object header. Length is out of bounds");
+
+	return len+1;
+}
+
+int git_odb__hash_obj(git_oid *id, git_rawobj *obj)
+{
+	git_buf_vec vec[2];
+	char header[64];
+	int hdrlen;
+
+	assert(id && obj);
+
+	if (!git_object_typeisloose(obj->type))
+		return git__throw(GIT_ERROR, "Failed to hash object. Wrong object type");
+
+	if (!obj->data && obj->len != 0)
+		return git__throw(GIT_ERROR, "Failed to hash object. No data given");
+
+	if ((hdrlen = format_object_header(header, sizeof(header), obj->len, obj->type)) < 0)
+		return git__rethrow(hdrlen, "Failed to hash object");
+
+	vec[0].data = header;
+	vec[0].len = hdrlen;
+	vec[1].data = obj->data;
+	vec[1].len = obj->len;
+
+	git_hash_vec(id, vec, 2);
+
+	return GIT_SUCCESS;
+}
+
+
+static git_odb_object *new_odb_object(const git_oid *oid, git_rawobj *source)
+{
+	git_odb_object *object = git__malloc(sizeof(git_odb_object));
+	memset(object, 0x0, sizeof(git_odb_object));
+
+	git_oid_cpy(&object->cached.oid, oid);
+	memcpy(&object->raw, source, sizeof(git_rawobj));
+
+	return object;
+}
+
+static void free_odb_object(void *o)
+{
+	git_odb_object *object = (git_odb_object *)o;
+
+	if (object != NULL) {
+		git__free(object->raw.data);
+		git__free(object);
+	}
+}
+
+const git_oid *git_odb_object_id(git_odb_object *object)
+{
+	return &object->cached.oid;
+}
+
+const void *git_odb_object_data(git_odb_object *object)
+{
+	return object->raw.data;
+}
+
+size_t git_odb_object_size(git_odb_object *object)
+{
+	return object->raw.len;
+}
+
+git_otype git_odb_object_type(git_odb_object *object)
+{
+	return object->raw.type;
+}
+
+void git_odb_object_free(git_odb_object *object)
+{
+	git_cached_obj_decref((git_cached_obj *)object, &free_odb_object);
+}
+
+int git_odb_hashfile(git_oid *out, const char *path, git_otype type)
+{
+	int fd, hdr_len;
+	char hdr[64], buffer[2048];
+	git_off_t size;
+	git_hash_ctx *ctx;
+
+	if ((fd = p_open(path, O_RDONLY)) < 0)
+		return git__throw(GIT_ENOTFOUND, "Could not open '%s'", path);
+
+	if ((size = git_futils_filesize(fd)) < 0 || !git__is_sizet(size)) {
+		p_close(fd);
+		return git__throw(GIT_EOSERR, "'%s' appears to be corrupted", path);
+	}
+
+	hdr_len = format_object_header(hdr, sizeof(hdr), (size_t)size, type);
+	if (hdr_len < 0)
+		return git__throw(GIT_ERROR, "Failed to format blob header. Length is out of bounds");
+
+	ctx = git_hash_new_ctx();
+
+	git_hash_update(ctx, hdr, hdr_len);
+
+	while (size > 0) {
+		ssize_t read_len;
+
+		read_len = read(fd, buffer, sizeof(buffer));
+
+		if (read_len < 0) {
+			p_close(fd);
+			git_hash_free_ctx(ctx);
+			return git__throw(GIT_EOSERR, "Can't read full file '%s'", path);
+		}
+
+		git_hash_update(ctx, buffer, read_len);
+		size -= read_len;
+	}
+
+	p_close(fd);
+
+	git_hash_final(out, ctx);
+	git_hash_free_ctx(ctx);
+
+	return GIT_SUCCESS;
+}
+
+int git_odb_hash(git_oid *id, const void *data, size_t len, git_otype type)
+{
+	git_rawobj raw;
+
+	assert(id);
+
+	raw.data = (void *)data;
+	raw.len = len;
+	raw.type = type;
+
+	return git_odb__hash_obj(id, &raw);
+}
+
+/**
+ * FAKE WSTREAM
+ */
+
+typedef struct {
+	git_odb_stream stream;
+	char *buffer;
+	size_t size, written;
+	git_otype type;
+} fake_wstream;
+
+static int fake_wstream__fwrite(git_oid *oid, git_odb_stream *_stream)
+{
+	fake_wstream *stream = (fake_wstream *)_stream;
+	return _stream->backend->write(oid, _stream->backend, stream->buffer, stream->size, stream->type);
+}
+
+static int fake_wstream__write(git_odb_stream *_stream, const char *data, size_t len)
+{
+	fake_wstream *stream = (fake_wstream *)_stream;
+
+	if (stream->written + len > stream->size)
+		return GIT_ENOMEM;
+
+	memcpy(stream->buffer + stream->written, data, len);
+	stream->written += len;
+	return GIT_SUCCESS;
+}
+
+static void fake_wstream__free(git_odb_stream *_stream)
+{
+	fake_wstream *stream = (fake_wstream *)_stream;
+
+	git__free(stream->buffer);
+	git__free(stream);
+}
+
+static int init_fake_wstream(git_odb_stream **stream_p, git_odb_backend *backend, size_t size, git_otype type)
+{
+	fake_wstream *stream;
+
+	stream = git__calloc(1, sizeof(fake_wstream));
+	if (stream == NULL)
+		return GIT_ENOMEM;
+
+	stream->size = size;
+	stream->type = type;
+	stream->buffer = git__malloc(size);
+	if (stream->buffer == NULL) {
+		git__free(stream);
+		return GIT_ENOMEM;
+	}
+
+	stream->stream.backend = backend;
+	stream->stream.read = NULL; /* read only */
+	stream->stream.write = &fake_wstream__write;
+	stream->stream.finalize_write = &fake_wstream__fwrite;
+	stream->stream.free = &fake_wstream__free;
+	stream->stream.mode = GIT_STREAM_WRONLY;
+
+	*stream_p = (git_odb_stream *)stream;
+	return GIT_SUCCESS;
+}
+
+/***********************************************************
+ *
+ * OBJECT DATABASE PUBLIC API
+ *
+ * Public calls for the ODB functionality
+ *
+ ***********************************************************/
+
+static int backend_sort_cmp(const void *a, const void *b)
+{
+	const backend_internal *backend_a = (const backend_internal *)(a);
+	const backend_internal *backend_b = (const backend_internal *)(b);
+
+	if (backend_a->is_alternate == backend_b->is_alternate)
+		return (backend_b->priority - backend_a->priority);
+
+	return backend_a->is_alternate ? 1 : -1;
+}
+
+int git_odb_new(git_odb **out)
+{
+	int error;
+
+	git_odb *db = git__calloc(1, sizeof(*db));
+	if (!db)
+		return GIT_ENOMEM;
+
+	error = git_cache_init(&db->cache, GIT_DEFAULT_CACHE_SIZE, &free_odb_object);
+	if (error < GIT_SUCCESS) {
+		git__free(db);
+		return git__rethrow(error, "Failed to create object database");
+	}
+
+	if ((error = git_vector_init(&db->backends, 4, backend_sort_cmp)) < GIT_SUCCESS) {
+		git__free(db);
+		return git__rethrow(error, "Failed to create object database");
+	}
+
+	*out = db;
+	GIT_REFCOUNT_INC(db);
+	return GIT_SUCCESS;
+}
+
+static int add_backend_internal(git_odb *odb, git_odb_backend *backend, int priority, int is_alternate)
+{
+	backend_internal *internal;
+
+	assert(odb && backend);
+
+	if (backend->odb != NULL && backend->odb != odb)
+		return git__throw(GIT_EBUSY, "The backend is already owned by another ODB");
+
+	internal = git__malloc(sizeof(backend_internal));
+	if (internal == NULL)
+		return GIT_ENOMEM;
+
+	internal->backend = backend;
+	internal->priority = priority;
+	internal->is_alternate = is_alternate;
+
+	if (git_vector_insert(&odb->backends, internal) < 0) {
+		git__free(internal);
+		return GIT_ENOMEM;
+	}
+
+	git_vector_sort(&odb->backends);
+	internal->backend->odb = odb;
+	return GIT_SUCCESS;
+}
+
+int git_odb_add_backend(git_odb *odb, git_odb_backend *backend, int priority)
+{
+	return add_backend_internal(odb, backend, priority, 0);
+}
+
+int git_odb_add_alternate(git_odb *odb, git_odb_backend *backend, int priority)
+{
+	return add_backend_internal(odb, backend, priority, 1);
+}
+
+static int add_default_backends(git_odb *db, const char *objects_dir, int as_alternates)
+{
+	git_odb_backend *loose, *packed;
+	int error;
+
+	/* add the loose object backend */
+	error = git_odb_backend_loose(&loose, objects_dir, -1, 0);
+	if (error < GIT_SUCCESS)
+		return error;
+
+	error = add_backend_internal(db, loose, GIT_LOOSE_PRIORITY, as_alternates);
+	if (error < GIT_SUCCESS)
+		return git__rethrow(error, "Failed to add backend");
+
+	/* add the packed file backend */
+	error = git_odb_backend_pack(&packed, objects_dir);
+	if (error < GIT_SUCCESS)
+		return error;
+
+	error = add_backend_internal(db, packed, GIT_PACKED_PRIORITY, as_alternates);
+	if (error < GIT_SUCCESS)
+		return git__rethrow(error, "Failed to add backend");
+
+	return GIT_SUCCESS;
+}
+
+static int load_alternates(git_odb *odb, const char *objects_dir)
+{
+	char alternates_path[GIT_PATH_MAX];
+	char *buffer, *alternate;
+
+	git_fbuffer alternates_buf = GIT_FBUFFER_INIT;
+	int error;
+
+	git_path_join(alternates_path, objects_dir, GIT_ALTERNATES_FILE);
+
+	if (git_futils_exists(alternates_path) < GIT_SUCCESS)
+		return GIT_SUCCESS;
+
+	if (git_futils_readbuffer(&alternates_buf, alternates_path) < GIT_SUCCESS)
+		return git__throw(GIT_EOSERR, "Failed to add backend. Can't read alternates");
+
+	buffer = (char *)alternates_buf.data;
+	error = GIT_SUCCESS;
+
+	/* add each alternate as a new backend; one alternate per line */
+	while ((alternate = git__strtok(&buffer, "\r\n")) != NULL) {
+		char full_path[GIT_PATH_MAX];
+
+		if (*alternate == '\0' || *alternate == '#')
+			continue;
+
+		/* relative path: build based on the current `objects` folder */
+		if (*alternate == '.') {
+			git_path_join(full_path, objects_dir, alternate);
+			alternate = full_path;
+		}
+
+		if ((error = add_default_backends(odb, alternate, 1)) < GIT_SUCCESS)
+			break;
+	}
+
+	git_futils_freebuffer(&alternates_buf);
+	if (error < GIT_SUCCESS)
+		return git__rethrow(error, "Failed to load alternates");
+	return error;
+}
+
+int git_odb_open(git_odb **out, const char *objects_dir)
+{
+	git_odb *db;
+	int error;
+
+	assert(out && objects_dir);
+
+	*out = NULL;
+
+	if ((error = git_odb_new(&db)) < 0)
+		return git__rethrow(error, "Failed to open ODB");
+
+	if ((error = add_default_backends(db, objects_dir, 0)) < GIT_SUCCESS)
+		goto cleanup;
+
+	if ((error = load_alternates(db, objects_dir)) < GIT_SUCCESS)
+		goto cleanup;
+
+	*out = db;
+	return GIT_SUCCESS;
+
+cleanup:
+	git_odb_free(db);
+	return error; /* error already set - pass through */
+}
+
+static void odb_free(git_odb *db)
+{
+	unsigned int i;
+
+	for (i = 0; i < db->backends.length; ++i) {
+		backend_internal *internal = git_vector_get(&db->backends, i);
+		git_odb_backend *backend = internal->backend;
+
+		if (backend->free) backend->free(backend);
+		else git__free(backend);
+
+		git__free(internal);
+	}
+
+	git_vector_free(&db->backends);
+	git_cache_free(&db->cache);
+	git__free(db);
+}
+
+void git_odb_free(git_odb *db)
+{
+	if (db == NULL)
+		return;
+
+	GIT_REFCOUNT_DEC(db, odb_free);
+}
+
+int git_odb_exists(git_odb *db, const git_oid *id)
+{
+	git_odb_object *object;
+	unsigned int i;
+	int found = 0;
+
+	assert(db && id);
+
+	if ((object = git_cache_get(&db->cache, id)) != NULL) {
+		git_odb_object_free(object);
+		return 1;
+	}
+
+	for (i = 0; i < db->backends.length && !found; ++i) {
+		backend_internal *internal = git_vector_get(&db->backends, i);
+		git_odb_backend *b = internal->backend;
+
+		if (b->exists != NULL)
+			found = b->exists(b, id);
+	}
+
+	return found;
+}
+
+int git_odb_read_header(size_t *len_p, git_otype *type_p, git_odb *db, const git_oid *id)
+{
+	unsigned int i;
+	int error = GIT_ENOTFOUND;
+	git_odb_object *object;
+
+	assert(db && id);
+
+	if ((object = git_cache_get(&db->cache, id)) != NULL) {
+		*len_p = object->raw.len;
+		*type_p = object->raw.type;
+		git_odb_object_free(object);
+		return GIT_SUCCESS;
+	}
+
+	for (i = 0; i < db->backends.length && error < 0; ++i) {
+		backend_internal *internal = git_vector_get(&db->backends, i);
+		git_odb_backend *b = internal->backend;
+
+		if (b->read_header != NULL)
+			error = b->read_header(len_p, type_p, b, id);
+	}
+
+	if (error == GIT_EPASSTHROUGH)
+		return GIT_SUCCESS;
+
+	/*
+	 * no backend could read only the header.
+	 * try reading the whole object and freeing the contents
+	 */
+	if (error < 0) {
+		if ((error = git_odb_read(&object, db, id)) < GIT_SUCCESS)
+			return error; /* error already set - pass through */
+
+		*len_p = object->raw.len;
+		*type_p = object->raw.type;
+		git_odb_object_free(object);
+	}
+
+	return GIT_SUCCESS;
+}
+
+int git_odb_read(git_odb_object **out, git_odb *db, const git_oid *id)
+{
+	unsigned int i;
+	int error = GIT_ENOTFOUND;
+	git_rawobj raw;
+
+	assert(out && db && id);
+
+	*out = git_cache_get(&db->cache, id);
+	if (*out != NULL)
+		return GIT_SUCCESS;
+
+	for (i = 0; i < db->backends.length && error < 0; ++i) {
+		backend_internal *internal = git_vector_get(&db->backends, i);
+		git_odb_backend *b = internal->backend;
+
+		if (b->read != NULL)
+			error = b->read(&raw.data, &raw.len, &raw.type, b, id);
+	}
+
+	if (error == GIT_EPASSTHROUGH || error == GIT_SUCCESS) {
+		*out = git_cache_try_store(&db->cache, new_odb_object(id, &raw));
+		return GIT_SUCCESS;
+	}
+
+	return git__rethrow(error, "Failed to read object");
+}
+
+int git_odb_read_prefix(git_odb_object **out, git_odb *db, const git_oid *short_id, unsigned int len)
+{
+	unsigned int i;
+	int error = GIT_ENOTFOUND;
+	git_oid full_oid;
+	git_rawobj raw;
+	int found = 0;
+
+	assert(out && db);
+
+	if (len < GIT_OID_MINPREFIXLEN)
+		return git__throw(GIT_EAMBIGUOUSOIDPREFIX, "Failed to lookup object. Prefix length is lower than %d.", GIT_OID_MINPREFIXLEN);
+
+	if (len > GIT_OID_HEXSZ)
+		len = GIT_OID_HEXSZ;
+
+	if (len == GIT_OID_HEXSZ) {
+		*out = git_cache_get(&db->cache, short_id);
+		if (*out != NULL)
+			return GIT_SUCCESS;
+	}
+
+	for (i = 0; i < db->backends.length && found < 2; ++i) {
+		backend_internal *internal = git_vector_get(&db->backends, i);
+		git_odb_backend *b = internal->backend;
+
+		if (b->read != NULL) {
+			error = b->read_prefix(&full_oid, &raw.data, &raw.len, &raw.type, b, short_id, len);
+			switch (error) {
+			case GIT_SUCCESS:
+				found++;
+				break;
+			case GIT_ENOTFOUND:
+			case GIT_EPASSTHROUGH:
+				break;
+			case GIT_EAMBIGUOUSOIDPREFIX:
+				return git__rethrow(error, "Failed to read object. Ambiguous sha1 prefix");
+			default:
+				return git__rethrow(error, "Failed to read object");
+			}
+		}
+	}
+
+	if (found == 1) {
+		*out = git_cache_try_store(&db->cache, new_odb_object(&full_oid, &raw));
+	} else if (found > 1) {
+		return git__throw(GIT_EAMBIGUOUSOIDPREFIX, "Failed to read object. Ambiguous sha1 prefix");
+	} else {
+		return git__throw(GIT_ENOTFOUND, "Failed to read object. Object not found");
+	}
+
+	return GIT_SUCCESS;
+}
+
+int git_odb_write(git_oid *oid, git_odb *db, const void *data, size_t len, git_otype type)
+{
+	unsigned int i;
+	int error = GIT_ERROR;
+	git_odb_stream *stream;
+
+	assert(oid && db);
+
+	for (i = 0; i < db->backends.length && error < 0; ++i) {
+		backend_internal *internal = git_vector_get(&db->backends, i);
+		git_odb_backend *b = internal->backend;
+
+		/* we don't write in alternates! */
+		if (internal->is_alternate)
+			continue;
+
+		if (b->write != NULL)
+			error = b->write(oid, b, data, len, type);
+	}
+
+	if (error == GIT_EPASSTHROUGH || error == GIT_SUCCESS)
+		return GIT_SUCCESS;
+
+	/* if no backends were able to write the object directly, we try a streaming
+	 * write to the backends; just write the whole object into the stream in one
+	 * push */
+
+	if ((error = git_odb_open_wstream(&stream, db, len, type)) == GIT_SUCCESS) {
+		stream->write(stream, data, len);
+		error = stream->finalize_write(oid, stream);
+		stream->free(stream);
+		return GIT_SUCCESS;
+	}
+
+	return git__rethrow(error, "Failed to write object");
+}
+
+int git_odb_open_wstream(git_odb_stream **stream, git_odb *db, size_t size, git_otype type)
+{
+	unsigned int i;
+	int error = GIT_ERROR;
+
+	assert(stream && db);
+
+	for (i = 0; i < db->backends.length && error < 0; ++i) {
+		backend_internal *internal = git_vector_get(&db->backends, i);
+		git_odb_backend *b = internal->backend;
+
+		/* we don't write in alternates! */
+		if (internal->is_alternate)
+			continue;
+
+		if (b->writestream != NULL)
+			error = b->writestream(stream, b, size, type);
+		else if (b->write != NULL)
+			error = init_fake_wstream(stream, b, size, type);
+	}
+
+	if (error == GIT_EPASSTHROUGH || error == GIT_SUCCESS)
+		return GIT_SUCCESS;
+
+	return git__rethrow(error, "Failed to open write stream");
+}
+
+int git_odb_open_rstream(git_odb_stream **stream, git_odb *db, const git_oid *oid)
+{
+	unsigned int i;
+	int error = GIT_ERROR;
+
+	assert(stream && db);
+
+	for (i = 0; i < db->backends.length && error < 0; ++i) {
+		backend_internal *internal = git_vector_get(&db->backends, i);
+		git_odb_backend *b = internal->backend;
+
+		if (b->readstream != NULL)
+			error = b->readstream(stream, b, oid);
+	}
+
+	if (error == GIT_EPASSTHROUGH || error == GIT_SUCCESS)
+		return GIT_SUCCESS;
+
+	return git__rethrow(error, "Failed to open read stream");
+}
+