rugged 0.27.7 → 0.27.10

data/vendor/libgit2/src/config_mem.c

@@ -0,0 +1,220 @@
+/*
+ * 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.h"
+
+#include "config_backend.h"
+#include "config_parse.h"
+#include "config_entries.h"
+
+typedef struct {
+	git_config_backend parent;
+	git_config_entries *entries;
+	git_buf cfg;
+} config_memory_backend;
+
+typedef struct {
+	git_config_entries *entries;
+	git_config_level_t level;
+} config_memory_parse_data;
+
+static int config_error_readonly(void)
+{
+	git_error_set(GIT_ERROR_CONFIG, "this backend is read-only");
+	return -1;
+}
+
+static int read_variable_cb(
+	git_config_parser *reader,
+	const char *current_section,
+	const char *var_name,
+	const char *var_value,
+	const char *line,
+	size_t line_len,
+	void *payload)
+{
+	config_memory_parse_data *parse_data = (config_memory_parse_data *) payload;
+	git_buf buf = GIT_BUF_INIT;
+	git_config_entry *entry;
+	const char *c;
+	int result;
+
+	GIT_UNUSED(reader);
+	GIT_UNUSED(line);
+	GIT_UNUSED(line_len);
+
+	if (current_section) {
+		/* TODO: Once warnings land, we should likely warn
+		 * here. Git appears to warn in most cases if it sees
+		 * un-namespaced config options.
+		 */
+		git_buf_puts(&buf, current_section);
+		git_buf_putc(&buf, '.');
+	}
+
+	for (c = var_name; *c; c++)
+		git_buf_putc(&buf, git__tolower(*c));
+
+	if (git_buf_oom(&buf))
+		return -1;
+
+	entry = git__calloc(1, sizeof(git_config_entry));
+	GIT_ERROR_CHECK_ALLOC(entry);
+	entry->name = git_buf_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)
+		return result;
+
+	return result;
+}
+
+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_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)
+		goto out;
+	parse_data.entries = memory_backend->entries;
+	parse_data.level = level;
+
+	if ((error = git_config_parse(&parser, NULL, read_variable_cb, NULL, NULL, &parse_data)) < 0)
+		goto out;
+
+out:
+	git_config_parser_dispose(&parser);
+	return error;
+}
+
+static int config_memory_get(git_config_backend *backend, const char *key, git_config_entry **out)
+{
+	config_memory_backend *memory_backend = (config_memory_backend *) backend;
+	return git_config_entries_get(out, memory_backend->entries, key);
+}
+
+static int config_memory_iterator(
+	git_config_iterator **iter,
+	git_config_backend *backend)
+{
+	config_memory_backend *memory_backend = (config_memory_backend *) backend;
+	git_config_entries *entries;
+	int error;
+
+	if ((error = git_config_entries_dup(&entries, memory_backend->entries)) < 0)
+		goto out;
+
+	if ((error = git_config_entries_iterator_new(iter, entries)) < 0)
+		goto out;
+
+out:
+	/* Let iterator delete duplicated entries when it's done */
+	git_config_entries_free(entries);
+	return error;
+}
+
+static int config_memory_set(git_config_backend *backend, const char *name, const char *value)
+{
+	GIT_UNUSED(backend);
+	GIT_UNUSED(name);
+	GIT_UNUSED(value);
+	return config_error_readonly();
+}
+
+static int config_memory_set_multivar(
+	git_config_backend *backend, const char *name, const char *regexp, const char *value)
+{
+	GIT_UNUSED(backend);
+	GIT_UNUSED(name);
+	GIT_UNUSED(regexp);
+	GIT_UNUSED(value);
+	return config_error_readonly();
+}
+
+static int config_memory_delete(git_config_backend *backend, const char *name)
+{
+	GIT_UNUSED(backend);
+	GIT_UNUSED(name);
+	return config_error_readonly();
+}
+
+static int config_memory_delete_multivar(git_config_backend *backend, const char *name, const char *regexp)
+{
+	GIT_UNUSED(backend);
+	GIT_UNUSED(name);
+	GIT_UNUSED(regexp);
+	return config_error_readonly();
+}
+
+static int config_memory_lock(git_config_backend *backend)
+{
+	GIT_UNUSED(backend);
+	return config_error_readonly();
+}
+
+static int config_memory_unlock(git_config_backend *backend, int success)
+{
+	GIT_UNUSED(backend);
+	GIT_UNUSED(success);
+	return config_error_readonly();
+}
+
+static void config_memory_free(git_config_backend *_backend)
+{
+	config_memory_backend *backend = (config_memory_backend *)_backend;
+
+	if (backend == NULL)
+		return;
+
+	git_config_entries_free(backend->entries);
+	git_buf_dispose(&backend->cfg);
+	git__free(backend);
+}
+
+int git_config_backend_from_string(git_config_backend **out, const char *cfg, size_t len)
+{
+	config_memory_backend *backend;
+
+	backend = git__calloc(1, sizeof(config_memory_backend));
+	GIT_ERROR_CHECK_ALLOC(backend);
+
+	if (git_config_entries_new(&backend->entries) < 0) {
+		git__free(backend);
+		return -1;
+	}
+
+	if (git_buf_set(&backend->cfg, cfg, len) < 0) {
+		git_config_entries_free(backend->entries);
+		git__free(backend);
+		return -1;
+	}
+
+	backend->parent.version = GIT_CONFIG_BACKEND_VERSION;
+	backend->parent.readonly = 1;
+	backend->parent.open = config_memory_open;
+	backend->parent.get = config_memory_get;
+	backend->parent.set = config_memory_set;
+	backend->parent.set_multivar = config_memory_set_multivar;
+	backend->parent.del = config_memory_delete;
+	backend->parent.del_multivar = config_memory_delete_multivar;
+	backend->parent.iterator = config_memory_iterator;
+	backend->parent.lock = config_memory_lock;
+	backend->parent.unlock = config_memory_unlock;
+	backend->parent.snapshot = git_config_backend_snapshot;
+	backend->parent.free = config_memory_free;
+
+	*out = (git_config_backend *)backend;
+
+	return 0;
+}

data/vendor/libgit2/src/config_parse.c

@@ -11,10 +11,19 @@
 
 #include <ctype.h>
 
+const char *git_config_escapes = "ntb\"\\";
+const char *git_config_escaped = "\n\t\b\"\\";
+
 static void set_parse_error(git_config_parser *reader, int col, const char *error_str)
 {
-	giterr_set(GITERR_CONFIG, "failed to parse config file: %s (in %s:%"PRIuZ", column %d)",
-		error_str, reader->file->path, reader->ctx.line_num, col);
+	if (col)
+		git_error_set(GIT_ERROR_CONFIG,
+		              "failed to parse config file: %s (in %s:%"PRIuZ", column %d)",
+		              error_str, reader->path, reader->ctx.line_num, col);
+	else
+		git_error_set(GIT_ERROR_CONFIG,
+		              "failed to parse config file: %s (in %s:%"PRIuZ")",
+		              error_str, reader->path, reader->ctx.line_num);
 }
 
 
@@ -55,35 +64,40 @@ static int strip_comments(char *line, int in_quotes)
 }
 
 
-static int parse_section_header_ext(git_config_parser *reader, const char *line, const char *base_name, char **section_name)
+static int parse_subsection_header(git_config_parser *reader, const char *line, size_t pos, const char *base_name, char **section_name)
 {
 	int c, rpos;
-	char *first_quote, *last_quote;
+	const char *first_quote, *last_quote;
+	const char *line_start = line;
 	git_buf buf = GIT_BUF_INIT;
 	size_t quoted_len, alloc_len, base_name_len = strlen(base_name);
 
-	/*
-	 * base_name is what came before the space. We should be at the
-	 * first quotation mark, except for now, line isn't being kept in
-	 * sync so we only really use it to calculate the length.
-	 */
+	/* Skip any additional whitespace before our section name */
+	while (git__isspace(line[pos]))
+		pos++;
 
-	first_quote = strchr(line, '"');
-	if (first_quote == NULL) {
-		set_parse_error(reader, 0, "Missing quotation marks in section header");
+	/* We should be at the first quotation mark. */
+	if (line[pos] != '"') {
+		set_parse_error(reader, 0, "missing quotation marks in section header");
 		goto end_error;
 	}
 
+	first_quote = &line[pos];
 	last_quote = strrchr(line, '"');
 	quoted_len = last_quote - first_quote;
 
+	if ((last_quote - line) > INT_MAX) {
+		set_parse_error(reader, 0, "invalid section header, line too long");
+		goto end_error;
+	}
+
 	if (quoted_len == 0) {
-		set_parse_error(reader, 0, "Missing closing quotation mark in section header");
+		set_parse_error(reader, 0, "missing closing quotation mark in section header");
 		goto end_error;
 	}
 
-	GITERR_CHECK_ALLOC_ADD(&alloc_len, base_name_len, quoted_len);
-	GITERR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, 2);
+	GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, base_name_len, quoted_len);
+	GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, 2);
 
 	if (git_buf_grow(&buf, alloc_len) < 0 ||
 	    git_buf_printf(&buf, "%s.", base_name) < 0)
@@ -102,7 +116,7 @@ static int parse_section_header_ext(git_config_parser *reader, const char *line,
 
 		switch (c) {
 		case 0:
-			set_parse_error(reader, 0, "Unexpected end-of-line in section header");
+			set_parse_error(reader, 0, "unexpected end-of-line in section header");
 			goto end_error;
 
 		case '"':
@@ -112,7 +126,7 @@ static int parse_section_header_ext(git_config_parser *reader, const char *line,
 			c = line[++rpos];
 
 			if (c == 0) {
-				set_parse_error(reader, rpos, "Unexpected end-of-line in section header");
+				set_parse_error(reader, rpos, "unexpected end-of-line in section header");
 				goto end_error;
 			}
 
@@ -129,13 +143,13 @@ end_parse:
 		goto end_error;
 
 	if (line[rpos] != '"' || line[rpos + 1] != ']') {
-		set_parse_error(reader, rpos, "Unexpected text after closing quotes");
+		set_parse_error(reader, rpos, "unexpected text after closing quotes");
 		git_buf_dispose(&buf);
 		return -1;
 	}
 
 	*section_name = git_buf_detach(&buf);
-	return base_name_len + 1 /* SP */ + 1 /* " */ + rpos + 1 /* " */ + 1 /* ] */;
+	return (int)(&line[rpos + 2] - line_start); /* rpos is at the closing quote */
 
 end_error:
 	git_buf_dispose(&buf);
@@ -160,13 +174,13 @@ static int parse_section_header(git_config_parser *reader, char **section_out)
 	name_end = strrchr(line, ']');
 	if (name_end == NULL) {
 		git__free(line);
-		set_parse_error(reader, 0, "Missing ']' in section header");
+		set_parse_error(reader, 0, "missing ']' in section header");
 		return -1;
 	}
 
-	GITERR_CHECK_ALLOC_ADD(&line_len, (size_t)(name_end - line), 1);
+	GIT_ERROR_CHECK_ALLOC_ADD(&line_len, (size_t)(name_end - line), 1);
 	name = git__malloc(line_len);
-	GITERR_CHECK_ALLOC(name);
+	GIT_ERROR_CHECK_ALLOC(name);
 
 	name_length = 0;
 	pos = 0;
@@ -180,14 +194,14 @@ static int parse_section_header(git_config_parser *reader, char **section_out)
 	do {
 		if (git__isspace(c)){
 			name[name_length] = '\0';
-			result = parse_section_header_ext(reader, line, name, section_out);
+			result = parse_subsection_header(reader, line, pos, name, section_out);
 			git__free(line);
 			git__free(name);
 			return result;
 		}
 
 		if (!config_keychar(c) && c != '.') {
-			set_parse_error(reader, pos, "Unexpected character in header");
+			set_parse_error(reader, pos, "unexpected character in header");
 			goto fail_parse;
 		}
 
@@ -196,7 +210,7 @@ static int parse_section_header(git_config_parser *reader, char **section_out)
 	} while ((c = line[pos++]) != ']');
 
 	if (line[pos - 1] != ']') {
-		set_parse_error(reader, pos, "Unexpected end of file");
+		set_parse_error(reader, pos, "unexpected end of file");
 		goto fail_parse;
 	}
 
@@ -299,7 +313,7 @@ static int unescape_line(
 				*fixed++ = git_config_escaped[esc - git_config_escapes];
 			} else {
 				git__free(str);
-				giterr_set(GITERR_CONFIG, "invalid escape at %s", ptr);
+				git_error_set(GIT_ERROR_CONFIG, "invalid escape at %s", ptr);
 				return -1;
 			}
 		}
@@ -315,49 +329,51 @@ done:
 
 static int parse_multiline_variable(git_config_parser *reader, git_buf *value, int in_quotes)
 {
-	char *line = NULL, *proc_line = NULL;
 	int quote_count;
-	bool multiline;
+	bool multiline = true;
 
-	/* Check that the next line exists */
-	git_parse_advance_line(&reader->ctx);
-	line = git__strndup(reader->ctx.line, reader->ctx.line_len);
-	if (line == NULL)
-		return -1;
+	while (multiline) {
+		char *line = NULL, *proc_line = NULL;
+		int error;
 
-	/* We've reached the end of the file, there is no continuation.
-	 * (this is not an error).
-	 */
-	if (line[0] == '\0') {
-		git__free(line);
-		return 0;
-	}
+		/* Check that the next line exists */
+		git_parse_advance_line(&reader->ctx);
+		line = git__strndup(reader->ctx.line, reader->ctx.line_len);
+		GIT_ERROR_CHECK_ALLOC(line);
+
+		/*
+		 * We've reached the end of the file, there is no continuation.
+		 * (this is not an error).
+		 */
+		if (line[0] == '\0') {
+			error = 0;
+			goto out;
+		}
 
-	quote_count = strip_comments(line, !!in_quotes);
+		/* If it was just a comment, pretend it didn't exist */
+		quote_count = strip_comments(line, !!in_quotes);
+		if (line[0] == '\0')
+			goto next;
 
-	/* If it was just a comment, pretend it didn't exist */
-	if (line[0] == '\0') {
+		if ((error = unescape_line(&proc_line, &multiline,
+					   line, in_quotes)) < 0)
+			goto out;
+
+		/* Add this line to the multiline var */
+		if ((error = git_buf_puts(value, proc_line)) < 0)
+			goto out;
+
+next:
 		git__free(line);
-		return parse_multiline_variable(reader, value, quote_count);
-		/* TODO: unbounded recursion. This **could** be exploitable */
-	}
+		git__free(proc_line);
+		in_quotes = quote_count;
+		continue;
 
-	if (unescape_line(&proc_line, &multiline, line, in_quotes) < 0) {
+out:
 		git__free(line);
-		return -1;
+		git__free(proc_line);
+		return error;
 	}
-	/* add this line to the multiline var */
-
-	git_buf_puts(value, proc_line);
-	git__free(line);
-	git__free(proc_line);
-
-	/*
-	 * If we need to continue reading the next line, let's just
-	 * keep putting stuff in the buffer
-	 */
-	if (multiline)
-		return parse_multiline_variable(reader, value, quote_count);
 
 	return 0;
 }
@@ -379,7 +395,7 @@ static int parse_name(
 		name_end++;
 
 	if (line == name_end) {
-		set_parse_error(reader, 0, "Invalid configuration key");
+		set_parse_error(reader, 0, "invalid configuration key");
 		return -1;
 	}
 
@@ -391,7 +407,7 @@ static int parse_name(
 	if (*value_start == '=') {
 		*value = value_start + 1;
 	} else if (*value_start) {
-		set_parse_error(reader, 0, "Invalid configuration key");
+		set_parse_error(reader, 0, "invalid configuration key");
 		return -1;
 	}
 
@@ -413,7 +429,7 @@ static int parse_variable(git_config_parser *reader, char **var_name, char **var
 
 	git_parse_advance_ws(&reader->ctx);
 	line = git__strndup(reader->ctx.line, reader->ctx.line_len);
-	GITERR_CHECK_ALLOC(line);
+	GIT_ERROR_CHECK_ALLOC(line);
 
 	quote_count = strip_comments(line, 0);
 
@@ -433,6 +449,7 @@ static int parse_variable(git_config_parser *reader, char **var_name, char **var
 		if (multiline) {
 			git_buf multi_value = GIT_BUF_INIT;
 			git_buf_attach(&multi_value, value, 0);
+			value = NULL;
 
 			if (parse_multiline_variable(reader, &multi_value, quote_count) < 0 ||
 			    git_buf_oom(&multi_value)) {
@@ -457,13 +474,24 @@ out:
 	return error;
 }
 
+int git_config_parser_init(git_config_parser *out, const char *path, const char *data, size_t datalen)
+{
+	out->path = path;
+	return git_parse_ctx_init(&out->ctx, data, datalen);
+}
+
+void git_config_parser_dispose(git_config_parser *parser)
+{
+	git_parse_ctx_clear(&parser->ctx);
+}
+
 int git_config_parse(
 	git_config_parser *parser,
 	git_config_parser_section_cb on_section,
 	git_config_parser_variable_cb on_variable,
 	git_config_parser_comment_cb on_comment,
 	git_config_parser_eof_cb on_eof,
-	void *data)
+	void *payload)
 {
 	git_parse_ctx *ctx;
 	char *current_section = NULL, *var_name = NULL, *var_value = NULL;
@@ -503,7 +531,7 @@ int git_config_parse(
 			git_parse_advance_chars(ctx, result);
 
 			if (on_section)
-				result = on_section(parser, current_section, line_start, line_len, data);
+				result = on_section(parser, current_section, line_start, line_len, payload);
 			/*
 			 * After we've parsed the section header we may not be
 			 * done with the line. If there's still data in there,
@@ -523,13 +551,13 @@ int git_config_parse(
 		case ';':
 		case '#':
 			if (on_comment) {
-				result = on_comment(parser, line_start, line_len, data);
+				result = on_comment(parser, line_start, line_len, payload);
 			}
 			break;
 
 		default: /* assume variable declaration */
 			if ((result = parse_variable(parser, &var_name, &var_value)) == 0 && on_variable) {
-				result = on_variable(parser, current_section, var_name, var_value, line_start, line_len, data);
+				result = on_variable(parser, current_section, var_name, var_value, line_start, line_len, payload);
 				git__free(var_name);
 				git__free(var_value);
 			}
@@ -542,7 +570,7 @@ int git_config_parse(
 	}
 
 	if (on_eof)
-		result = on_eof(parser, current_section, data);
+		result = on_eof(parser, current_section, payload);
 
 out:
 	git__free(current_section);

data/vendor/libgit2/src/config_parse.h

@@ -8,30 +8,28 @@
 #define INCLUDE_config_parse_h__
 
 #include "common.h"
+
 #include "array.h"
+#include "futils.h"
 #include "oid.h"
 #include "parse.h"
 
-static const char *git_config_escapes = "ntb\"\\";
-static const char *git_config_escaped = "\n\t\b\"\\";
-
-typedef struct config_file {
-	git_oid checksum;
-	char *path;
-	git_array_t(struct config_file) includes;
-} git_config_file;
+extern const char *git_config_escapes;
+extern const char *git_config_escaped;
 
 typedef struct {
-	struct config_file *file;
+	const char *path;
 	git_parse_ctx ctx;
 } git_config_parser;
 
+#define GIT_CONFIG_PARSER_INIT { NULL, GIT_PARSE_CTX_INIT }
+
 typedef int (*git_config_parser_section_cb)(
 	git_config_parser *parser,
 	const char *current_section,
 	const char *line,
 	size_t line_len,
-	void *data);
+	void *payload);
 
 typedef int (*git_config_parser_variable_cb)(
 	git_config_parser *parser,
@@ -40,18 +38,21 @@ typedef int (*git_config_parser_variable_cb)(
 	const char *var_value,
 	const char *line,
 	size_t line_len,
-	void *data);
+	void *payload);
 
 typedef int (*git_config_parser_comment_cb)(
 	git_config_parser *parser,
 	const char *line,
 	size_t line_len,
-	void *data);
+	void *payload);
 
 typedef int (*git_config_parser_eof_cb)(
 	git_config_parser *parser,
 	const char *current_section,
-	void *data);
+	void *payload);
+
+int git_config_parser_init(git_config_parser *out, const char *path, const char *data, size_t datalen);
+void git_config_parser_dispose(git_config_parser *parser);
 
 int git_config_parse(
 	git_config_parser *parser,
@@ -59,6 +60,6 @@ int git_config_parse(
 	git_config_parser_variable_cb on_variable,
 	git_config_parser_comment_cb on_comment,
 	git_config_parser_eof_cb on_eof,
-	void *data);
+	void *payload);
 
 #endif