rugged 1.7.2 → 1.9.0

data/vendor/libgit2/src/util/date.c

@@ -129,9 +129,9 @@ static size_t match_string(const char *date, const char *str)
 	for (i = 0; *date; date++, str++, i++) {
 		if (*date == *str)
 			continue;
-		if (toupper(*date) == toupper(*str))
+		if (git__toupper(*date) == git__toupper(*str))
 			continue;
-		if (!isalnum(*date))
+		if (!git__isalnum(*date))
 			break;
 		return 0;
 	}
@@ -143,7 +143,7 @@ static int skip_alpha(const char *date)
 	int i = 0;
 	do {
 		i++;
-	} while (isalpha(date[i]));
+	} while (git__isalpha(date[i]));
 	return i;
 }
 
@@ -251,7 +251,7 @@ static size_t match_multi_number(unsigned long num, char c, const char *date, ch
 
 	num2 = strtol(end+1, &end, 10);
 	num3 = -1;
-	if (*end == c && isdigit(end[1]))
+	if (*end == c && git__isdigit(end[1]))
 		num3 = strtol(end+1, &end, 10);
 
 	/* Time? Date? */
@@ -349,7 +349,7 @@ static size_t match_digit(const char *date, struct tm *tm, int *offset, int *tm_
 	case '.':
 	case '/':
 	case '-':
-		if (isdigit(end[1])) {
+		if (git__isdigit(end[1])) {
 			size_t match = match_multi_number(num, *end, date, end, tm);
 			if (match)
 				return match;
@@ -364,7 +364,7 @@ static size_t match_digit(const char *date, struct tm *tm, int *offset, int *tm_
 	n = 0;
 	do {
 		n++;
-	} while (isdigit(date[n]));
+	} while (git__isdigit(date[n]));
 
 	/* Four-digit year or a timezone? */
 	if (n == 4) {
@@ -514,11 +514,11 @@ static int parse_date_basic(const char *date, git_time_t *timestamp, int *offset
 		if (!c || c == '\n')
 			break;
 
-		if (isalpha(c))
+		if (git__isalpha(c))
 			match = match_alpha(date, &tm, offset);
-		else if (isdigit(c))
+		else if (git__isdigit(c))
 			match = match_digit(date, &tm, offset, &tm_gmt);
-		else if ((c == '-' || c == '+') && isdigit(date[1]))
+		else if ((c == '-' || c == '+') && git__isdigit(date[1]))
 			match = match_tz(date, offset);
 
 		if (!match) {
@@ -682,7 +682,7 @@ static const char *approxidate_alpha(const char *date, struct tm *tm, struct tm
 	const char *end = date;
 	int i;
 
-	while (isalpha(*++end))
+	while (git__isalpha(*++end))
 		/* scan to non-alpha */;
 
 	for (i = 0; i < 12; i++) {
@@ -783,7 +783,7 @@ static const char *approxidate_digit(const char *date, struct tm *tm, int *num)
 	case '.':
 	case '/':
 	case '-':
-		if (isdigit(end[1])) {
+		if (git__isdigit(end[1])) {
 			size_t match = match_multi_number(number, *end, date, end, tm);
 			if (match)
 				return date + match;
@@ -843,13 +843,13 @@ static git_time_t approxidate_str(const char *date,
 		if (!c)
 			break;
 		date++;
-		if (isdigit(c)) {
+		if (git__isdigit(c)) {
 			pending_number(&tm, &number);
 			date = approxidate_digit(date-1, &tm, &number);
 			touched = 1;
 			continue;
 		}
-		if (isalpha(c))
+		if (git__isalpha(c))
 			date = approxidate_alpha(date-1, &tm, &now, &number, &touched);
 	}
 	pending_number(&tm, &number);
@@ -858,7 +858,7 @@ static git_time_t approxidate_str(const char *date,
 	return update_tm(&tm, &now, 0);
 }
 
-int git_date_parse(git_time_t *out, const char *date)
+int git_date_offset_parse(git_time_t *out, int *out_offset, const char *date)
 {
 	time_t time_sec;
 	git_time_t timestamp;
@@ -866,6 +866,7 @@ int git_date_parse(git_time_t *out, const char *date)
 
 	if (!parse_date_basic(date, &timestamp, &offset)) {
 		*out = timestamp;
+		*out_offset = offset;
 		return 0;
 	}
 
@@ -876,6 +877,13 @@ int git_date_parse(git_time_t *out, const char *date)
 	return error_ret;
 }
 
+int git_date_parse(git_time_t *out, const char *date)
+{
+	int offset;
+
+	return git_date_offset_parse(out, &offset, date);
+}
+
 int git_date_rfc2822_fmt(git_str *out, git_time_t time, int offset)
 {
 	time_t t;

data/vendor/libgit2/src/util/date.h

@@ -10,9 +10,21 @@
 #include "util.h"
 #include "str.h"
 
+/*
+ * Parse a string into a value as a git_time_t with a timezone offset.
+ *
+ * Sample valid input:
+ * - "yesterday"
+ * - "July 17, 2003"
+ * - "2003-7-17 08:23i+03"
+ */
+extern int git_date_offset_parse(git_time_t *out, int *out_offset, const char *date);
+
 /*
  * Parse a string into a value as a git_time_t.
  *
+ * Timezone offset is ignored.
+ *
  * Sample valid input:
  * - "yesterday"
  * - "July 17, 2003"

data/vendor/libgit2/src/util/errors.c

@@ -0,0 +1,401 @@
+/*
+ * 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 "git2_util.h"
+
+#include "errors.h"
+#include "posix.h"
+#include "str.h"
+#include "runtime.h"
+
+/*
+ * Some static error data that is used when we're out of memory, TLS
+ * has not been setup, or TLS has failed.
+ */
+
+static git_error oom_error = {
+	"Out of memory",
+	GIT_ERROR_NOMEMORY
+};
+
+static git_error uninitialized_error = {
+	"library has not been initialized",
+	GIT_ERROR_INVALID
+};
+
+static git_error tlsdata_error = {
+	"thread-local data initialization failure",
+	GIT_ERROR_THREAD
+};
+
+static git_error no_error = {
+	"no error",
+	GIT_ERROR_NONE
+};
+
+#define IS_STATIC_ERROR(err) \
+	((err) == &oom_error || (err) == &uninitialized_error || \
+	 (err) == &tlsdata_error || (err) == &no_error)
+
+/* Per-thread error state (TLS) */
+
+static git_tlsdata_key tls_key;
+
+struct error_threadstate {
+	/* The error message buffer. */
+	git_str message;
+
+	/* Error information, set by `git_error_set` and friends. */
+	git_error error;
+
+	/*
+	 * The last error to occur; points to the error member of this
+	 * struct _or_ a static error.
+	 */
+	git_error *last;
+};
+
+static void threadstate_dispose(struct error_threadstate *threadstate)
+{
+	if (!threadstate)
+		return;
+
+	git_str_dispose(&threadstate->message);
+}
+
+static struct error_threadstate *threadstate_get(void)
+{
+	struct error_threadstate *threadstate;
+
+	if ((threadstate = git_tlsdata_get(tls_key)) != NULL)
+		return threadstate;
+
+	/*
+	 * Avoid git__malloc here, since if it fails, it sets an error
+	 * message, which requires thread state, which would allocate
+	 * here, which would fail, which would set an error message...
+	 */
+
+	if ((threadstate = git__allocator.gmalloc(
+			sizeof(struct error_threadstate),
+			__FILE__, __LINE__)) == NULL)
+		return NULL;
+
+	memset(threadstate, 0, sizeof(struct error_threadstate));
+
+	if (git_str_init(&threadstate->message, 0) < 0) {
+		git__allocator.gfree(threadstate);
+		return NULL;
+	}
+
+	git_tlsdata_set(tls_key, threadstate);
+	return threadstate;
+}
+
+static void GIT_SYSTEM_CALL threadstate_free(void *threadstate)
+{
+	threadstate_dispose(threadstate);
+	git__free(threadstate);
+}
+
+static void git_error_global_shutdown(void)
+{
+	struct error_threadstate *threadstate;
+
+	threadstate = git_tlsdata_get(tls_key);
+	git_tlsdata_set(tls_key, NULL);
+
+	threadstate_dispose(threadstate);
+	git__free(threadstate);
+
+	git_tlsdata_dispose(tls_key);
+}
+
+int git_error_global_init(void)
+{
+	if (git_tlsdata_init(&tls_key, &threadstate_free) != 0)
+		return -1;
+
+	return git_runtime_shutdown_register(git_error_global_shutdown);
+}
+
+static void set_error_from_buffer(int error_class)
+{
+	struct error_threadstate *threadstate = threadstate_get();
+	git_error *error;
+	git_str *buf;
+
+	if (!threadstate)
+		return;
+
+	error = &threadstate->error;
+	buf = &threadstate->message;
+
+	error->message = buf->ptr;
+	error->klass = error_class;
+
+	threadstate->last = error;
+}
+
+static void set_error(int error_class, char *string)
+{
+	struct error_threadstate *threadstate = threadstate_get();
+	git_str *buf;
+
+	if (!threadstate)
+		return;
+
+	buf = &threadstate->message;
+
+	git_str_clear(buf);
+
+	if (string)
+		git_str_puts(buf, string);
+
+	if (!git_str_oom(buf))
+		set_error_from_buffer(error_class);
+}
+
+void git_error_set_oom(void)
+{
+	struct error_threadstate *threadstate = threadstate_get();
+
+	if (!threadstate)
+		return;
+
+	threadstate->last = &oom_error;
+}
+
+void git_error_set(int error_class, const char *fmt, ...)
+{
+	va_list ap;
+
+	va_start(ap, fmt);
+	git_error_vset(error_class, fmt, ap);
+	va_end(ap);
+}
+
+void git_error_vset(int error_class, const char *fmt, va_list ap)
+{
+#ifdef GIT_WIN32
+	DWORD win32_error_code = (error_class == GIT_ERROR_OS) ? GetLastError() : 0;
+#endif
+
+	struct error_threadstate *threadstate = threadstate_get();
+	int error_code = (error_class == GIT_ERROR_OS) ? errno : 0;
+	git_str *buf;
+
+	if (!threadstate)
+		return;
+
+	buf = &threadstate->message;
+
+	git_str_clear(buf);
+
+	if (fmt) {
+		git_str_vprintf(buf, fmt, ap);
+		if (error_class == GIT_ERROR_OS)
+			git_str_PUTS(buf, ": ");
+	}
+
+	if (error_class == GIT_ERROR_OS) {
+#ifdef GIT_WIN32
+		char *win32_error = git_win32_get_error_message(win32_error_code);
+		if (win32_error) {
+			git_str_puts(buf, win32_error);
+			git__free(win32_error);
+
+			SetLastError(0);
+		}
+		else
+#endif
+		if (error_code)
+			git_str_puts(buf, strerror(error_code));
+
+		if (error_code)
+			errno = 0;
+	}
+
+	if (!git_str_oom(buf))
+		set_error_from_buffer(error_class);
+}
+
+int git_error_set_str(int error_class, const char *string)
+{
+	struct error_threadstate *threadstate = threadstate_get();
+	git_str *buf;
+
+	GIT_ASSERT_ARG(string);
+
+	if (!threadstate)
+		return -1;
+
+	buf = &threadstate->message;
+
+	git_str_clear(buf);
+	git_str_puts(buf, string);
+
+	if (git_str_oom(buf))
+		return -1;
+
+	set_error_from_buffer(error_class);
+	return 0;
+}
+
+void git_error_clear(void)
+{
+	struct error_threadstate *threadstate = threadstate_get();
+
+	if (!threadstate)
+		return;
+
+	if (threadstate->last != NULL) {
+		set_error(0, NULL);
+		threadstate->last = NULL;
+	}
+
+	errno = 0;
+#ifdef GIT_WIN32
+	SetLastError(0);
+#endif
+}
+
+bool git_error_exists(void)
+{
+	struct error_threadstate *threadstate;
+
+	if ((threadstate = threadstate_get()) == NULL)
+		return true;
+
+	return threadstate->last != NULL;
+}
+
+const git_error *git_error_last(void)
+{
+	struct error_threadstate *threadstate;
+
+	/* If the library is not initialized, return a static error. */
+	if (!git_runtime_init_count())
+		return &uninitialized_error;
+
+	if ((threadstate = threadstate_get()) == NULL)
+		return &tlsdata_error;
+
+	if (!threadstate->last)
+		return &no_error;
+
+	return threadstate->last;
+}
+
+int git_error_save(git_error **out)
+{
+	struct error_threadstate *threadstate = threadstate_get();
+	git_error *error, *dup;
+
+	if (!threadstate) {
+		*out = &tlsdata_error;
+		return -1;
+	}
+
+	error = threadstate->last;
+
+	if (!error || error == &no_error) {
+		*out = &no_error;
+		return 0;
+	} else if (IS_STATIC_ERROR(error)) {
+		*out = error;
+		return 0;
+	}
+
+	if ((dup = git__malloc(sizeof(git_error))) == NULL) {
+		*out = &oom_error;
+		return -1;
+	}
+
+	dup->klass = error->klass;
+	dup->message = git__strdup(error->message);
+
+	if (!dup->message) {
+		*out = &oom_error;
+		return -1;
+	}
+
+	*out = dup;
+	return 0;
+}
+
+int git_error_restore(git_error *error)
+{
+	struct error_threadstate *threadstate = threadstate_get();
+
+	GIT_ASSERT_ARG(error);
+
+	if (IS_STATIC_ERROR(error) && threadstate)
+		threadstate->last = error;
+	else
+		set_error(error->klass, error->message);
+
+	git_error_free(error);
+	return 0;
+}
+
+void git_error_free(git_error *error)
+{
+	if (!error)
+		return;
+
+	if (IS_STATIC_ERROR(error))
+		return;
+
+	git__free(error->message);
+	git__free(error);
+}
+
+int git_error_system_last(void)
+{
+#ifdef GIT_WIN32
+	return GetLastError();
+#else
+	return errno;
+#endif
+}
+
+void git_error_system_set(int code)
+{
+#ifdef GIT_WIN32
+	SetLastError(code);
+#else
+	errno = code;
+#endif
+}
+
+/* Deprecated error values and functions */
+
+#ifndef GIT_DEPRECATE_HARD
+
+#include "git2/deprecated.h"
+
+const git_error *giterr_last(void)
+{
+	return git_error_last();
+}
+
+void giterr_clear(void)
+{
+	git_error_clear();
+}
+
+void giterr_set_str(int error_class, const char *string)
+{
+	git_error_set_str(error_class, string);
+}
+
+void giterr_set_oom(void)
+{
+	git_error_set_oom();
+}
+#endif

data/vendor/libgit2/src/{libgit2 → util}/errors.h

@@ -8,13 +8,22 @@
 #ifndef INCLUDE_errors_h__
 #define INCLUDE_errors_h__
 
-#include "common.h"
+#include "git2_util.h"
+#include "git2/sys/errors.h"
+
+/* Initialize the error thread-state. */
+int git_error_global_init(void);
 
 /*
  * `vprintf`-style formatting for the error message for this thread.
  */
 void git_error_vset(int error_class, const char *fmt, va_list ap);
 
+/**
+ * Determines whether an error exists.
+ */
+bool git_error_exists(void);
+
 /**
  * Set error message for user callback if needed.
  *
@@ -27,9 +36,8 @@ GIT_INLINE(int) git_error_set_after_callback_function(
 	int error_code, const char *action)
 {
 	if (error_code) {
-		const git_error *e = git_error_last();
-		if (!e || !e->message)
-			git_error_set(e ? e->klass : GIT_ERROR_CALLBACK,
+		if (!git_error_exists())
+			git_error_set(GIT_ERROR_CALLBACK,
 				"%s callback returned %d", action, error_code);
 	}
 	return error_code;
@@ -53,28 +61,24 @@ int git_error_system_last(void);
  */
 void git_error_system_set(int code);
 
-/**
- * Structure to preserve libgit2 error state
- */
-typedef struct {
-	int error_code;
-	unsigned int oom : 1;
-	git_error error_msg;
-} git_error_state;
-
 /**
  * Capture current error state to restore later, returning error code.
  * If `error_code` is zero, this does not clear the current error state.
  * You must either restore this error state, or free it.
+ *
+ * This function returns 0 on success, or -1 on failure. If the function
+ * fails, the `out` structure is set to the failure error message and
+ * the normal system error message is not updated.
  */
-extern int git_error_state_capture(git_error_state *state, int error_code);
+extern int git_error_save(git_error **out);
 
 /**
- * Restore error state to a previous value, returning saved error code.
+ * Restore thread error state to the given value. The given value is
+ * freed and `git_error_free` need not be called on it.
  */
-extern int git_error_state_restore(git_error_state *state);
+extern int git_error_restore(git_error *error);
 
 /** Free an error state. */
-extern void git_error_state_free(git_error_state *state);
+extern void git_error_free(git_error *error);
 
 #endif

data/vendor/libgit2/src/util/fs_path.c

@@ -419,6 +419,16 @@ int git_fs_path_to_dir(git_str *path)
 	return git_str_oom(path) ? -1 : 0;
 }
 
+size_t git_fs_path_dirlen(const char *path)
+{
+	size_t len = strlen(path);
+
+	while (len > 1 && path[len - 1] == '/')
+		len--;
+
+	return len;
+}
+
 void git_fs_path_string_to_dir(char *path, size_t size)
 {
 	size_t end = strlen(path);
@@ -1938,12 +1948,13 @@ static int sudo_uid_lookup(uid_t *out)
 {
 	git_str uid_str = GIT_STR_INIT;
 	int64_t uid;
-	int error;
+	int error = -1;
 
-	if ((error = git__getenv(&uid_str, "SUDO_UID")) == 0 &&
-	    (error = git__strntol64(&uid, uid_str.ptr, uid_str.size, NULL, 10)) == 0 &&
-	    uid == (int64_t)((uid_t)uid)) {
+	if (git__getenv(&uid_str, "SUDO_UID") == 0 &&
+		git__strntol64(&uid, uid_str.ptr, uid_str.size, NULL, 10) == 0 &&
+		uid == (int64_t)((uid_t)uid)) {
 		*out = (uid_t)uid;
+		error = 0;
 	}
 
 	git_str_dispose(&uid_str);

data/vendor/libgit2/src/util/fs_path.h

@@ -86,6 +86,29 @@ extern int git_fs_path_to_dir(git_str *path);
  */
 extern void git_fs_path_string_to_dir(char *path, size_t size);
 
+/**
+ * Provides the length of the given path string with no trailing
+ * slashes.
+ */
+size_t git_fs_path_dirlen(const char *path);
+
+/**
+ * Returns nonzero if the given path is a filesystem root; on Windows, this
+ * means a drive letter (eg `A:/`, `C:\`). On POSIX this is `/`.
+ */
+GIT_INLINE(int) git_fs_path_is_root(const char *name)
+{
+#ifdef GIT_WIN32
+	if (((name[0] >= 'A' && name[0] <= 'Z') || (name[0] >= 'a' && name[0] <= 'z')) &&
+	      name[1] == ':' &&
+	     (name[2] == '/' || name[2] == '\\') &&
+	      name[3] == '\0')
+		return 1;
+#endif
+
+	return (name[0] == '/' && name[1] == '\0');
+}
+
 /**
  * Taken from git.git; returns nonzero if the given path is "." or "..".
  */