rugged 1.3.1 → 1.9.0

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

@@ -8,14 +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);
 
 /*
- * Set the error message for this thread, formatting as needed.
+ * `vprintf`-style formatting for the error message for this thread.
  */
-void git_error_set(int error_class, const char *fmt, ...) GIT_FORMAT_PRINTF(2, 3);
 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.
  *
@@ -28,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;
@@ -54,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/{filebuf.c → util/filebuf.c}

@@ -43,7 +43,7 @@ static int verify_last_error(git_filebuf *file)
 
 static int lock_file(git_filebuf *file, int flags, mode_t mode)
 {
-	if (git_path_exists(file->path_lock) == true) {
+	if (git_fs_path_exists(file->path_lock) == true) {
 		git_error_clear(); /* actual OS error code just confuses */
 		git_error_set(GIT_ERROR_OS,
 			"failed to lock file '%s' for writing", file->path_lock);
@@ -63,9 +63,9 @@ static int lock_file(git_filebuf *file, int flags, mode_t mode)
 
 	file->fd_is_open = true;
 
-	if ((flags & GIT_FILEBUF_APPEND) && git_path_exists(file->path_original) == true) {
+	if ((flags & GIT_FILEBUF_APPEND) && git_fs_path_exists(file->path_original) == true) {
 		git_file source;
-		char buffer[FILEIO_BUFSIZE];
+		char buffer[GIT_BUFSIZE_FILEIO];
 		ssize_t read_bytes;
 		int error = 0;
 
@@ -103,7 +103,7 @@ void git_filebuf_cleanup(git_filebuf *file)
 	if (file->fd_is_open && file->fd >= 0)
 		p_close(file->fd);
 
-	if (file->created_lock && !file->did_rename && file->path_lock && git_path_exists(file->path_lock))
+	if (file->created_lock && !file->did_rename && file->path_lock && git_fs_path_exists(file->path_lock))
 		p_unlink(file->path_lock);
 
 	if (file->compute_digest) {
@@ -195,21 +195,21 @@ static int write_deflate(git_filebuf *file, void *source, size_t len)
 
 #define MAX_SYMLINK_DEPTH 5
 
-static int resolve_symlink(git_buf *out, const char *path)
+static int resolve_symlink(git_str *out, const char *path)
 {
 	int i, error, root;
 	ssize_t ret;
 	struct stat st;
-	git_buf curpath = GIT_BUF_INIT, target = GIT_BUF_INIT;
+	git_str curpath = GIT_STR_INIT, target = GIT_STR_INIT;
 
-	if ((error = git_buf_grow(&target, GIT_PATH_MAX + 1)) < 0 ||
-	    (error = git_buf_puts(&curpath, path)) < 0)
+	if ((error = git_str_grow(&target, GIT_PATH_MAX + 1)) < 0 ||
+	    (error = git_str_puts(&curpath, path)) < 0)
 		return error;
 
 	for (i = 0; i < MAX_SYMLINK_DEPTH; i++) {
 		error = p_lstat(curpath.ptr, &st);
 		if (error < 0 && errno == ENOENT) {
-			error = git_buf_puts(out, curpath.ptr);
+			error = git_str_puts(out, curpath.ptr);
 			goto cleanup;
 		}
 
@@ -220,7 +220,7 @@ static int resolve_symlink(git_buf *out, const char *path)
 		}
 
 		if (!S_ISLNK(st.st_mode)) {
-			error = git_buf_puts(out, curpath.ptr);
+			error = git_str_puts(out, curpath.ptr);
 			goto cleanup;
 		}
 
@@ -241,20 +241,20 @@ static int resolve_symlink(git_buf *out, const char *path)
 		target.ptr[ret] = '\0';
 		target.size = ret;
 
-		root = git_path_root(target.ptr);
+		root = git_fs_path_root(target.ptr);
 		if (root >= 0) {
-			if ((error = git_buf_sets(&curpath, target.ptr)) < 0)
+			if ((error = git_str_sets(&curpath, target.ptr)) < 0)
 				goto cleanup;
 		} else {
-			git_buf dir = GIT_BUF_INIT;
+			git_str dir = GIT_STR_INIT;
 
-			if ((error = git_path_dirname_r(&dir, curpath.ptr)) < 0)
+			if ((error = git_fs_path_dirname_r(&dir, curpath.ptr)) < 0)
 				goto cleanup;
 
-			git_buf_swap(&curpath, &dir);
-			git_buf_dispose(&dir);
+			git_str_swap(&curpath, &dir);
+			git_str_dispose(&dir);
 
-			if ((error = git_path_apply_relative(&curpath, target.ptr)) < 0)
+			if ((error = git_fs_path_apply_relative(&curpath, target.ptr)) < 0)
 				goto cleanup;
 		}
 	}
@@ -263,8 +263,8 @@ static int resolve_symlink(git_buf *out, const char *path)
 	error = -1;
 
 cleanup:
-	git_buf_dispose(&curpath);
-	git_buf_dispose(&target);
+	git_str_dispose(&curpath);
+	git_str_dispose(&target);
 	return error;
 }
 
@@ -302,10 +302,15 @@ int git_filebuf_open_withsize(git_filebuf *file, const char *path, int flags, mo
 	}
 
 	/* If we are hashing on-write, allocate a new hash context */
-	if (flags & GIT_FILEBUF_HASH_CONTENTS) {
+	if (flags & GIT_FILEBUF_HASH_SHA1) {
 		file->compute_digest = 1;
 
-		if (git_hash_ctx_init(&file->digest) < 0)
+		if (git_hash_ctx_init(&file->digest, GIT_HASH_ALGORITHM_SHA1) < 0)
+			goto cleanup;
+	} else if (flags & GIT_FILEBUF_HASH_SHA256) {
+		file->compute_digest = 1;
+
+		if (git_hash_ctx_init(&file->digest, GIT_HASH_ALGORITHM_SHA256) < 0)
 			goto cleanup;
 	}
 
@@ -332,13 +337,13 @@ int git_filebuf_open_withsize(git_filebuf *file, const char *path, int flags, mo
 
 	/* If we are writing to a temp file */
 	if (flags & GIT_FILEBUF_TEMPORARY) {
-		git_buf tmp_path = GIT_BUF_INIT;
+		git_str tmp_path = GIT_STR_INIT;
 
 		/* Open the file as temporary for locking */
 		file->fd = git_futils_mktmp(&tmp_path, path, mode);
 
 		if (file->fd < 0) {
-			git_buf_dispose(&tmp_path);
+			git_str_dispose(&tmp_path);
 			goto cleanup;
 		}
 		file->fd_is_open = true;
@@ -346,17 +351,17 @@ int git_filebuf_open_withsize(git_filebuf *file, const char *path, int flags, mo
 
 		/* No original path */
 		file->path_original = NULL;
-		file->path_lock = git_buf_detach(&tmp_path);
+		file->path_lock = git_str_detach(&tmp_path);
 		GIT_ERROR_CHECK_ALLOC(file->path_lock);
 	} else {
-		git_buf resolved_path = GIT_BUF_INIT;
+		git_str resolved_path = GIT_STR_INIT;
 
 		if ((error = resolve_symlink(&resolved_path, path)) < 0)
 			goto cleanup;
 
 		/* Save the original path of the file */
 		path_len = resolved_path.size;
-		file->path_original = git_buf_detach(&resolved_path);
+		file->path_original = git_str_detach(&resolved_path);
 
 		/* create the locking path by appending ".lock" to the original */
 		GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, path_len, GIT_FILELOCK_EXTLENGTH);
@@ -366,7 +371,7 @@ int git_filebuf_open_withsize(git_filebuf *file, const char *path, int flags, mo
 		memcpy(file->path_lock, file->path_original, path_len);
 		memcpy(file->path_lock + path_len, GIT_FILELOCK_EXTENSION, GIT_FILELOCK_EXTLENGTH);
 
-		if (git_path_isdir(file->path_original)) {
+		if (git_fs_path_isdir(file->path_original)) {
 			git_error_set(GIT_ERROR_FILESYSTEM, "path '%s' is a directory", file->path_original);
 			error = GIT_EDIRECTORY;
 			goto cleanup;
@@ -386,9 +391,9 @@ cleanup:
 	return error;
 }
 
-int git_filebuf_hash(git_oid *oid, git_filebuf *file)
+int git_filebuf_hash(unsigned char *out, git_filebuf *file)
 {
-	GIT_ASSERT_ARG(oid);
+	GIT_ASSERT_ARG(out);
 	GIT_ASSERT_ARG(file);
 	GIT_ASSERT_ARG(file->compute_digest);
 
@@ -397,7 +402,7 @@ int git_filebuf_hash(git_oid *oid, git_filebuf *file)
 	if (verify_last_error(file) < 0)
 		return -1;
 
-	git_hash_final(oid, &file->digest);
+	git_hash_final(out, &file->digest);
 	git_hash_ctx_cleanup(&file->digest);
 	file->compute_digest = 0;
 

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

@@ -7,7 +7,7 @@
 #ifndef INCLUDE_filebuf_h__
 #define INCLUDE_filebuf_h__
 
-#include "common.h"
+#include "git2_util.h"
 
 #include "futils.h"
 #include "hash.h"
@@ -17,13 +17,14 @@
 #	define GIT_FILEBUF_THREADS
 #endif
 
-#define GIT_FILEBUF_HASH_CONTENTS		(1 << 0)
-#define GIT_FILEBUF_APPEND				(1 << 2)
+#define GIT_FILEBUF_HASH_SHA1           (1 << 0)
+#define GIT_FILEBUF_HASH_SHA256         (1 << 1)
+#define GIT_FILEBUF_APPEND              (1 << 2)
 #define GIT_FILEBUF_CREATE_LEADING_DIRS	(1 << 3)
-#define GIT_FILEBUF_TEMPORARY			(1 << 4)
-#define GIT_FILEBUF_DO_NOT_BUFFER		(1 << 5)
-#define GIT_FILEBUF_FSYNC				(1 << 6)
-#define GIT_FILEBUF_DEFLATE_SHIFT		(7)
+#define GIT_FILEBUF_TEMPORARY           (1 << 4)
+#define GIT_FILEBUF_DO_NOT_BUFFER       (1 << 5)
+#define GIT_FILEBUF_FSYNC               (1 << 6)
+#define GIT_FILEBUF_DEFLATE_SHIFT       (7)
 
 #define GIT_FILELOCK_EXTENSION ".lock\0"
 #define GIT_FILELOCK_EXTLENGTH 6
@@ -87,8 +88,20 @@ int git_filebuf_open_withsize(git_filebuf *file, const char *path, int flags, mo
 int git_filebuf_commit(git_filebuf *lock);
 int git_filebuf_commit_at(git_filebuf *lock, const char *path);
 void git_filebuf_cleanup(git_filebuf *lock);
-int git_filebuf_hash(git_oid *oid, git_filebuf *file);
+int git_filebuf_hash(unsigned char *out, git_filebuf *file);
 int git_filebuf_flush(git_filebuf *file);
 int git_filebuf_stats(time_t *mtime, size_t *size, git_filebuf *file);
 
+GIT_INLINE(int) git_filebuf_hash_flags(git_hash_algorithm_t algorithm)
+{
+	switch (algorithm) {
+	case GIT_HASH_ALGORITHM_SHA1:
+		return GIT_FILEBUF_HASH_SHA1;
+	case GIT_HASH_ALGORITHM_SHA256:
+		return GIT_FILEBUF_HASH_SHA256;
+	default:
+		return 0;
+	}
+}
+
 #endif