rugged 1.9.0 → 1.9.5.1

data/vendor/libgit2/src/libgit2/submodule.c

@@ -77,6 +77,7 @@ static void submodule_get_index_status(unsigned int *, git_submodule *);
 static void submodule_get_wd_status(unsigned int *, git_submodule *, git_repository *, git_submodule_ignore_t);
 static void submodule_update_from_index_entry(git_submodule *sm, const git_index_entry *ie);
 static void submodule_update_from_head_data(git_submodule *sm, mode_t mode, const git_oid *id);
+static int path_is_valid(git_repository *repo, const char *path);
 
 static int submodule_cmp(const void *a, const void *b)
 {
@@ -221,6 +222,7 @@ static int load_submodule_names(git_submodule_namemap **out, git_repository *rep
 
 	while ((error = git_config_next(&entry, iter)) == 0) {
 		const char *fdot, *ldot;
+
 		fdot = strchr(entry->name, '.');
 		ldot = strrchr(entry->name, '.');
 
@@ -233,6 +235,7 @@ static int load_submodule_names(git_submodule_namemap **out, git_repository *rep
 
 		git_str_clear(&buf);
 		git_str_put(&buf, fdot + 1, ldot - fdot - 1);
+
 		isvalid = git_submodule_name_is_valid(repo, buf.ptr, 0);
 		if (isvalid < 0) {
 			error = isvalid;
@@ -241,6 +244,14 @@ static int load_submodule_names(git_submodule_namemap **out, git_repository *rep
 		if (!isvalid)
 			continue;
 
+		isvalid = path_is_valid(repo, entry->value);
+		if (isvalid < 0) {
+			error = isvalid;
+			goto out;
+		}
+		if (!isvalid)
+			continue;
+
 		if ((value = git__strdup(entry->value)) == NULL) {
 			error = -1;
 			goto out;
@@ -319,9 +330,9 @@ int git_submodule__lookup_with_cache(
 	const char *name,    /* trailing slash is allowed */
 	git_submodule_cache *cache)
 {
-	int error;
-	unsigned int location;
 	git_submodule *sm;
+	unsigned int location;
+	int error;
 
 	GIT_ASSERT_ARG(repo);
 	GIT_ASSERT_ARG(name);
@@ -344,7 +355,17 @@ int git_submodule__lookup_with_cache(
 	if ((error = submodule_alloc(&sm, repo, name)) < 0)
 		return error;
 
-	if ((error = git_submodule_reload(sm, false)) < 0) {
+	/*
+	 * Only try to reload if they gave us a valid _name_; if this is a
+	 * path, we'll do some lookups then try to reload to populate.
+	 */
+	if (git_submodule_name_is_valid(sm->repo, name, 0) <= 0) {
+		error = GIT_ENOTFOUND;
+	} else {
+		error = git_submodule_reload(sm, false);
+	}
+
+	if (error < 0 && error != GIT_ENOTFOUND) {
 		git_submodule_free(sm);
 		return error;
 	}
@@ -403,6 +424,7 @@ int git_submodule__lookup_with_cache(
 	/* If we still haven't found it, do the WD check */
 	if (location == 0 || location == GIT_SUBMODULE_STATUS_IN_WD) {
 		git_submodule_free(sm);
+		git_error_set(GIT_ERROR_SUBMODULE, "invalid submodule name: '%s'", name);
 		error = GIT_ENOTFOUND;
 
 		/* If it's not configured, we still check if there's a repo at the path */
@@ -454,6 +476,27 @@ int git_submodule_name_is_valid(git_repository *repo, const char *name, int flag
 	return isvalid;
 }
 
+static int path_is_valid(git_repository *repo, const char *path)
+{
+	git_str buf = GIT_STR_INIT;
+	int flags = GIT_FS_PATH_REJECT_FILESYSTEM_DEFAULTS &
+	            ~GIT_FS_PATH_REJECT_EMPTY_COMPONENT;
+	int error, isvalid;
+
+	/* Avoid allocating a new string if we can avoid it */
+	if (strchr(path, '\\') != NULL) {
+		if ((error = git_fs_path_normalize_slashes(&buf, path)) < 0)
+			return error;
+	} else {
+		git_str_attach_notowned(&buf, path, strlen(path));
+	}
+
+	isvalid = git_path_is_valid(repo, buf.ptr, 0, flags);
+	git_str_dispose(&buf);
+
+	return isvalid;
+}
+
 static void submodule_free_dup(void *sm)
 {
 	git_submodule_free(sm);
@@ -1075,16 +1118,23 @@ int git_submodule_add_to_index(git_submodule *sm, int write_index)
 	git_commit_free(head);
 
 	/* add it */
-	error = git_index_add(index, &entry);
+	if ((error = git_index_add(index, &entry)) < 0)
+		goto cleanup;
+
+	/* Adding implies conflict was resolved, move conflict entries to REUC */
+	if ((error = git_index__conflict_to_reuc(index, entry.path)) < 0 && error != GIT_ENOTFOUND)
+		goto cleanup;
 
 	/* write it, if requested */
-	if (!error && write_index) {
-		error = git_index_write(index);
+	if (write_index) {
+		if ((error = git_index_write(index)) < 0)
+			goto cleanup;
 
-		if (!error)
-			git_oid_cpy(&sm->index_oid, &sm->wd_oid);
+		git_oid_cpy(&sm->index_oid, &sm->wd_oid);
 	}
 
+	error = 0;
+
 cleanup:
 	git_repository_free(sm_repo);
 	git_str_dispose(&path);
@@ -1714,18 +1764,34 @@ static int submodule_update_head(git_submodule *submodule)
 	return 0;
 }
 
+static int submodule_name_error(const char *name)
+{
+	git_error_set(GIT_ERROR_SUBMODULE,
+		"invalid value for submodule name: '%s'", name);
+	return GIT_EINVALID;
+}
+
+static int submodule_config_error(const char *property, const char *value)
+{
+	git_error_set(GIT_ERROR_SUBMODULE,
+		"invalid value for submodule '%s' property: '%s'", property, value);
+	return GIT_EINVALID;
+}
+
 int git_submodule_reload(git_submodule *sm, int force)
 {
 	git_config *mods = NULL;
-	int error;
+	int valid, error = 0;
 
 	GIT_UNUSED(force);
 
 	GIT_ASSERT_ARG(sm);
 
-	if ((error = git_submodule_name_is_valid(sm->repo, sm->name, 0)) <= 0)
+	if ((valid = git_submodule_name_is_valid(sm->repo, sm->name, 0)) <= 0) {
 		/* This should come with a warning, but we've no API for that */
+		error = valid ? valid : submodule_name_error(sm->name);
 		goto out;
+	}
 
 	if (git_repository_is_bare(sm->repo))
 		goto out;
@@ -1748,6 +1814,12 @@ int git_submodule_reload(git_submodule *sm, int force)
 	    (error = submodule_update_head(sm)) < 0)
 		goto out;
 
+	if ((valid = path_is_valid(sm->repo, sm->path)) <= 0) {
+		/* This should come with a warning, but we've no API for that */
+		error = valid ? valid : submodule_config_error("path", sm->path);
+		goto out;
+	}
+
 out:
 	git_config_free(mods);
 	return error;
@@ -1931,13 +2003,6 @@ void git_submodule_free(git_submodule *sm)
 	GIT_REFCOUNT_DEC(sm, submodule_release);
 }
 
-static int submodule_config_error(const char *property, const char *value)
-{
-	git_error_set(GIT_ERROR_INVALID,
-		"invalid value for submodule '%s' property: '%s'", property, value);
-	return -1;
-}
-
 int git_submodule_parse_ignore(git_submodule_ignore_t *out, const char *value)
 {
 	int val;
@@ -2136,6 +2201,13 @@ static int submodule_load_each(const git_config_entry *entry, void *payload)
 		goto done;
 	}
 
+	isvalid = path_is_valid(data->repo, sm->path);
+	if (isvalid <= 0) {
+		git_submodule_free(sm);
+		error = isvalid;
+		goto done;
+	}
+
 	if ((error = git_submodule_cache_put(cache, sm->name, sm)) < 0)
 		goto done;
 

data/vendor/libgit2/src/libgit2/tag.c

@@ -263,8 +263,10 @@ static bool tag_name_is_valid(const char *tag_name)
 	/*
 	 * Discourage tag name starting with dash,
 	 * https://github.com/git/git/commit/4f0accd638b8d2
+	 * and refuse to use HEAD as a tagname,
+	 * https://github.com/git/git/commit/bbd445d5efd415
 	 */
-	return tag_name[0] != '-';
+	return tag_name[0] != '-' && git__strcmp(tag_name, "HEAD");
 }
 
 static int git_tag_create__internal(

data/vendor/libgit2/src/libgit2/transports/auth_sspi.c

@@ -324,12 +324,14 @@ static int sspi_init_context(
 	return 0;
 }
 
+#if defined(GIT_GSSAPI) || defined(GIT_GSSFRAMEWORK) || defined(GIT_WIN32)
 int git_http_auth_negotiate(
 	git_http_auth_context **out,
 	const git_net_url *url)
 {
 	return sspi_init_context(out, GIT_HTTP_AUTH_NEGOTIATE, url);
 }
+#endif
 
 int git_http_auth_ntlm(
 	git_http_auth_context **out,

data/vendor/libgit2/src/libgit2/transports/credential.c

@@ -161,7 +161,7 @@ static void ssh_custom_free(struct git_credential *cred)
 
 	if (c->publickey) {
 		/* Zero the memory which previously held the publickey */
-		size_t key_len = strlen(c->publickey);
+		size_t key_len = c->publickey_len;
 		git__memzero(c->publickey, key_len);
 		git__free(c->publickey);
 	}

data/vendor/libgit2/src/libgit2/transports/git.c

@@ -39,7 +39,7 @@ typedef struct {
  */
 static int gen_proto(git_str *request, const char *cmd, const char *url)
 {
-	char *delim, *repo;
+	const char *delim, *repo;
 	char host[] = "host=";
 	size_t len;
 

data/vendor/libgit2/src/libgit2/transports/http.c

@@ -130,12 +130,12 @@ GIT_INLINE(void) free_cred(git_credential **cred)
 static int handle_auth(
 	http_server *server,
 	const char *server_type,
-	const char *url,
 	unsigned int allowed_schemetypes,
 	unsigned int allowed_credtypes,
 	git_credential_acquire_cb callback,
 	void *callback_payload)
 {
+	git_str server_url = GIT_STR_INIT;
 	int error = 1;
 
 	if (server->cred)
@@ -154,7 +154,8 @@ static int handle_auth(
 	}
 
 	if (error > 0 && callback) {
-		error = callback(&server->cred, url, server->url.username, allowed_credtypes, callback_payload);
+		if ((error = git_net_url_fmt(&server_url, &server->url)) == 0)
+			error = callback(&server->cred, server_url.ptr, server->url.username, allowed_credtypes, callback_payload);
 
 		/* treat GIT_PASSTHROUGH as if callback isn't set */
 		if (error == GIT_PASSTHROUGH)
@@ -169,6 +170,7 @@ static int handle_auth(
 	if (!error)
 		server->auth_schemetypes = allowed_schemetypes;
 
+	git_str_dispose(&server_url);
 	return error;
 }
 
@@ -188,7 +190,6 @@ GIT_INLINE(int) handle_remote_auth(
 	return handle_auth(
 		&transport->server,
 		SERVER_TYPE_REMOTE,
-		transport->owner->url,
 		response->server_auth_schemetypes,
 		response->server_auth_credtypes,
 		connect_opts->callbacks.credentials,
@@ -211,7 +212,6 @@ GIT_INLINE(int) handle_proxy_auth(
 	return handle_auth(
 		&transport->proxy,
 		SERVER_TYPE_PROXY,
-		connect_opts->proxy_opts.url,
 		response->server_auth_schemetypes,
 		response->proxy_auth_credtypes,
 		connect_opts->proxy_opts.credentials,

data/vendor/libgit2/src/libgit2/transports/httpclient.c

@@ -379,7 +379,7 @@ static int on_headers_complete(git_http_parser *parser)
 	ctx->response->resend_credentials = resend_needed(ctx->client,
 	                                                  ctx->response);
 
-	if (ctx->response->content_type || ctx->response->chunked)
+	if (ctx->response->content_length || ctx->response->chunked)
 		ctx->client->state = READING_BODY;
 	else
 		ctx->client->state = DONE;
@@ -553,7 +553,7 @@ static int apply_credentials(
 {
 	git_http_auth_context *auth = server->auth_context;
 	git_vector *challenges = &server->auth_challenges;
-	const char *challenge;
+	const char *challenge = NULL;
 	git_str token = GIT_STR_INIT;
 	int error = 0;
 
@@ -1243,13 +1243,16 @@ GIT_INLINE(int) client_read_and_parse(git_http_client *client)
 }
 
 /*
- * See if we've consumed the entire response body.  If the client was
- * reading the body but did not consume it entirely, it's possible that
- * they knew that the stream had finished (in a git response, seeing a
- * final flush) and stopped reading.  But if the response was chunked,
- * we may have not consumed the final chunk marker.  Consume it to
- * ensure that we don't have it waiting in our socket.  If there's
- * more than just a chunk marker, close the connection.
+ * Try to consume any remaining response body. The client may have
+ * decided that it did not need to consume the entire response body.
+ * For example, the client saw a redirect in the header and ignored
+ * the body. Or the client saw a particular sequence (like a final
+ * flush in a git response) and stopped reading (but there were
+ * additional response bytes, perhaps because the response was chunked).
+ * Do one more read to try to clear this out; this takes care of small
+ * remainders, like a chunk response or a small redirect message. If
+ * there is too much data, we'll just leave it and close the
+ * connection.
  */
 static void complete_response_body(git_http_client *client)
 {

data/vendor/libgit2/src/libgit2/transports/local.c

@@ -41,6 +41,9 @@ typedef struct {
 	git_vector refs;
 	unsigned connected : 1,
 		have_refs : 1;
+#ifdef GIT_EXPERIMENTAL_SHA256
+	git_oid_t oid_type;
+#endif
 } transport_local;
 
 static void free_head(git_remote_head *head)
@@ -231,6 +234,10 @@ static int local_connect(
 
 	t->repo = repo;
 
+#ifdef GIT_EXPERIMENTAL_SHA256
+	t->oid_type = repo->oid_type;
+#endif
+
 	if (store_refs(t) < 0)
 		return -1;
 
@@ -267,7 +274,7 @@ static int local_oid_type(git_oid_t *out, git_transport *transport)
 {
 	transport_local *t = (transport_local *)transport;
 
-	*out = t->repo->oid_type;
+	*out = t->oid_type;
 
 	return 0;
 }

data/vendor/libgit2/src/libgit2/transports/smart.c

@@ -64,13 +64,13 @@ GIT_INLINE(int) git_smart__reset_stream(transport_smart *t, bool close_subtransp
 
 		if (t->wrapped->close(t->wrapped) < 0)
 			return -1;
-	}
 
-	git__free(t->caps.object_format);
-	t->caps.object_format = NULL;
+		git__free(t->caps.object_format);
+		t->caps.object_format = NULL;
 
-	git__free(t->caps.agent);
-	t->caps.agent = NULL;
+		git__free(t->caps.agent);
+		t->caps.agent = NULL;
+	}
 
 	return 0;
 }

data/vendor/libgit2/src/libgit2/transports/smart_pkt.c

@@ -236,15 +236,16 @@ static int set_data(
 	    len > (size_t)((caps - line) + 1)) {
 		caps++;
 
-		if (strncmp(caps, "object-format=", CONST_STRLEN("object-format=")) == 0)
+		if (len - (caps - line) >= CONST_STRLEN("object-format=") &&
+		    strncmp(caps, "object-format=", CONST_STRLEN("object-format=")) == 0)
 			format_str = caps + CONST_STRLEN("object-format=");
-		else if ((format_str = strstr(caps, " object-format=")) != NULL)
+		else if ((format_str = git__memmem(caps, len - (caps - line), " object-format=", CONST_STRLEN(" object-format="))) != NULL)
 			format_str += CONST_STRLEN(" object-format=");
 	}
 
 	if (format_str) {
-		if ((eos = strchr(format_str, ' ')) == NULL)
-			eos = strchr(format_str, '\0');
+		if ((eos = memchr(format_str, ' ', len - (format_str - line))) == NULL)
+			eos = memchr(format_str, '\0', len - (format_str - line));
 
 		GIT_ASSERT(eos);
 

data/vendor/libgit2/src/libgit2/transports/ssh_exec.c

@@ -120,7 +120,8 @@ GIT_INLINE(int) ensure_transport_state(
 }
 
 static int get_ssh_cmdline(
-	git_str *out,
+	git_vector *args,
+	bool *use_shell,
 	ssh_exec_subtransport *transport,
 	git_net_url *url,
 	const char *command)
@@ -128,7 +129,8 @@ static int get_ssh_cmdline(
 	git_remote *remote = ((transport_smart *)transport->owner)->owner;
 	git_repository *repo = remote->repo;
 	git_config *cfg;
-	git_str ssh_cmd = GIT_STR_INIT;
+	git_str ssh_cmd = GIT_STR_INIT, url_and_host = GIT_STR_INIT,
+		remote_cmd = GIT_STR_INIT;
 	const char *default_ssh_cmd = "ssh";
 	int error;
 
@@ -151,25 +153,57 @@ static int get_ssh_cmdline(
 	if ((error = git_repository_config_snapshot(&cfg, repo)) < 0)
 		return error;
 
-	if ((error = git__getenv(&ssh_cmd, "GIT_SSH")) == 0)
-		;
+	if ((error = git__getenv(&ssh_cmd, "GIT_SSH_COMMAND")) == 0)
+		*use_shell = true;
+	else if (error != GIT_ENOTFOUND)
+		goto done;
+	else if ((error = git__getenv(&ssh_cmd, "GIT_SSH")) == 0)
+		*use_shell = false;
 	else if (error != GIT_ENOTFOUND)
 		goto done;
 	else if ((error = git_config__get_string_buf(&ssh_cmd, cfg, "core.sshcommand")) < 0 && error != GIT_ENOTFOUND)
 		goto done;
 
-	error = git_str_printf(out, "%s %s %s \"%s%s%s\" \"%s\" \"%s\"",
-		ssh_cmd.size > 0 ? ssh_cmd.ptr : default_ssh_cmd,
-		url->port_specified ? "-p" : "",
-		url->port_specified ? url->port : "",
-		url->username ? url->username : "",
-		url->username ? "@" : "",
-		url->host,
-		command,
-		url->path);
+	git_error_clear();
+
+	if (!ssh_cmd.size &&
+	    git_str_puts(&ssh_cmd, default_ssh_cmd) < 0)
+		goto done;
+
+	if ((error = git_vector_insert(args, git_str_detach(&ssh_cmd))) < 0)
+		goto done;
+
+	if (url->port_specified) {
+		char *p = git__strdup("-p");
+		char *port = git__strdup(url->port);
+
+		if (!p || !port ||
+		    (error = git_vector_insert(args, p)) < 0 ||
+		    (error = git_vector_insert(args, port)) < 0)
+			goto done;
+	}
+
+	if (url->username) {
+		if ((error = git_str_puts(&url_and_host, url->username)) < 0 ||
+		    (error = git_str_putc(&url_and_host, '@')) < 0)
+			goto done;
+	}
+
+	if ((error = git_str_puts(&url_and_host, url->host)) < 0 ||
+	    (error = git_vector_insert(args, git_str_detach(&url_and_host))) < 0)
+		goto done;
+
+	if ((error = git_str_puts(&remote_cmd, command)) < 0 ||
+	    (error = git_str_puts(&remote_cmd, " '")) < 0 ||
+	    (error = git_str_puts_escaped(&remote_cmd, url->path, "'!", "'\\", "'")) < 0 ||
+	    (error = git_str_puts(&remote_cmd, "'")) < 0 ||
+	    (error = git_vector_insert(args, git_str_detach(&remote_cmd))) < 0)
+		goto done;
 
 done:
 	git_str_dispose(&ssh_cmd);
+	git_str_dispose(&url_and_host);
+	git_str_dispose(&remote_cmd);
 	git_config_free(cfg);
 	return error;
 }
@@ -183,7 +217,8 @@ static int start_ssh(
 
 	git_process_options process_opts = GIT_PROCESS_OPTIONS_INIT;
 	git_net_url url = GIT_NET_URL_INIT;
-	git_str ssh_cmdline = GIT_STR_INIT;
+	git_vector args = GIT_VECTOR_INIT;
+	bool use_shell = false;
 	const char *command;
 	int error;
 
@@ -214,11 +249,15 @@ static int start_ssh(
 	if (error < 0)
 		goto done;
 
-	if ((error = get_ssh_cmdline(&ssh_cmdline, transport, &url, command)) < 0)
+	if ((error = get_ssh_cmdline(&args, &use_shell,
+			transport, &url, command)) < 0)
 		goto done;
 
-	if ((error = git_process_new_from_cmdline(&transport->process,
-	     ssh_cmdline.ptr, env, ARRAY_SIZE(env), &process_opts)) < 0 ||
+	process_opts.use_shell = use_shell;
+
+	if ((error = git_process_new(&transport->process,
+	     (const char **)args.contents, args.length,
+	     env, ARRAY_SIZE(env), &process_opts)) < 0 ||
 	    (error = git_process_start(transport->process)) < 0) {
 		git_process_free(transport->process);
 		transport->process = NULL;
@@ -226,7 +265,7 @@ static int start_ssh(
 	}
 
 done:
-	git_str_dispose(&ssh_cmdline);
+	git_vector_dispose_deep(&args);
 	git_net_url_dispose(&url);
 	return error;
 }

data/vendor/libgit2/src/libgit2/transports/ssh_libssh2.c

@@ -366,7 +366,7 @@ static int _git_ssh_authenticate_session(
 		default:
 			rc = LIBSSH2_ERROR_AUTHENTICATION_FAILED;
 		}
-	} while (LIBSSH2_ERROR_EAGAIN == rc || LIBSSH2_ERROR_TIMEOUT == rc);
+	} while (LIBSSH2_ERROR_EAGAIN == rc);
 
 	if (rc == LIBSSH2_ERROR_PASSWORD_EXPIRED ||
 		rc == LIBSSH2_ERROR_AUTHENTICATION_FAILED ||
@@ -556,7 +556,7 @@ static int _git_ssh_session_create(
 	if (git_str_len(&prefs) > 0) {
 		do {
 			rc = libssh2_session_method_pref(s, LIBSSH2_METHOD_HOSTKEY, git_str_cstr(&prefs));
-		} while (LIBSSH2_ERROR_EAGAIN == rc || LIBSSH2_ERROR_TIMEOUT == rc);
+		} while (LIBSSH2_ERROR_EAGAIN == rc);
 		if (rc != LIBSSH2_ERROR_NONE) {
 			ssh_error(s, "failed to set hostkey preference");
 			goto on_error;
@@ -566,7 +566,7 @@ static int _git_ssh_session_create(
 
 	do {
 		rc = libssh2_session_handshake(s, socket->s);
-	} while (LIBSSH2_ERROR_EAGAIN == rc || LIBSSH2_ERROR_TIMEOUT == rc);
+	} while (LIBSSH2_ERROR_EAGAIN == rc);
 
 	if (rc != LIBSSH2_ERROR_NONE) {
 		ssh_error(s, "failed to start SSH session");

data/vendor/libgit2/src/util/CMakeLists.txt

@@ -2,13 +2,12 @@
 
 add_library(util OBJECT)
 
-configure_file(git2_features.h.in git2_features.h)
+configure_file(git2_features.h.in "${PROJECT_BINARY_DIR}/gen_headers/git2_features.h")
 
 set(UTIL_INCLUDES
-	"${PROJECT_BINARY_DIR}/src/util"
-	"${PROJECT_BINARY_DIR}/include"
 	"${PROJECT_SOURCE_DIR}/src/util"
-	"${PROJECT_SOURCE_DIR}/include")
+	"${PROJECT_SOURCE_DIR}/include"
+	"${PROJECT_BINARY_DIR}/gen_headers")
 
 file(GLOB UTIL_SRC *.c *.h allocators/*.c allocators/*.h hash.h)
 list(SORT UTIL_SRC)