rugged 1.6.3 → 1.9.0

data/vendor/libgit2/src/libgit2/config_list.c

@@ -0,0 +1,285 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * 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 "config_list.h"
+#include "hashmap_str.h"
+
+typedef struct config_entry_list {
+	struct config_entry_list *next;
+	struct config_entry_list *last;
+	git_config_list_entry *entry;
+} config_entry_list;
+
+typedef struct {
+	git_config_list_entry *entry;
+	bool multivar;
+} config_entry_map_head;
+
+typedef struct config_list_iterator {
+	git_config_iterator parent;
+	git_config_list *list;
+	config_entry_list *head;
+} config_list_iterator;
+
+GIT_HASHMAP_STR_SETUP(git_config_list_pathmap, char *);
+GIT_HASHMAP_STR_SETUP(git_config_list_headmap, config_entry_map_head *);
+
+struct git_config_list {
+	git_refcount rc;
+
+	/* Interned strings - paths to config files or backend types */
+	git_config_list_pathmap strings;
+
+	/* Config entries */
+	git_config_list_headmap map;
+	config_entry_list *entries;
+};
+
+int git_config_list_new(git_config_list **out)
+{
+	git_config_list *config_list;
+
+	config_list = git__calloc(1, sizeof(git_config_list));
+	GIT_ERROR_CHECK_ALLOC(config_list);
+	GIT_REFCOUNT_INC(config_list);
+
+	*out = config_list;
+	return 0;
+}
+
+int git_config_list_dup_entry(git_config_list *config_list, const git_config_entry *entry)
+{
+	git_config_list_entry *duplicated;
+	int error;
+
+	duplicated = git__calloc(1, sizeof(git_config_list_entry));
+	GIT_ERROR_CHECK_ALLOC(duplicated);
+
+	duplicated->base.entry.name = git__strdup(entry->name);
+	GIT_ERROR_CHECK_ALLOC(duplicated->base.entry.name);
+
+	if (entry->value) {
+		duplicated->base.entry.value = git__strdup(entry->value);
+		GIT_ERROR_CHECK_ALLOC(duplicated->base.entry.value);
+	}
+
+	duplicated->base.entry.backend_type = git_config_list_add_string(config_list, entry->backend_type);
+	GIT_ERROR_CHECK_ALLOC(duplicated->base.entry.backend_type);
+
+	if (entry->origin_path) {
+		duplicated->base.entry.origin_path = git_config_list_add_string(config_list, entry->origin_path);
+		GIT_ERROR_CHECK_ALLOC(duplicated->base.entry.origin_path);
+	}
+
+	duplicated->base.entry.level = entry->level;
+	duplicated->base.entry.include_depth = entry->include_depth;
+	duplicated->base.free = git_config_list_entry_free;
+	duplicated->config_list = config_list;
+
+	if ((error = git_config_list_append(config_list, duplicated)) < 0)
+		goto out;
+
+out:
+	if (error && duplicated) {
+		git__free((char *) duplicated->base.entry.name);
+		git__free((char *) duplicated->base.entry.value);
+		git__free(duplicated);
+	}
+	return error;
+}
+
+int git_config_list_dup(git_config_list **out, git_config_list *config_list)
+{
+	git_config_list *result = NULL;
+	config_entry_list *head;
+	int error;
+
+	if ((error = git_config_list_new(&result)) < 0)
+		goto out;
+
+	for (head = config_list->entries; head; head = head->next)
+		if ((git_config_list_dup_entry(result, &head->entry->base.entry)) < 0)
+			goto out;
+
+	*out = result;
+	result = NULL;
+
+out:
+	git_config_list_free(result);
+	return error;
+}
+
+void git_config_list_incref(git_config_list *config_list)
+{
+	GIT_REFCOUNT_INC(config_list);
+}
+
+static void config_list_free(git_config_list *config_list)
+{
+	config_entry_list *entry_list = NULL, *next;
+	config_entry_map_head *head;
+	char *str;
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
+
+	while (git_config_list_pathmap_iterate(&iter, NULL, &str, &config_list->strings) == 0)
+		git__free(str);
+
+	git_config_list_pathmap_dispose(&config_list->strings);
+
+	iter = GIT_HASHMAP_ITER_INIT;
+	while (git_config_list_headmap_iterate(&iter, NULL, &head, &config_list->map) == 0) {
+		git__free((char *) head->entry->base.entry.name);
+		git__free(head);
+	}
+	git_config_list_headmap_dispose(&config_list->map);
+
+	entry_list = config_list->entries;
+	while (entry_list != NULL) {
+		next = entry_list->next;
+		git__free((char *) entry_list->entry->base.entry.value);
+		git__free(entry_list->entry);
+		git__free(entry_list);
+		entry_list = next;
+	}
+
+	git__free(config_list);
+}
+
+void git_config_list_free(git_config_list *config_list)
+{
+	if (config_list)
+		GIT_REFCOUNT_DEC(config_list, config_list_free);
+}
+
+int git_config_list_append(git_config_list *config_list, git_config_list_entry *entry)
+{
+	config_entry_list *list_head;
+	config_entry_map_head *map_head;
+
+	if (git_config_list_headmap_get(&map_head, &config_list->map, entry->base.entry.name) == 0) {
+		map_head->multivar = true;
+		/*
+		 * This is a micro-optimization for configuration files
+		 * with a lot of same keys. As for multivars the entry's
+		 * key will be the same for all list, we can just free
+		 * all except the first entry's name and just re-use it.
+		 */
+		git__free((char *) entry->base.entry.name);
+		entry->base.entry.name = map_head->entry->base.entry.name;
+	} else {
+		map_head = git__calloc(1, sizeof(*map_head));
+		if ((git_config_list_headmap_put(&config_list->map, entry->base.entry.name, map_head)) < 0)
+			return -1;
+	}
+	map_head->entry = entry;
+
+	list_head = git__calloc(1, sizeof(config_entry_list));
+	GIT_ERROR_CHECK_ALLOC(list_head);
+	list_head->entry = entry;
+
+	if (config_list->entries)
+		config_list->entries->last->next = list_head;
+	else
+		config_list->entries = list_head;
+	config_list->entries->last = list_head;
+
+	return 0;
+}
+
+int git_config_list_get(git_config_list_entry **out, git_config_list *config_list, const char *key)
+{
+	config_entry_map_head *entry;
+
+	if (git_config_list_headmap_get(&entry, &config_list->map, key) != 0)
+		return GIT_ENOTFOUND;
+
+	*out = entry->entry;
+	return 0;
+}
+
+int git_config_list_get_unique(git_config_list_entry **out, git_config_list *config_list, const char *key)
+{
+	config_entry_map_head *entry;
+
+	if (git_config_list_headmap_get(&entry, &config_list->map, key) != 0)
+		return GIT_ENOTFOUND;
+
+	if (entry->multivar) {
+		git_error_set(GIT_ERROR_CONFIG, "entry is not unique due to being a multivar");
+		return -1;
+	}
+
+	if (entry->entry->base.entry.include_depth) {
+		git_error_set(GIT_ERROR_CONFIG, "entry is not unique due to being included");
+		return -1;
+	}
+
+	*out = entry->entry;
+	return 0;
+}
+
+static void config_iterator_free(git_config_iterator *iter)
+{
+	config_list_iterator *it = (config_list_iterator *) iter;
+	git_config_list_free(it->list);
+	git__free(it);
+}
+
+static int config_iterator_next(
+	git_config_backend_entry **entry,
+	git_config_iterator *iter)
+{
+	config_list_iterator *it = (config_list_iterator *) iter;
+
+	if (!it->head)
+		return GIT_ITEROVER;
+
+	*entry = &it->head->entry->base;
+	it->head = it->head->next;
+
+	return 0;
+}
+
+int git_config_list_iterator_new(git_config_iterator **out, git_config_list *config_list)
+{
+	config_list_iterator *it;
+
+	it = git__calloc(1, sizeof(config_list_iterator));
+	GIT_ERROR_CHECK_ALLOC(it);
+	it->parent.next = config_iterator_next;
+	it->parent.free = config_iterator_free;
+	it->head = config_list->entries;
+	it->list = config_list;
+
+	git_config_list_incref(config_list);
+	*out = &it->parent;
+
+	return 0;
+}
+
+/* release the map containing the entry as an equivalent to freeing it */
+void git_config_list_entry_free(git_config_backend_entry *e)
+{
+	git_config_list_entry *entry = (git_config_list_entry *)e;
+	git_config_list_free(entry->config_list);
+}
+
+const char *git_config_list_add_string(
+	git_config_list *config_list,
+	const char *str)
+{
+	char *s;
+
+	if (git_config_list_pathmap_get(&s, &config_list->strings, str) == 0)
+		return s;
+
+	if ((s = git__strdup(str)) == NULL ||
+	     git_config_list_pathmap_put(&config_list->strings, s, s) < 0)
+		return NULL;
+
+	return s;
+}

data/vendor/libgit2/src/libgit2/config_list.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * 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/sys/config.h"
+#include "config.h"
+
+typedef struct git_config_list git_config_list;
+
+typedef struct {
+	git_config_backend_entry base;
+	git_config_list *config_list;
+} git_config_list_entry;
+
+int git_config_list_new(git_config_list **out);
+int git_config_list_dup(git_config_list **out, git_config_list *list);
+int git_config_list_dup_entry(git_config_list *list, const git_config_entry *entry);
+void git_config_list_incref(git_config_list *list);
+void git_config_list_free(git_config_list *list);
+/* Add or append the new config option */
+int git_config_list_append(git_config_list *list, git_config_list_entry *entry);
+int git_config_list_get(git_config_list_entry **out, git_config_list *list, const char *key);
+int git_config_list_get_unique(git_config_list_entry **out, git_config_list *list, const char *key);
+int git_config_list_iterator_new(git_config_iterator **out, git_config_list *list);
+const char *git_config_list_add_string(git_config_list *list, const char *str);
+
+void git_config_list_entry_free(git_config_backend_entry *entry);

data/vendor/libgit2/src/libgit2/config_mem.c

@@ -9,16 +9,29 @@
 
 #include "config_backend.h"
 #include "config_parse.h"
-#include "config_entries.h"
+#include "config_list.h"
+#include "strlist.h"
 
 typedef struct {
 	git_config_backend parent;
-	git_config_entries *entries;
+
+	char *backend_type;
+	char *origin_path;
+
+	git_config_list *config_list;
+
+	/* Configuration data in the config file format */
 	git_str cfg;
+
+	/* Array of key=value pairs */
+	char **values;
+	size_t values_len;
 } config_memory_backend;
 
 typedef struct {
-	git_config_entries *entries;
+	const char *backend_type;
+	const char *origin_path;
+	git_config_list *config_list;
 	git_config_level_t level;
 } config_memory_parse_data;
 
@@ -39,7 +52,7 @@ static int read_variable_cb(
 {
 	config_memory_parse_data *parse_data = (config_memory_parse_data *) payload;
 	git_str buf = GIT_STR_INIT;
-	git_config_entry *entry;
+	git_config_list_entry *entry;
 	const char *c;
 	int result;
 
@@ -62,35 +75,46 @@ static int read_variable_cb(
 	if (git_str_oom(&buf))
 		return -1;
 
-	entry = git__calloc(1, sizeof(git_config_entry));
+	entry = git__calloc(1, sizeof(git_config_list_entry));
 	GIT_ERROR_CHECK_ALLOC(entry);
-	entry->name = git_str_detach(&buf);
-	entry->value = var_value ? git__strdup(var_value) : NULL;
-	entry->level = parse_data->level;
-	entry->include_depth = 0;
-
-	if ((result = git_config_entries_append(parse_data->entries, entry)) < 0)
+	entry->base.entry.name = git_str_detach(&buf);
+	entry->base.entry.value = var_value ? git__strdup(var_value) : NULL;
+	entry->base.entry.level = parse_data->level;
+	entry->base.entry.include_depth = 0;
+	entry->base.entry.backend_type = parse_data->backend_type;
+	entry->base.entry.origin_path = parse_data->origin_path;
+	entry->base.free = git_config_list_entry_free;
+	entry->config_list = parse_data->config_list;
+
+	if ((result = git_config_list_append(parse_data->config_list, entry)) < 0)
 		return result;
 
 	return result;
 }
 
-static int config_memory_open(git_config_backend *backend, git_config_level_t level, const git_repository *repo)
+static int parse_config(
+	config_memory_backend *memory_backend,
+	git_config_level_t level)
 {
-	config_memory_backend *memory_backend = (config_memory_backend *) backend;
 	git_config_parser parser = GIT_PARSE_CTX_INIT;
 	config_memory_parse_data parse_data;
 	int error;
 
-	GIT_UNUSED(repo);
-
-	if ((error = git_config_parser_init(&parser, "in-memory", memory_backend->cfg.ptr,
-					    memory_backend->cfg.size)) < 0)
+	if ((error = git_config_parser_init(&parser, "in-memory",
+		memory_backend->cfg.ptr, memory_backend->cfg.size)) < 0)
 		goto out;
-	parse_data.entries = memory_backend->entries;
+
+	parse_data.backend_type = git_config_list_add_string(
+		memory_backend->config_list, memory_backend->backend_type);
+	parse_data.origin_path = memory_backend->origin_path ?
+		git_config_list_add_string(memory_backend->config_list,
+			memory_backend->origin_path) :
+		NULL;
+	parse_data.config_list = memory_backend->config_list;
 	parse_data.level = level;
 
-	if ((error = git_config_parse(&parser, NULL, read_variable_cb, NULL, NULL, &parse_data)) < 0)
+	if ((error = git_config_parse(&parser, NULL, read_variable_cb,
+		NULL, NULL, &parse_data)) < 0)
 		goto out;
 
 out:
@@ -98,10 +122,85 @@ out:
 	return error;
 }
 
-static int config_memory_get(git_config_backend *backend, const char *key, git_config_entry **out)
+static int parse_values(
+	config_memory_backend *memory_backend,
+	git_config_level_t level)
+{
+	git_config_list_entry *entry;
+	const char *eql, *backend_type, *origin_path;
+	size_t name_len, i;
+
+	backend_type = git_config_list_add_string(
+		memory_backend->config_list, memory_backend->backend_type);
+	GIT_ERROR_CHECK_ALLOC(backend_type);
+
+	origin_path = memory_backend->origin_path ?
+		git_config_list_add_string(memory_backend->config_list,
+			memory_backend->origin_path) :
+		NULL;
+
+	for (i = 0; i < memory_backend->values_len; i++) {
+		eql = strchr(memory_backend->values[i], '=');
+		name_len = eql - memory_backend->values[i];
+
+		if (name_len == 0) {
+			git_error_set(GIT_ERROR_CONFIG, "empty config key");
+			return -1;
+		}
+
+		entry = git__calloc(1, sizeof(git_config_list_entry));
+		GIT_ERROR_CHECK_ALLOC(entry);
+
+		entry->base.entry.name = git__strndup(memory_backend->values[i], name_len);
+		GIT_ERROR_CHECK_ALLOC(entry->base.entry.name);
+
+		if (eql) {
+			entry->base.entry.value = git__strdup(eql + 1);
+			GIT_ERROR_CHECK_ALLOC(entry->base.entry.value);
+		}
+
+		entry->base.entry.level = level;
+		entry->base.entry.include_depth = 0;
+		entry->base.entry.backend_type = backend_type;
+		entry->base.entry.origin_path = origin_path;
+		entry->base.free = git_config_list_entry_free;
+		entry->config_list = memory_backend->config_list;
+
+		if (git_config_list_append(memory_backend->config_list, entry) < 0)
+			return -1;
+	}
+
+	return 0;
+}
+
+static int config_memory_open(git_config_backend *backend, git_config_level_t level, const git_repository *repo)
+{
+	config_memory_backend *memory_backend = (config_memory_backend *) backend;
+
+	GIT_UNUSED(repo);
+
+	if (memory_backend->cfg.size > 0 &&
+	    parse_config(memory_backend, level) < 0)
+		return -1;
+
+	if (memory_backend->values_len > 0 &&
+	    parse_values(memory_backend, level) < 0)
+		return -1;
+
+	return 0;
+}
+
+static int config_memory_get(git_config_backend *backend, const char *key, git_config_backend_entry **out)
 {
 	config_memory_backend *memory_backend = (config_memory_backend *) backend;
-	return git_config_entries_get(out, memory_backend->entries, key);
+	git_config_list_entry *entry;
+	int error;
+
+	if ((error = git_config_list_get(&entry, memory_backend->config_list, key)) != 0)
+		return error;
+
+	*out = &entry->base;
+	return 0;
 }
 
 static int config_memory_iterator(
@@ -109,18 +208,18 @@ static int config_memory_iterator(
 	git_config_backend *backend)
 {
 	config_memory_backend *memory_backend = (config_memory_backend *) backend;
-	git_config_entries *entries;
+	git_config_list *config_list;
 	int error;
 
-	if ((error = git_config_entries_dup(&entries, memory_backend->entries)) < 0)
+	if ((error = git_config_list_dup(&config_list, memory_backend->config_list)) < 0)
 		goto out;
 
-	if ((error = git_config_entries_iterator_new(iter, entries)) < 0)
+	if ((error = git_config_list_iterator_new(iter, config_list)) < 0)
 		goto out;
 
 out:
-	/* Let iterator delete duplicated entries when it's done */
-	git_config_entries_free(entries);
+	/* Let iterator delete duplicated config_list when it's done */
+	git_config_list_free(config_list);
 	return error;
 }
 
@@ -177,28 +276,24 @@ static void config_memory_free(git_config_backend *_backend)
 	if (backend == NULL)
 		return;
 
-	git_config_entries_free(backend->entries);
+	git__free(backend->origin_path);
+	git__free(backend->backend_type);
+	git_config_list_free(backend->config_list);
+	git_strlist_free(backend->values, backend->values_len);
 	git_str_dispose(&backend->cfg);
 	git__free(backend);
 }
 
-int git_config_backend_from_string(git_config_backend **out, const char *cfg, size_t len)
+static config_memory_backend *config_backend_new(
+	git_config_backend_memory_options *opts)
 {
 	config_memory_backend *backend;
 
-	backend = git__calloc(1, sizeof(config_memory_backend));
-	GIT_ERROR_CHECK_ALLOC(backend);
+	if ((backend = git__calloc(1, sizeof(config_memory_backend))) == NULL)
+		return NULL;
 
-	if (git_config_entries_new(&backend->entries) < 0) {
-		git__free(backend);
-		return -1;
-	}
-
-	if (git_str_set(&backend->cfg, cfg, len) < 0) {
-		git_config_entries_free(backend->entries);
-		git__free(backend);
-		return -1;
-	}
+	if (git_config_list_new(&backend->config_list) < 0)
+		goto on_error;
 
 	backend->parent.version = GIT_CONFIG_BACKEND_VERSION;
 	backend->parent.readonly = 1;
@@ -214,7 +309,66 @@ int git_config_backend_from_string(git_config_backend **out, const char *cfg, si
 	backend->parent.snapshot = git_config_backend_snapshot;
 	backend->parent.free = config_memory_free;
 
+	backend->backend_type = git__strdup(opts && opts->backend_type ?
+		opts->backend_type : "in-memory");
+
+	if (backend->backend_type == NULL)
+		goto on_error;
+
+	if (opts && opts->origin_path &&
+	    (backend->origin_path = git__strdup(opts->origin_path)) == NULL)
+		goto on_error;
+
+	return backend;
+
+on_error:
+	git_config_list_free(backend->config_list);
+	git__free(backend->origin_path);
+	git__free(backend->backend_type);
+	git__free(backend);
+	return NULL;
+}
+
+int git_config_backend_from_string(
+	git_config_backend **out,
+	const char *cfg,
+	size_t len,
+	git_config_backend_memory_options *opts)
+{
+	config_memory_backend *backend;
+
+	if ((backend = config_backend_new(opts)) == NULL)
+		return -1;
+
+	if (git_str_set(&backend->cfg, cfg, len) < 0) {
+		git_config_list_free(backend->config_list);
+		git__free(backend);
+		return -1;
+	}
+
 	*out = (git_config_backend *)backend;
+	return 0;
+}
+
+int git_config_backend_from_values(
+	git_config_backend **out,
+	const char **values,
+	size_t len,
+	git_config_backend_memory_options *opts)
+{
+	config_memory_backend *backend;
 
+	if ((backend = config_backend_new(opts)) == NULL)
+		return -1;
+
+	if (git_strlist_copy(&backend->values, values, len) < 0) {
+		git_config_list_free(backend->config_list);
+		git__free(backend);
+		return -1;
+	}
+
+	backend->values_len = len;
+
+	*out = (git_config_backend *)backend;
 	return 0;
 }

data/vendor/libgit2/src/libgit2/config_parse.c

@@ -25,9 +25,9 @@ static void set_parse_error(git_config_parser *reader, int col, const char *erro
 }
 
 
-GIT_INLINE(int) config_keychar(int c)
+GIT_INLINE(int) config_keychar(char c)
 {
-	return isalnum(c) || c == '-';
+	return git__isalnum(c) || c == '-';
 }
 
 static int strip_comments(char *line, int in_quotes)
@@ -158,9 +158,10 @@ end_error:
 static int parse_section_header(git_config_parser *reader, char **section_out)
 {
 	char *name, *name_end;
-	int name_length, c, pos;
+	int name_length, pos;
 	int result;
 	char *line;
+	char c;
 	size_t line_len;
 
 	git_parse_advance_ws(&reader->ctx);
@@ -279,8 +280,7 @@ static int skip_bom(git_parse_ctx *parser)
 */
 
 /* '\"' -> '"' etc */
-static int unescape_line(
-	char **out, bool *is_multi, const char *ptr, int quote_count)
+static int unescape_line(char **out, bool *is_multi, const char *ptr, int *quote_count)
 {
 	char *str, *fixed, *esc;
 	size_t ptr_len = strlen(ptr), alloc_len;
@@ -296,7 +296,8 @@ static int unescape_line(
 
 	while (*ptr != '\0') {
 		if (*ptr == '"') {
-			quote_count++;
+			if (quote_count)
+				(*quote_count)++;
 		} else if (*ptr != '\\') {
 			*fixed++ = *ptr;
 		} else {
@@ -358,7 +359,7 @@ static int parse_multiline_variable(git_config_parser *reader, git_str *value, i
 			goto next;
 
 		if ((error = unescape_line(&proc_line, &multiline,
-					   line, in_quotes)) < 0)
+					   line, &in_quotes)) < 0)
 			goto out;
 
 		/* Add this line to the multiline var */
@@ -382,7 +383,7 @@ out:
 
 GIT_INLINE(bool) is_namechar(char c)
 {
-	return isalnum(c) || c == '-';
+	return git__isalnum(c) || c == '-';
 }
 
 static int parse_name(
@@ -445,7 +446,7 @@ static int parse_variable(git_config_parser *reader, char **var_name, char **var
 		while (git__isspace(value_start[0]))
 			value_start++;
 
-		if ((error = unescape_line(&value, &multiline, value_start, 0)) < 0)
+		if ((error = unescape_line(&value, &multiline, value_start, NULL)) < 0)
 			goto out;
 
 		if (multiline) {