rugged 1.1.1 → 1.4.3

data/vendor/libgit2/src/config.c

@@ -10,7 +10,7 @@
 #include "git2/config.h"
 #include "git2/sys/config.h"
 
-#include "buf_text.h"
+#include "buf.h"
 #include "config_backend.h"
 #include "regexp.h"
 #include "sysdir.h"
@@ -108,7 +108,8 @@ int git_config_add_file_ondisk(
 	struct stat st;
 	int res;
 
-	assert(cfg && path);
+	GIT_ASSERT_ARG(cfg);
+	GIT_ASSERT_ARG(path);
 
 	res = p_stat(path, &st);
 	if (res < 0 && errno != ENOENT && errno != ENOTDIR) {
@@ -316,7 +317,8 @@ int git_config_add_backend(
 	backend_internal *internal;
 	int result;
 
-	assert(cfg && backend);
+	GIT_ASSERT_ARG(cfg);
+	GIT_ASSERT_ARG(backend);
 
 	GIT_ERROR_CHECK_VERSION(backend, GIT_CONFIG_BACKEND_VERSION, "git_config_backend");
 
@@ -510,11 +512,12 @@ int git_config_backend_foreach_match(
 	void *payload)
 {
 	git_config_entry *entry;
-	git_config_iterator* iter;
+	git_config_iterator *iter;
 	git_regexp regex;
 	int error = 0;
 
-	assert(backend && cb);
+	GIT_ASSERT_ARG(backend);
+	GIT_ASSERT_ARG(cb);
 
 	if (regexp && git_regexp_compile(&regex, regexp, 0) < 0)
 		return -1;
@@ -846,7 +849,40 @@ static int is_readonly(const git_config *cfg)
 	return 1;
 }
 
-int git_config_get_path(git_buf *out, const git_config *cfg, const char *name)
+static int git_config__parse_path(git_str *out, const char *value)
+{
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(value);
+
+	if (value[0] == '~') {
+		if (value[1] != '\0' && value[1] != '/') {
+			git_error_set(GIT_ERROR_CONFIG, "retrieving a homedir by name is not supported");
+			return -1;
+		}
+
+		return git_sysdir_expand_global_file(out, value[1] ? &value[2] : NULL);
+	}
+
+	return git_str_sets(out, value);
+}
+
+int git_config_parse_path(git_buf *out, const char *value)
+{
+	GIT_BUF_WRAP_PRIVATE(out, git_config__parse_path, value);
+}
+
+int git_config_get_path(
+	git_buf *out,
+	const git_config *cfg,
+	const char *name)
+{
+	GIT_BUF_WRAP_PRIVATE(out, git_config__get_path, cfg, name);
+}
+
+int git_config__get_path(
+	git_str *out,
+	const git_config *cfg,
+	const char *name)
 {
 	git_config_entry *entry;
 	int error;
@@ -854,7 +890,7 @@ int git_config_get_path(git_buf *out, const git_config *cfg, const char *name)
 	if ((error = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)
 		return error;
 
-	 error = git_config_parse_path(out, entry->value);
+	 error = git_config__parse_path(out, entry->value);
 	 git_config_entry_free(entry);
 
 	 return error;
@@ -881,18 +917,25 @@ int git_config_get_string(
 
 int git_config_get_string_buf(
 	git_buf *out, const git_config *cfg, const char *name)
+{
+	GIT_BUF_WRAP_PRIVATE(out, git_config__get_string_buf, cfg, name);
+}
+
+int git_config__get_string_buf(
+	git_str *out, const git_config *cfg, const char *name)
 {
 	git_config_entry *entry;
 	int ret;
 	const char *str;
 
-	git_buf_sanitize(out);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(cfg);
 
 	ret  = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS);
 	str = !ret ? (entry->value ? entry->value : "") : NULL;
 
 	if (str)
-		ret = git_buf_puts(out, str);
+		ret = git_str_puts(out, str);
 
 	git_config_entry_free(entry);
 
@@ -1084,87 +1127,116 @@ void git_config_iterator_free(git_config_iterator *iter)
 
 int git_config_find_global(git_buf *path)
 {
-	git_buf_sanitize(path);
+	GIT_BUF_WRAP_PRIVATE(path, git_sysdir_find_global_file, GIT_CONFIG_FILENAME_GLOBAL);
+}
+
+int git_config__find_global(git_str *path)
+{
 	return git_sysdir_find_global_file(path, GIT_CONFIG_FILENAME_GLOBAL);
 }
 
 int git_config_find_xdg(git_buf *path)
 {
-	git_buf_sanitize(path);
+	GIT_BUF_WRAP_PRIVATE(path, git_sysdir_find_global_file, GIT_CONFIG_FILENAME_XDG);
+}
+
+int git_config__find_xdg(git_str *path)
+{
 	return git_sysdir_find_xdg_file(path, GIT_CONFIG_FILENAME_XDG);
 }
 
 int git_config_find_system(git_buf *path)
 {
-	git_buf_sanitize(path);
+	GIT_BUF_WRAP_PRIVATE(path, git_sysdir_find_global_file, GIT_CONFIG_FILENAME_SYSTEM);
+}
+
+int git_config__find_system(git_str *path)
+{
 	return git_sysdir_find_system_file(path, GIT_CONFIG_FILENAME_SYSTEM);
 }
 
 int git_config_find_programdata(git_buf *path)
 {
-	int ret;
+	git_str str = GIT_STR_INIT;
+	int error;
 
-	git_buf_sanitize(path);
-	ret = git_sysdir_find_programdata_file(path,
-					       GIT_CONFIG_FILENAME_PROGRAMDATA);
-	if (ret != GIT_OK)
-		return ret;
+	if ((error = git_buf_tostr(&str, path)) == 0 &&
+	    (error = git_config__find_programdata(&str)) == 0)
+		error = git_buf_fromstr(path, &str);
+
+	git_str_dispose(&str);
+	return error;
+}
+
+int git_config__find_programdata(git_str *path)
+{
+	bool is_safe;
+
+	if (git_sysdir_find_programdata_file(path, GIT_CONFIG_FILENAME_PROGRAMDATA) < 0 ||
+	    git_fs_path_owner_is_system_or_current_user(&is_safe, path->ptr) < 0)
+		return -1;
+
+	if (!is_safe) {
+		git_error_set(GIT_ERROR_CONFIG, "programdata path has invalid ownership");
+		return -1;
+	}
 
-	return git_path_validate_system_file_ownership(path->ptr);
+	return 0;
 }
 
-int git_config__global_location(git_buf *buf)
+int git_config__global_location(git_str *buf)
 {
-	const git_buf *paths;
+	const git_str *paths;
 	const char *sep, *start;
 
 	if (git_sysdir_get(&paths, GIT_SYSDIR_GLOBAL) < 0)
 		return -1;
 
 	/* no paths, so give up */
-	if (!paths || !git_buf_len(paths))
+	if (!paths || !git_str_len(paths))
 		return -1;
 
 	/* find unescaped separator or end of string */
-	for (sep = start = git_buf_cstr(paths); *sep; ++sep) {
+	for (sep = start = git_str_cstr(paths); *sep; ++sep) {
 		if (*sep == GIT_PATH_LIST_SEPARATOR &&
 			(sep <= start || sep[-1] != '\\'))
 			break;
 	}
 
-	if (git_buf_set(buf, start, (size_t)(sep - start)) < 0)
+	if (git_str_set(buf, start, (size_t)(sep - start)) < 0)
 		return -1;
 
-	return git_buf_joinpath(buf, buf->ptr, GIT_CONFIG_FILENAME_GLOBAL);
+	return git_str_joinpath(buf, buf->ptr, GIT_CONFIG_FILENAME_GLOBAL);
 }
 
 int git_config_open_default(git_config **out)
 {
 	int error;
 	git_config *cfg = NULL;
-	git_buf buf = GIT_BUF_INIT;
+	git_str buf = GIT_STR_INIT;
 
 	if ((error = git_config_new(&cfg)) < 0)
 		return error;
 
-	if (!git_config_find_global(&buf) || !git_config__global_location(&buf)) {
+	if (!git_config__find_global(&buf) ||
+	    !git_config__global_location(&buf)) {
 		error = git_config_add_file_ondisk(cfg, buf.ptr,
 			GIT_CONFIG_LEVEL_GLOBAL, NULL, 0);
 	}
 
-	if (!error && !git_config_find_xdg(&buf))
+	if (!error && !git_config__find_xdg(&buf))
 		error = git_config_add_file_ondisk(cfg, buf.ptr,
 			GIT_CONFIG_LEVEL_XDG, NULL, 0);
 
-	if (!error && !git_config_find_system(&buf))
+	if (!error && !git_config__find_system(&buf))
 		error = git_config_add_file_ondisk(cfg, buf.ptr,
 			GIT_CONFIG_LEVEL_SYSTEM, NULL, 0);
 
-	if (!error && !git_config_find_programdata(&buf))
+	if (!error && !git_config__find_programdata(&buf))
 		error = git_config_add_file_ondisk(cfg, buf.ptr,
 			GIT_CONFIG_LEVEL_PROGRAMDATA, NULL, 0);
 
-	git_buf_dispose(&buf);
+	git_str_dispose(&buf);
 
 	if (error) {
 		git_config_free(cfg);
@@ -1182,7 +1254,7 @@ int git_config_lock(git_transaction **out, git_config *cfg)
 	git_config_backend *backend;
 	backend_internal *internal;
 
-	assert(cfg);
+	GIT_ASSERT_ARG(cfg);
 
 	internal = git_vector_get(&cfg->backends, 0);
 	if (!internal || !internal->backend) {
@@ -1202,7 +1274,7 @@ int git_config_unlock(git_config *cfg, int commit)
 	git_config_backend *backend;
 	backend_internal *internal;
 
-	assert(cfg);
+	GIT_ASSERT_ARG(cfg);
 
 	internal = git_vector_get(&cfg->backends, 0);
 	if (!internal || !internal->backend) {
@@ -1358,24 +1430,6 @@ fail_parse:
 	return -1;
 }
 
-int git_config_parse_path(git_buf *out, const char *value)
-{
-	assert(out && value);
-
-	git_buf_sanitize(out);
-
-	if (value[0] == '~') {
-		if (value[1] != '\0' && value[1] != '/') {
-			git_error_set(GIT_ERROR_CONFIG, "retrieving a homedir by name is not supported");
-			return -1;
-		}
-
-		return git_sysdir_expand_global_file(out, value[1] ? &value[2] : NULL);
-	}
-
-	return git_buf_sets(out, value);
-}
-
 static int normalize_section(char *start, char *end)
 {
 	char *scan;
@@ -1405,7 +1459,8 @@ int git_config__normalize_name(const char *in, char **out)
 {
 	char *name, *fdot, *ldot;
 
-	assert(in && out);
+	GIT_ASSERT_ARG(in);
+	GIT_ASSERT_ARG(out);
 
 	name = git__strdup(in);
 	GIT_ERROR_CHECK_ALLOC(name);
@@ -1437,7 +1492,7 @@ invalid:
 
 struct rename_data {
 	git_config *config;
-	git_buf *name;
+	git_str *name;
 	size_t old_len;
 };
 
@@ -1447,15 +1502,15 @@ static int rename_config_entries_cb(
 {
 	int error = 0;
 	struct rename_data *data = (struct rename_data *)payload;
-	size_t base_len = git_buf_len(data->name);
+	size_t base_len = git_str_len(data->name);
 
 	if (base_len > 0 &&
-		!(error = git_buf_puts(data->name, entry->name + data->old_len)))
+		!(error = git_str_puts(data->name, entry->name + data->old_len)))
 	{
 		error = git_config_set_string(
-			data->config, git_buf_cstr(data->name), entry->value);
+			data->config, git_str_cstr(data->name), entry->value);
 
-		git_buf_truncate(data->name, base_len);
+		git_str_truncate(data->name, base_len);
 	}
 
 	if (!error)
@@ -1470,13 +1525,13 @@ int git_config_rename_section(
 	const char *new_section_name)
 {
 	git_config *config;
-	git_buf pattern = GIT_BUF_INIT, replace = GIT_BUF_INIT;
+	git_str pattern = GIT_STR_INIT, replace = GIT_STR_INIT;
 	int error = 0;
 	struct rename_data data;
 
-	git_buf_text_puts_escape_regex(&pattern, old_section_name);
+	git_str_puts_escape_regex(&pattern, old_section_name);
 
-	if ((error = git_buf_puts(&pattern, "\\..+")) < 0)
+	if ((error = git_str_puts(&pattern, "\\..+")) < 0)
 		goto cleanup;
 
 	if ((error = git_repository_config__weakptr(&config, repo)) < 0)
@@ -1486,7 +1541,7 @@ int git_config_rename_section(
 	data.name    = &replace;
 	data.old_len = strlen(old_section_name) + 1;
 
-	if ((error = git_buf_join(&replace, '.', new_section_name, "")) < 0)
+	if ((error = git_str_join(&replace, '.', new_section_name, "")) < 0)
 		goto cleanup;
 
 	if (new_section_name != NULL &&
@@ -1498,11 +1553,11 @@ int git_config_rename_section(
 	}
 
 	error = git_config_foreach_match(
-		config, git_buf_cstr(&pattern), rename_config_entries_cb, &data);
+		config, git_str_cstr(&pattern), rename_config_entries_cb, &data);
 
 cleanup:
-	git_buf_dispose(&pattern);
-	git_buf_dispose(&replace);
+	git_str_dispose(&pattern);
+	git_str_dispose(&replace);
 
 	return error;
 }

data/vendor/libgit2/src/config.h

@@ -27,7 +27,12 @@ struct git_config {
 	git_vector backends;
 };
 
-extern int git_config__global_location(git_buf *buf);
+extern int git_config__global_location(git_str *buf);
+
+extern int git_config__find_global(git_str *path);
+extern int git_config__find_xdg(git_str *path);
+extern int git_config__find_system(git_str *path);
+extern int git_config__find_programdata(git_str *path);
 
 extern int git_config_rename_section(
 	git_repository *repo,
@@ -51,6 +56,14 @@ extern int git_config__update_entry(
 	bool overwrite_existing,
 	bool only_if_existing);
 
+int git_config__get_path(
+	git_str *out,
+	const git_config *cfg,
+	const char *name);
+
+int git_config__get_string_buf(
+	git_str *out, const git_config *cfg, const char *name);
+
 /*
  * Lookup functions that cannot fail.  These functions look up a config
  * value and return a fallback value if the value is missing or if any
@@ -83,7 +96,7 @@ int git_config_lookup_map_enum(git_configmap_t *type_out,
 /**
  * Unlock the backend with the highest priority
  *
- * Unlocking will allow other writers to updat the configuration
+ * Unlocking will allow other writers to update the configuration
  * file. Optionally, any changes performed since the lock will be
  * applied to the configuration.
  *

data/vendor/libgit2/src/config_cache.c

@@ -86,6 +86,7 @@ static struct map_data _configmaps[] = {
 	{"core.protecthfs", NULL, 0, GIT_PROTECTHFS_DEFAULT },
 	{"core.protectntfs", NULL, 0, GIT_PROTECTNTFS_DEFAULT },
 	{"core.fsyncobjectfiles", NULL, 0, GIT_FSYNCOBJECTFILES_DEFAULT },
+	{"core.longpaths", NULL, 0, GIT_LONGPATHS_DEFAULT },
 };
 
 int git_config__configmap_lookup(int *out, git_config *config, git_configmap_item item)
@@ -111,20 +112,21 @@ int git_config__configmap_lookup(int *out, git_config *config, git_configmap_ite
 
 int git_repository__configmap_lookup(int *out, git_repository *repo, git_configmap_item item)
 {
-	intptr_t value = repo->configmap_cache[(int)item];
+	intptr_t value = (intptr_t)git_atomic_load(repo->configmap_cache[(int)item]);
 
 	*out = (int)value;
 
 	if (value == GIT_CONFIGMAP_NOT_CACHED) {
-		int error;
 		git_config *config;
+		intptr_t oldval = value;
+		int error;
 
 		if ((error = git_repository_config__weakptr(&config, repo)) < 0 ||
 			(error = git_config__configmap_lookup(out, config, item)) < 0)
 			return error;
 
 		value = *out;
-		repo->configmap_cache[(int)item] = value;
+		git_atomic_compare_and_swap(&repo->configmap_cache[(int)item], (void *)oldval, (void *)value);
 	}
 
 	return 0;