errors.c 5.33 KB
Newer Older
1
/*
schu committed
2
 * Copyright (C) 2009-2012 the libgit2 contributors
3
 *
Vicent Marti committed
4 5
 * This file is part of libgit2, distributed under the GNU GPL v2 with
 * a Linking Exception. For full terms see the included COPYING file.
6
 */
7
#include "common.h"
8
#include "global.h"
9
#include "posix.h"
10 11
#include <stdarg.h>

12 13 14 15
static struct {
	int num;
	const char *str;
} error_codes[] = {
16 17 18 19 20 21 22 23
	{GIT_ERROR, "Unspecified error"},
	{GIT_ENOTOID, "Input was not a properly formatted Git object id."},
	{GIT_ENOTFOUND, "Object does not exist in the scope searched."},
	{GIT_ENOMEM, "Not enough space available."},
	{GIT_EOSERR, "Consult the OS error information."},
	{GIT_EOBJTYPE, "The specified object is of invalid type"},
	{GIT_EOBJCORRUPTED, "The specified object has its data corrupted"},
	{GIT_ENOTAREPO, "The specified repository is invalid"},
24
	{GIT_EINVALIDTYPE, "The object or config variable type is invalid or doesn't match"},
25 26 27 28 29
	{GIT_EMISSINGOBJDATA, "The object cannot be written that because it's missing internal data"},
	{GIT_EPACKCORRUPTED, "The packfile for the ODB is corrupted"},
	{GIT_EFLOCKFAIL, "Failed to adquire or release a file lock"},
	{GIT_EZLIB, "The Z library failed to inflate/deflate an object's data"},
	{GIT_EBUSY, "The queried object is currently busy"},
30
	{GIT_EINVALIDPATH, "The path is invalid"},
31 32 33 34
	{GIT_EBAREINDEX, "The index file is not backed up by an existing repository"},
	{GIT_EINVALIDREFNAME, "The name of the reference is not valid"},
	{GIT_EREFCORRUPTED, "The specified reference has its data corrupted"},
	{GIT_ETOONESTEDSYMREF, "The specified symbolic reference is too deeply nested"},
35 36
	{GIT_EPACKEDREFSCORRUPTED, "The pack-refs file is either corrupted of its format is not currently supported"},
	{GIT_EINVALIDPATH, "The path is invalid" },
37
	{GIT_EREVWALKOVER, "The revision walker is empty; there are no more commits left to iterate"},
Vicent Marti committed
38
	{GIT_EINVALIDREFSTATE, "The state of the reference is not valid"},
39
	{GIT_ENOTIMPLEMENTED, "This feature has not been implemented yet"},
40 41 42
	{GIT_EEXISTS, "A reference with this name already exists"},
	{GIT_EOVERFLOW, "The given integer literal is too large to be parsed"},
	{GIT_ENOTNUM, "The given literal is not a valid number"},
43
	{GIT_EAMBIGUOUS, "The given oid prefix is ambiguous"},
44 45 46 47
};

const char *git_strerror(int num)
{
48
	size_t i;
49 50 51

	if (num == GIT_EOSERR)
		return strerror(errno);
52 53 54 55 56 57
	for (i = 0; i < ARRAY_SIZE(error_codes); i++)
		if (num == error_codes[i].num)
			return error_codes[i].str;

	return "Unknown error";
}
Vicent Marti committed
58

59 60
#define ERROR_MAX_LEN 1024

61
void git___rethrow(const char *msg, ...)
62
{
63 64
	char new_error[ERROR_MAX_LEN];
	char *last_error;
65 66 67 68
	char *old_error = NULL;

	va_list va;

69 70
	last_error = GIT_GLOBAL->error.last;

71
	va_start(va, msg);
72
	vsnprintf(new_error, ERROR_MAX_LEN, msg, va);
73 74
	va_end(va);

75 76 77 78
	old_error = git__strdup(last_error);

	snprintf(last_error, ERROR_MAX_LEN, "%s \n	- %s", new_error, old_error);

79
	git__free(old_error);
80 81
}

82
void git___throw(const char *msg, ...)
83 84 85 86
{
	va_list va;

	va_start(va, msg);
87
	vsnprintf(GIT_GLOBAL->error.last, ERROR_MAX_LEN, msg, va);
88 89
	va_end(va);
}
90 91 92

const char *git_lasterror(void)
{
93 94 95
	char *last_error = GIT_GLOBAL->error.last;

	if (!last_error[0])
96 97
		return NULL;

98
	return last_error;
99 100
}

101 102
void git_clearerror(void)
{
103 104
	char *last_error = GIT_GLOBAL->error.last;
	last_error[0] = '\0';
105
}
106 107 108 109 110

/********************************************
 * New error handling
 ********************************************/

111 112 113 114 115 116 117 118 119 120 121
static git_error g_git_oom_error = {
	"Out of memory",
	GITERR_NOMEMORY
};

void giterr_set_oom(void)
{
	GIT_GLOBAL->last_error = &g_git_oom_error;
}

void giterr_set(int error_class, const char *string, ...)
122 123 124 125
{
	char error_str[1024];
	va_list arglist;

126 127 128 129 130 131 132
	/* Grab errno before calling vsnprintf() so it won't be overwritten */
	const char *os_error_msg =
		(error_class == GITERR_OS && errno != 0) ? strerror(errno) : NULL;
#ifdef GIT_WIN32
	DWORD dwLastError = GetLastError();
#endif

133 134 135 136
	va_start(arglist, string);
	p_vsnprintf(error_str, sizeof(error_str), string, arglist);
	va_end(arglist);

137
	/* automatically suffix strerror(errno) for GITERR_OS errors */
138
	if (error_class == GITERR_OS) {
139
		if (os_error_msg != NULL) {
140
			strncat(error_str, ": ", sizeof(error_str));
141 142
			strncat(error_str, os_error_msg, sizeof(error_str));
			errno = 0; /* reset so same error won't be reported twice */
143 144
		}
#ifdef GIT_WIN32
145 146
		else if (dwLastError != 0) {
			LPVOID lpMsgBuf = NULL;
147 148 149 150 151

			FormatMessage(
				FORMAT_MESSAGE_ALLOCATE_BUFFER | 
				FORMAT_MESSAGE_FROM_SYSTEM |
				FORMAT_MESSAGE_IGNORE_INSERTS,
152
				NULL, dwLastError, 0, (LPTSTR) &lpMsgBuf, 0, NULL);
153 154 155 156 157 158

			if (lpMsgBuf) {
				strncat(error_str, ": ", sizeof(error_str));
				strncat(error_str, (const char *)lpMsgBuf, sizeof(error_str));
				LocalFree(lpMsgBuf);
			}
159 160

			SetLastError(0);
161 162
		}
#endif
163 164
	}

165 166 167 168 169 170 171 172 173 174
	giterr_set_str(error_class, error_str);
}

void giterr_set_str(int error_class, const char *string)
{
	git_error *error = &GIT_GLOBAL->error_t;

	free(error->message);

	error->message = git__strdup(string);
175 176 177
	error->klass = error_class;

	if (error->message == NULL) {
178
		giterr_set_oom();
179 180 181
		return;
	}

182
	GIT_GLOBAL->last_error = error;
183 184
}

185 186 187 188 189 190 191
void giterr_set_regex(const regex_t *regex, int error_code)
{
	char error_buf[1024];
	regerror(error_code, regex, error_buf, sizeof(error_buf));
	giterr_set_str(GITERR_REGEX, error_buf);
}

192
void giterr_clear(void)
193
{
194
	GIT_GLOBAL->last_error = NULL;
195
}
196 197 198 199 200 201 202 203 204 205 206

const git_error *git_error_last(void)
{
	return GIT_GLOBAL->last_error;
}

void git_error_clear(void)
{
	giterr_clear();
}