rugged 0.24.6.1 → 0.25.0

data/vendor/libgit2/src/commit.c

@@ -18,6 +18,7 @@
 #include "message.h"
 #include "refs.h"
 #include "object.h"
+#include "oidarray.h"
 
 void git_commit__free(void *_commit)
 {
@@ -37,94 +38,142 @@ void git_commit__free(void *_commit)
 	git__free(commit);
 }
 
-static int git_commit__create_internal(
-	git_oid *id,
-	git_repository *repo,
-	const char *update_ref,
+static int git_commit__create_buffer_internal(
+	git_buf *out,
 	const git_signature *author,
 	const git_signature *committer,
 	const char *message_encoding,
 	const char *message,
 	const git_oid *tree,
-	git_commit_parent_callback parent_cb,
-	void *parent_payload,
-	bool validate)
+	git_array_oid_t *parents)
 {
-	git_reference *ref = NULL;
-	int error = 0, matched_parent = 0;
-	const git_oid *current_id = NULL;
-	git_buf commit = GIT_BUF_INIT;
 	size_t i = 0;
-	git_odb *odb;
 	const git_oid *parent;
 
-	assert(id && repo && tree && parent_cb);
+	assert(out && tree);
 
-	if (validate && !git_object__is_valid(repo, tree, GIT_OBJ_TREE))
-		return -1;
+	git_oid__writebuf(out, "tree ", tree);
 
-	if (update_ref) {
-		error = git_reference_lookup_resolved(&ref, repo, update_ref, 10);
-		if (error < 0 && error != GIT_ENOTFOUND)
-			return error;
+	for (i = 0; i < git_array_size(*parents); i++) {
+		parent = git_array_get(*parents, i);
+		git_oid__writebuf(out, "parent ", parent);
 	}
-	giterr_clear();
 
-	if (ref)
-		current_id = git_reference_target(ref);
+	git_signature__writebuf(out, "author ", author);
+	git_signature__writebuf(out, "committer ", committer);
+
+	if (message_encoding != NULL)
+		git_buf_printf(out, "encoding %s\n", message_encoding);
+
+	git_buf_putc(out, '\n');
+
+	if (git_buf_puts(out, message) < 0)
+		goto on_error;
+
+	return 0;
+
+on_error:
+	git_buf_free(out);
+	return -1;
+}
 
-	git_oid__writebuf(&commit, "tree ", tree);
+static int validate_tree_and_parents(git_array_oid_t *parents, git_repository *repo, const git_oid *tree,
+				     git_commit_parent_callback parent_cb, void *parent_payload,
+				     const git_oid *current_id, bool validate)
+{
+	size_t i;
+	int error;
+	git_oid *parent_cpy;
+	const git_oid *parent;
+
+	if (validate && !git_object__is_valid(repo, tree, GIT_OBJ_TREE))
+		return -1;
 
+	i = 0;
 	while ((parent = parent_cb(i, parent_payload)) != NULL) {
 		if (validate && !git_object__is_valid(repo, parent, GIT_OBJ_COMMIT)) {
 			error = -1;
 			goto on_error;
 		}
 
-		git_oid__writebuf(&commit, "parent ", parent);
-		if (i == 0 && current_id && git_oid_equal(current_id, parent))
-			matched_parent = 1;
+		parent_cpy = git_array_alloc(*parents);
+		GITERR_CHECK_ALLOC(parent_cpy);
+
+		git_oid_cpy(parent_cpy, parent);
 		i++;
 	}
 
-	if (ref && !matched_parent) {
-		git_reference_free(ref);
-		git_buf_free(&commit);
+	if (current_id && (parents->size == 0 || git_oid_cmp(current_id, git_array_get(*parents, 0)))) {
 		giterr_set(GITERR_OBJECT, "failed to create commit: current tip is not the first parent");
-		return GIT_EMODIFIED;
+		error = GIT_EMODIFIED;
+		goto on_error;
 	}
 
-	git_signature__writebuf(&commit, "author ", author);
-	git_signature__writebuf(&commit, "committer ", committer);
+	return 0;
 
-	if (message_encoding != NULL)
-		git_buf_printf(&commit, "encoding %s\n", message_encoding);
+on_error:
+	git_array_clear(*parents);
+	return error;
+}
+
+static int git_commit__create_internal(
+	git_oid *id,
+	git_repository *repo,
+	const char *update_ref,
+	const git_signature *author,
+	const git_signature *committer,
+	const char *message_encoding,
+	const char *message,
+	const git_oid *tree,
+	git_commit_parent_callback parent_cb,
+	void *parent_payload,
+	bool validate)
+{
+	int error;
+	git_odb *odb;
+	git_reference *ref = NULL;
+	git_buf buf = GIT_BUF_INIT;
+	const git_oid *current_id = NULL;
+	git_array_oid_t parents = GIT_ARRAY_INIT;
 
-	git_buf_putc(&commit, '\n');
+	if (update_ref) {
+		error = git_reference_lookup_resolved(&ref, repo, update_ref, 10);
+		if (error < 0 && error != GIT_ENOTFOUND)
+			return error;
+	}
+	giterr_clear();
 
-	if (git_buf_puts(&commit, message) < 0)
-		goto on_error;
+	if (ref)
+		current_id = git_reference_target(ref);
+
+	if ((error = validate_tree_and_parents(&parents, repo, tree, parent_cb, parent_payload, current_id, validate)) < 0)
+		goto cleanup;
+
+	error = git_commit__create_buffer_internal(&buf, author, committer,
+						   message_encoding, message, tree,
+						   &parents);
+
+	if (error < 0)
+		goto cleanup;
 
 	if (git_repository_odb__weakptr(&odb, repo) < 0)
-		goto on_error;
+		goto cleanup;
 
-	if (git_odb_write(id, odb, commit.ptr, commit.size, GIT_OBJ_COMMIT) < 0)
-		goto on_error;
+	if (git_odb_write(id, odb, buf.ptr, buf.size, GIT_OBJ_COMMIT) < 0)
+		goto cleanup;
 
-	git_buf_free(&commit);
 
 	if (update_ref != NULL) {
 		error = git_reference__update_for_commit(
 			repo, ref, update_ref, id, "commit");
-		git_reference_free(ref);
-		return error;
+		goto cleanup;
 	}
 
-	return 0;
-
-on_error:
-	git_buf_free(&commit);
-	return -1;
+cleanup:
+	git_array_clear(parents);
+	git_reference_free(ref);
+	git_buf_free(&buf);
+	return error;
 }
 
 int git_commit_create_from_callback(
@@ -566,7 +615,7 @@ int git_commit_nth_gen_ancestor(
 
 	assert(ancestor && commit);
 
-	if (git_object_dup((git_object **) &current, (git_object *) commit) < 0)
+	if (git_commit_dup(&current, (git_commit *)commit) < 0)
 		return -1;
 
 	if (n == 0) {
@@ -740,3 +789,98 @@ cleanup:
 	git_buf_clear(signed_data);
 	return error;
 }
+
+int git_commit_create_buffer(git_buf *out,
+	git_repository *repo,
+	const git_signature *author,
+	const git_signature *committer,
+	const char *message_encoding,
+	const char *message,
+	const git_tree *tree,
+	size_t parent_count,
+	const git_commit *parents[])
+{
+	int error;
+	commit_parent_data data = { parent_count, parents, repo };
+	git_array_oid_t parents_arr = GIT_ARRAY_INIT;
+	const git_oid *tree_id;
+
+	assert(tree && git_tree_owner(tree) == repo);
+
+	tree_id = git_tree_id(tree);
+
+	if ((error = validate_tree_and_parents(&parents_arr, repo, tree_id, commit_parent_from_array, &data, NULL, true)) < 0)
+		return error;
+
+	error = git_commit__create_buffer_internal(
+		out, author, committer,
+		message_encoding, message, tree_id,
+		&parents_arr);
+
+	git_array_clear(parents_arr);
+	return error;
+}
+
+/**
+ * Append to 'out' properly marking continuations when there's a newline in 'content'
+ */
+static void format_header_field(git_buf *out, const char *field, const char *content)
+{
+	const char *lf;
+
+	assert(out && field && content);
+
+	git_buf_puts(out, field);
+	git_buf_putc(out, ' ');
+
+	while ((lf = strchr(content, '\n')) != NULL) {
+		git_buf_put(out, content, lf - content);
+		git_buf_puts(out, "\n ");
+		content = lf + 1;
+	}
+
+	git_buf_puts(out, content);
+	git_buf_putc(out, '\n');
+}
+
+int git_commit_create_with_signature(
+	git_oid *out,
+	git_repository *repo,
+	const char *commit_content,
+	const char *signature,
+	const char *signature_field)
+{
+	git_odb *odb;
+	int error = 0;
+	const char *field;
+	const char *header_end;
+	git_buf commit = GIT_BUF_INIT;
+
+	/* We start by identifying the end of the commit header */
+	header_end = strstr(commit_content, "\n\n");
+	if (!header_end) {
+		giterr_set(GITERR_INVALID, "malformed commit contents");
+		return -1;
+	}
+
+	field = signature_field ? signature_field : "gpgsig";
+
+	/* The header ends after the first LF */
+	header_end++;
+	git_buf_put(&commit, commit_content, header_end - commit_content);
+	format_header_field(&commit, field, signature);
+	git_buf_puts(&commit, header_end);
+
+	if (git_buf_oom(&commit))
+		return -1;
+
+	if ((error = git_repository_odb__weakptr(&odb, repo)) < 0)
+		goto cleanup;
+
+	if ((error = git_odb_write(out, odb, commit.ptr, commit.size, GIT_OBJ_COMMIT)) < 0)
+		goto cleanup;
+
+cleanup:
+	git_buf_free(&commit);
+	return error;
+}

data/vendor/libgit2/src/commit_list.c

@@ -13,10 +13,15 @@
 
 int git_commit_list_time_cmp(const void *a, const void *b)
 {
-	const git_commit_list_node *commit_a = a;
-	const git_commit_list_node *commit_b = b;
+	int64_t time_a = ((git_commit_list_node *) a)->time;
+	int64_t time_b = ((git_commit_list_node *) b)->time;
 
-	return (commit_a->time < commit_b->time);
+	if (time_a < time_b)
+		return 1;
+	if (time_a > time_b)
+		return -1;
+
+	return 0;
 }
 
 git_commit_list *git_commit_list_insert(git_commit_list_node *item, git_commit_list **list_p)

data/vendor/libgit2/src/commit_list.h

@@ -28,6 +28,7 @@ typedef struct git_commit_list_node {
 			 uninteresting:1,
 			 topo_delay:1,
 			 parsed:1,
+			 added:1,
 			 flags : FLAG_BITS;
 
 	unsigned short in_degree;

data/vendor/libgit2/src/common.h

@@ -103,7 +103,8 @@
 /**
  * Set the error message for this thread, formatting as needed.
  */
-void giterr_set(int error_class, const char *string, ...);
+
+void giterr_set(int error_class, const char *string, ...) GIT_FORMAT_PRINTF(2, 3);
 
 /**
  * Set the error message for a regex failure, using the internal regex

data/vendor/libgit2/src/config.c

@@ -478,7 +478,7 @@ int git_config_iterator_glob_new(git_config_iterator **out, const git_config *cf
 	iter = git__calloc(1, sizeof(all_iter));
 	GITERR_CHECK_ALLOC(iter);
 
-	if ((result = regcomp(&iter->regex, regexp, REG_EXTENDED)) != 0) {
+	if ((result = p_regcomp(&iter->regex, regexp, REG_EXTENDED)) != 0) {
 		giterr_set_regex(&iter->regex, result);
 		git__free(iter);
 		return -1;
@@ -512,7 +512,7 @@ int git_config_backend_foreach_match(
 	int error = 0;
 
 	if (regexp != NULL) {
-		if ((error = regcomp(&regex, regexp, REG_EXTENDED)) != 0) {
+		if ((error = p_regcomp(&regex, regexp, REG_EXTENDED)) != 0) {
 			giterr_set_regex(&regex, error);
 			regfree(&regex);
 			return -1;
@@ -1003,7 +1003,7 @@ int git_config_multivar_iterator_new(git_config_iterator **out, const git_config
 		goto on_error;
 
 	if (regexp != NULL) {
-		error = regcomp(&iter->regex, regexp, REG_EXTENDED);
+		error = p_regcomp(&iter->regex, regexp, REG_EXTENDED);
 		if (error != 0) {
 			giterr_set_regex(&iter->regex, error);
 			error = -1;

data/vendor/libgit2/src/config_file.c

@@ -232,7 +232,10 @@ static refcounted_strmap *refcounted_strmap_take(diskfile_header *h)
 {
 	refcounted_strmap *map;
 
-	git_mutex_lock(&h->values_mutex);
+	if (git_mutex_lock(&h->values_mutex) < 0) {
+	    giterr_set(GITERR_OS, "Failed to lock config backend");
+	    return NULL;
+	}
 
 	map = h->values;
 	git_atomic_inc(&map->refcount);
@@ -318,7 +321,10 @@ static int config__refresh(git_config_backend *cfg)
 	if ((error = config_read(values->values, b, reader, b->level, 0)) < 0)
 		goto out;
 
-	git_mutex_lock(&b->header.values_mutex);
+	if ((error = git_mutex_lock(&b->header.values_mutex)) < 0) {
+		giterr_set(GITERR_OS, "Failed to lock config backend");
+		goto out;
+	}
 
 	tmp = b->header.values;
 	b->header.values = values;
@@ -460,7 +466,8 @@ static int config_set(git_config_backend *cfg, const char *name, const char *val
 	if ((rval = git_config__normalize_name(name, &key)) < 0)
 		return rval;
 
-	map = refcounted_strmap_take(&b->header);
+	if ((map = refcounted_strmap_take(&b->header)) == NULL)
+		return -1;
 	values = map->values;
 
 	/*
@@ -527,7 +534,8 @@ static int config_get(git_config_backend *cfg, const char *key, git_config_entry
 	if (!h->parent.readonly && ((error = config_refresh(cfg)) < 0))
 		return error;
 
-	map = refcounted_strmap_take(h);
+	if ((map = refcounted_strmap_take(h)) == NULL)
+		return -1;
 	values = map->values;
 
 	pos = git_strmap_lookup_index(values, key);
@@ -562,7 +570,7 @@ static int config_set_multivar(
 	if ((result = git_config__normalize_name(name, &key)) < 0)
 		return result;
 
-	result = regcomp(&preg, regexp, REG_EXTENDED);
+	result = p_regcomp(&preg, regexp, REG_EXTENDED);
 	if (result != 0) {
 		giterr_set_regex(&preg, result);
 		result = -1;
@@ -594,7 +602,8 @@ static int config_delete(git_config_backend *cfg, const char *name)
 	if ((result = git_config__normalize_name(name, &key)) < 0)
 		return result;
 
-	map = refcounted_strmap_take(&b->header);
+	if ((map = refcounted_strmap_take(&b->header)) == NULL)
+		return -1;
 	values = b->header.values->values;
 
 	pos = git_strmap_lookup_index(values, key);
@@ -633,7 +642,8 @@ static int config_delete_multivar(git_config_backend *cfg, const char *name, con
 	if ((result = git_config__normalize_name(name, &key)) < 0)
 		return result;
 
-	map = refcounted_strmap_take(&b->header);
+	if ((map = refcounted_strmap_take(&b->header)) == NULL)
+		return -1;
 	values = b->header.values->values;
 
 	pos = git_strmap_lookup_index(values, key);
@@ -647,7 +657,7 @@ static int config_delete_multivar(git_config_backend *cfg, const char *name, con
 
 	refcounted_strmap_free(map);
 
-	result = regcomp(&preg, regexp, REG_EXTENDED);
+	result = p_regcomp(&preg, regexp, REG_EXTENDED);
 	if (result != 0) {
 		giterr_set_regex(&preg, result);
 		result = -1;
@@ -816,7 +826,8 @@ static int config_readonly_open(git_config_backend *cfg, git_config_level_t leve
 	/* We're just copying data, don't care about the level */
 	GIT_UNUSED(level);
 
-	src_map = refcounted_strmap_take(src_header);
+	if ((src_map = refcounted_strmap_take(src_header)) == NULL)
+		return -1;
 	b->header.values = src_map;
 
 	return 0;
@@ -1946,4 +1957,3 @@ done:
 	git_buf_free(&reader->buffer);
 	return result;
 }
-

data/vendor/libgit2/src/crlf.c

@@ -289,6 +289,7 @@ static int crlf_check(
 		ca.eol = check_eol(attr_values[1]); /* eol */
 	}
 	ca.auto_crlf = GIT_AUTO_CRLF_DEFAULT;
+	ca.safe_crlf = GIT_SAFE_CRLF_DEFAULT;
 
 	/*
 	 * Use the core Git logic to see if we should perform CRLF for this file

data/vendor/libgit2/src/curl_stream.c

@@ -13,6 +13,17 @@
 #include "git2/transport.h"
 #include "buffer.h"
 #include "vector.h"
+#include "proxy.h"
+
+/* This is for backwards compatibility with curl<7.45.0. */
+#ifndef CURLINFO_ACTIVESOCKET
+# define CURLINFO_ACTIVESOCKET CURLINFO_LASTSOCKET
+# define GIT_CURL_BADSOCKET -1
+# define git_activesocket_t long
+#else
+# define GIT_CURL_BADSOCKET CURL_SOCKET_BAD
+# define git_activesocket_t curl_socket_t
+#endif
 
 typedef struct {
 	git_stream parent;
@@ -21,6 +32,8 @@ typedef struct {
 	char curl_error[CURL_ERROR_SIZE + 1];
 	git_cert_x509 cert_info;
 	git_strarray cert_info_strings;
+	git_proxy_options proxy;
+	git_cred *proxy_cred;
 } curl_stream;
 
 static int seterr_curl(curl_stream *s)
@@ -29,21 +42,100 @@ static int seterr_curl(curl_stream *s)
 	return -1;
 }
 
+GIT_INLINE(int) error_no_credentials(void)
+{
+	giterr_set(GITERR_NET, "proxy authentication required, but no callback provided");
+	return GIT_EAUTH;
+}
+
+static int apply_proxy_creds(curl_stream *s)
+{
+	CURLcode res;
+	git_cred_userpass_plaintext *userpass;
+
+	if (!s->proxy_cred)
+		return GIT_ENOTFOUND;
+
+	userpass = (git_cred_userpass_plaintext *) s->proxy_cred;
+	if ((res = curl_easy_setopt(s->handle, CURLOPT_PROXYUSERNAME, userpass->username)) != CURLE_OK)
+		return seterr_curl(s);
+	if ((res = curl_easy_setopt(s->handle, CURLOPT_PROXYPASSWORD, userpass->password)) != CURLE_OK)
+		return seterr_curl(s);
+
+	return 0;
+}
+
+static int ask_and_apply_proxy_creds(curl_stream *s)
+{
+	int error;
+	git_proxy_options *opts = &s->proxy;
+
+	if (!opts->credentials)
+		return error_no_credentials();
+
+	/* TODO: see if PROXYAUTH_AVAIL helps us here */
+	git_cred_free(s->proxy_cred);
+	s->proxy_cred = NULL;
+	giterr_clear();
+	error = opts->credentials(&s->proxy_cred, opts->url, NULL, GIT_CREDTYPE_USERPASS_PLAINTEXT, opts->payload);
+	if (error == GIT_PASSTHROUGH)
+		return error_no_credentials();
+	if (error < 0) {
+		if (!giterr_last())
+			giterr_set(GITERR_NET, "proxy authentication was aborted by the user");
+		return error;
+	}
+
+	if (s->proxy_cred->credtype != GIT_CREDTYPE_USERPASS_PLAINTEXT) {
+		giterr_set(GITERR_NET, "credentials callback returned invalid credential type");
+		return -1;
+	}
+
+	return apply_proxy_creds(s);
+}
+
 static int curls_connect(git_stream *stream)
 {
 	curl_stream *s = (curl_stream *) stream;
-	long sockextr;
-	int failed_cert = 0;
+	git_activesocket_t sockextr;
+	long connect_last = 0;
+	int failed_cert = 0, error;
+	bool retry_connect;
 	CURLcode res;
-	res = curl_easy_perform(s->handle);
+
+	/* Apply any credentials we've already established */
+	error = apply_proxy_creds(s);
+	if (error < 0 && error != GIT_ENOTFOUND)
+		return seterr_curl(s);
+
+	do {
+		retry_connect = 0;
+		res = curl_easy_perform(s->handle);
+
+		curl_easy_getinfo(s->handle, CURLINFO_HTTP_CONNECTCODE, &connect_last);
+
+		/* HTTP 407 Proxy Authentication Required */
+		if (connect_last == 407) {
+			if ((error = ask_and_apply_proxy_creds(s)) < 0)
+				return error;
+
+			retry_connect = true;
+		}
+	} while (retry_connect);
 
 	if (res != CURLE_OK && res != CURLE_PEER_FAILED_VERIFICATION)
 		return seterr_curl(s);
 	if (res == CURLE_PEER_FAILED_VERIFICATION)
 		failed_cert = 1;
 
-	if ((res = curl_easy_getinfo(s->handle, CURLINFO_LASTSOCKET, &sockextr)) != CURLE_OK)
+	if ((res = curl_easy_getinfo(s->handle, CURLINFO_ACTIVESOCKET, &sockextr)) != CURLE_OK) {
 		return seterr_curl(s);
+	}
+
+	if (sockextr == GIT_CURL_BADSOCKET) {
+		giterr_set(GITERR_NET, "curl socket is no longer valid");
+		return -1;
+	}
 
 	s->socket = sockextr;
 
@@ -95,12 +187,19 @@ static int curls_certificate(git_cert **out, git_stream *stream)
 	return 0;
 }
 
-static int curls_set_proxy(git_stream *stream, const char *proxy_url)
+static int curls_set_proxy(git_stream *stream, const git_proxy_options *proxy_opts)
 {
+	int error;
 	CURLcode res;
 	curl_stream *s = (curl_stream *) stream;
 
-	if ((res = curl_easy_setopt(s->handle, CURLOPT_PROXY, proxy_url)) != CURLE_OK)
+	if ((error = git_proxy_options_dup(&s->proxy, proxy_opts)) < 0)
+		return error;
+
+	if ((res = curl_easy_setopt(s->handle, CURLOPT_PROXY, s->proxy.url)) != CURLE_OK)
+		return seterr_curl(s);
+
+	if ((res = curl_easy_setopt(s->handle, CURLOPT_PROXYAUTH, CURLAUTH_ANY)) != CURLE_OK)
 		return seterr_curl(s);
 
 	return 0;
@@ -115,6 +214,7 @@ static int wait_for(curl_socket_t fd, bool reading)
 	FD_ZERO(&outfd);
 	FD_ZERO(&errfd);
 
+	assert(fd >= 0);
 	FD_SET(fd, &errfd);
 	if (reading)
 		FD_SET(fd, &infd);