Welcome to mirror list, hosted at ThFree Co, Russian Federation.

github.com/mono/libgit2.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--include/git2/errors.h11
-rw-r--r--src/attr_file.c5
-rw-r--r--src/cc-compat.h8
-rw-r--r--src/errors.c54
-rw-r--r--src/filebuf.c75
-rw-r--r--src/fileops.c73
-rw-r--r--src/global.h3
-rw-r--r--src/index.c4
-rw-r--r--src/odb.c2
-rw-r--r--src/odb_loose.c9
-rw-r--r--src/odb_pack.c2
-rw-r--r--src/pack.c2
-rw-r--r--src/path.c74
-rw-r--r--src/path.h24
-rw-r--r--src/reflog.c6
-rw-r--r--src/refs.c808
-rw-r--r--src/repository.c14
-rw-r--r--src/status.c8
-rw-r--r--tests-clar/config/stress.c2
-rw-r--r--tests-clar/core/filebuf.c16
-rw-r--r--tests/t00-core.c2
-rw-r--r--tests/t03-objwrite.c4
-rw-r--r--tests/t08-tag.c2
-rw-r--r--tests/t10-refs.c34
-rw-r--r--tests/t12-repo.c2
-rw-r--r--tests/test_helpers.c10
26 files changed, 590 insertions, 664 deletions
diff --git a/include/git2/errors.h b/include/git2/errors.h
index e3f5f4cb0..9b28093dc 100644
--- a/include/git2/errors.h
+++ b/include/git2/errors.h
@@ -122,16 +122,17 @@ typedef struct {
typedef enum {
GITERR_NOMEMORY,
+ GITERR_OS,
GITERR_REFERENCE,
+ GITERR_ZLIB,
} git_error_class;
-#define GITERR_CHECK_ALLOC(ptr, error) if (ptr == NULL) { giterr_set_oom(error); return -1 }
+#define GITERR_CHECK_ALLOC(ptr) if (ptr == NULL) { return -1; }
-GIT_EXTERN(void) giterr_set(git_error **error_out, int error_class, const char *string, ...);
-GIT_EXTERN(void) giterr_set_oom(git_error **error);
-GIT_EXTERN(void) giterr_free(git_error *error);
-GIT_EXTERN(void) giterr_clear(git_error **error);
+GIT_EXTERN(void) giterr_set_oom(void);
+GIT_EXTERN(void) giterr_set(int error_class, const char *string, ...);
+GIT_EXTERN(void) giterr_clear(void);
/**
* Return a detailed error string with the latest error
diff --git a/src/attr_file.c b/src/attr_file.c
index 3783b5ef3..48424123a 100644
--- a/src/attr_file.c
+++ b/src/attr_file.c
@@ -250,11 +250,12 @@ int git_attr_path__init(
git_buf full_path = GIT_BUF_INIT;
int error = git_buf_joinpath(&full_path, base, path);
if (error == GIT_SUCCESS)
- info->is_dir = (git_path_isdir(full_path.ptr) == GIT_SUCCESS);
+ info->is_dir = (int)git_path_isdir(full_path.ptr);
+
git_buf_free(&full_path);
return error;
}
- info->is_dir = (git_path_isdir(path) == GIT_SUCCESS);
+ info->is_dir = (int)git_path_isdir(path);
return GIT_SUCCESS;
}
diff --git a/src/cc-compat.h b/src/cc-compat.h
index 3df36b61f..507985daa 100644
--- a/src/cc-compat.h
+++ b/src/cc-compat.h
@@ -50,4 +50,12 @@
# pragma warning ( disable : 4127 )
#endif
+#if defined (_MSC_VER)
+ typedef unsigned char bool;
+# define true 1
+# define false 0
+#else
+# include <stdbool.h>
+#endif
+
#endif /* INCLUDE_compat_h__ */
diff --git a/src/errors.c b/src/errors.c
index 0105c2538..548e44a32 100644
--- a/src/errors.c
+++ b/src/errors.c
@@ -108,20 +108,24 @@ void git_clearerror(void)
* New error handling
********************************************/
-void giterr_set(git_error **error_out, int error_class, const char *string, ...)
+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, ...)
{
char error_str[1024];
va_list arglist;
git_error *error;
- if (error_out == NULL)
- return;
-
- error = git__malloc(sizeof(git_error));
- if (!error) {
- giterr_set_oom(error_out);
- return;
- }
+ error = &GIT_GLOBAL->error_t;
+ free(error->message);
va_start(arglist, string);
p_vsnprintf(error_str, sizeof(error_str), string, arglist);
@@ -131,38 +135,14 @@ void giterr_set(git_error **error_out, int error_class, const char *string, ...)
error->klass = error_class;
if (error->message == NULL) {
- free(error);
- giterr_set_oom(error_out);
+ giterr_set_oom();
return;
}
- *error_out = error;
-}
-
-static git_error g_git_oom_error = {
- "Out of memory",
- GITERR_NOMEMORY
-};
-
-void giterr_set_oom(git_error **error)
-{
- if (error != NULL)
- *error = &g_git_oom_error;
-}
-
-void giterr_free(git_error *error)
-{
- if (error == NULL || error == &g_git_oom_error)
- return;
-
- free(error->message);
- free(error);
+ GIT_GLOBAL->last_error = error;
}
-void giterr_clear(git_error **error)
+void giterr_clear(void)
{
- if (error != NULL) {
- giterr_free(*error);
- *error = NULL;
- }
+ GIT_GLOBAL->last_error = NULL;
}
diff --git a/src/filebuf.c b/src/filebuf.c
index 01df8e2d0..e6e68014a 100644
--- a/src/filebuf.c
+++ b/src/filebuf.c
@@ -16,11 +16,14 @@ static const size_t WRITE_BUFFER_SIZE = (4096 * 2);
static int lock_file(git_filebuf *file, int flags)
{
- if (git_path_exists(file->path_lock) == 0) {
+ if (git_path_exists(file->path_lock) == true) {
if (flags & GIT_FILEBUF_FORCE)
p_unlink(file->path_lock);
- else
- return git__throw(GIT_EOSERR, "Failed to lock file");
+ else {
+ giterr_set(GITERR_OS,
+ "Failed to lock file '%s' for writing", file->path_lock);
+ return -1;
+ }
}
/* create path to the file buffer is required */
@@ -32,16 +35,20 @@ static int lock_file(git_filebuf *file, int flags)
}
if (file->fd < 0)
- return git__throw(GIT_EOSERR, "Failed to create lock");
+ return -1;
- if ((flags & GIT_FILEBUF_APPEND) && git_path_exists(file->path_original) == 0) {
+ if ((flags & GIT_FILEBUF_APPEND) && git_path_exists(file->path_original) == true) {
git_file source;
char buffer[2048];
size_t read_bytes;
source = p_open(file->path_original, O_RDONLY);
- if (source < 0)
- return git__throw(GIT_EOSERR, "Failed to lock file. Could not open %s", file->path_original);
+ if (source < 0) {
+ giterr_set(GITERR_OS,
+ "Failed to open file '%s' for reading: %s",
+ file->path_original, strerror(errno));
+ return -1;
+ }
while ((read_bytes = p_read(source, buffer, 2048)) > 0) {
p_write(file->fd, buffer, read_bytes);
@@ -60,7 +67,7 @@ void git_filebuf_cleanup(git_filebuf *file)
if (file->fd >= 0)
p_close(file->fd);
- if (file->fd >= 0 && file->path_lock && git_path_exists(file->path_lock) == GIT_SUCCESS)
+ if (file->fd >= 0 && file->path_lock && git_path_exists(file->path_lock) == true)
p_unlink(file->path_lock);
if (file->digest)
@@ -141,13 +148,13 @@ static int write_deflate(git_filebuf *file, void *source, size_t len)
int git_filebuf_open(git_filebuf *file, const char *path, int flags)
{
- int error, compression;
+ int compression;
size_t path_len;
- assert(file && path);
-
- if (file->buffer)
- return git__throw(GIT_EINVALIDARGS, "Tried to reopen an open filebuf");
+ /* opening an already open buffer is a programming error;
+ * assert that this never happens instead of returning
+ * an error code */
+ assert(file && path && file->buffer == NULL);
memset(file, 0x0, sizeof(git_filebuf));
@@ -157,17 +164,12 @@ int git_filebuf_open(git_filebuf *file, const char *path, int flags)
/* Allocate the main cache buffer */
file->buffer = git__malloc(file->buf_size);
- if (file->buffer == NULL){
- error = GIT_ENOMEM;
- goto cleanup;
- }
+ GITERR_CHECK_ALLOC(file->buffer);
/* If we are hashing on-write, allocate a new hash context */
if (flags & GIT_FILEBUF_HASH_CONTENTS) {
- if ((file->digest = git_hash_new_ctx()) == NULL) {
- error = GIT_ENOMEM;
- goto cleanup;
- }
+ file->digest = git_hash_new_ctx();
+ GITERR_CHECK_ALLOC(file->digest);
}
compression = flags >> GIT_FILEBUF_DEFLATE_SHIFT;
@@ -176,16 +178,13 @@ int git_filebuf_open(git_filebuf *file, const char *path, int flags)
if (compression != 0) {
/* Initialize the ZLib stream */
if (deflateInit(&file->zs, compression) != Z_OK) {
- error = git__throw(GIT_EZLIB, "Failed to initialize zlib");
+ giterr_set(GITERR_ZLIB, "Failed to initialize zlib");
goto cleanup;
}
/* Allocate the Zlib cache buffer */
file->z_buf = git__malloc(file->buf_size);
- if (file->z_buf == NULL){
- error = GIT_ENOMEM;
- goto cleanup;
- }
+ GITERR_CHECK_ALLOC(file->z_buf);
/* Never flush */
file->flush_mode = Z_NO_FLUSH;
@@ -200,50 +199,40 @@ int git_filebuf_open(git_filebuf *file, const char *path, int flags)
/* Open the file as temporary for locking */
file->fd = git_futils_mktmp(&tmp_path, path);
+
if (file->fd < 0) {
git_buf_free(&tmp_path);
- error = GIT_EOSERR;
goto cleanup;
}
/* No original path */
file->path_original = NULL;
file->path_lock = git_buf_detach(&tmp_path);
-
- if (file->path_lock == NULL) {
- error = GIT_ENOMEM;
- goto cleanup;
- }
+ GITERR_CHECK_ALLOC(file->path_lock);
} else {
path_len = strlen(path);
/* Save the original path of the file */
file->path_original = git__strdup(path);
- if (file->path_original == NULL) {
- error = GIT_ENOMEM;
- goto cleanup;
- }
+ GITERR_CHECK_ALLOC(file->path_original);
/* create the locking path by appending ".lock" to the original */
file->path_lock = git__malloc(path_len + GIT_FILELOCK_EXTLENGTH);
- if (file->path_lock == NULL) {
- error = GIT_ENOMEM;
- goto cleanup;
- }
+ GITERR_CHECK_ALLOC(file->path_lock);
memcpy(file->path_lock, file->path_original, path_len);
memcpy(file->path_lock + path_len, GIT_FILELOCK_EXTENSION, GIT_FILELOCK_EXTLENGTH);
/* open the file for locking */
- if ((error = lock_file(file, flags)) < GIT_SUCCESS)
+ if (lock_file(file, flags) < 0)
goto cleanup;
}
- return GIT_SUCCESS;
+ return 0;
cleanup:
git_filebuf_cleanup(file);
- return git__rethrow(error, "Failed to open file buffer for '%s'", path);
+ return -1;
}
int git_filebuf_hash(git_oid *oid, git_filebuf *file)
diff --git a/src/fileops.c b/src/fileops.c
index 856823afb..ffaf8319d 100644
--- a/src/fileops.c
+++ b/src/fileops.c
@@ -10,25 +10,19 @@
int git_futils_mkpath2file(const char *file_path, const mode_t mode)
{
- int error;
+ int result = 0;
git_buf target_folder = GIT_BUF_INIT;
- error = git_path_dirname_r(&target_folder, file_path);
- if (error < GIT_SUCCESS) {
- git_buf_free(&target_folder);
- return git__throw(GIT_EINVALIDPATH, "Failed to recursively build `%s` tree structure. Unable to parse parent folder name", file_path);
- } else {
- /* reset error */
- error = GIT_SUCCESS;
- }
+ if (git_path_dirname_r(&target_folder, file_path) < 0)
+ return -1;
/* Does the containing folder exist? */
- if (git_path_isdir(target_folder.ptr) != GIT_SUCCESS)
+ if (git_path_isdir(target_folder.ptr) == false)
/* Let's create the tree structure */
- error = git_futils_mkdir_r(target_folder.ptr, NULL, mode);
+ result = git_futils_mkdir_r(target_folder.ptr, NULL, mode);
git_buf_free(&target_folder);
- return error;
+ return result;
}
int git_futils_mktmp(git_buf *path_out, const char *filename)
@@ -39,33 +33,50 @@ int git_futils_mktmp(git_buf *path_out, const char *filename)
git_buf_puts(path_out, "_git2_XXXXXX");
if (git_buf_oom(path_out))
- return git__rethrow(git_buf_lasterror(path_out),
- "Failed to create temporary file for %s", filename);
+ return -1;
- if ((fd = p_mkstemp(path_out->ptr)) < 0)
- return git__throw(GIT_EOSERR, "Failed to create temporary file %s", path_out->ptr);
+ if ((fd = p_mkstemp(path_out->ptr)) < 0) {
+ giterr_set(GITERR_OS,
+ "Failed to create temporary file '%s': %s", path_out->ptr, strerror(errno));
+ return -1;
+ }
return fd;
}
int git_futils_creat_withpath(const char *path, const mode_t dirmode, const mode_t mode)
{
- if (git_futils_mkpath2file(path, dirmode) < GIT_SUCCESS)
- return git__throw(GIT_EOSERR, "Failed to create file %s", path);
+ int fd;
- return p_creat(path, mode);
+ if (git_futils_mkpath2file(path, dirmode) < 0)
+ return -1;
+
+ fd = p_creat(path, mode);
+ if (fd < 0) {
+ giterr_set(GITERR_OS,
+ "Failed to create file '%s': %s", path, strerror(errno));
+ return -1;
+ }
+
+ return fd;
}
int git_futils_creat_locked(const char *path, const mode_t mode)
{
int fd = open(path, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_EXCL, mode);
- return fd >= 0 ? fd : git__throw(GIT_EOSERR, "Failed to create locked file. Could not open %s", path);
+ if (fd < 0) {
+ giterr_set(GITERR_OS,
+ "Failed to create locked file '%s': %s", path, strerror(errno));
+ return -1;
+ }
+
+ return fd;
}
int git_futils_creat_locked_withpath(const char *path, const mode_t dirmode, const mode_t mode)
{
- if (git_futils_mkpath2file(path, dirmode) < GIT_SUCCESS)
- return git__throw(GIT_EOSERR, "Failed to create locked file %s", path);
+ if (git_futils_mkpath2file(path, dirmode) < 0)
+ return -1;
return git_futils_creat_locked(path, mode);
}
@@ -105,12 +116,14 @@ int git_futils_readbuffer_updated(git_buf *buf, const char *path, time_t *mtime,
*updated = 0;
if ((fd = p_open(path, O_RDONLY)) < 0) {
- return git__throw(GIT_ENOTFOUND, "Failed to read file '%s': %s", path, strerror(errno));
+ giterr_set(GITERR_OS, "Failed to read file '%s': %s", path, strerror(errno));
+ return (errno == ENOENT) ? GIT_ENOTFOUND : -1;
}
if (p_fstat(fd, &st) < 0 || S_ISDIR(st.st_mode) || !git__is_sizet(st.st_size+1)) {
close(fd);
- return git__throw(GIT_EOSERR, "Failed to stat file '%s'", path);
+ giterr_set(GITERR_OS, "Invalid regular file stat for '%s'", path);
+ return -1;
}
/*
@@ -141,7 +154,9 @@ int git_futils_readbuffer_updated(git_buf *buf, const char *path, time_t *mtime,
if (read_size < 0) {
close(fd);
- return git__throw(GIT_EOSERR, "Failed to read from FD");
+ giterr_set(GITERR_OS, "Failed to read descriptor for %s: %s",
+ path, strerror(errno));
+ return -1;
}
len -= read_size;
@@ -218,7 +233,7 @@ int git_futils_mkdir_r(const char *path, const char *base, const mode_t mode)
pp += root_path_offset; /* On Windows, will skip the drive name (eg. C: or D:) */
while (error == GIT_SUCCESS && (sp = strchr(pp, '/')) != NULL) {
- if (sp != pp && git_path_isdir(make_path.ptr) < GIT_SUCCESS) {
+ if (sp != pp && git_path_isdir(make_path.ptr) == false) {
*sp = 0;
error = p_mkdir(make_path.ptr, mode);
@@ -251,7 +266,7 @@ static int _rmdir_recurs_foreach(void *opaque, git_buf *path)
int error = GIT_SUCCESS;
int force = *(int *)opaque;
- if (git_path_isdir(path->ptr) == GIT_SUCCESS) {
+ if (git_path_isdir(path->ptr) == true) {
error = git_path_direach(path, _rmdir_recurs_foreach, opaque);
if (error < GIT_SUCCESS)
return git__rethrow(error, "Failed to remove directory `%s`", path->ptr);
@@ -293,7 +308,7 @@ int git_futils_find_global_file(git_buf *path, const char *filename)
if ((error = git_buf_joinpath(path, home, filename)) < GIT_SUCCESS)
return error;
- if (git_path_exists(path->ptr) < GIT_SUCCESS) {
+ if (git_path_exists(path->ptr) == false) {
git_buf_clear(path);
return GIT_ENOTFOUND;
}
@@ -395,7 +410,7 @@ int git_futils_find_system_file(git_buf *path, const char *filename)
if (git_buf_joinpath(path, "/etc", filename) < GIT_SUCCESS)
return git_buf_lasterror(path);
- if (git_path_exists(path->ptr) == GIT_SUCCESS)
+ if (git_path_exists(path->ptr) == true)
return GIT_SUCCESS;
git_buf_clear(path);
diff --git a/src/global.h b/src/global.h
index 0c1e3289c..2b525ce07 100644
--- a/src/global.h
+++ b/src/global.h
@@ -14,6 +14,9 @@ typedef struct {
char last[1024];
} error;
+ git_error *last_error;
+ git_error error_t;
+
git_mwindow_ctl mem_ctl;
} git_global_st;
diff --git a/src/index.c b/src/index.c
index 5ac99de3e..b646dfcbb 100644
--- a/src/index.c
+++ b/src/index.c
@@ -150,7 +150,7 @@ int git_index_open(git_index **index_out, const char *index_path)
git_vector_init(&index->entries, 32, index_cmp);
/* Check if index file is stored on disk already */
- if (git_path_exists(index->index_file_path) == 0)
+ if (git_path_exists(index->index_file_path) == true)
index->on_disk = 1;
*index_out = index;
@@ -221,7 +221,7 @@ int git_index_read(git_index *index)
assert(index->index_file_path);
- if (!index->on_disk || git_path_exists(index->index_file_path) < 0) {
+ if (!index->on_disk || git_path_exists(index->index_file_path) == false) {
git_index_clear(index);
index->on_disk = 0;
return GIT_SUCCESS;
diff --git a/src/odb.c b/src/odb.c
index 81fc82ba8..53e07519d 100644
--- a/src/odb.c
+++ b/src/odb.c
@@ -402,7 +402,7 @@ static int load_alternates(git_odb *odb, const char *objects_dir)
if (error < GIT_SUCCESS)
return error;
- if (git_path_exists(alternates_path.ptr) < GIT_SUCCESS) {
+ if (git_path_exists(alternates_path.ptr) == false) {
git_buf_free(&alternates_path);
return GIT_SUCCESS;
}
diff --git a/src/odb_loose.c b/src/odb_loose.c
index f5f6e35ac..6546fa839 100644
--- a/src/odb_loose.c
+++ b/src/odb_loose.c
@@ -466,7 +466,7 @@ static int locate_object(
int error = object_file_name(object_location, backend->objects_dir, oid);
if (error == GIT_SUCCESS)
- error = git_path_exists(git_buf_cstr(object_location));
+ error = git_path_exists(git_buf_cstr(object_location)) ? GIT_SUCCESS : GIT_ENOTFOUND;
return error;
}
@@ -480,7 +480,7 @@ static int fn_locate_object_short_oid(void *state, git_buf *pathbuf) {
return GIT_SUCCESS;
}
- if (!git_path_exists(pathbuf->ptr) && git_path_isdir(pathbuf->ptr)) {
+ if (git_path_isdir(pathbuf->ptr) == true) {
/* We are already in the directory matching the 2 first hex characters,
* compare the first ncmp characters of the oids */
if (!memcmp(sstate->short_oid + 2,
@@ -533,8 +533,7 @@ static int locate_object_short_oid(
return git__rethrow(error, "Failed to locate object from short oid");
/* Check that directory exists */
- if (git_path_exists(object_location->ptr) ||
- git_path_isdir(object_location->ptr))
+ if (git_path_isdir(object_location->ptr) == false)
return git__throw(GIT_ENOTFOUND, "Failed to locate object from short oid. Object not found");
state.dir_len = object_location->size;
@@ -716,7 +715,7 @@ static int loose_backend__stream_fwrite(git_oid *oid, git_odb_stream *_stream)
* is what git does and allows us to sidestep the fact that
* we're not allowed to overwrite a read-only file on Windows.
*/
- if (git_path_exists(final_path.ptr) == GIT_SUCCESS) {
+ if (git_path_exists(final_path.ptr) == true) {
git_filebuf_cleanup(&stream->fbuf);
goto cleanup;
}
diff --git a/src/odb_pack.c b/src/odb_pack.c
index 249144a3a..159c88685 100644
--- a/src/odb_pack.c
+++ b/src/odb_pack.c
@@ -469,7 +469,7 @@ int git_odb_backend_pack(git_odb_backend **backend_out, const char *objects_dir)
if (error < GIT_SUCCESS)
goto cleanup;
- if (git_path_isdir(git_buf_cstr(&path)) == GIT_SUCCESS) {
+ if (git_path_isdir(git_buf_cstr(&path)) == true) {
backend->pack_folder = git_buf_detach(&path);
backend->pack_folder_mtime = 0;
}
diff --git a/src/pack.c b/src/pack.c
index 0d618324b..acab8734b 100644
--- a/src/pack.c
+++ b/src/pack.c
@@ -600,7 +600,7 @@ int git_packfile_check(struct git_pack_file **pack_out, const char *path)
memcpy(p->pack_name, path, path_len);
strcpy(p->pack_name + path_len, ".keep");
- if (git_path_exists(p->pack_name) == GIT_SUCCESS)
+ if (git_path_exists(p->pack_name) == true)
p->pack_keep = 1;
strcpy(p->pack_name + path_len, ".pack");
diff --git a/src/path.c b/src/path.c
index c882fe387..5d35e0ef2 100644
--- a/src/path.c
+++ b/src/path.c
@@ -354,80 +354,75 @@ int git_path_walk_up(
return error;
}
-int git_path_exists(const char *path)
+bool git_path_exists(const char *path)
{
assert(path);
- return p_access(path, F_OK);
+ return p_access(path, F_OK) == 0;
}
-int git_path_isdir(const char *path)
+bool git_path_isdir(const char *path)
{
#ifdef GIT_WIN32
DWORD attr = GetFileAttributes(path);
if (attr == INVALID_FILE_ATTRIBUTES)
- return GIT_ERROR;
+ return false;
- return (attr & FILE_ATTRIBUTE_DIRECTORY) ? GIT_SUCCESS : GIT_ERROR;
+ return (attr & FILE_ATTRIBUTE_DIRECTORY) != 0;
#else
struct stat st;
- if (p_stat(path, &st) < GIT_SUCCESS)
- return GIT_ERROR;
+ if (p_stat(path, &st) < 0)
+ return false;
- return S_ISDIR(st.st_mode) ? GIT_SUCCESS : GIT_ERROR;
+ return S_ISDIR(st.st_mode) != 0;
#endif
}
-int git_path_isfile(const char *path)
+bool git_path_isfile(const char *path)
{
struct stat st;
- int stat_error;
assert(path);
- stat_error = p_stat(path, &st);
+ if (p_stat(path, &st) < 0)
+ return false;
- if (stat_error < GIT_SUCCESS)
- return -1;
-
- if (!S_ISREG(st.st_mode))
- return -1;
-
- return 0;
+ return S_ISREG(st.st_mode) != 0;
}
-static int _check_dir_contents(
+static bool _check_dir_contents(
git_buf *dir,
const char *sub,
- int (*predicate)(const char *))
+ bool (*predicate)(const char *))
{
- int error = GIT_SUCCESS;
+ bool result;
size_t dir_size = dir->size;
size_t sub_size = strlen(sub);
- /* separate allocation and join, so we can always leave git_buf valid */
- if ((error = git_buf_try_grow(dir, dir_size + sub_size + 2)) < GIT_SUCCESS)
- return error;
+ /* leave base valid even if we could not make space for subdir */
+ if (git_buf_try_grow(dir, dir_size + sub_size + 2) < 0)
+ return false;
+
+ /* save excursion */
git_buf_joinpath(dir, dir->ptr, sub);
- error = (*predicate)(dir->ptr);
+ result = predicate(dir->ptr);
/* restore path */
git_buf_truncate(dir, dir_size);
-
- return error;
+ return result;
}
-int git_path_contains(git_buf *dir, const char *item)
+bool git_path_contains(git_buf *dir, const char *item)
{
return _check_dir_contents(dir, item, &git_path_exists);
}
-int git_path_contains_dir(git_buf *base, const char *subdir)
+bool git_path_contains_dir(git_buf *base, const char *subdir)
{
return _check_dir_contents(base, subdir, &git_path_isdir);
}
-int git_path_contains_file(git_buf *base, const char *file)
+bool git_path_contains_file(git_buf *base, const char *file)
{
return _check_dir_contents(base, file, &git_path_isfile);
}
@@ -448,7 +443,7 @@ int git_path_find_dir(git_buf *dir, const char *path, const char *base)
}
/* call dirname if this is not a directory */
- if (error == GIT_SUCCESS && git_path_isdir(dir->ptr) != GIT_SUCCESS)
+ if (error == GIT_SUCCESS && git_path_isdir(dir->ptr) == false)
if (git_path_dirname_r(dir, dir->ptr) < GIT_SUCCESS)
error = git_buf_lasterror(dir);
@@ -486,21 +481,20 @@ GIT_INLINE(int) is_dot_or_dotdot(const char *name)
int git_path_direach(
git_buf *path,
- int (*fn)(void *, git_buf *, git_error **),
- void *arg,
- git_error **error)
+ int (*fn)(void *, git_buf *),
+ void *arg)
{
ssize_t wd_len;
DIR *dir;
struct dirent de_buf, *de;
- if (git_path_to_dir(path, error) < 0)
+ if (git_path_to_dir(path) < 0)
return -1;
wd_len = path->size;
dir = opendir(path->ptr);
if (!dir) {
- giterr_set(error, GITERR_OS, "Failed to `opendir` %s: %s", path->ptr, strerror(errno));
+ giterr_set(GITERR_OS, "Failed to `opendir` %s: %s", path->ptr, strerror(errno));
return -1;
}
@@ -510,12 +504,10 @@ int git_path_direach(
if (is_dot_or_dotdot(de->d_name))
continue;
- if (git_buf_puts(path, de->d_name) < 0) {
- giterr_set_oom(error);
+ if (git_buf_puts(path, de->d_name) < 0)
return -1;
- }
- result = fn(arg, path, error);
+ result = fn(arg, path);
git_buf_truncate(path, wd_len); /* restore path */
@@ -526,7 +518,7 @@ int git_path_direach(
}
closedir(dir);
- return GIT_SUCCESS;
+ return 0;
}
int git_path_dirload(
diff --git a/src/path.h b/src/path.h
index 981fdd6a4..e885d875e 100644
--- a/src/path.h
+++ b/src/path.h
@@ -113,21 +113,21 @@ extern int git_path_fromurl(git_buf *local_path_out, const char *file_url);
/**
* Check if a file exists and can be accessed.
- * @return GIT_SUCCESS if file exists, < 0 otherwise.
+ * @return true or false
*/
-extern int git_path_exists(const char *path);
+extern bool git_path_exists(const char *path);
/**
* Check if the given path points to a directory.
- * @return GIT_SUCCESS if it is a directory, < 0 otherwise.
+ * @return true or false
*/
-extern int git_path_isdir(const char *path);
+extern bool git_path_isdir(const char *path);
/**
* Check if the given path points to a regular file.
- * @return GIT_SUCCESS if it is a regular file, < 0 otherwise.
+ * @return true or false
*/
-extern int git_path_isfile(const char *path);
+extern bool git_path_isfile(const char *path);
/**
* Check if the parent directory contains the item.
@@ -136,25 +136,27 @@ extern int git_path_isfile(const char *path);
* @param item Item that might be in the directory.
* @return GIT_SUCCESS if item exists in directory, <0 otherwise.
*/
-extern int git_path_contains(git_buf *dir, const char *item);
+extern bool git_path_contains(git_buf *dir, const char *item);
/**
* Check if the given path contains the given subdirectory.
*
* @param parent Directory path that might contain subdir
* @param subdir Subdirectory name to look for in parent
- * @return GIT_SUCCESS if subdirectory exists, < 0 otherwise.
+ * @param append_if_exists If true, then subdir will be appended to the parent path if it does exist
+ * @return true if subdirectory exists, false otherwise.
*/
-extern int git_path_contains_dir(git_buf *parent, const char *subdir);
+extern bool git_path_contains_dir(git_buf *parent, const char *subdir);
/**
* Check if the given path contains the given file.
*
* @param dir Directory path that might contain file
* @param file File name to look for in parent
- * @return GIT_SUCCESS if file exists, < 0 otherwise.
+ * @param append_if_exists If true, then file will be appended to the path if it does exist
+ * @return true if file exists, false otherwise.
*/
-extern int git_path_contains_file(git_buf *dir, const char *file);
+extern bool git_path_contains_file(git_buf *dir, const char *file);
/**
* Clean up path, prepending base if it is not already rooted.
diff --git a/src/reflog.c b/src/reflog.c
index 6ca9418cf..8f68a3ac7 100644
--- a/src/reflog.c
+++ b/src/reflog.c
@@ -246,12 +246,12 @@ int git_reflog_write(git_reference *ref, const git_oid *oid_old,
if (error < GIT_SUCCESS)
goto cleanup;
- if (git_path_exists(log_path.ptr)) {
+ if (git_path_exists(log_path.ptr) == false) {
error = git_futils_mkpath2file(log_path.ptr, GIT_REFLOG_DIR_MODE);
if (error < GIT_SUCCESS)
git__rethrow(error,
"Failed to write reflog. Cannot create reflog directory");
- } else if (git_path_isfile(log_path.ptr)) {
+ } else if (git_path_isfile(log_path.ptr) == false) {
error = git__throw(GIT_ERROR,
"Failed to write reflog. `%s` is directory", log_path.ptr);
} else if (oid_old == NULL) {
@@ -302,7 +302,7 @@ int git_reflog_delete(git_reference *ref)
error = git_buf_join_n(&path, '/', 3,
ref->owner->path_repository, GIT_REFLOG_DIR, ref->name);
- if (error == GIT_SUCCESS && git_path_exists(path.ptr) == 0)
+ if (error == GIT_SUCCESS && git_path_exists(path.ptr) == true)
error = p_unlink(path.ptr);
git_buf_free(&path);
diff --git a/src/refs.c b/src/refs.c
index ebfabc635..461b50719 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -61,8 +61,8 @@ static int packed_lookup(git_reference *ref);
static int packed_write(git_repository *repo);
/* internal helpers */
-static int reference_available(git_repository *repo,
- const char *ref, const char *old_ref, git_error **error);
+static int reference_path_available(git_repository *repo,
+ const char *ref, const char *old_ref);
static int reference_delete(git_reference *ref);
static int reference_lookup(git_reference *ref);
@@ -97,36 +97,37 @@ static int reference_alloc(
assert(ref_out && repo && name);
reference = git__malloc(sizeof(git_reference));
- if (reference == NULL)
- return GIT_ENOMEM;
+ GITERR_CHECK_ALLOC(reference);
memset(reference, 0x0, sizeof(git_reference));
reference->owner = repo;
reference->name = git__strdup(name);
- if (reference->name == NULL) {
- git__free(reference);
- return GIT_ENOMEM;
- }
+ GITERR_CHECK_ALLOC(reference->name);
*ref_out = reference;
- return GIT_SUCCESS;
+ return 0;
}
-static int reference_read(git_buf *file_content, time_t *mtime, const char *repo_path, const char *ref_name, int *updated)
+static int reference_read(
+ git_buf *file_content,
+ time_t *mtime,
+ const char *repo_path,
+ const char *ref_name,
+ int *updated)
{
git_buf path = GIT_BUF_INIT;
- int error = GIT_SUCCESS;
+ int result;
assert(file_content && repo_path && ref_name);
/* Determine the full path of the file */
- if ((error = git_buf_joinpath(&path, repo_path, ref_name)) == GIT_SUCCESS)
- error = git_futils_readbuffer_updated(file_content, path.ptr, mtime, updated);
+ if (git_buf_joinpath(&path, repo_path, ref_name) < 0)
+ return -1;
+ result = git_futils_readbuffer_updated(file_content, path.ptr, mtime, updated);
git_buf_free(&path);
-
- return error;
+ return result;
}
static int loose_parse_symbolic(git_reference *ref, git_buf *file_content)
@@ -138,57 +139,58 @@ static int loose_parse_symbolic(git_reference *ref, git_buf *file_content)
refname_start = (const char *)file_content->ptr;
if (file_content->size < (header_len + 1))
- return git__throw(GIT_EOBJCORRUPTED,
- "Failed to parse loose reference. Object too short");
+ goto corrupt;
/*
* Assume we have already checked for the header
* before calling this function
*/
-
refname_start += header_len;
ref->target.symbolic = git__strdup(refname_start);
- if (ref->target.symbolic == NULL)
- return GIT_ENOMEM;
+ GITERR_CHECK_ALLOC(ref->target.symbolic);
/* remove newline at the end of file */
eol = strchr(ref->target.symbolic, '\n');
if (eol == NULL)
- return git__throw(GIT_EOBJCORRUPTED,
- "Failed to parse loose reference. Missing EOL");
+ goto corrupt;
*eol = '\0';
if (eol[-1] == '\r')
eol[-1] = '\0';
- return GIT_SUCCESS;
+ return 0;
+
+corrupt:
+ giterr_set(GITERR_REFERENCE, "Corrupted loose reference file");
+ return -1;
}
static int loose_parse_oid(git_oid *oid, git_buf *file_content)
{
- int error;
char *buffer;
buffer = (char *)file_content->ptr;
/* File format: 40 chars (OID) + newline */
if (file_content->size < GIT_OID_HEXSZ + 1)
- return git__throw(GIT_EOBJCORRUPTED,
- "Failed to parse loose reference. Reference too short");
+ goto corrupt;
- if ((error = git_oid_fromstr(oid, buffer)) < GIT_SUCCESS)
- return git__rethrow(GIT_EOBJCORRUPTED, "Failed to parse loose reference.");
+ if (git_oid_fromstr(oid, buffer) < 0)
+ goto corrupt;
buffer = buffer + GIT_OID_HEXSZ;
if (*buffer == '\r')
buffer++;
if (*buffer != '\n')
- return git__throw(GIT_EOBJCORRUPTED,
- "Failed to parse loose reference. Missing EOL");
+ goto corrupt;
return GIT_SUCCESS;
+
+corrupt:
+ giterr_set(GITERR_REFERENCE, "Corrupted loose reference file");
+ return -1;
}
static git_rtype loose_guess_rtype(const git_buf *full_path)
@@ -211,15 +213,17 @@ static git_rtype loose_guess_rtype(const git_buf *full_path)
static int loose_lookup(git_reference *ref)
{
- int error = GIT_SUCCESS, updated;
+ int result, updated;
git_buf ref_file = GIT_BUF_INIT;
- if (reference_read(&ref_file, &ref->mtime,
- ref->owner->path_repository, ref->name, &updated) < GIT_SUCCESS)
- return git__throw(GIT_ENOTFOUND, "Failed to lookup loose reference");
+ result = reference_read(&ref_file, &ref->mtime,
+ ref->owner->path_repository, ref->name, &updated);
+
+ if (result < 0)
+ return result;
if (!updated)
- return GIT_SUCCESS;
+ return 0;
if (ref->flags & GIT_REF_SYMBOLIC) {
git__free(ref->target.symbolic);
@@ -230,18 +234,14 @@ static int loose_lookup(git_reference *ref)
if (git__prefixcmp((const char *)(ref_file.ptr), GIT_SYMREF) == 0) {
ref->flags |= GIT_REF_SYMBOLIC;
- error = loose_parse_symbolic(ref, &ref_file);
+ result = loose_parse_symbolic(ref, &ref_file);
} else {
ref->flags |= GIT_REF_OID;
- error = loose_parse_oid(&ref->target.oid, &ref_file);
+ result = loose_parse_oid(&ref->target.oid, &ref_file);
}
git_buf_free(&ref_file);
-
- if (error < GIT_SUCCESS)
- return git__rethrow(error, "Failed to lookup loose reference");
-
- return GIT_SUCCESS;
+ return result;
}
static int loose_lookup_to_packfile(
@@ -249,54 +249,50 @@ static int loose_lookup_to_packfile(
git_repository *repo,
const char *name)
{
- int error = GIT_SUCCESS;
git_buf ref_file = GIT_BUF_INIT;
struct packref *ref = NULL;
size_t name_len;
*ref_out = NULL;
- error = reference_read(&ref_file, NULL, repo->path_repository, name, NULL);
- if (error < GIT_SUCCESS)
- goto cleanup;
+ if (reference_read(&ref_file, NULL, repo->path_repository, name, NULL) < 0)
+ return -1;
name_len = strlen(name);
ref = git__malloc(sizeof(struct packref) + name_len + 1);
+ GITERR_CHECK_ALLOC(ref);
memcpy(ref->name, name, name_len);
ref->name[name_len] = 0;
- error = loose_parse_oid(&ref->oid, &ref_file);
- if (error < GIT_SUCCESS)
- goto cleanup;
+ if (loose_parse_oid(&ref->oid, &ref_file) < 0) {
+ git_buf_free(&ref_file);
+ free(ref);
+ return -1;
+ }
ref->flags = GIT_PACKREF_WAS_LOOSE;
*ref_out = ref;
git_buf_free(&ref_file);
- return GIT_SUCCESS;
-
-cleanup:
- git_buf_free(&ref_file);
- git__free(ref);
-
- return git__rethrow(error, "Failed to lookup loose reference");
+ return 0;
}
static int loose_write(git_reference *ref)
{
git_filebuf file = GIT_FILEBUF_INIT;
git_buf ref_path = GIT_BUF_INIT;
- int error;
struct stat st;
- error = git_buf_joinpath(&ref_path, ref->owner->path_repository, ref->name);
- if (error < GIT_SUCCESS)
- goto unlock;
+ if (git_buf_joinpath(&ref_path, ref->owner->path_repository, ref->name) < 0)
+ return -1;
+
+ if (git_filebuf_open(&file, ref_path.ptr, GIT_FILEBUF_FORCE) < 0) {
+ git_buf_free(&ref_path);
+ return -1;
+ }
- error = git_filebuf_open(&file, ref_path.ptr, GIT_FILEBUF_FORCE);
- if (error < GIT_SUCCESS)
- goto unlock;
+ git_buf_free(&ref_path);
if (ref->flags & GIT_REF_OID) {
char oid[GIT_OID_HEXSZ + 1];
@@ -304,29 +300,18 @@ static int loose_write(git_reference *ref)
git_oid_fmt(oid, &ref->target.oid);
oid[GIT_OID_HEXSZ] = '\0';
- error = git_filebuf_printf(&file, "%s\n", oid);
- if (error < GIT_SUCCESS)
- goto unlock;
+ git_filebuf_printf(&file, "%s\n", oid);
- } else if (ref->flags & GIT_REF_SYMBOLIC) { /* GIT_REF_SYMBOLIC */
- error = git_filebuf_printf(&file, GIT_SYMREF "%s\n", ref->target.symbolic);
+ } else if (ref->flags & GIT_REF_SYMBOLIC) {
+ git_filebuf_printf(&file, GIT_SYMREF "%s\n", ref->target.symbolic);
} else {
- error = git__throw(GIT_EOBJCORRUPTED,
- "Failed to write reference. Invalid reference type");
- goto unlock;
+ assert(0); /* don't let this happen */
}
- if (p_stat(ref_path.ptr, &st) == GIT_SUCCESS)
+ if (p_stat(ref_path.ptr, &st) == 0)
ref->mtime = st.st_mtime;
- git_buf_free(&ref_path);
-
return git_filebuf_commit(&file, GIT_REFS_FILE_MODE);
-
-unlock:
- git_buf_free(&ref_path);
- git_filebuf_cleanup(&file);
- return git__rethrow(error, "Failed to write loose reference");
}
static int packed_parse_peel(
@@ -340,34 +325,32 @@ static int packed_parse_peel(
/* Ensure it's not the first entry of the file */
if (tag_ref == NULL)
- return git__throw(GIT_EPACKEDREFSCORRUPTED,
- "Failed to parse packed reference. "
- "Reference is the first entry of the file");
+ goto corrupt;
/* Ensure reference is a tag */
if (git__prefixcmp(tag_ref->name, GIT_REFS_TAGS_DIR) != 0)
- return git__throw(GIT_EPACKEDREFSCORRUPTED,
- "Failed to parse packed reference. Reference is not a tag");
+ goto corrupt;
if (buffer + GIT_OID_HEXSZ >= buffer_end)
- return git__throw(GIT_EPACKEDREFSCORRUPTED,
- "Failed to parse packed reference. Buffer too small");
+ goto corrupt;
/* Is this a valid object id? */
if (git_oid_fromstr(&tag_ref->peel, buffer) < GIT_SUCCESS)
- return git__throw(GIT_EPACKEDREFSCORRUPTED,
- "Failed to parse packed reference. Not a valid object ID");
+ goto corrupt;
buffer = buffer + GIT_OID_HEXSZ;
if (*buffer == '\r')
buffer++;
if (*buffer != '\n')
- return git__throw(GIT_EPACKEDREFSCORRUPTED,
- "Failed to parse packed reference. Buffer not terminated correctly");
+ goto corrupt;
*buffer_out = buffer + 1;
- return GIT_SUCCESS;
+ return 0;
+
+corrupt:
+ giterr_set(GITERR_REFERENCE, "The packed references file is corrupted");
+ return -1;
}
static int packed_parse_oid(
@@ -380,26 +363,20 @@ static int packed_parse_oid(
const char *buffer = *buffer_out;
const char *refname_begin, *refname_end;
- int error = GIT_SUCCESS;
size_t refname_len;
git_oid id;
refname_begin = (buffer + GIT_OID_HEXSZ + 1);
- if (refname_begin >= buffer_end ||
- refname_begin[-1] != ' ') {
- error = GIT_EPACKEDREFSCORRUPTED;
- goto cleanup;
- }
+ if (refname_begin >= buffer_end || refname_begin[-1] != ' ')
+ goto corrupt;
/* Is this a valid object id? */
- if ((error = git_oid_fromstr(&id, buffer)) < GIT_SUCCESS)
- goto cleanup;
+ if (git_oid_fromstr(&id, buffer) < 0)
+ goto corrupt;
refname_end = memchr(refname_begin, '\n', buffer_end - refname_begin);
- if (refname_end == NULL) {
- error = GIT_EPACKEDREFSCORRUPTED;
- goto cleanup;
- }
+ if (refname_end == NULL)
+ goto corrupt;
if (refname_end[-1] == '\r')
refname_end--;
@@ -407,6 +384,7 @@ static int packed_parse_oid(
refname_len = refname_end - refname_begin;
ref = git__malloc(sizeof(struct packref) + refname_len + 1);
+ GITERR_CHECK_ALLOC(ref);
memcpy(ref->name, refname_begin, refname_len);
ref->name[refname_len] = 0;
@@ -418,16 +396,17 @@ static int packed_parse_oid(
*ref_out = ref;
*buffer_out = refname_end + 1;
- return GIT_SUCCESS;
+ return 0;
-cleanup:
+corrupt:
git__free(ref);
- return git__rethrow(error, "Failed to parse OID of packed reference");
+ giterr_set(GITERR_REFERENCE, "The packed references file is corrupted");
+ return -1;
}
static int packed_load(git_repository *repo)
{
- int error = GIT_SUCCESS, updated;
+ int result, updated;
git_buf packfile = GIT_BUF_INIT;
const char *buffer_start, *buffer_end;
git_refcache *ref_cache = &repo->references;
@@ -437,13 +416,10 @@ static int packed_load(git_repository *repo)
ref_cache->packfile = git_hashtable_alloc(
default_table_size, git_hash__strhash_cb, git_hash__strcmp_cb);
- if (ref_cache->packfile == NULL) {
- error = GIT_ENOMEM;
- goto cleanup;
- }
+ GITERR_CHECK_ALLOC(ref_cache->packfile);
}
- error = reference_read(&packfile, &ref_cache->packfile_time,
+ result = reference_read(&packfile, &ref_cache->packfile_time,
repo->path_repository, GIT_PACKEDREFS_FILE, &updated);
/*
@@ -453,20 +429,21 @@ static int packed_load(git_repository *repo)
* for us here, so just return. Anything else means we need to
* refresh the packed refs.
*/
- if (error == GIT_ENOTFOUND) {
+ if (result == GIT_ENOTFOUND) {
git_hashtable_clear(ref_cache->packfile);
- return GIT_SUCCESS;
- } else if (error < GIT_SUCCESS) {
- return git__rethrow(error, "Failed to read packed refs");
- } else if (!updated) {
- return GIT_SUCCESS;
+ return 0;
}
+ if (result < 0)
+ return -1;
+
+ if (!updated)
+ return 0;
+
/*
* At this point, we want to refresh the packed refs. We already
* have the contents in our buffer.
*/
-
git_hashtable_clear(ref_cache->packfile);
buffer_start = (const char *)packfile.ptr;
@@ -474,41 +451,35 @@ static int packed_load(git_repository *repo)
while (buffer_start < buffer_end && buffer_start[0] == '#') {
buffer_start = strchr(buffer_start, '\n');
- if (buffer_start == NULL) {
- error = GIT_EPACKEDREFSCORRUPTED;
- goto cleanup;
- }
+ if (buffer_start == NULL)
+ goto parse_failed;
+
buffer_start++;
}
while (buffer_start < buffer_end) {
struct packref *ref = NULL;
- error = packed_parse_oid(&ref, &buffer_start, buffer_end);
- if (error < GIT_SUCCESS)
- goto cleanup;
+ if (packed_parse_oid(&ref, &buffer_start, buffer_end) < 0)
+ goto parse_failed;
if (buffer_start[0] == '^') {
- error = packed_parse_peel(ref, &buffer_start, buffer_end);
- if (error < GIT_SUCCESS)
- goto cleanup;
+ if (packed_parse_peel(ref, &buffer_start, buffer_end) < 0)
+ goto parse_failed;
}
- error = git_hashtable_insert(ref_cache->packfile, ref->name, ref);
- if (error < GIT_SUCCESS) {
- git__free(ref);
- goto cleanup;
- }
+ if (git_hashtable_insert(ref_cache->packfile, ref->name, ref) < 0)
+ return -1;
}
git_buf_free(&packfile);
- return GIT_SUCCESS;
+ return 0;
-cleanup:
+parse_failed:
git_hashtable_free(ref_cache->packfile);
ref_cache->packfile = NULL;
git_buf_free(&packfile);
- return git__rethrow(error, "Failed to load packed references");
+ return -1;
}
@@ -521,22 +492,22 @@ struct dirent_list_data {
void *callback_payload;
};
-static int _dirent_loose_listall(void *_data, git_buf *full_path, git_error **error)
+static int _dirent_loose_listall(void *_data, git_buf *full_path)
{
struct dirent_list_data *data = (struct dirent_list_data *)_data;
const char *file_path = full_path->ptr + data->repo_path_len;
- if (git_path_isdir(full_path->ptr) == GIT_SUCCESS)
+ if (git_path_isdir(full_path->ptr) == true)
return git_path_direach(full_path, _dirent_loose_listall, _data);
/* do not add twice a reference that exists already in the packfile */
if ((data->list_flags & GIT_REF_PACKED) != 0 &&
git_hashtable_lookup(data->repo->references.packfile, file_path) != NULL)
- return GIT_SUCCESS;
+ return 0;
if (data->list_flags != GIT_REF_LISTALL) {
if ((data->list_flags & loose_guess_rtype(full_path)) == 0)
- return GIT_SUCCESS; /* we are filtering out this reference */
+ return 0; /* we are filtering out this reference */
}
return data->callback(file_path, data->callback_payload);
@@ -548,30 +519,23 @@ static int _dirent_loose_load(void *data, git_buf *full_path)
void *old_ref = NULL;
struct packref *ref;
const char *file_path;
- int error;
- if (git_path_isdir(full_path->ptr) == GIT_SUCCESS)
+ if (git_path_isdir(full_path->ptr) == true)
return git_path_direach(full_path, _dirent_loose_load, repository);
file_path = full_path->ptr + strlen(repository->path_repository);
- error = loose_lookup_to_packfile(&ref, repository, file_path);
- if (error == GIT_SUCCESS) {
-
- if (git_hashtable_insert2(
- repository->references.packfile,
- ref->name, ref, &old_ref) < GIT_SUCCESS) {
- git__free(ref);
- return GIT_ENOMEM;
- }
+ if (loose_lookup_to_packfile(&ref, repository, file_path) < 0)
+ return -1;
- if (old_ref != NULL)
- git__free(old_ref);
+ if (git_hashtable_insert2(repository->references.packfile,
+ ref->name, ref, &old_ref) < 0) {
+ git__free(ref);
+ return -1;
}
- return error == GIT_SUCCESS ?
- GIT_SUCCESS :
- git__rethrow(error, "Failed to load loose references into packfile");
+ git__free(old_ref);
+ return 0;
}
/*
@@ -582,24 +546,24 @@ static int _dirent_loose_load(void *data, git_buf *full_path)
*/
static int packed_loadloose(git_repository *repository)
{
- int error = GIT_SUCCESS;
git_buf refs_path = GIT_BUF_INIT;
+ int result;
/* the packfile must have been previously loaded! */
assert(repository->references.packfile);
- if ((error = git_buf_joinpath(&refs_path,
- repository->path_repository, GIT_REFS_DIR)) < GIT_SUCCESS)
- return error;
+ if (git_buf_joinpath(&refs_path, repository->path_repository, GIT_REFS_DIR) < 0)
+ return -1;
/*
* Load all the loose files from disk into the Packfile table.
* This will overwrite any old packed entries with their
* updated loose versions
*/
- error = git_path_direach(&refs_path, _dirent_loose_load, repository);
+ result = git_path_direach(&refs_path, _dirent_loose_load, repository);
git_buf_free(&refs_path);
- return error;
+
+ return result;
}
/*
@@ -607,7 +571,6 @@ static int packed_loadloose(git_repository *repository)
*/
static int packed_write_ref(struct packref *ref, git_filebuf *file)
{
- int error;
char oid[GIT_OID_HEXSZ + 1];
git_oid_fmt(oid, &ref->oid);
@@ -628,14 +591,14 @@ static int packed_write_ref(struct packref *ref, git_filebuf *file)
git_oid_fmt(peel, &ref->peel);
peel[GIT_OID_HEXSZ] = 0;
- error = git_filebuf_printf(file, "%s %s\n^%s\n", oid, ref->name, peel);
+ if (git_filebuf_printf(file, "%s %s\n^%s\n", oid, ref->name, peel) < 0)
+ return -1;
} else {
- error = git_filebuf_printf(file, "%s %s\n", oid, ref->name);
+ if (git_filebuf_printf(file, "%s %s\n", oid, ref->name) < 0)
+ return -1;
}
- return error == GIT_SUCCESS ?
- GIT_SUCCESS :
- git__rethrow(error, "Failed to write packed reference");
+ return 0;
}
/*
@@ -649,24 +612,22 @@ static int packed_write_ref(struct packref *ref, git_filebuf *file)
static int packed_find_peel(git_repository *repo, struct packref *ref)
{
git_object *object;
- int error;
if (ref->flags & GIT_PACKREF_HAS_PEEL)
- return GIT_SUCCESS;
+ return 0;
/*
* Only applies to tags, i.e. references
* in the /refs/tags folder
*/
if (git__prefixcmp(ref->name, GIT_REFS_TAGS_DIR) != 0)
- return GIT_SUCCESS;
+ return 0;
/*
* Find the tagged object in the repository
*/
- error = git_object_lookup(&object, repo, &ref->oid, GIT_OBJ_ANY);
- if (error < GIT_SUCCESS)
- return git__throw(GIT_EOBJCORRUPTED, "Failed to find packed reference");
+ if (git_object_lookup(&object, repo, &ref->oid, GIT_OBJ_ANY) < 0)
+ return -1;
/*
* If the tagged object is a Tag object, we need to resolve it;
@@ -690,7 +651,7 @@ static int packed_find_peel(git_repository *repo, struct packref *ref)
}
git_object_free(object);
- return GIT_SUCCESS;
+ return 0;
}
/*
@@ -708,25 +669,27 @@ static int packed_remove_loose(git_repository *repo, git_vector *packing_list)
{
unsigned int i;
git_buf full_path = GIT_BUF_INIT;
- int error = GIT_SUCCESS;
+ int failed = 0;
for (i = 0; i < packing_list->length; ++i) {
struct packref *ref = git_vector_get(packing_list, i);
- int an_error;
if ((ref->flags & GIT_PACKREF_WAS_LOOSE) == 0)
continue;
- an_error = git_buf_joinpath(&full_path, repo->path_repository, ref->name);
+ if (git_buf_joinpath(&full_path, repo->path_repository, ref->name) < 0)
+ return -1; /* critical; do not try to recover on oom */
- if (an_error == GIT_SUCCESS &&
- git_path_exists(full_path.ptr) == GIT_SUCCESS &&
- p_unlink(full_path.ptr) < GIT_SUCCESS)
- an_error = GIT_EOSERR;
+ if (git_path_exists(full_path.ptr) == true && p_unlink(full_path.ptr) < 0) {
+ if (failed)
+ continue;
- /* keep the error if we haven't seen one yet */
- if (error > an_error)
- error = an_error;
+ giterr_set(GITERR_REFERENCE,
+ "Failed to remove loose reference '%s' after packing: %s",
+ full_path.ptr, strerror(errno));
+
+ failed = 1;
+ }
/*
* if we fail to remove a single file, this is *not* good,
@@ -737,10 +700,7 @@ static int packed_remove_loose(git_repository *repo, git_vector *packing_list)
}
git_buf_free(&full_path);
-
- return error == GIT_SUCCESS ?
- GIT_SUCCESS :
- git__rethrow(error, "Failed to remove loose packed reference");
+ return failed ? -1 : 0;
}
static int packed_sort(const void *a, const void *b)
@@ -757,8 +717,6 @@ static int packed_sort(const void *a, const void *b)
static int packed_write(git_repository *repo)
{
git_filebuf pack_file = GIT_FILEBUF_INIT;
- int error;
- const char *errmsg = "Failed to write packed references file";
unsigned int i;
git_buf pack_file_path = GIT_BUF_INIT;
git_vector packing_list;
@@ -767,9 +725,9 @@ static int packed_write(git_repository *repo)
assert(repo && repo->references.packfile);
total_refs = repo->references.packfile->key_count;
- if ((error =
- git_vector_init(&packing_list, total_refs, packed_sort)) < GIT_SUCCESS)
- return git__rethrow(error, "Failed to init packed references list");
+
+ if (git_vector_init(&packing_list, total_refs, packed_sort) < 0)
+ return -1;
/* Load all the packfile into a vector */
{
@@ -785,63 +743,58 @@ static int packed_write(git_repository *repo)
git_vector_sort(&packing_list);
/* Now we can open the file! */
- error = git_buf_joinpath(&pack_file_path, repo->path_repository, GIT_PACKEDREFS_FILE);
- if (error < GIT_SUCCESS)
- goto cleanup;
+ if (git_buf_joinpath(&pack_file_path, repo->path_repository, GIT_PACKEDREFS_FILE) < 0)
+ goto cleanup_memory;
- if ((error = git_filebuf_open(&pack_file, pack_file_path.ptr, 0)) < GIT_SUCCESS) {
- errmsg = "Failed to open packed references file";
- goto cleanup;
- }
+ if (git_filebuf_open(&pack_file, pack_file_path.ptr, 0) < 0)
+ goto cleanup_packfile;
/* Packfiles have a header... apparently
* This is in fact not required, but we might as well print it
* just for kicks */
- if ((error =
- git_filebuf_printf(&pack_file, "%s\n", GIT_PACKEDREFS_HEADER)) < GIT_SUCCESS) {
- errmsg = "Failed to write packed references file header";
- goto cleanup;
- }
+ if (git_filebuf_printf(&pack_file, "%s\n", GIT_PACKEDREFS_HEADER) < 0)
+ goto cleanup_packfile;
for (i = 0; i < packing_list.length; ++i) {
struct packref *ref = (struct packref *)git_vector_get(&packing_list, i);
- if ((error = packed_find_peel(repo, ref)) < GIT_SUCCESS) {
- error = git__throw(GIT_EOBJCORRUPTED,
- "A reference cannot be peeled");
- goto cleanup;
- }
+ if (packed_find_peel(repo, ref) < 0)
+ goto cleanup_packfile;
- if ((error = packed_write_ref(ref, &pack_file)) < GIT_SUCCESS)
- goto cleanup;
+ if (packed_write_ref(ref, &pack_file) < 0)
+ goto cleanup_packfile;
}
-cleanup:
/* if we've written all the references properly, we can commit
* the packfile to make the changes effective */
- if (error == GIT_SUCCESS) {
- error = git_filebuf_commit(&pack_file, GIT_PACKEDREFS_FILE_MODE);
-
- /* when and only when the packfile has been properly written,
- * we can go ahead and remove the loose refs */
- if (error == GIT_SUCCESS) {
- struct stat st;
+ if (git_filebuf_commit(&pack_file, GIT_PACKEDREFS_FILE_MODE) < 0)
+ goto cleanup_memory;
- error = packed_remove_loose(repo, &packing_list);
+ /* when and only when the packfile has been properly written,
+ * we can go ahead and remove the loose refs */
+ if (packed_remove_loose(repo, &packing_list) < 0)
+ goto cleanup_memory;
- if (p_stat(pack_file_path.ptr, &st) == GIT_SUCCESS)
- repo->references.packfile_time = st.st_mtime;
- }
- }
- else git_filebuf_cleanup(&pack_file);
+ {
+ struct stat st;
+ if (p_stat(pack_file_path.ptr, &st) == 0)
+ repo->references.packfile_time = st.st_mtime;
+ }
git_vector_free(&packing_list);
git_buf_free(&pack_file_path);
- if (error < GIT_SUCCESS)
- git__rethrow(error, "%s", errmsg);
+ /* we're good now */
+ return 0;
+
+cleanup_packfile:
+ git_filebuf_cleanup(&pack_file);
- return error;
+cleanup_memory:
+ git_vector_free(&packing_list);
+ git_buf_free(&pack_file_path);
+
+ return -1;
}
struct reference_available_t {
@@ -855,9 +808,7 @@ static int _reference_available_cb(const char *ref, void *data)
struct reference_available_t *d;
assert(ref && data);
-
- d = (reference_available_t *)data;
- refs = (const char **)data;
+ d = (struct reference_available_t *)data;
if (!d->old_ref || strcmp(d->old_ref, ref)) {
int reflen = strlen(ref);
@@ -874,12 +825,10 @@ static int _reference_available_cb(const char *ref, void *data)
return 0;
}
-static int reference_available(
- int *available,
+static int reference_path_available(
git_repository *repo,
const char *ref,
- const char* old_ref,
- git_error **error)
+ const char* old_ref)
{
struct reference_available_t data;
@@ -888,27 +837,29 @@ static int reference_available(
data.available = 1;
if (git_reference_foreach(repo, GIT_REF_LISTALL,
- _reference_available_cb, (void *)&data, error) < 0)
+ _reference_available_cb, (void *)&data) < 0)
+ return -1;
+
+ if (!data.available) {
+ giterr_set(GITERR_REFERENCE,
+ "The path to reference '%s' collides with an existing one");
return -1;
+ }
- *available = data.available;
return 0;
}
static int reference_exists(int *exists, git_repository *repo, const char *ref_name)
{
- int error;
git_buf ref_path = GIT_BUF_INIT;
- error = packed_load(repo);
- if (error < GIT_SUCCESS)
- return git__rethrow(error, "Cannot resolve if a reference exists");
+ if (packed_load(repo) < 0)
+ return -1;
- error = git_buf_joinpath(&ref_path, repo->path_repository, ref_name);
- if (error < GIT_SUCCESS)
- return git__rethrow(error, "Cannot resolve if a reference exists");
+ if (git_buf_joinpath(&ref_path, repo->path_repository, ref_name) < 0)
+ return -1;
- if (git_path_isfile(ref_path.ptr) == GIT_SUCCESS ||
+ if (git_path_isfile(ref_path.ptr) == true ||
git_hashtable_lookup(repo->references.packfile, ref_path.ptr) != NULL) {
*exists = 1;
} else {
@@ -916,23 +867,74 @@ static int reference_exists(int *exists, git_repository *repo, const char *ref_n
}
git_buf_free(&ref_path);
+ return 0;
+}
- return GIT_SUCCESS;
+/*
+ * Check if a reference could be written to disk, based on:
+ *
+ * - Whether a reference with the same name already exists,
+ * and we are allowing or disallowing overwrites
+ *
+ * - Whether the name of the reference would collide with
+ * an existing path
+ */
+static int reference_can_write(
+ git_repository *repo,
+ const char *refname,
+ const char *previous_name,
+ int force)
+{
+ /* see if the reference shares a path with an existing reference;
+ * if a path is shared, we cannot create the reference, even when forcing */
+ if (reference_path_available(repo, refname, previous_name) < 0)
+ return -1;
+
+ /* check if the reference actually exists, but only if we are not forcing
+ * the rename. If we are forcing, it's OK to overwrite */
+ if (!force) {
+ int exists;
+
+ if (reference_exists(&exists, repo, refname) < 0)
+ return -1;
+
+ /* We cannot proceed if the reference already exists and we're not forcing
+ * the rename; the existing one would be overwritten */
+ if (exists) {
+ giterr_set(GITERR_REFERENCE,
+ "A reference with that name (%s) already exists");
+ return GIT_EEXISTS;
+ }
+ }
+
+ /* FIXME: if the reference exists and we are forcing, do we really need to
+ * remove the reference first?
+ *
+ * Two cases:
+ *
+ * - the reference already exists and is loose: not a problem, the file
+ * gets overwritten on disk
+ *
+ * - the reference already exists and is packed: we write a new one as
+ * loose, which by all means renders the packed one useless
+ */
+
+ return 0;
}
+
static int packed_lookup(git_reference *ref)
{
- int error;
struct packref *pack_ref = NULL;
- error = packed_load(ref->owner);
- if (error < GIT_SUCCESS)
- return git__rethrow(error,
- "Failed to lookup reference from packfile");
+ if (packed_load(ref->owner) < 0)
+ return -1;
- if (ref->flags & GIT_REF_PACKED &&
+ /* maybe the packfile hasn't changed at all, so we don't
+ * have to re-lookup the reference */
+ if ((ref->flags & GIT_REF_PACKED) &&
ref->mtime == ref->owner->references.packfile_time)
- return GIT_SUCCESS;
+ return 0;
if (ref->flags & GIT_REF_SYMBOLIC) {
git__free(ref->target.symbolic);
@@ -941,38 +943,38 @@ static int packed_lookup(git_reference *ref)
/* Look up on the packfile */
pack_ref = git_hashtable_lookup(ref->owner->references.packfile, ref->name);
- if (pack_ref == NULL)
- return git__throw(GIT_ENOTFOUND,
- "Failed to lookup reference from packfile");
+ if (pack_ref == NULL) {
+ giterr_set(GITERR_REFERENCE, "Reference '%s' not found", ref->name);
+ return GIT_ENOTFOUND;
+ }
ref->flags = GIT_REF_OID | GIT_REF_PACKED;
ref->mtime = ref->owner->references.packfile_time;
git_oid_cpy(&ref->target.oid, &pack_ref->oid);
- return GIT_SUCCESS;
+ return 0;
}
-static int reference_lookup(git_reference *ref, git_error **error)
+static int reference_lookup(git_reference *ref)
{
int result;
- result = loose_lookup(ref, error);
- if (result != GIT_ENOTFOUND)
- return result;
+ result = loose_lookup(ref);
+ if (result == 0)
+ return 0;
- result = packed_lookup(ref, error);
- if (result != GIT_ENOTFOUND)
- return result;
+ /* only try to lookup this reference on the packfile if it
+ * wasn't found on the loose refs; not if there was a critical error */
+ if (result == GIT_ENOTFOUND) {
+ giterr_clear();
+ result = packed_lookup(ref);
+ if (result == 0)
+ return 0;
+ }
+ /* unexpected error; free the reference */
git_reference_free(ref);
-
- if (error_loose != GIT_ENOTFOUND)
- return git__rethrow(error_loose, "Failed to lookup reference");
-
- if (error_packed != GIT_ENOTFOUND)
- return git__rethrow(error_packed, "Failed to lookup reference");
-
- return git__throw(GIT_ENOTFOUND, "Reference not found");
+ return result;
}
/*
@@ -980,7 +982,7 @@ static int reference_lookup(git_reference *ref, git_error **error)
* This is an internal method; the reference is removed
* from disk or the packfile, but the pointer is not freed
*/
-static int reference_delete(git_reference *ref, git_error **error)
+static int reference_delete(git_reference *ref)
{
int result;
@@ -992,18 +994,18 @@ static int reference_delete(git_reference *ref, git_error **error)
if (ref->flags & GIT_REF_PACKED) {
struct packref *packref;
/* load the existing packfile */
- if (packed_load(ref->owner, error) < 0)
+ if (packed_load(ref->owner) < 0)
return -1;
if (git_hashtable_remove2(ref->owner->references.packfile,
ref->name, (void **) &packref) < 0) {
- giterr_set(error, GITERR_REFERENCE,
+ giterr_set(GITERR_REFERENCE,
"Reference %s stopped existing in the packfile", ref->name);
return -1;
}
git__free(packref);
- if (packed_write(ref->owner, error) < 0)
+ if (packed_write(ref->owner) < 0)
return -1;
/* If the reference is loose, we can just remove the reference
@@ -1012,55 +1014,59 @@ static int reference_delete(git_reference *ref, git_error **error)
git_reference *ref_in_pack;
git_buf full_path = GIT_BUF_INIT;
- if (git_buf_joinpath(&full_path, ref->owner->path_repository, ref->name) < 0) {
- giterr_set_oom(error);
+ if (git_buf_joinpath(&full_path, ref->owner->path_repository, ref->name) < 0)
return -1;
- }
result = p_unlink(full_path.ptr);
git_buf_free(&full_path); /* done with path at this point */
if (result < 0) {
- giterr_set(error, GITERR_OS,
+ giterr_set(GITERR_OS,
"Failed to unlink '%s': %s", full_path.ptr, strerror(errno));
return -1;
}
/* When deleting a loose reference, we have to ensure that an older
* packed version of it doesn't exist */
- if (git_reference_lookup(&ref_in_pack, ref->owner, ref->name, NULL) == GIT_SUCCESS) {
+ if (git_reference_lookup(&ref_in_pack, ref->owner, ref->name) == 0) {
assert((ref_in_pack->flags & GIT_REF_PACKED) != 0);
- return git_reference_delete(ref_in_pack, error);
+ return git_reference_delete(ref_in_pack);
}
+
+ giterr_clear();
}
return 0;
}
-int git_reference_delete(git_reference *ref, git_error **error)
+int git_reference_delete(git_reference *ref)
{
- int result = reference_delete(ref, error);
+ int result = reference_delete(ref);
git_reference_free(ref);
return result;
}
-
int git_reference_lookup(git_reference **ref_out,
- git_repository *repo, const char *name, git_error **error)
+ git_repository *repo, const char *name)
{
char normalized_name[GIT_REFNAME_MAX];
git_reference *ref = NULL;
+ int result;
assert(ref_out && repo && name);
+ *ref_out = NULL;
- if (normalize_name(normalized_name, sizeof(normalized_name), name, 0, error) < 0)
+ if (normalize_name(normalized_name, sizeof(normalized_name), name, 0) < 0)
return -1;
- if (reference_alloc(&ref, repo, normalized_name, error) < 0)
+ if (reference_alloc(&ref, repo, normalized_name) < 0)
return -1;
- *ref_out = ref;
- return reference_lookup(ref, error);
+ result = reference_lookup(ref);
+ if (result == 0)
+ *ref_out = ref;
+
+ return result;
}
/**
@@ -1122,33 +1128,25 @@ int git_reference_create_symbolic(
git_repository *repo,
const char *name,
const char *target,
- int force,
- git_error **error)
+ int force)
{
char normalized[GIT_REFNAME_MAX];
- int exists;
git_reference *ref = NULL;
- if (normalize_name(normalized, sizeof(normalized), name, 0, error) < 0)
+ if (normalize_name(normalized, sizeof(normalized), name, 0) < 0)
return -1;
- if (reference_exists(&exists, repo, normalized, error) < 0)
+ if (reference_can_write(repo, normalized, NULL, force) < 0)
return -1;
- if (exists && !force) {
- giterr_set(error, GITERR_REFERENCE,
- "A reference with that name (%s) already exists");
- return GIT_EEXISTS;
- }
-
- if (reference_alloc(&ref, repo, normalized, error) < 0)
+ if (reference_alloc(&ref, repo, normalized) < 0)
return -1;
ref->flags |= GIT_REF_SYMBOLIC;
/* set the target; this will normalize the name automatically
* and write the reference on disk */
- if (git_reference_set_target(ref, target, error) < 0) {
+ if (git_reference_set_target(ref, target) < 0) {
git_reference_free(ref);
return -1;
}
@@ -1166,32 +1164,24 @@ int git_reference_create_oid(
git_repository *repo,
const char *name,
const git_oid *id,
- int force,
- git_error **error)
+ int force)
{
- int exists;
git_reference *ref = NULL;
char normalized[GIT_REFNAME_MAX];
- if (normalize_name(normalized, sizeof(normalized), name, 1, error) < 0)
+ if (normalize_name(normalized, sizeof(normalized), name, 1) < 0)
return -1;
- if (reference_exists(&exists, repo, normalized, error) < 0)
+ if (reference_can_write(repo, normalized, NULL, force) < 0)
return -1;
- if (exists && !force) {
- giterr_set(error, GITERR_REFERENCE,
- "A reference with that name (%s) already exists");
- return GIT_EEXISTS;
- }
-
- if (reference_alloc(&ref, repo, name, error) < 0)
+ if (reference_alloc(&ref, repo, name) < 0)
return -1;
ref->flags |= GIT_REF_OID;
/* set the oid; this will write the reference on disk */
- if (git_reference_set_oid(ref, id, error) < 0) {
+ if (git_reference_set_oid(ref, id) < 0) {
git_reference_free(ref);
return -1;
}
@@ -1213,25 +1203,24 @@ int git_reference_create_oid(
* We do not repack packed references because of performance
* reasons.
*/
-int git_reference_set_oid(git_reference *ref, const git_oid *id, git_error **error)
+int git_reference_set_oid(git_reference *ref, const git_oid *id)
{
git_odb *odb = NULL;
if ((ref->flags & GIT_REF_OID) == 0) {
- giterr_set(error, GITERR_REFERENCE,
- "Cannot set OID on symbolic reference");
+ giterr_set(GITERR_REFERENCE, "Cannot set OID on symbolic reference");
return -1;
}
assert(ref->owner);
- if (git_repository_odb__weakptr(&odb, ref->owner, error) < 0)
+ if (git_repository_odb__weakptr(&odb, ref->owner) < 0)
return -1;
/* Don't let the user create references to OIDs that
* don't exist in the ODB */
if (!git_odb_exists(odb, id)) {
- giterr_set(error, GITERR_REFERENCE,
+ giterr_set(GITERR_REFERENCE,
"Target OID for the reference doesn't exist on the repository");
return -1;
}
@@ -1240,7 +1229,7 @@ int git_reference_set_oid(git_reference *ref, const git_oid *id, git_error **err
git_oid_cpy(&ref->target.oid, id);
/* Write back to disk */
- return loose_write(ref, error);
+ return loose_write(ref);
}
/*
@@ -1250,72 +1239,46 @@ int git_reference_set_oid(git_reference *ref, const git_oid *id, git_error **err
* a pack. We just change the target in memory
* and overwrite the file on disk.
*/
-int git_reference_set_target(git_reference *ref, const char *target, git_error **error)
+int git_reference_set_target(git_reference *ref, const char *target)
{
char normalized[GIT_REFNAME_MAX];
if ((ref->flags & GIT_REF_SYMBOLIC) == 0) {
- giterr_set(error, GITERR_REFERENCE,
+ giterr_set(GITERR_REFERENCE,
"Cannot set symbolic target on a direct reference");
return -1;
}
- if (normalize_name(normalized, sizeof(normalized), target, 0, error))
+ if (normalize_name(normalized, sizeof(normalized), target, 0))
return -1;
git__free(ref->target.symbolic);
ref->target.symbolic = git__strdup(normalized);
- GITERR_CHECK_ALLOC(ref->target.symbolic, error);
+ GITERR_CHECK_ALLOC(ref->target.symbolic);
- return loose_write(ref, error);
+ return loose_write(ref);
}
-int git_reference_rename(git_reference *ref, const char *new_name, int force, git_error **error)
+int git_reference_rename(git_reference *ref, const char *new_name, int force)
{
- int result, ref_available;
+ int result;
git_buf aux_path = GIT_BUF_INIT;
char normalized[GIT_REFNAME_MAX];
const char *head_target = NULL;
- git_reference *existing_ref = NULL, *head = NULL;
+ git_reference *head = NULL;
if (normalize_name(normalized, sizeof(normalized),
- new_name, ref->flags & GIT_REF_OID, error) < 0)
+ new_name, ref->flags & GIT_REF_OID) < 0)
return -1;
- new_name = normalized;
-
- /* see if the reference already exists */
- if (reference_available(&ref_available, ref->owner, new_name, ref->name, error) < 0)
+ if (reference_can_write(ref->owner, normalized, ref->name, force) < 0)
return -1;
- /* We cannot proceed if the reference already exists and we're not forcing
- * the rename; the existing one would be overwritten */
- if (!force && !ref_available) {
- giterr_set(error, GITERR_REFERENCE,
- "A reference with the same name (%s) already exists", normalized);
- return GIT_EEXISTS;
- }
-
- /* FIXME: if the reference exists and we are forcing, do we really need to
- * remove the reference first?
- *
- * Two cases:
- *
- * - the reference already exists and is loose: not a problem, the file
- * gets overwritten on disk
- *
- * - the reference already exists and is packed: we write a new one as
- * loose, which by all means renders the packed one useless
- */
-
/* Initialize path now so we won't get an allocation failure once
- * we actually start removing things.
- */
- if (git_buf_joinpath(&aux_path, ref->owner->path_repository, new_name) < 0) {
- giterr_set_oom(error);
+ * we actually start removing things. */
+ if (git_buf_joinpath(&aux_path, ref->owner->path_repository, new_name) < 0)
return -1;
- }
/*
* Now delete the old ref and remove an possibly existing directory
@@ -1323,25 +1286,18 @@ int git_reference_rename(git_reference *ref, const char *new_name, int force, gi
* method deletes the ref from disk but doesn't free the pointer, so
* we can still access the ref's attributes for creating the new one
*/
- if (reference_delete(ref, error) < 0)
+ if (reference_delete(ref) < 0)
goto cleanup;
- if (git_path_exists(aux_path.ptr) == GIT_SUCCESS) {
- if (git_path_isdir(aux_path.ptr) == GIT_SUCCESS) {
- if (git_futils_rmdir_r(aux_path.ptr, 0, error) < 0)
- goto rollback;
- } else goto rollback;
- }
-
/*
* Finally we can create the new reference.
*/
if (ref->flags & GIT_REF_SYMBOLIC) {
result = git_reference_create_symbolic(
- NULL, ref->owner, new_name, ref->target.symbolic, force, error);
+ NULL, ref->owner, new_name, ref->target.symbolic, force);
} else {
result = git_reference_create_oid(
- NULL, ref->owner, new_name, &ref->target.oid, force, error);
+ NULL, ref->owner, new_name, &ref->target.oid, force);
}
if (result < 0)
@@ -1350,8 +1306,8 @@ int git_reference_rename(git_reference *ref, const char *new_name, int force, gi
/*
* Check if we have to update HEAD.
*/
- if (git_reference_lookup(&head, ref->owner, GIT_HEAD_FILE, NULL) < 0) {
- giterr_set(error, GITERR_REFERENCE,
+ if (git_reference_lookup(&head, ref->owner, GIT_HEAD_FILE) < 0) {
+ giterr_set(GITERR_REFERENCE,
"Failed to update HEAD after renaming reference");
goto cleanup;
}
@@ -1359,8 +1315,8 @@ int git_reference_rename(git_reference *ref, const char *new_name, int force, gi
head_target = git_reference_target(head);
if (head_target && !strcmp(head_target, ref->name)) {
- if (git_reference_create_symbolic(&head, ref->owner, "HEAD", new_name, 1, NULL) < 0) {
- giterr_set(error, GITERR_REFERENCE,
+ if (git_reference_create_symbolic(&head, ref->owner, "HEAD", new_name, 1) < 0) {
+ giterr_set(GITERR_REFERENCE,
"Failed to update HEAD after renaming reference");
goto cleanup;
}
@@ -1369,15 +1325,14 @@ int git_reference_rename(git_reference *ref, const char *new_name, int force, gi
/*
* Rename the reflog file.
*/
- if (git_buf_join_n(&aux_path, '/', 3, ref->owner->path_repository,
- GIT_REFLOG_DIR, ref->name) < 0) {
- giterr_set_oom(error);
+ if (git_buf_join_n(&aux_path, '/', 3, ref->owner->path_repository, GIT_REFLOG_DIR, ref->name) < 0)
goto cleanup;
- }
- if (git_path_exists(aux_path.ptr) == 0) {
- if (git_reflog_rename(ref, new_name, error) < 0)
+ if (git_path_exists(aux_path.ptr) == true) {
+ if (git_reflog_rename(ref, new_name) < 0)
goto cleanup;
+ } else {
+ giterr_clear();
}
/*
@@ -1404,20 +1359,19 @@ rollback:
*/
if (ref->flags & GIT_REF_SYMBOLIC)
git_reference_create_symbolic(
- NULL, ref->owner, ref->name, ref->target.symbolic, 0, NULL);
+ NULL, ref->owner, ref->name, ref->target.symbolic, 0);
else
git_reference_create_oid(
- NULL, ref->owner, ref->name, &ref->target.oid, 0. NULL);
+ NULL, ref->owner, ref->name, &ref->target.oid, 0);
/* The reference is no longer packed */
ref->flags &= ~GIT_REF_PACKED;
git_buf_free(&aux_path);
-
return -1;
}
-int git_reference_resolve(git_reference **ref_out, git_reference *ref, git_error **error)
+int git_reference_resolve(git_reference **ref_out, git_reference *ref)
{
int result, i = 0;
git_repository *repo;
@@ -1431,13 +1385,13 @@ int git_reference_resolve(git_reference **ref_out, git_reference *ref, git_error
* copy. Instead of duplicating `ref`, we look it up again to
* ensure the copy is out to date */
if (ref->flags & GIT_REF_OID)
- return git_reference_lookup(ref_out, ref->owner, ref->name, error);
+ return git_reference_lookup(ref_out, ref->owner, ref->name);
/* Otherwise, keep iterating until the reference is resolved */
for (i = 0; i < MAX_NESTING_LEVEL; ++i) {
git_reference *new_ref;
- result = git_reference_lookup(&new_ref, repo, ref->target.symbolic, error);
+ result = git_reference_lookup(&new_ref, repo, ref->target.symbolic);
if (result < 0)
return result;
@@ -1452,21 +1406,21 @@ int git_reference_resolve(git_reference **ref_out, git_reference *ref, git_error
* successfully resolved the symbolic ref */
if (ref->flags & GIT_REF_OID) {
*ref_out = ref;
- return GIT_SUCCESS;
+ return 0;
}
}
- giterr_set(error, GITERR_REFERENCE,
+ giterr_set(GITERR_REFERENCE,
"Symbolic reference too nested (%d levels deep)", MAX_NESTING_LEVEL);
return -1;
}
-int git_reference_packall(git_repository *repo, git_error **error)
+int git_reference_packall(git_repository *repo)
{
- if (packed_load(repo, error) < 0 || /* load the existing packfile */
- packed_loadloose(repo, error) < 0 || /* add all the loose refs */
- packed_write(repo, error) < 0) /* write back to disk */
+ if (packed_load(repo) < 0 || /* load the existing packfile */
+ packed_loadloose(repo) < 0 || /* add all the loose refs */
+ packed_write(repo) < 0) /* write back to disk */
return -1;
return 0;
@@ -1476,8 +1430,7 @@ int git_reference_foreach(
git_repository *repo,
unsigned int list_flags,
int (*callback)(const char *, void *),
- void *payload,
- git_error **error)
+ void *payload)
{
int result;
struct dirent_list_data data;
@@ -1487,10 +1440,10 @@ int git_reference_foreach(
if (list_flags & GIT_REF_PACKED) {
const char *ref_name;
- if (packed_load(repo, error) < 0)
+ if (packed_load(repo) < 0)
return -1;
- GIT_HASHTABLE_FOREACH(repo->references.packfile, ref_name, _unused,
+ GIT_HASHTABLE_FOREACH_KEY(repo->references.packfile, ref_name,
if (callback(ref_name, payload) < 0)
return 0;
);
@@ -1505,12 +1458,10 @@ int git_reference_foreach(
data.callback = callback;
data.callback_payload = payload;
- if (git_buf_joinpath(&refs_path, repo->path_repository, GIT_REFS_DIR) < 0) {
- giterr_set_oom(error);
+ if (git_buf_joinpath(&refs_path, repo->path_repository, GIT_REFS_DIR) < 0)
return -1;
- }
- result = git_path_direach(&refs_path, _dirent_loose_listall, &data, error);
+ result = git_path_direach(&refs_path, _dirent_loose_listall, &data);
git_buf_free(&refs_path);
return result;
@@ -1524,10 +1475,8 @@ static int cb__reflist_add(const char *ref, void *data)
int git_reference_listall(
git_strarray *array,
git_repository *repo,
- unsigned int list_flags,
- git_error **error)
+ unsigned int list_flags)
{
- int result;
git_vector ref_list;
assert(array && repo);
@@ -1535,25 +1484,23 @@ int git_reference_listall(
array->strings = NULL;
array->count = 0;
- if (git_vector_init(&ref_list, 8, NULL) < GIT_SUCCESS) {
- giterr_set_oom(error);
+ if (git_vector_init(&ref_list, 8, NULL) < GIT_SUCCESS)
return -1;
- }
if (git_reference_foreach(
- repo, list_flags, &cb__reflist_add, (void *)&ref_list, error) < 0) {
+ repo, list_flags, &cb__reflist_add, (void *)&ref_list) < 0) {
git_vector_free(&ref_list);
return -1;
}
array->strings = (char **)ref_list.contents;
array->count = ref_list.length;
- return GIT_SUCCESS;
+ return 0;
}
-int git_reference_reload(git_reference *ref, git_error **error)
+int git_reference_reload(git_reference *ref)
{
- return reference_lookup(ref, error);
+ return reference_lookup(ref);
}
void git_repository__refcache_free(git_refcache *refs)
@@ -1610,33 +1557,26 @@ static int normalize_name(
/* A refname can not be empty */
if (name_end == name)
- return git__throw(GIT_EINVALIDREFNAME,
- "Failed to normalize name. Reference name is empty");
+ goto invalid_name;
/* A refname can not end with a dot or a slash */
if (*(name_end - 1) == '.' || *(name_end - 1) == '/')
- return git__throw(GIT_EINVALIDREFNAME,
- "Failed to normalize name. Reference name ends with dot or slash");
+ goto invalid_name;
while (current < name_end && out_size) {
if (!is_valid_ref_char(*current))
- return git__throw(GIT_EINVALIDREFNAME,
- "Failed to normalize name. "
- "Reference name contains invalid characters");
+ goto invalid_name;
if (buffer_out > buffer_out_start) {
char prev = *(buffer_out - 1);
/* A refname can not start with a dot nor contain a double dot */
if (*current == '.' && ((prev == '.') || (prev == '/')))
- return git__throw(GIT_EINVALIDREFNAME,
- "Failed to normalize name. "
- "Reference name starts with a dot or contains a double dot");
+ goto invalid_name;
/* '@{' is forbidden within a refname */
if (*current == '{' && prev == '@')
- return git__throw(GIT_EINVALIDREFNAME,
- "Failed to normalize name. Reference name contains '@{'");
+ goto invalid_name;
/* Prevent multiple slashes from being added to the output */
if (*current == '/' && prev == '/') {
@@ -1653,7 +1593,7 @@ static int normalize_name(
}
if (!out_size)
- return git__throw(GIT_EINVALIDREFNAME, "Reference name is too long");
+ goto invalid_name;
/* Object id refname have to contain at least one slash, except
* for HEAD in a detached state or MERGE_HEAD if we're in the
@@ -1663,13 +1603,11 @@ static int normalize_name(
strcmp(name, GIT_HEAD_FILE) != 0 &&
strcmp(name, GIT_MERGE_HEAD_FILE) != 0 &&
strcmp(name, GIT_FETCH_HEAD_FILE) != 0)
- return git__throw(GIT_EINVALIDREFNAME,
- "Failed to normalize name. Reference name contains no slashes");
+ goto invalid_name;
/* A refname can not end with ".lock" */
if (!git__suffixcmp(name, GIT_FILELOCK_EXTENSION))
- return git__throw(GIT_EINVALIDREFNAME,
- "Failed to normalize name. Reference name ends with '.lock'");
+ goto invalid_name;
*buffer_out = '\0';
@@ -1679,11 +1617,13 @@ static int normalize_name(
*/
if (is_oid_ref && !(git__prefixcmp(buffer_out_start, GIT_REFS_DIR) ||
strcmp(buffer_out_start, GIT_HEAD_FILE)))
- return git__throw(GIT_EINVALIDREFNAME,
- "Failed to normalize name. "
- "Reference name does not start with 'refs/'");
+ goto invalid_name;
- return GIT_SUCCESS;
+ return 0;
+
+invalid_name:
+ giterr_set(GITERR_REFERENCE, "The given reference name is not valid");
+ return -1;
}
int git_reference__normalize_name(
diff --git a/src/repository.c b/src/repository.c
index 1f8306991..fe785cfcd 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -83,14 +83,14 @@ void git_repository_free(git_repository *repo)
static int quickcheck_repository_dir(git_buf *repository_path)
{
/* Check OBJECTS_DIR first, since it will generate the longest path name */
- if (git_path_contains_dir(repository_path, GIT_OBJECTS_DIR) < 0)
+ if (git_path_contains_dir(repository_path, GIT_OBJECTS_DIR) == false)
return GIT_ERROR;
/* Ensure HEAD file exists */
- if (git_path_contains_file(repository_path, GIT_HEAD_FILE) < 0)
+ if (git_path_contains_file(repository_path, GIT_HEAD_FILE) == false)
return GIT_ERROR;
- if (git_path_contains_dir(repository_path, GIT_REFS_DIR) < 0)
+ if (git_path_contains_dir(repository_path, GIT_REFS_DIR) == false)
return GIT_ERROR;
return GIT_SUCCESS;
@@ -498,7 +498,7 @@ static int read_gitfile(git_buf *path_out, const char *file_path, const char *ba
git_buf_free(&file);
- if (error == GIT_SUCCESS && git_path_exists(path_out->ptr) == 0)
+ if (error == GIT_SUCCESS && git_path_exists(path_out->ptr) == true)
return GIT_SUCCESS;
return git__throw(GIT_EOBJCORRUPTED, "The `.git` file points to a nonexistent path");
@@ -542,7 +542,7 @@ int git_repository_discover(
* If the `.git` file is regular instead of
* a directory, it should contain the path of the actual git repository
*/
- if (git_path_isfile(normal_path.ptr) == GIT_SUCCESS) {
+ if (git_path_isfile(normal_path.ptr) == true) {
git_buf gitfile_path = GIT_BUF_INIT;
error = read_gitfile(&gitfile_path, normal_path.ptr, bare_path.ptr);
@@ -564,7 +564,7 @@ int git_repository_discover(
/**
* If the `.git` file is a folder, we check inside of it
*/
- if (git_path_isdir(normal_path.ptr) == GIT_SUCCESS) {
+ if (git_path_isdir(normal_path.ptr) == true) {
error = quickcheck_repository_dir(&normal_path);
if (error == GIT_SUCCESS) {
found_path = &normal_path;
@@ -774,7 +774,7 @@ int git_repository_init(git_repository **repo_out, const char *path, unsigned is
if (error < GIT_SUCCESS)
return error;
- if (git_path_isdir(repository_path.ptr) == GIT_SUCCESS) {
+ if (git_path_isdir(repository_path.ptr) == true) {
if (quickcheck_repository_dir(&repository_path) == GIT_SUCCESS) {
error = repo_init_reinit(repo_out, repository_path.ptr, is_bare);
git_buf_free(&repository_path);
diff --git a/src/status.c b/src/status.c
index 106e5005d..e80fc02c0 100644
--- a/src/status.c
+++ b/src/status.c
@@ -505,7 +505,7 @@ int git_status_foreach(
dirent_st.index_position = 0;
dirent_st.is_dir = 1;
- if (git_path_isdir(workdir)) {
+ if (git_path_isdir(workdir) == false) {
error = git__throw(GIT_EINVALIDPATH,
"Failed to determine status of file '%s'. "
"The given path doesn't lead to a folder", workdir);
@@ -608,7 +608,7 @@ int git_status_file(unsigned int *status_flags, git_repository *repo, const char
return git__rethrow(error,
"Failed to determine status of file '%s'", path);
- if (git_path_isdir(temp_path.ptr) == GIT_SUCCESS) {
+ if (git_path_isdir(temp_path.ptr) == true) {
git_buf_free(&temp_path);
return git__throw(GIT_EINVALIDPATH,
"Failed to determine status of file '%s'. "
@@ -622,7 +622,7 @@ int git_status_file(unsigned int *status_flags, git_repository *repo, const char
}
/* Find file in Workdir */
- if (git_path_exists(temp_path.ptr) == GIT_SUCCESS) {
+ if (git_path_exists(temp_path.ptr) == true) {
if ((error = status_entry_update_from_workdir(e, temp_path.ptr)) < GIT_SUCCESS)
goto cleanup; /* The callee has already set the error message */
}
@@ -702,7 +702,7 @@ static char *alphasorted_dirent_info_new(const git_buf *path)
git_buf_copy_cstr(di, path->size + 1, path);
- if (git_path_isdir(path->ptr) == GIT_SUCCESS) {
+ if (git_path_isdir(path->ptr) == true) {
/*
* Append a forward slash to the name to force folders
* to be ordered in a similar way than in a tree
diff --git a/tests-clar/config/stress.c b/tests-clar/config/stress.c
index e3b1114f0..25c2c66db 100644
--- a/tests-clar/config/stress.c
+++ b/tests-clar/config/stress.c
@@ -27,7 +27,7 @@ void test_config_stress__dont_break_on_invalid_input(void)
struct git_config_file *file;
git_config *config;
- cl_git_pass(git_path_exists("git-test-config"));
+ cl_assert(git_path_exists("git-test-config"));
cl_git_pass(git_config_file__ondisk(&file, "git-test-config"));
cl_git_pass(git_config_new(&config));
cl_git_pass(git_config_add_file(config, file, 0));
diff --git a/tests-clar/core/filebuf.c b/tests-clar/core/filebuf.c
index 29d6bca74..eab8a26eb 100644
--- a/tests-clar/core/filebuf.c
+++ b/tests-clar/core/filebuf.c
@@ -14,7 +14,7 @@ void test_core_filebuf__0(void)
cl_must_pass(p_close(fd));
cl_git_fail(git_filebuf_open(&file, test, 0));
- cl_git_pass(git_path_exists(testlock));
+ cl_assert(git_path_exists(testlock));
cl_must_pass(p_unlink(testlock));
}
@@ -56,20 +56,6 @@ void test_core_filebuf__2(void)
cl_must_pass(p_unlink(test));
}
-
-/* make sure git_filebuf_open won't reopen an open buffer */
-void test_core_filebuf__3(void)
-{
- git_filebuf file = GIT_FILEBUF_INIT;
- char test[] = "test";
-
- cl_git_pass(git_filebuf_open(&file, test, 0));
- cl_git_fail(git_filebuf_open(&file, test, 0));
-
- git_filebuf_cleanup(&file);
-}
-
-
/* make sure git_filebuf_cleanup clears the buffer */
void test_core_filebuf__4(void)
{
diff --git a/tests/t00-core.c b/tests/t00-core.c
index 7f142ba21..10e6aaebf 100644
--- a/tests/t00-core.c
+++ b/tests/t00-core.c
@@ -485,7 +485,7 @@ BEGIN_TEST(filebuf0, "make sure git_filebuf_open doesn't delete an existing lock
must_pass(fd);
must_pass(p_close(fd));
must_fail(git_filebuf_open(&file, test, 0));
- must_pass(git_path_exists(testlock));
+ must_be_true(git_path_exists(testlock));
must_pass(p_unlink(testlock));
END_TEST
diff --git a/tests/t03-objwrite.c b/tests/t03-objwrite.c
index 1650b8060..2d4fb1ad7 100644
--- a/tests/t03-objwrite.c
+++ b/tests/t03-objwrite.c
@@ -44,9 +44,9 @@ static int make_odb_dir(void)
static int check_object_files(object_data *d)
{
- if (git_path_exists(d->dir) < 0)
+ if (git_path_exists(d->dir) == false)
return -1;
- if (git_path_exists(d->file) < 0)
+ if (git_path_exists(d->file) == false)
return -1;
return 0;
}
diff --git a/tests/t08-tag.c b/tests/t08-tag.c
index eacbb3ae1..4cbd48379 100644
--- a/tests/t08-tag.c
+++ b/tests/t08-tag.c
@@ -337,8 +337,6 @@ BEGIN_TEST(delete0, "Delete an already existing tag")
must_fail(git_reference_lookup(&ref_tag, repo, "refs/tags/e90810b"));
close_temp_repo(repo);
-
- git_reference_free(ref_tag);
END_TEST
BEGIN_SUITE(tag)
diff --git a/tests/t10-refs.c b/tests/t10-refs.c
index 63d1cb7d1..ad881726e 100644
--- a/tests/t10-refs.c
+++ b/tests/t10-refs.c
@@ -69,7 +69,6 @@ BEGIN_TEST(readtag1, "lookup a loose tag reference that doesn't exist")
must_fail(git_reference_lookup(&reference, repo, non_existing_tag_ref_name));
git_repository_free(repo);
-
git_reference_free(reference);
END_TEST
@@ -530,7 +529,7 @@ BEGIN_TEST(pack1, "create a packfile from all the loose rn a repo")
/* Ensure the packed-refs file exists */
must_pass(git_buf_joinpath(&temp_path, repo->path_repository, GIT_PACKEDREFS_FILE));
- must_pass(git_path_exists(temp_path.ptr));
+ must_be_true(git_path_exists(temp_path.ptr));
/* Ensure the known ref can still be looked up but is now packed */
must_pass(git_reference_lookup(&reference, repo, loose_tag_ref_name));
@@ -539,7 +538,7 @@ BEGIN_TEST(pack1, "create a packfile from all the loose rn a repo")
/* Ensure the known ref has been removed from the loose folder structure */
must_pass(git_buf_joinpath(&temp_path, repo->path_repository, loose_tag_ref_name));
- must_pass(!git_path_exists(temp_path.ptr));
+ must_be_true(!git_path_exists(temp_path.ptr));
close_temp_repo(repo);
@@ -557,7 +556,7 @@ BEGIN_TEST(rename0, "rename a loose reference")
/* Ensure the ref doesn't exist on the file system */
must_pass(git_buf_joinpath(&temp_path, repo->path_repository, new_name));
- must_pass(!git_path_exists(temp_path.ptr));
+ must_be_true(!git_path_exists(temp_path.ptr));
/* Retrieval of the reference to rename */
must_pass(git_reference_lookup(&looked_up_ref, repo, loose_tag_ref_name));
@@ -582,7 +581,7 @@ BEGIN_TEST(rename0, "rename a loose reference")
/* ...and the ref can be found in the file system */
must_pass(git_buf_joinpath(&temp_path, repo->path_repository, new_name));
- must_pass(git_path_exists(temp_path.ptr));
+ must_be_true(git_path_exists(temp_path.ptr));
close_temp_repo(repo);
@@ -601,7 +600,7 @@ BEGIN_TEST(rename1, "rename a packed reference (should make it loose)")
/* Ensure the ref doesn't exist on the file system */
must_pass(git_buf_joinpath(&temp_path, repo->path_repository, packed_head_name));
- must_pass(!git_path_exists(temp_path.ptr));
+ must_be_true(!git_path_exists(temp_path.ptr));
/* The reference can however be looked-up... */
must_pass(git_reference_lookup(&looked_up_ref, repo, packed_head_name));
@@ -626,7 +625,7 @@ BEGIN_TEST(rename1, "rename a packed reference (should make it loose)")
/* ...and the ref now happily lives in the file system */
must_pass(git_buf_joinpath(&temp_path, repo->path_repository, brand_new_name));
- must_pass(git_path_exists(temp_path.ptr));
+ must_be_true(git_path_exists(temp_path.ptr));
close_temp_repo(repo);
@@ -645,7 +644,7 @@ BEGIN_TEST(rename2, "renaming a packed reference does not pack another reference
/* Ensure the other reference exists on the file system */
must_pass(git_buf_joinpath(&temp_path, repo->path_repository, packed_test_head_name));
- must_pass(git_path_exists(temp_path.ptr));
+ must_be_true(git_path_exists(temp_path.ptr));
/* Lookup the other reference */
must_pass(git_reference_lookup(&another_looked_up_ref, repo, packed_test_head_name));
@@ -670,7 +669,7 @@ BEGIN_TEST(rename2, "renaming a packed reference does not pack another reference
must_be_true(git_reference_is_packed(another_looked_up_ref) == 0);
/* Ensure the other ref still exists on the file system */
- must_pass(git_path_exists(temp_path.ptr));
+ must_be_true(git_path_exists(temp_path.ptr));
close_temp_repo(repo);
@@ -857,6 +856,18 @@ BEGIN_TEST(rename8, "can be renamed to a new name prefixed with the old name")
END_TEST
BEGIN_TEST(rename9, "can move a reference to a upper reference hierarchy")
+ /*
+ * I'm killing this test because it adds a shitton of complexity
+ * to the reference renaming code for an use case which I'd consider
+ * "clinically stupid".
+ *
+ * If somebody shows me a workflow which involves turning a reference
+ * into a folder with its same name, we'll bring back the ridiculous
+ * logic.
+ *
+ * -Vicent
+ */
+#if 0
git_reference *ref, *ref_two, *looked_up_ref;
git_repository *repo;
git_oid id;
@@ -888,6 +899,7 @@ BEGIN_TEST(rename9, "can move a reference to a upper reference hierarchy")
git_reference_free(looked_up_ref);
close_temp_repo(repo);
+#endif
END_TEST
BEGIN_TEST(delete0, "deleting a ref which is both packed and loose should remove both tracks in the filesystem")
@@ -899,7 +911,7 @@ BEGIN_TEST(delete0, "deleting a ref which is both packed and loose should remove
/* Ensure the loose reference exists on the file system */
must_pass(git_buf_joinpath(&temp_path, repo->path_repository, packed_test_head_name));
- must_pass(git_path_exists(temp_path.ptr));
+ must_be_true(git_path_exists(temp_path.ptr));
/* Lookup the reference */
must_pass(git_reference_lookup(&looked_up_ref, repo, packed_test_head_name));
@@ -914,7 +926,7 @@ BEGIN_TEST(delete0, "deleting a ref which is both packed and loose should remove
must_fail(git_reference_lookup(&another_looked_up_ref, repo, packed_test_head_name));
/* Ensure the loose reference doesn't exist any longer on the file system */
- must_pass(!git_path_exists(temp_path.ptr));
+ must_be_true(!git_path_exists(temp_path.ptr));
close_temp_repo(repo);
diff --git a/tests/t12-repo.c b/tests/t12-repo.c
index 6a080ecb3..7c45e0126 100644
--- a/tests/t12-repo.c
+++ b/tests/t12-repo.c
@@ -68,7 +68,7 @@ static int write_file(const char *path, const char *content)
int error;
git_file file;
- if (git_path_exists(path) == GIT_SUCCESS) {
+ if (git_path_exists(path) == true) {
error = p_unlink(path);
if (error < GIT_SUCCESS)
diff --git a/tests/test_helpers.c b/tests/test_helpers.c
index 837358453..9ed0d79d8 100644
--- a/tests/test_helpers.c
+++ b/tests/test_helpers.c
@@ -239,7 +239,7 @@ static int copy_filesystem_element_recurs(void *_data, git_buf *source)
git_buf_truncate(&data->dst, data->dst_baselen);
git_buf_puts(&data->dst, source->ptr + data->src_baselen);
- if (git_path_isdir(source->ptr) == GIT_SUCCESS)
+ if (git_path_isdir(source->ptr) == true)
return git_path_direach(source, copy_filesystem_element_recurs, _data);
else
return copy_file(source->ptr, data->dst.ptr);
@@ -253,8 +253,8 @@ int copydir_recurs(
copydir_data data = { GIT_BUF_INIT, 0, GIT_BUF_INIT, 0 };
/* Source has to exist, Destination hast to _not_ exist */
- if (git_path_isdir(source_directory_path) != GIT_SUCCESS ||
- git_path_isdir(destination_directory_path) == GIT_SUCCESS)
+ if (git_path_isdir(source_directory_path) == false ||
+ git_path_isdir(destination_directory_path) == true)
return GIT_EINVALIDPATH;
git_buf_joinpath(&data.src, source_directory_path, "");
@@ -299,7 +299,7 @@ static int remove_placeholders_recurs(void *_data, git_buf *path)
remove_data *data = (remove_data *)_data;
size_t pathlen;
- if (!git_path_isdir(path->ptr))
+ if (git_path_isdir(path->ptr) == true)
return git_path_direach(path, remove_placeholders_recurs, data);
pathlen = path->size;
@@ -322,7 +322,7 @@ int remove_placeholders(const char *directory_path, const char *filename)
remove_data data;
git_buf buffer = GIT_BUF_INIT;
- if (git_path_isdir(directory_path))
+ if (git_path_isdir(directory_path) == false)
return GIT_EINVALIDPATH;
if ((error = git_buf_sets(&buffer, directory_path)) < GIT_SUCCESS)
generated by cgit v1.2.3 (git 2.25.1) at 2024-09-05 09:13:28 +0300