rugged 0.1.2 → 0.16.0b1

data/ext/rugged/vendor/libgit2-dist/src/commit.c

@@ -0,0 +1,299 @@
+/*
+ * Copyright (C) 2009-2011 the libgit2 contributors
+ *
+ * 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 "git2/common.h"
+#include "git2/object.h"
+#include "git2/repository.h"
+#include "git2/signature.h"
+
+#include "common.h"
+#include "odb.h"
+#include "commit.h"
+#include "signature.h"
+
+#include <stdarg.h>
+
+#define COMMIT_BASIC_PARSE 0x0
+#define COMMIT_FULL_PARSE 0x1
+
+#define COMMIT_PRINT(commit) {\
+	char oid[41]; oid[40] = 0;\
+	git_oid_fmt(oid, &commit->object.id);\
+	printf("Oid: %s | In degree: %d | Time: %u\n", oid, commit->in_degree, commit->commit_time);\
+}
+
+static void clear_parents(git_commit *commit)
+{
+	unsigned int i;
+
+	for (i = 0; i < commit->parent_oids.length; ++i) {
+		git_oid *parent = git_vector_get(&commit->parent_oids, i);
+		git__free(parent);
+	}
+
+	git_vector_clear(&commit->parent_oids);
+}
+
+void git_commit__free(git_commit *commit)
+{
+	clear_parents(commit);
+	git_vector_free(&commit->parent_oids);
+
+	git_signature_free(commit->author);
+	git_signature_free(commit->committer);
+
+	git__free(commit->message);
+	git__free(commit->message_encoding);
+	git__free(commit);
+}
+
+const git_oid *git_commit_id(git_commit *c)
+{
+	return git_object_id((git_object *)c);
+}
+
+int git_commit_create_v(
+		git_oid *oid,
+		git_repository *repo,
+		const char *update_ref,
+		const git_signature *author,
+		const git_signature *committer,
+		const char *message_encoding,
+		const char *message,
+		const git_tree *tree,
+		int parent_count,
+		...)
+{
+	va_list ap;
+	int i, error;
+	const git_commit **parents;
+
+	parents = git__malloc(parent_count * sizeof(git_commit *));
+
+	va_start(ap, parent_count);
+	for (i = 0; i < parent_count; ++i)
+		parents[i] = va_arg(ap, const git_commit *);
+	va_end(ap);
+
+	error = git_commit_create(
+		oid, repo, update_ref, author, committer,
+		message_encoding, message,
+		tree, parent_count, parents);
+
+	git__free((void *)parents);
+
+	return error;
+}
+
+int git_commit_create(
+		git_oid *oid,
+		git_repository *repo,
+		const char *update_ref,
+		const git_signature *author,
+		const git_signature *committer,
+		const char *message_encoding,
+		const char *message,
+		const git_tree *tree,
+		int parent_count,
+		const git_commit *parents[])
+{
+	git_buf commit = GIT_BUF_INIT;
+	int error, i;
+	git_odb *odb;
+
+	if (git_object_owner((const git_object *)tree) != repo)
+		return git__throw(GIT_EINVALIDARGS, "The given tree does not belong to this repository");
+
+	git_oid__writebuf(&commit, "tree ", git_object_id((const git_object *)tree));
+
+	for (i = 0; i < parent_count; ++i) {
+		if (git_object_owner((const git_object *)parents[i]) != repo) {
+			error = git__throw(GIT_EINVALIDARGS, "The given parent does not belong to this repository");
+			goto cleanup;
+		}
+
+		git_oid__writebuf(&commit, "parent ", git_object_id((const git_object *)parents[i]));
+	}
+
+	git_signature__writebuf(&commit, "author ", author);
+	git_signature__writebuf(&commit, "committer ", committer);
+
+	if (message_encoding != NULL)
+		git_buf_printf(&commit, "encoding %s\n", message_encoding);
+
+	git_buf_putc(&commit, '\n');
+	git_buf_puts(&commit, message);
+
+	if (git_buf_oom(&commit)) {
+		error = git__throw(GIT_ENOMEM, "Not enough memory to build the commit data");
+		goto cleanup;
+	}
+
+	error = git_repository_odb__weakptr(&odb, repo);
+	if (error < GIT_SUCCESS)
+		goto cleanup;
+
+	error = git_odb_write(oid, odb, commit.ptr, commit.size, GIT_OBJ_COMMIT);
+	git_buf_free(&commit);
+
+	if (error == GIT_SUCCESS && update_ref != NULL) {
+		git_reference *head;
+		git_reference *target;
+
+		error = git_reference_lookup(&head, repo, update_ref);
+		if (error < GIT_SUCCESS)
+			return git__rethrow(error, "Failed to create commit");
+
+		error = git_reference_resolve(&target, head);
+		if (error < GIT_SUCCESS) {
+			if (error != GIT_ENOTFOUND) {
+				git_reference_free(head);
+				return git__rethrow(error, "Failed to create commit");
+			}
+		/*
+		 * The target of the reference was not found. This can happen
+		 * just after a repository has been initialized (the master
+		 * branch doesn't exist yet, as it doesn't have anything to
+		 * point to) or after an orphan checkout, so if the target
+		 * branch doesn't exist yet, create it and return.
+		 */
+			error = git_reference_create_oid(&target, repo, git_reference_target(head), oid, 1);
+
+			git_reference_free(head);
+			if (error == GIT_SUCCESS)
+				git_reference_free(target);
+
+			return error;
+		}
+
+		error = git_reference_set_oid(target, oid);
+
+		git_reference_free(head);
+		git_reference_free(target);
+	}
+
+	if (error < GIT_SUCCESS)
+		return git__rethrow(error, "Failed to create commit");
+
+	return GIT_SUCCESS;
+
+cleanup:
+	git_buf_free(&commit);
+	return error;
+}
+
+int git_commit__parse_buffer(git_commit *commit, const void *data, size_t len)
+{
+	const char *buffer = data;
+	const char *buffer_end = (const char *)data + len;
+
+	git_oid parent_oid;
+	int error;
+
+	git_vector_init(&commit->parent_oids, 4, NULL);
+
+	if ((error = git_oid__parse(&commit->tree_oid, &buffer, buffer_end, "tree ")) < GIT_SUCCESS)
+		return git__rethrow(error, "Failed to parse buffer");
+
+	/*
+	 * TODO: commit grafts!
+	 */
+
+	while (git_oid__parse(&parent_oid, &buffer, buffer_end, "parent ") == GIT_SUCCESS) {
+		git_oid *new_oid;
+
+		new_oid = git__malloc(sizeof(git_oid));
+		git_oid_cpy(new_oid, &parent_oid);
+
+		if (git_vector_insert(&commit->parent_oids, new_oid) < GIT_SUCCESS)
+			return GIT_ENOMEM;
+	}
+
+	commit->author = git__malloc(sizeof(git_signature));
+	if ((error = git_signature__parse(commit->author, &buffer, buffer_end, "author ", '\n')) < GIT_SUCCESS)
+		return git__rethrow(error, "Failed to parse commit");
+
+	/* Always parse the committer; we need the commit time */
+	commit->committer = git__malloc(sizeof(git_signature));
+	if ((error = git_signature__parse(commit->committer, &buffer, buffer_end, "committer ", '\n')) < GIT_SUCCESS)
+		return git__rethrow(error, "Failed to parse commit");
+
+	if (git__prefixcmp(buffer, "encoding ") == 0) {
+		const char *encoding_end;
+		buffer += strlen("encoding ");
+
+		encoding_end = buffer;
+		while (encoding_end < buffer_end && *encoding_end != '\n')
+			encoding_end++;
+
+		commit->message_encoding = git__strndup(buffer, encoding_end - buffer);
+		if (!commit->message_encoding)
+			return GIT_ENOMEM;
+
+		buffer = encoding_end;
+	}
+
+	/* parse commit message */
+	while (buffer < buffer_end - 1 && *buffer == '\n')
+		buffer++;
+
+	if (buffer <= buffer_end) {
+		commit->message = git__strndup(buffer, buffer_end - buffer);
+		if (!commit->message)
+			return GIT_ENOMEM;
+	}
+
+	return GIT_SUCCESS;
+}
+
+int git_commit__parse(git_commit *commit, git_odb_object *obj)
+{
+	assert(commit);
+	return git_commit__parse_buffer(commit, obj->raw.data, obj->raw.len);
+}
+
+#define GIT_COMMIT_GETTER(_rvalue, _name, _return) \
+	_rvalue git_commit_##_name(git_commit *commit) \
+	{\
+		assert(commit); \
+		return _return; \
+	}
+
+GIT_COMMIT_GETTER(const git_signature *, author, commit->author)
+GIT_COMMIT_GETTER(const git_signature *, committer, commit->committer)
+GIT_COMMIT_GETTER(const char *, message, commit->message)
+GIT_COMMIT_GETTER(const char *, message_encoding, commit->message_encoding)
+GIT_COMMIT_GETTER(git_time_t, time, commit->committer->when.time)
+GIT_COMMIT_GETTER(int, time_offset, commit->committer->when.offset)
+GIT_COMMIT_GETTER(unsigned int, parentcount, commit->parent_oids.length)
+GIT_COMMIT_GETTER(const git_oid *, tree_oid, &commit->tree_oid);
+
+
+int git_commit_tree(git_tree **tree_out, git_commit *commit)
+{
+	assert(commit);
+	return git_tree_lookup(tree_out, commit->object.repo, &commit->tree_oid);
+}
+
+int git_commit_parent(git_commit **parent, git_commit *commit, unsigned int n)
+{
+	git_oid *parent_oid;
+	assert(commit);
+
+	parent_oid = git_vector_get(&commit->parent_oids, n);
+	if (parent_oid == NULL)
+		return git__throw(GIT_ENOTFOUND, "Parent %u does not exist", n);
+
+	return git_commit_lookup(parent, commit->object.repo, parent_oid);
+}
+
+const git_oid *git_commit_parent_oid(git_commit *commit, unsigned int n)
+{
+	assert(commit);
+
+	return git_vector_get(&commit->parent_oids, n);
+}

data/ext/rugged/vendor/libgit2-dist/src/commit.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2009-2011 the libgit2 contributors
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_commit_h__
+#define INCLUDE_commit_h__
+
+#include "git2/commit.h"
+#include "tree.h"
+#include "repository.h"
+#include "vector.h"
+
+#include <time.h>
+
+struct git_commit {
+	git_object object;
+
+	git_vector parent_oids;
+	git_oid tree_oid;
+
+	git_signature *author;
+	git_signature *committer;
+
+	char *message_encoding;
+	char *message;
+};
+
+void git_commit__free(git_commit *c);
+int git_commit__parse(git_commit *commit, git_odb_object *obj);
+
+int git_commit__parse_buffer(git_commit *commit, const void *data, size_t len);
+#endif

data/ext/rugged/vendor/libgit2-dist/src/common.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2009-2011 the libgit2 contributors
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_common_h__
+#define INCLUDE_common_h__
+
+#include "git2/common.h"
+#include "cc-compat.h"
+
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#ifdef GIT_WIN32
+
+# include <io.h>
+# include <direct.h>
+# include <windows.h>
+# include "win32/msvc-compat.h"
+# include "win32/mingw-compat.h"
+# ifdef GIT_THREADS
+#	include "win32/pthread.h"
+#endif
+
+# define snprintf _snprintf
+
+#ifndef _SSIZE_T_DEFINED
+typedef SSIZE_T ssize_t;
+#endif
+
+#else
+# include <unistd.h>
+
+# ifdef GIT_THREADS
+#	include <pthread.h>
+# endif
+#endif
+
+#include "git2/types.h"
+#include "git2/errors.h"
+#include "thread-utils.h"
+#include "bswap.h"
+
+extern void git___throw(const char *, ...) GIT_FORMAT_PRINTF(1, 2);
+#define git__throw(error, ...) \
+	(git___throw(__VA_ARGS__), error)
+
+extern void git___rethrow(const char *, ...) GIT_FORMAT_PRINTF(1, 2);
+#define git__rethrow(error, ...) \
+	(git___rethrow(__VA_ARGS__), error)
+
+#include "util.h"
+
+
+#endif /* INCLUDE_common_h__ */

data/ext/rugged/vendor/libgit2-dist/src/config.c

@@ -0,0 +1,418 @@
+/*
+ * Copyright (C) 2009-2011 the libgit2 contributors
+ *
+ * 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 "fileops.h"
+#include "hashtable.h"
+#include "config.h"
+#include "git2/config.h"
+#include "vector.h"
+#if GIT_WIN32
+# include <windows.h>
+#endif
+
+#include <ctype.h>
+
+typedef struct {
+	git_config_file *file;
+	int priority;
+} file_internal;
+
+static void config_free(git_config *cfg)
+{
+	unsigned int i;
+	git_config_file *file;
+	file_internal *internal;
+
+	for(i = 0; i < cfg->files.length; ++i){
+		internal = git_vector_get(&cfg->files, i);
+		file = internal->file;
+		file->free(file);
+		git__free(internal);
+	}
+
+	git_vector_free(&cfg->files);
+	git__free(cfg);
+}
+
+void git_config_free(git_config *cfg)
+{
+	if (cfg == NULL)
+		return;
+
+	GIT_REFCOUNT_DEC(cfg, config_free);
+}
+
+static int config_backend_cmp(const void *a, const void *b)
+{
+	const file_internal *bk_a = (const file_internal *)(a);
+	const file_internal *bk_b = (const file_internal *)(b);
+
+	return bk_b->priority - bk_a->priority;
+}
+
+int git_config_new(git_config **out)
+{
+	git_config *cfg;
+
+	cfg = git__malloc(sizeof(git_config));
+	if (cfg == NULL)
+		return GIT_ENOMEM;
+
+	memset(cfg, 0x0, sizeof(git_config));
+
+	if (git_vector_init(&cfg->files, 3, config_backend_cmp) < 0) {
+		git__free(cfg);
+		return GIT_ENOMEM;
+	}
+
+	*out = cfg;
+	GIT_REFCOUNT_INC(cfg);
+	return GIT_SUCCESS;
+}
+
+int git_config_add_file_ondisk(git_config *cfg, const char *path, int priority)
+{
+	git_config_file *file = NULL;
+	int error;
+
+	error = git_config_file__ondisk(&file, path);
+	if (error < GIT_SUCCESS)
+		return error;
+
+	error = git_config_add_file(cfg, file, priority);
+	if (error < GIT_SUCCESS) {
+		/*
+		 * free manually; the file is not owned by the config
+		 * instance yet and will not be freed on cleanup
+		 */
+		file->free(file);
+		return error;
+	}
+
+	return GIT_SUCCESS;
+}
+
+int git_config_open_ondisk(git_config **cfg, const char *path)
+{
+	int error;
+
+	error = git_config_new(cfg);
+	if (error < GIT_SUCCESS)
+		return error;
+
+	error = git_config_add_file_ondisk(*cfg, path, 1);
+	if (error < GIT_SUCCESS)
+		git_config_free(*cfg);
+
+	return error;
+}
+
+int git_config_add_file(git_config *cfg, git_config_file *file, int priority)
+{
+	file_internal *internal;
+	int error;
+
+	assert(cfg && file);
+
+	if ((error = file->open(file)) < GIT_SUCCESS)
+		return git__rethrow(error, "Failed to open config file");
+
+	internal = git__malloc(sizeof(file_internal));
+	if (internal == NULL)
+		return GIT_ENOMEM;
+
+	internal->file = file;
+	internal->priority = priority;
+
+	if (git_vector_insert(&cfg->files, internal) < 0) {
+		git__free(internal);
+		return GIT_ENOMEM;
+	}
+
+	git_vector_sort(&cfg->files);
+	internal->file->cfg = cfg;
+
+	return GIT_SUCCESS;
+}
+
+/*
+ * Loop over all the variables
+ */
+
+int git_config_foreach(git_config *cfg, int (*fn)(const char *, const char *, void *), void *data)
+{
+	int ret = GIT_SUCCESS;
+	unsigned int i;
+	file_internal *internal;
+	git_config_file *file;
+
+	for(i = 0; i < cfg->files.length && ret == 0; ++i) {
+		internal = git_vector_get(&cfg->files, i);
+		file = internal->file;
+		ret = file->foreach(file, fn, data);
+	}
+
+	return ret;
+}
+
+int git_config_delete(git_config *cfg, const char *name)
+{
+	return git_config_set_string(cfg, name, NULL);
+}
+
+/**************
+ * Setters
+ **************/
+
+int git_config_set_int64(git_config *cfg, const char *name, int64_t value)
+{
+	char str_value[32]; /* All numbers should fit in here */
+	p_snprintf(str_value, sizeof(str_value), "%" PRId64, value);
+	return git_config_set_string(cfg, name, str_value);
+}
+
+int git_config_set_int32(git_config *cfg, const char *name, int32_t value)
+{
+	return git_config_set_int64(cfg, name, (int64_t)value);
+}
+
+int git_config_set_bool(git_config *cfg, const char *name, int value)
+{
+	return git_config_set_string(cfg, name, value ? "true" : "false");
+}
+
+int git_config_set_string(git_config *cfg, const char *name, const char *value)
+{
+	file_internal *internal;
+	git_config_file *file;
+
+	if (cfg->files.length == 0)
+		return git__throw(GIT_EINVALIDARGS, "Cannot set variable value; no files open in the `git_config` instance");
+
+	internal = git_vector_get(&cfg->files, 0);
+	file = internal->file;
+
+	return file->set(file, name, value);
+}
+
+/***********
+ * Getters
+ ***********/
+
+int git_config_get_int64(git_config *cfg, const char *name, int64_t *out)
+{
+	const char *value, *num_end;
+	int ret;
+	int64_t num;
+
+	ret = git_config_get_string(cfg, name, &value);
+	if (ret < GIT_SUCCESS)
+		return git__rethrow(ret, "Failed to retrieve value for '%s'", name);
+
+	ret = git__strtol64(&num, value, &num_end, 0);
+	if (ret < GIT_SUCCESS)
+		return git__rethrow(ret, "Failed to convert value for '%s'", name);
+
+	switch (*num_end) {
+	case 'g':
+	case 'G':
+		num *= 1024;
+		/* fallthrough */
+
+	case 'm':
+	case 'M':
+		num *= 1024;
+		/* fallthrough */
+
+	case 'k':
+	case 'K':
+		num *= 1024;
+
+		/* check that that there are no more characters after the
+		 * given modifier suffix */
+		if (num_end[1] != '\0')
+			return git__throw(GIT_EINVALIDTYPE,
+				"Failed to get value for '%s'. Invalid type suffix", name);
+
+		/* fallthrough */
+
+	case '\0':
+		*out = num;
+		return GIT_SUCCESS;
+
+	default:
+		return git__throw(GIT_EINVALIDTYPE,
+			"Failed to get value for '%s'. Value is of invalid type", name);
+	}
+}
+
+int git_config_get_int32(git_config *cfg, const char *name, int32_t *out)
+{
+	int64_t tmp_long;
+	int32_t tmp_int;
+	int ret;
+
+	ret = git_config_get_int64(cfg, name, &tmp_long);
+	if (ret < GIT_SUCCESS)
+		return git__rethrow(ret, "Failed to convert value for '%s'", name);
+	
+	tmp_int = tmp_long & 0xFFFFFFFF;
+	if (tmp_int != tmp_long)
+		return git__throw(GIT_EOVERFLOW, "Value for '%s' is too large", name);
+
+	*out = tmp_int;
+
+	return ret;
+}
+
+int git_config_get_bool(git_config *cfg, const char *name, int *out)
+{
+	const char *value;
+	int error = GIT_SUCCESS;
+
+	error = git_config_get_string(cfg, name, &value);
+	if (error < GIT_SUCCESS)
+		return git__rethrow(error, "Failed to get value for %s", name);
+
+	/* A missing value means true */
+	if (value == NULL) {
+		*out = 1;
+		return GIT_SUCCESS;
+	}
+
+	if (!strcasecmp(value, "true") ||
+		!strcasecmp(value, "yes") ||
+		!strcasecmp(value, "on")) {
+		*out = 1;
+		return GIT_SUCCESS;
+	}
+	if (!strcasecmp(value, "false") ||
+		!strcasecmp(value, "no") ||
+		!strcasecmp(value, "off")) {
+		*out = 0;
+		return GIT_SUCCESS;
+	}
+
+	/* Try to parse it as an integer */
+	error = git_config_get_int32(cfg, name, out);
+	if (error == GIT_SUCCESS)
+		*out = !!(*out);
+
+	if (error < GIT_SUCCESS)
+		return git__rethrow(error, "Failed to get value for %s", name);
+	return error;
+}
+
+int git_config_get_string(git_config *cfg, const char *name, const char **out)
+{
+	file_internal *internal;
+	git_config_file *file;
+	int error = GIT_ENOTFOUND;
+	unsigned int i;
+
+	if (cfg->files.length == 0)
+		return git__throw(GIT_EINVALIDARGS, "Cannot get variable value; no files open in the `git_config` instance");
+
+	for (i = 0; i < cfg->files.length; ++i) {
+		internal = git_vector_get(&cfg->files, i);
+		file = internal->file;
+		if ((error = file->get(file, name, out)) == GIT_SUCCESS)
+			return GIT_SUCCESS;
+	}
+
+	return git__throw(error, "Config value '%s' not found", name);
+}
+
+int git_config_find_global(char *global_config_path)
+{
+	const char *home;
+
+	home = getenv("HOME");
+
+#ifdef GIT_WIN32
+	if (home == NULL)
+		home = getenv("USERPROFILE");
+#endif
+
+	if (home == NULL)
+		return git__throw(GIT_EOSERR, "Failed to open global config file. Cannot locate the user's home directory");
+
+	git_path_join(global_config_path, home, GIT_CONFIG_FILENAME);
+
+	if (git_futils_exists(global_config_path) < GIT_SUCCESS)
+		return git__throw(GIT_EOSERR, "Failed to open global config file. The file does not exist");
+
+	return GIT_SUCCESS;
+}
+
+
+
+#if GIT_WIN32
+static int win32_find_system(char *system_config_path)
+{
+	const wchar_t *query = L"%PROGRAMFILES%\\Git\\etc\\gitconfig";
+	wchar_t *apphome_utf16;
+	char *apphome_utf8;
+	DWORD size, ret;
+
+	size = ExpandEnvironmentStringsW(query, NULL, 0);
+	/* The function gave us the full size of the buffer in chars, including NUL */
+	apphome_utf16 = git__malloc(size * sizeof(wchar_t));
+	if (apphome_utf16 == NULL)
+		return GIT_ENOMEM;
+
+	ret = ExpandEnvironmentStringsW(query, apphome_utf16, size);
+	if (ret != size)
+		return git__throw(GIT_ERROR, "Failed to expand environment strings");
+
+	if (_waccess(apphome_utf16, F_OK) < 0) {
+		git__free(apphome_utf16);
+		return GIT_ENOTFOUND;
+	}
+
+	apphome_utf8 = gitwin_from_utf16(apphome_utf16);
+	git__free(apphome_utf16);
+
+	if (strlen(apphome_utf8) >= GIT_PATH_MAX) {
+		git__free(apphome_utf8);
+		return git__throw(GIT_ESHORTBUFFER, "Path is too long");
+	}
+
+	strcpy(system_config_path, apphome_utf8);
+	git__free(apphome_utf8);
+	return GIT_SUCCESS;
+}
+#endif
+
+int git_config_find_system(char *system_config_path)
+{
+	const char *etc = "/etc/gitconfig";
+
+	if (git_futils_exists(etc) == GIT_SUCCESS) {
+		memcpy(system_config_path, etc, strlen(etc) + 1);
+		return GIT_SUCCESS;
+	}
+
+#if GIT_WIN32
+	return win32_find_system(system_config_path);
+#else
+	return GIT_ENOTFOUND;
+#endif
+}
+
+int git_config_open_global(git_config **out)
+{
+	int error;
+	char global_path[GIT_PATH_MAX];
+
+	if ((error = git_config_find_global(global_path)) < GIT_SUCCESS)
+		return error;
+
+	return git_config_open_ondisk(out, global_path);
+}
+