rugged 0.27.10 → 0.27.10.1

data/vendor/libgit2/src/netops.h

@@ -11,7 +11,6 @@
 
 #include "posix.h"
 #include "stream.h"
-#include "net.h"
 
 #ifdef GIT_OPENSSL
 # include <openssl/ssl.h>
@@ -65,15 +64,36 @@ 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);
 
+typedef struct gitno_connection_data {
+	char *host;
+	char *port;
+	char *path;
+	char *user;
+	char *pass;
+	bool use_ssl;
+} gitno_connection_data;
+
 /*
  * This replaces all the pointers in `data` with freshly-allocated strings,
  * that the caller is responsible for freeing.
  * `gitno_connection_data_free_ptrs` is good for this.
  */
 
-int gitno_connection_data_handle_redirect(
-		git_net_url *data,
+int gitno_connection_data_from_url(
+		gitno_connection_data *data,
 		const char *url,
 		const char *service_suffix);
 
+/* This frees all the pointers IN the struct, but not the struct itself. */
+void gitno_connection_data_free_ptrs(gitno_connection_data *data);
+
+int gitno_extract_url_parts(
+		char **host,
+		char **port,
+		char **path,
+		char **username,
+		char **password,
+		const char *url,
+		const char *default_port);
+
 #endif

data/vendor/libgit2/src/notes.c

@@ -12,11 +12,10 @@
 #include "config.h"
 #include "iterator.h"
 #include "signature.h"
-#include "blob.h"
 
 static int note_error_notfound(void)
 {
-	git_error_set(GIT_ERROR_INVALID, "note could not be found");
+	giterr_set(GITERR_INVALID, "note could not be found");
 	return GIT_ENOTFOUND;
 }
 
@@ -227,7 +226,7 @@ static int remove_note_in_tree_enotfound_cb(
 	GIT_UNUSED(note_oid);
 	GIT_UNUSED(fanout);
 
-	git_error_set(GIT_ERROR_REPOSITORY, "object '%s' has no note", annotated_object_sha);
+	giterr_set(GITERR_REPOSITORY, "object '%s' has no note", annotated_object_sha);
 	return current_error;
 }
 
@@ -245,7 +244,7 @@ static int insert_note_in_tree_eexists_cb(git_tree **out,
 	GIT_UNUSED(note_oid);
 	GIT_UNUSED(fanout);
 
-	git_error_set(GIT_ERROR_REPOSITORY, "note for '%s' exists already", annotated_object_sha);
+	giterr_set(GITERR_REPOSITORY, "note for '%s' exists already", annotated_object_sha);
 	return current_error;
 }
 
@@ -286,9 +285,9 @@ static int note_write(
 	git_oid oid;
 	git_tree *tree = NULL;
 
-	/* TODO: should we apply filters? */
+	// TODO: should we apply filters?
 	/* create note object */
-	if ((error = git_blob_create_from_buffer(&oid, repo, note, strlen(note))) < 0)
+	if ((error = git_blob_create_frombuffer(&oid, repo, note, strlen(note))) < 0)
 		goto cleanup;
 
 	if ((error = manipulate_note_in_tree_r(
@@ -320,10 +319,9 @@ static int note_new(
 	git_blob *blob)
 {
 	git_note *note = NULL;
-	git_object_size_t blobsize;
 
 	note = git__malloc(sizeof(git_note));
-	GIT_ERROR_CHECK_ALLOC(note);
+	GITERR_CHECK_ALLOC(note);
 
 	git_oid_cpy(&note->id, note_oid);
 
@@ -331,11 +329,8 @@ static int note_new(
 		git_signature_dup(&note->committer, git_commit_committer(commit)) < 0)
 		return -1;
 
-	blobsize = git_blob_rawsize(blob);
-	GIT_ERROR_CHECK_BLOBSIZE(blobsize);
-
-	note->message = git__strndup(git_blob_rawcontent(blob), (size_t)blobsize);
-	GIT_ERROR_CHECK_ALLOC(note->message);
+	note->message = git__strndup(git_blob_rawcontent(blob), git_blob_rawsize(blob));
+	GITERR_CHECK_ALLOC(note->message);
 
 	*out = note;
 	return 0;
@@ -422,7 +417,7 @@ static int normalize_namespace(char **out, git_repository *repo, const char *not
 {
 	if (notes_ref) {
 		*out = git__strdup(notes_ref);
-		GIT_ERROR_CHECK_ALLOC(*out);
+		GITERR_CHECK_ALLOC(*out);
 		return 0;
 	}
 
@@ -715,7 +710,7 @@ static int process_entry_path(
 	error = git_oid_fromstr(annotated_object_id, buf.ptr);
 
 cleanup:
-	git_buf_dispose(&buf);
+	git_buf_free(&buf);
 	return error;
 }
 
@@ -734,7 +729,7 @@ int git_note_foreach(
 
 	while (!(error = git_note_next(&note_id, &annotated_id, iter))) {
 		if ((error = note_cb(&note_id, &annotated_id, payload)) != 0) {
-			git_error_set_after_callback(error);
+			giterr_set_after_callback(error);
 			break;
 		}
 	}

data/vendor/libgit2/src/object.c

@@ -12,7 +12,6 @@
 #include "repository.h"
 
 #include "commit.h"
-#include "hash.h"
 #include "tree.h"
 #include "blob.h"
 #include "oid.h"
@@ -20,94 +19,43 @@
 
 bool git_object__strict_input_validation = true;
 
-extern int git_odb_hash(git_oid *out, const void *data, size_t len, git_object_t type);
-size_t git_object__size(git_object_t type);
-
 typedef struct {
 	const char	*str;	/* type name string */
 	size_t		size;	/* size in bytes of the object structure */
 
 	int  (*parse)(void *self, git_odb_object *obj);
-	int  (*parse_raw)(void *self, const char *data, size_t size);
 	void (*free)(void *self);
 } git_object_def;
 
 static git_object_def git_objects_table[] = {
-	/* 0 = GIT_OBJECT__EXT1 */
-	{ "", 0, NULL, NULL, NULL },
+	/* 0 = GIT_OBJ__EXT1 */
+	{ "", 0, NULL, NULL },
 
-	/* 1 = GIT_OBJECT_COMMIT */
-	{ "commit", sizeof(git_commit), git_commit__parse, git_commit__parse_raw, git_commit__free },
+	/* 1 = GIT_OBJ_COMMIT */
+	{ "commit", sizeof(git_commit), git_commit__parse, git_commit__free },
 
-	/* 2 = GIT_OBJECT_TREE */
-	{ "tree", sizeof(git_tree), git_tree__parse, git_tree__parse_raw, git_tree__free },
+	/* 2 = GIT_OBJ_TREE */
+	{ "tree", sizeof(git_tree), git_tree__parse, git_tree__free },
 
-	/* 3 = GIT_OBJECT_BLOB */
-	{ "blob", sizeof(git_blob), git_blob__parse, git_blob__parse_raw, git_blob__free },
+	/* 3 = GIT_OBJ_BLOB */
+	{ "blob", sizeof(git_blob), git_blob__parse, git_blob__free },
 
-	/* 4 = GIT_OBJECT_TAG */
-	{ "tag", sizeof(git_tag), git_tag__parse, git_tag__parse_raw, git_tag__free },
+	/* 4 = GIT_OBJ_TAG */
+	{ "tag", sizeof(git_tag), git_tag__parse, git_tag__free },
 
-	/* 5 = GIT_OBJECT__EXT2 */
-	{ "", 0, NULL, NULL, NULL },
-	/* 6 = GIT_OBJECT_OFS_DELTA */
-	{ "OFS_DELTA", 0, NULL, NULL, NULL },
-	/* 7 = GIT_OBJECT_REF_DELTA */
-	{ "REF_DELTA", 0, NULL, NULL, NULL },
+	/* 5 = GIT_OBJ__EXT2 */
+	{ "", 0, NULL, NULL },
+	/* 6 = GIT_OBJ_OFS_DELTA */
+	{ "OFS_DELTA", 0, NULL, NULL },
+	/* 7 = GIT_OBJ_REF_DELTA */
+	{ "REF_DELTA", 0, NULL, NULL },
 };
 
-int git_object__from_raw(
-	git_object **object_out,
-	const char *data,
-	size_t size,
-	git_object_t type)
-{
-	git_object_def *def;
-	git_object *object;
-	size_t object_size;
-	int error;
-
-	assert(object_out);
-	*object_out = NULL;
-
-	/* Validate type match */
-	if (type != GIT_OBJECT_BLOB && type != GIT_OBJECT_TREE && type != GIT_OBJECT_COMMIT && type != GIT_OBJECT_TAG) {
-		git_error_set(GIT_ERROR_INVALID, "the requested type is invalid");
-		return GIT_ENOTFOUND;
-	}
-
-	if ((object_size = git_object__size(type)) == 0) {
-		git_error_set(GIT_ERROR_INVALID, "the requested type is invalid");
-		return GIT_ENOTFOUND;
-	}
-
-	/* Allocate and initialize base object */
-	object = git__calloc(1, object_size);
-	GIT_ERROR_CHECK_ALLOC(object);
-	object->cached.flags = GIT_CACHE_STORE_PARSED;
-	object->cached.type = type;
-	git_odb_hash(&object->cached.oid, data, size, type);
-
-	/* Parse raw object data */
-	def = &git_objects_table[type];
-	assert(def->free && def->parse_raw);
-
-	if ((error = def->parse_raw(object, data, size)) < 0) {
-		def->free(object);
-		return error;
-	}
-
-	git_cached_obj_incref(object);
-	*object_out = object;
-
-	return 0;
-}
-
 int git_object__from_odb_object(
 	git_object **object_out,
 	git_repository *repo,
 	git_odb_object *odb_obj,
-	git_object_t type)
+	git_otype type)
 {
 	int error;
 	size_t object_size;
@@ -118,20 +66,20 @@ int git_object__from_odb_object(
 	*object_out = NULL;
 
 	/* Validate type match */
-	if (type != GIT_OBJECT_ANY && type != odb_obj->cached.type) {
-		git_error_set(GIT_ERROR_INVALID,
+	if (type != GIT_OBJ_ANY && type != odb_obj->cached.type) {
+		giterr_set(GITERR_INVALID,
 			"the requested type does not match the type in the ODB");
 		return GIT_ENOTFOUND;
 	}
 
 	if ((object_size = git_object__size(odb_obj->cached.type)) == 0) {
-		git_error_set(GIT_ERROR_INVALID, "the requested type is invalid");
+		giterr_set(GITERR_INVALID, "the requested type is invalid");
 		return GIT_ENOTFOUND;
 	}
 
 	/* Allocate and initialize base object */
 	object = git__calloc(1, object_size);
-	GIT_ERROR_CHECK_ALLOC(object);
+	GITERR_CHECK_ALLOC(object);
 
 	git_oid_cpy(&object->cached.oid, &odb_obj->cached.oid);
 	object->cached.type = odb_obj->cached.type;
@@ -152,7 +100,7 @@ int git_object__from_odb_object(
 
 void git_object__free(void *obj)
 {
-	git_object_t type = ((git_object *)obj)->cached.type;
+	git_otype type = ((git_object *)obj)->cached.type;
 
 	if (type < 0 || ((size_t)type) >= ARRAY_SIZE(git_objects_table) ||
 		!git_objects_table[type].free)
@@ -166,7 +114,7 @@ int git_object_lookup_prefix(
 	git_repository *repo,
 	const git_oid *id,
 	size_t len,
-	git_object_t type)
+	git_otype type)
 {
 	git_object *object = NULL;
 	git_odb *odb = NULL;
@@ -176,7 +124,7 @@ int git_object_lookup_prefix(
 	assert(repo && object_out && id);
 
 	if (len < GIT_OID_MINPREFIXLEN) {
-		git_error_set(GIT_ERROR_OBJECT, "ambiguous lookup - OID prefix is too short");
+		giterr_set(GITERR_OBJECT, "ambiguous lookup - OID prefix is too short");
 		return GIT_EAMBIGUOUS;
 	}
 
@@ -198,9 +146,9 @@ int git_object_lookup_prefix(
 			if (cached->flags == GIT_CACHE_STORE_PARSED) {
 				object = (git_object *)cached;
 
-				if (type != GIT_OBJECT_ANY && type != object->cached.type) {
+				if (type != GIT_OBJ_ANY && type != object->cached.type) {
 					git_object_free(object);
-					git_error_set(GIT_ERROR_INVALID,
+					giterr_set(GITERR_INVALID,
 						"the requested type does not match the type in ODB");
 					return GIT_ENOTFOUND;
 				}
@@ -248,7 +196,7 @@ int git_object_lookup_prefix(
 	return error;
 }
 
-int git_object_lookup(git_object **object_out, git_repository *repo, const git_oid *id, git_object_t type) {
+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);
 }
 
@@ -266,7 +214,7 @@ const git_oid *git_object_id(const git_object *obj)
 	return &obj->cached.oid;
 }
 
-git_object_t git_object_type(const git_object *obj)
+git_otype git_object_type(const git_object *obj)
 {
 	assert(obj);
 	return obj->cached.type;
@@ -278,7 +226,7 @@ git_repository *git_object_owner(const git_object *obj)
 	return obj->repo;
 }
 
-const char *git_object_type2string(git_object_t type)
+const char *git_object_type2string(git_otype type)
 {
 	if (type < 0 || ((size_t) type) >= ARRAY_SIZE(git_objects_table))
 		return "";
@@ -286,30 +234,30 @@ const char *git_object_type2string(git_object_t type)
 	return git_objects_table[type].str;
 }
 
-git_object_t git_object_string2type(const char *str)
+git_otype git_object_string2type(const char *str)
 {
 	if (!str)
-		return GIT_OBJECT_INVALID;
+		return GIT_OBJ_BAD;
 
 	return git_object_stringn2type(str, strlen(str));
 }
 
-git_object_t git_object_stringn2type(const char *str, size_t len)
+git_otype git_object_stringn2type(const char *str, size_t len)
 {
 	size_t i;
 
 	if (!str || !len || !*str)
-		return GIT_OBJECT_INVALID;
+		return GIT_OBJ_BAD;
 
 	for (i = 0; i < ARRAY_SIZE(git_objects_table); i++)
 		if (*git_objects_table[i].str &&
 			!git__prefixncmp(str, len, git_objects_table[i].str))
-			return (git_object_t)i;
+			return (git_otype)i;
 
-	return GIT_OBJECT_INVALID;
+	return GIT_OBJ_BAD;
 }
 
-int git_object_typeisloose(git_object_t type)
+int git_object_typeisloose(git_otype type)
 {
 	if (type < 0 || ((size_t) type) >= ARRAY_SIZE(git_objects_table))
 		return 0;
@@ -317,7 +265,7 @@ int git_object_typeisloose(git_object_t type)
 	return (git_objects_table[type].size > 0) ? 1 : 0;
 }
 
-size_t git_object__size(git_object_t type)
+size_t git_object__size(git_otype type)
 {
 	if (type < 0 || ((size_t) type) >= ARRAY_SIZE(git_objects_table))
 		return 0;
@@ -327,17 +275,17 @@ size_t git_object__size(git_object_t type)
 
 static int dereference_object(git_object **dereferenced, git_object *obj)
 {
-	git_object_t type = git_object_type(obj);
+	git_otype type = git_object_type(obj);
 
 	switch (type) {
-	case GIT_OBJECT_COMMIT:
+	case GIT_OBJ_COMMIT:
 		return git_commit_tree((git_tree **)dereferenced, (git_commit*)obj);
 
-	case GIT_OBJECT_TAG:
+	case GIT_OBJ_TAG:
 		return git_tag_target(dereferenced, (git_tag*)obj);
 
-	case GIT_OBJECT_BLOB:
-	case GIT_OBJECT_TREE:
+	case GIT_OBJ_BLOB:
+	case GIT_OBJ_TREE:
 		return GIT_EPEEL;
 
 	default:
@@ -345,7 +293,7 @@ static int dereference_object(git_object **dereferenced, git_object *obj)
 	}
 }
 
-static int peel_error(int error, const git_oid *oid, git_object_t type)
+static int peel_error(int error, const git_oid *oid, git_otype type)
 {
 	const char *type_name;
 	char hex_oid[GIT_OID_HEXSZ + 1];
@@ -355,29 +303,29 @@ static int peel_error(int error, const git_oid *oid, git_object_t type)
 	git_oid_fmt(hex_oid, oid);
 	hex_oid[GIT_OID_HEXSZ] = '\0';
 
-	git_error_set(GIT_ERROR_OBJECT, "the git_object of id '%s' can not be "
-		"successfully peeled into a %s (git_object_t=%i).", hex_oid, type_name, type);
+	giterr_set(GITERR_OBJECT, "the git_object of id '%s' can not be "
+		"successfully peeled into a %s (git_otype=%i).", hex_oid, type_name, type);
 
 	return error;
 }
 
-static int check_type_combination(git_object_t type, git_object_t target)
+static int check_type_combination(git_otype type, git_otype target)
 {
 	if (type == target)
 		return 0;
 
 	switch (type) {
-	case GIT_OBJECT_BLOB:
-	case GIT_OBJECT_TREE:
+	case GIT_OBJ_BLOB:
+	case GIT_OBJ_TREE:
 		/* a blob or tree can never be peeled to anything but themselves */
 		return GIT_EINVALIDSPEC;
 		break;
-	case GIT_OBJECT_COMMIT:
+	case GIT_OBJ_COMMIT:
 		/* a commit can only be peeled to a tree */
-		if (target != GIT_OBJECT_TREE && target != GIT_OBJECT_ANY)
+		if (target != GIT_OBJ_TREE && target != GIT_OBJ_ANY)
 			return GIT_EINVALIDSPEC;
 		break;
-	case GIT_OBJECT_TAG:
+	case GIT_OBJ_TAG:
 		/* a tag may point to anything, so we let anything through */
 		break;
 	default:
@@ -390,18 +338,18 @@ static int check_type_combination(git_object_t type, git_object_t target)
 int git_object_peel(
 	git_object **peeled,
 	const git_object *object,
-	git_object_t target_type)
+	git_otype target_type)
 {
 	git_object *source, *deref = NULL;
 	int error;
 
 	assert(object && peeled);
 
-	assert(target_type == GIT_OBJECT_TAG ||
-		target_type == GIT_OBJECT_COMMIT ||
-		target_type == GIT_OBJECT_TREE ||
-		target_type == GIT_OBJECT_BLOB ||
-		target_type == GIT_OBJECT_ANY);
+	assert(target_type == GIT_OBJ_TAG ||
+		target_type == GIT_OBJ_COMMIT ||
+		target_type == GIT_OBJ_TREE ||
+		target_type == GIT_OBJ_BLOB ||
+		target_type == GIT_OBJ_ANY);
 
 	if ((error = check_type_combination(git_object_type(object), target_type)) < 0)
 		return peel_error(error, git_object_id(object), target_type);
@@ -421,7 +369,7 @@ int git_object_peel(
 			return 0;
 		}
 
-		if (target_type == GIT_OBJECT_ANY &&
+		if (target_type == GIT_OBJ_ANY &&
 			git_object_type(deref) != git_object_type(object))
 		{
 			*peeled = deref;
@@ -454,7 +402,7 @@ int git_object_lookup_bypath(
 		git_object **out,
 		const git_object *treeish,
 		const char *path,
-		git_object_t type)
+		git_otype type)
 {
 	int error = -1;
 	git_tree *tree = NULL;
@@ -462,15 +410,15 @@ int git_object_lookup_bypath(
 
 	assert(out && treeish && path);
 
-	if ((error = git_object_peel((git_object**)&tree, treeish, GIT_OBJECT_TREE)) < 0 ||
+	if ((error = git_object_peel((git_object**)&tree, treeish, GIT_OBJ_TREE)) < 0 ||
 		 (error = git_tree_entry_bypath(&entry, tree, path)) < 0)
 	{
 		goto cleanup;
 	}
 
-	if (type != GIT_OBJECT_ANY && git_tree_entry_type(entry) != type)
+	if (type != GIT_OBJ_ANY && git_tree_entry_type(entry) != type)
 	{
-		git_error_set(GIT_ERROR_OBJECT,
+		giterr_set(GITERR_OBJECT,
 				"object at path '%s' is not of the asked-for type %d",
 				path, type);
 		error = GIT_EINVALIDSPEC;
@@ -497,7 +445,7 @@ int git_object_short_id(git_buf *out, const git_object *obj)
 	git_buf_sanitize(out);
 	repo = git_object_owner(obj);
 
-	if ((error = git_repository__configmap_lookup(&len, repo, GIT_CONFIGMAP_ABBREV)) < 0)
+	if ((error = git_repository__cvar(&len, repo, GIT_CVAR_ABBREV)) < 0)
 		return error;
 
 	if ((error = git_repository_odb(&odb, repo)) < 0)
@@ -513,7 +461,7 @@ int git_object_short_id(git_buf *out, const git_object *obj)
 		if (error != GIT_EAMBIGUOUS)
 			break;
 
-		git_error_clear();
+		giterr_clear();
 		len++;
 	}
 
@@ -528,10 +476,10 @@ int git_object_short_id(git_buf *out, const git_object *obj)
 }
 
 bool git_object__is_valid(
-	git_repository *repo, const git_oid *id, git_object_t expected_type)
+	git_repository *repo, const git_oid *id, git_otype expected_type)
 {
 	git_odb *odb;
-	git_object_t actual_type;
+	git_otype actual_type;
 	size_t len;
 	int error;
 
@@ -542,11 +490,12 @@ bool git_object__is_valid(
 		(error = git_odb_read_header(&len, &actual_type, odb, id)) < 0)
 		return false;
 
-	if (expected_type != GIT_OBJECT_ANY && expected_type != actual_type) {
-		git_error_set(GIT_ERROR_INVALID,
+	if (expected_type != GIT_OBJ_ANY && expected_type != actual_type) {
+		giterr_set(GITERR_INVALID,
 			"the requested type does not match the type in the ODB");
 		return false;
 	}
 
 	return true;
 }
+