rugged 0.1.2 → 0.16.0b1

data/ext/rugged/vendor/libgit2-dist/src/delta-apply.c

@@ -0,0 +1,115 @@
+/*
+ * 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/odb.h"
+#include "delta-apply.h"
+
+/*
+ * This file was heavily cribbed from BinaryDelta.java in JGit, which
+ * itself was heavily cribbed from <code>patch-delta.c</code> in the
+ * GIT project.	The original delta patching code was written by
+ * Nicolas Pitre <nico@cam.org>.
+ */
+
+static int hdr_sz(
+	size_t *size,
+	const unsigned char **delta,
+	const unsigned char *end)
+{
+	const unsigned char *d = *delta;
+	size_t r = 0;
+	unsigned int c, shift = 0;
+
+	do {
+		if (d == end)
+			return -1;
+		c = *d++;
+		r |= (c & 0x7f) << shift;
+		shift += 7;
+	} while (c & 0x80);
+	*delta = d;
+	*size = r;
+	return 0;
+}
+
+int git__delta_apply(
+	git_rawobj *out,
+	const unsigned char *base,
+	size_t base_len,
+	const unsigned char *delta,
+	size_t delta_len)
+{
+	const unsigned char *delta_end = delta + delta_len;
+	size_t base_sz, res_sz;
+	unsigned char *res_dp;
+
+	/* Check that the base size matches the data we were given;
+	 * if not we would underflow while accessing data from the
+	 * base object, resulting in data corruption or segfault.
+	 */
+	if ((hdr_sz(&base_sz, &delta, delta_end) < 0) || (base_sz != base_len))
+		return git__throw(GIT_ERROR, "Failed to apply delta. Base size does not match given data");
+
+	if (hdr_sz(&res_sz, &delta, delta_end) < 0)
+		return git__throw(GIT_ERROR, "Failed to apply delta. Base size does not match given data");
+
+	if ((res_dp = git__malloc(res_sz + 1)) == NULL)
+		return GIT_ENOMEM;
+	res_dp[res_sz] = '\0';
+	out->data = res_dp;
+	out->len = res_sz;
+
+	while (delta < delta_end) {
+		unsigned char cmd = *delta++;
+		if (cmd & 0x80) {
+			/* cmd is a copy instruction; copy from the base.
+			 */
+			size_t off = 0, len = 0;
+
+			if (cmd & 0x01) off = *delta++;
+			if (cmd & 0x02) off |= *delta++ << 8;
+			if (cmd & 0x04) off |= *delta++ << 16;
+			if (cmd & 0x08) off |= *delta++ << 24;
+
+			if (cmd & 0x10) len = *delta++;
+			if (cmd & 0x20) len |= *delta++ << 8;
+			if (cmd & 0x40) len |= *delta++ << 16;
+			if (!len)		len = 0x10000;
+
+			if (base_len < off + len || res_sz < len)
+				goto fail;
+			memcpy(res_dp, base + off, len);
+			res_dp += len;
+			res_sz -= len;
+
+		} else if (cmd) {
+			/* cmd is a literal insert instruction; copy from
+			 * the delta stream itself.
+			 */
+			if (delta_end - delta < cmd || res_sz < cmd)
+				goto fail;
+			memcpy(res_dp, delta, cmd);
+			delta += cmd;
+			res_dp += cmd;
+			res_sz -= cmd;
+
+		} else {
+			/* cmd == 0 is reserved for future encodings.
+			 */
+			goto fail;
+		}
+	}
+
+	if (delta != delta_end || res_sz)
+		goto fail;
+	return GIT_SUCCESS;
+
+fail:
+	git__free(out->data);
+	out->data = NULL;
+	return git__throw(GIT_ERROR, "Failed to apply delta");
+}

data/ext/rugged/vendor/libgit2-dist/src/delta-apply.h

@@ -0,0 +1,33 @@
+/*
+ * 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_delta_apply_h__
+#define INCLUDE_delta_apply_h__
+
+#include "odb.h"
+
+/**
+ * Apply a git binary delta to recover the original content.
+ *
+ * @param out the output buffer to receive the original data.
+ *		Only out->data and out->len are populated, as this is
+ *		the only information available in the delta.
+ * @param base the base to copy from during copy instructions.
+ * @param base_len number of bytes available at base.
+ * @param delta the delta to execute copy/insert instructions from.
+ * @param delta_len total number of bytes in the delta.
+ * @return
+ * - GIT_SUCCESS on a successful delta unpack.
+ * - GIT_ERROR if the delta is corrupt or doesn't match the base.
+ */
+extern int git__delta_apply(
+	git_rawobj *out,
+	const unsigned char *base,
+	size_t base_len,
+	const unsigned char *delta,
+	size_t delta_len);
+
+#endif

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

@@ -0,0 +1,47 @@
+/*
+ * 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_dir_h__
+#define INCLUDE_dir_h__
+
+#include "common.h"
+
+#ifndef GIT_WIN32
+# include <dirent.h>
+#endif
+
+#ifdef GIT_WIN32
+
+struct git__dirent {
+	int d_ino;
+	char d_name[261];
+};
+
+typedef struct {
+	HANDLE h;
+	WIN32_FIND_DATAW f;
+	struct git__dirent entry;
+	char *dir;
+	int first;
+} git__DIR;
+
+extern git__DIR *git__opendir(const char *);
+extern struct git__dirent *git__readdir(git__DIR *);
+extern void git__rewinddir(git__DIR *);
+extern int git__closedir(git__DIR *);
+
+# ifndef GIT__WIN32_NO_WRAP_DIR
+#	define dirent git__dirent
+#	define DIR git__DIR
+#	define opendir	git__opendir
+#	define readdir	git__readdir
+#	define rewinddir git__rewinddir
+#	define closedir git__closedir
+# endif
+
+#endif
+
+#endif /* INCLUDE_dir_h__ */

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

@@ -0,0 +1,104 @@
+/*
+ * 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 "global.h"
+#include <stdarg.h>
+
+static struct {
+	int num;
+	const char *str;
+} error_codes[] = {
+	{GIT_ERROR, "Unspecified error"},
+	{GIT_ENOTOID, "Input was not a properly formatted Git object id."},
+	{GIT_ENOTFOUND, "Object does not exist in the scope searched."},
+	{GIT_ENOMEM, "Not enough space available."},
+	{GIT_EOSERR, "Consult the OS error information."},
+	{GIT_EOBJTYPE, "The specified object is of invalid type"},
+	{GIT_EOBJCORRUPTED, "The specified object has its data corrupted"},
+	{GIT_ENOTAREPO, "The specified repository is invalid"},
+	{GIT_EINVALIDTYPE, "The object or config variable type is invalid or doesn't match"},
+	{GIT_EMISSINGOBJDATA, "The object cannot be written that because it's missing internal data"},
+	{GIT_EPACKCORRUPTED, "The packfile for the ODB is corrupted"},
+	{GIT_EFLOCKFAIL, "Failed to adquire or release a file lock"},
+	{GIT_EZLIB, "The Z library failed to inflate/deflate an object's data"},
+	{GIT_EBUSY, "The queried object is currently busy"},
+	{GIT_EINVALIDPATH, "The path is invalid"},
+	{GIT_EBAREINDEX, "The index file is not backed up by an existing repository"},
+	{GIT_EINVALIDREFNAME, "The name of the reference is not valid"},
+	{GIT_EREFCORRUPTED, "The specified reference has its data corrupted"},
+	{GIT_ETOONESTEDSYMREF, "The specified symbolic reference is too deeply nested"},
+	{GIT_EPACKEDREFSCORRUPTED, "The pack-refs file is either corrupted of its format is not currently supported"},
+	{GIT_EINVALIDPATH, "The path is invalid" },
+	{GIT_EREVWALKOVER, "The revision walker is empty; there are no more commits left to iterate"},
+	{GIT_EINVALIDREFSTATE, "The state of the reference is not valid"},
+	{GIT_ENOTIMPLEMENTED, "This feature has not been implemented yet"},
+	{GIT_EEXISTS, "A reference with this name already exists"},
+	{GIT_EOVERFLOW, "The given integer literal is too large to be parsed"},
+	{GIT_ENOTNUM, "The given literal is not a valid number"},
+	{GIT_EAMBIGUOUSOIDPREFIX, "The given oid prefix is ambiguous"},
+};
+
+const char *git_strerror(int num)
+{
+	size_t i;
+
+	if (num == GIT_EOSERR)
+		return strerror(errno);
+	for (i = 0; i < ARRAY_SIZE(error_codes); i++)
+		if (num == error_codes[i].num)
+			return error_codes[i].str;
+
+	return "Unknown error";
+}
+
+#define ERROR_MAX_LEN 1024
+
+void git___rethrow(const char *msg, ...)
+{
+	char new_error[ERROR_MAX_LEN];
+	char *last_error;
+	char *old_error = NULL;
+
+	va_list va;
+
+	last_error = GIT_GLOBAL->error.last;
+
+	va_start(va, msg);
+	vsnprintf(new_error, ERROR_MAX_LEN, msg, va);
+	va_end(va);
+
+	old_error = git__strdup(last_error);
+
+	snprintf(last_error, ERROR_MAX_LEN, "%s \n	- %s", new_error, old_error);
+
+	git__free(old_error);
+}
+
+void git___throw(const char *msg, ...)
+{
+	va_list va;
+
+	va_start(va, msg);
+	vsnprintf(GIT_GLOBAL->error.last, ERROR_MAX_LEN, msg, va);
+	va_end(va);
+}
+
+const char *git_lasterror(void)
+{
+	char *last_error = GIT_GLOBAL->error.last;
+
+	if (!last_error[0])
+		return NULL;
+
+	return last_error;
+}
+
+void git_clearerror(void)
+{
+	char *last_error = GIT_GLOBAL->error.last;
+	last_error[0] = '\0';
+}

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

@@ -0,0 +1,172 @@
+/*
+ * 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 "git2/remote.h"
+#include "git2/oid.h"
+#include "git2/refs.h"
+#include "git2/revwalk.h"
+
+#include "common.h"
+#include "transport.h"
+#include "remote.h"
+#include "refspec.h"
+#include "pack.h"
+#include "fetch.h"
+#include "netops.h"
+
+struct filter_payload {
+	git_remote *remote;
+	const git_refspec *spec;
+	git_odb *odb;
+	int found_head;
+};
+
+static int filter_ref__cb(git_remote_head *head, void *payload)
+{
+	struct filter_payload *p = payload;
+	int error;
+
+	if (!p->found_head && strcmp(head->name, GIT_HEAD_FILE) == 0) {
+		p->found_head = 1;
+	} else {
+		/* If it doesn't match the refpec, we don't want it */
+		error = git_refspec_src_match(p->spec, head->name);
+
+		if (error == GIT_ENOMATCH)
+			return GIT_SUCCESS;
+
+		if (error < GIT_SUCCESS)
+			return git__rethrow(error, "Error matching remote ref name");
+	}
+
+	/* If we have the object, mark it so we don't ask for it */
+	if (git_odb_exists(p->odb, &head->oid))
+		head->local = 1;
+	else
+		p->remote->need_pack = 1;
+
+	return git_vector_insert(&p->remote->refs, head);
+}
+
+static int filter_wants(git_remote *remote)
+{
+	int error;
+	struct filter_payload p;
+
+	git_vector_clear(&remote->refs);
+
+	/*
+	 * The fetch refspec can be NULL, and what this means is that the
+	 * user didn't specify one. This is fine, as it means that we're
+	 * not interested in any particular branch but just the remote's
+	 * HEAD, which will be stored in FETCH_HEAD after the fetch.
+	 */
+	p.spec = git_remote_fetchspec(remote);
+	p.found_head = 0;
+	p.remote = remote;
+
+	error = git_repository_odb__weakptr(&p.odb, remote->repo);
+	if (error < GIT_SUCCESS)
+		return error;
+
+	return remote->transport->ls(remote->transport, &filter_ref__cb, &p);
+}
+
+/*
+ * In this first version, we push all our refs in and start sending
+ * them out. When we get an ACK we hide that commit and continue
+ * traversing until we're done
+ */
+int git_fetch_negotiate(git_remote *remote)
+{
+	int error;
+	git_transport *t = remote->transport;
+
+	error = filter_wants(remote);
+	if (error < GIT_SUCCESS)
+		return git__rethrow(error, "Failed to filter the reference list for wants");
+
+	/* Don't try to negotiate when we don't want anything */
+	if (remote->refs.length == 0)
+		return GIT_SUCCESS;
+
+	if (!remote->need_pack)
+		return GIT_SUCCESS;
+
+	/*
+	 * Now we have everything set up so we can start tell the server
+	 * what we want and what we have.
+	 */
+	return t->negotiate_fetch(t, remote->repo, &remote->refs);
+}
+
+int git_fetch_download_pack(char **out, git_remote *remote)
+{
+	if(!remote->need_pack) {
+		*out = NULL;
+		return GIT_SUCCESS;
+	}
+
+	return remote->transport->download_pack(out, remote->transport, remote->repo);
+}
+
+/* Receiving data from a socket and storing it is pretty much the same for git and HTTP */
+int git_fetch__download_pack(char **out, const char *buffered, size_t buffered_size,
+                             GIT_SOCKET fd, git_repository *repo)
+{
+	git_filebuf file = GIT_FILEBUF_INIT;
+	int error;
+	char buff[1024], path[GIT_PATH_MAX];
+	static const char suff[] = "/objects/pack/pack-received";
+	gitno_buffer buf;
+
+
+	git_path_join(path, repo->path_repository, suff);
+
+	gitno_buffer_setup(&buf, buff, sizeof(buff), fd);
+
+	if (memcmp(buffered, "PACK", strlen("PACK"))) {
+		return git__throw(GIT_ERROR, "The pack doesn't start with the signature");
+	}
+
+	error = git_filebuf_open(&file, path, GIT_FILEBUF_TEMPORARY);
+	if (error < GIT_SUCCESS)
+		goto cleanup;
+
+	/* Part of the packfile has been received, don't loose it */
+	error = git_filebuf_write(&file, buffered, buffered_size);
+	if (error < GIT_SUCCESS)
+		goto cleanup;
+
+	while (1) {
+		error = git_filebuf_write(&file, buf.data, buf.offset);
+		if (error < GIT_SUCCESS)
+			goto cleanup;
+
+		gitno_consume_n(&buf, buf.offset);
+		error = gitno_recv(&buf);
+		if (error < GIT_SUCCESS)
+			goto cleanup;
+		if (error == 0) /* Orderly shutdown */
+			break;
+	}
+
+	*out = git__strdup(file.path_lock);
+	if (*out == NULL) {
+		error = GIT_ENOMEM;
+		goto cleanup;
+	}
+
+	/* A bit dodgy, but we need to keep the pack at the temporary path */
+	error = git_filebuf_commit_at(&file, file.path_lock, GIT_PACK_FILE_MODE);
+cleanup:
+	if (error < GIT_SUCCESS)
+		git_filebuf_cleanup(&file);
+
+	return error;
+
+}