proxmox-mirrors/libgit2
1
0
Fork 0
mirror of https://git.proxmox.com/git/libgit2 synced 2025-07-05 20:35:12 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #456 from brodie/perm-fixes

Browse Source 
Create objects, indexes, and directories with the right file permissions
This commit is contained in:
Vicent Martí 2011-10-28 19:04:23 -07:00
commit 89fb8f025a
41 changed files with 187 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/config.h
View File

@ -14,6 +14,7 @@
#define GIT_CONFIG_FILENAME ".gitconfig"
#define GIT_CONFIG_FILENAME_INREPO "config"
#define GIT_CONFIG_FILE_MODE 0666
struct git_config {
git_vector files;

2
src/config_file.c
View File

@ -1034,7 +1034,7 @@ static int config_write(diskfile_backend *cfg, cvar_t *var)
if (error < GIT_SUCCESS)
git_filebuf_cleanup(&file);
else
error = git_filebuf_commit(&file);
error = git_filebuf_commit(&file, GIT_CONFIG_FILE_MODE);
git_futils_freebuffer(&cfg->reader.buffer);
return error;

3
src/fetch.c
View File

@ -14,6 +14,7 @@
#include "transport.h"
#include "remote.h"
#include "refspec.h"
#include "pack.h"
#include "fetch.h"
#include "netops.h"
@ -181,7 +182,7 @@ int git_fetch__download_pack(char **out, const char *buffered, size_t buffered_s
}
/* A bit dodgy, but we need to keep the pack at the temporary path */
error = git_filebuf_commit_at(&file, file.path_lock);
error = git_filebuf_commit_at(&file, file.path_lock, GIT_PACK_FILE_MODE);
cleanup:
if (error < GIT_SUCCESS)
git_filebuf_cleanup(&file);

18
src/filebuf.c
View File

@ -10,6 +10,8 @@
#include "filebuf.h"
#include "fileops.h"
#define GIT_LOCK_FILE_MODE 0644
static const size_t WRITE_BUFFER_SIZE = (4096 * 2);
static int lock_file(git_filebuf *file, int flags)
@ -23,9 +25,10 @@ static int lock_file(git_filebuf *file, int flags)
/* create path to the file buffer is required */
if (flags & GIT_FILEBUF_FORCE) {
file->fd = git_futils_creat_locked_withpath(file->path_lock, 0644);
/* XXX: Should dirmode here be configurable? Or is 0777 always fine? */
file->fd = git_futils_creat_locked_withpath(file->path_lock, 0777, GIT_LOCK_FILE_MODE);
} else {
file->fd = git_futils_creat_locked(file->path_lock, 0644);
file->fd = git_futils_creat_locked(file->path_lock, GIT_LOCK_FILE_MODE);
}
if (file->fd < 0)
@ -246,17 +249,17 @@ int git_filebuf_hash(git_oid *oid, git_filebuf *file)
return GIT_SUCCESS;
}
int git_filebuf_commit_at(git_filebuf *file, const char *path)
int git_filebuf_commit_at(git_filebuf *file, const char *path, mode_t mode)
{
git__free(file->path_original);
file->path_original = git__strdup(path);
if (file->path_original == NULL)
return GIT_ENOMEM;
return git_filebuf_commit(file);
return git_filebuf_commit(file, mode);
}
int git_filebuf_commit(git_filebuf *file)
int git_filebuf_commit(git_filebuf *file, mode_t mode)
{
int error;
@ -270,6 +273,11 @@ int git_filebuf_commit(git_filebuf *file)
p_close(file->fd);
file->fd = -1;
if (p_chmod(file->path_lock, mode)) {
error = git__throw(GIT_EOSERR, "Failed to chmod locked file before committing");
goto cleanup;
}
error = git_futils_mv_atomic(file->path_lock, file->path_original);
cleanup:

4
src/filebuf.h
View File

@ -49,8 +49,8 @@ int git_filebuf_reserve(git_filebuf *file, void **buff, size_t len);
int git_filebuf_printf(git_filebuf *file, const char *format, ...) GIT_FORMAT_PRINTF(2, 3);
int git_filebuf_open(git_filebuf *lock, const char *path, int flags);
int git_filebuf_commit(git_filebuf *lock);
int git_filebuf_commit_at(git_filebuf *lock, const char *path);
int git_filebuf_commit(git_filebuf *lock, mode_t mode);
int git_filebuf_commit_at(git_filebuf *lock, const char *path, mode_t mode);
void git_filebuf_cleanup(git_filebuf *lock);
int git_filebuf_hash(git_oid *oid, git_filebuf *file);

19
src/fileops.c
View File

@ -31,9 +31,8 @@ int git_futils_mv_atomic(const char *from, const char *to)
#endif
}
int git_futils_mkpath2file(const char *file_path)
int git_futils_mkpath2file(const char *file_path, const mode_t mode)
{
const int mode = 0755; /* or 0777 ? */
int error = GIT_SUCCESS;
char target_folder_path[GIT_PATH_MAX];
@ -67,23 +66,23 @@ int git_futils_mktmp(char *path_out, const char *filename)
return fd;
}
int git_futils_creat_withpath(const char *path, int mode)
int git_futils_creat_withpath(const char *path, const mode_t dirmode, const mode_t mode)
{
if (git_futils_mkpath2file(path) < GIT_SUCCESS)
if (git_futils_mkpath2file(path, dirmode) < GIT_SUCCESS)
return git__throw(GIT_EOSERR, "Failed to create file %s", path);
return p_creat(path, mode);
}
int git_futils_creat_locked(const char *path, int mode)
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);
}
int git_futils_creat_locked_withpath(const char *path, int mode)
int git_futils_creat_locked_withpath(const char *path, const mode_t dirmode, const mode_t mode)
{
if (git_futils_mkpath2file(path) < GIT_SUCCESS)
if (git_futils_mkpath2file(path, dirmode) < GIT_SUCCESS)
return git__throw(GIT_EOSERR, "Failed to create locked file %s", path);
return git_futils_creat_locked(path, mode);
@ -212,9 +211,9 @@ void git_futils_freebuffer(git_fbuffer *obj)
}
int git_futils_mv_withpath(const char *from, const char *to)
int git_futils_mv_withpath(const char *from, const char *to, const mode_t dirmode)
{
if (git_futils_mkpath2file(to) < GIT_SUCCESS)
if (git_futils_mkpath2file(to, dirmode) < GIT_SUCCESS)
return GIT_EOSERR; /* The callee already takes care of setting the correct error message. */
return git_futils_mv_atomic(from, to); /* The callee already takes care of setting the correct error message. */
@ -289,7 +288,7 @@ int git_futils_direach(
return GIT_SUCCESS;
}
int git_futils_mkdir_r(const char *path, int mode)
int git_futils_mkdir_r(const char *path, const mode_t mode)
{
int error, root_path_offset;
char *pp, *sp;

12
src/fileops.h
View File

@ -48,18 +48,18 @@ extern int git_futils_exists(const char *path);
* Create and open a file, while also
* creating all the folders in its path
*/
extern int git_futils_creat_withpath(const char *path, int mode);
extern int git_futils_creat_withpath(const char *path, const mode_t dirmode, const mode_t mode);
/**
* Create an open a process-locked file
*/
extern int git_futils_creat_locked(const char *path, int mode);
extern int git_futils_creat_locked(const char *path, const mode_t mode);
/**
* Create an open a process-locked file, while
* also creating all the folders in its path
*/
extern int git_futils_creat_locked_withpath(const char *path, int mode);
extern int git_futils_creat_locked_withpath(const char *path, const mode_t dirmode, const mode_t mode);
/**
* Check if the given path points to a directory
@ -74,13 +74,13 @@ extern int git_futils_isfile(const char *path);
/**
* Create a path recursively
*/
extern int git_futils_mkdir_r(const char *path, int mode);
extern int git_futils_mkdir_r(const char *path, const mode_t mode);
/**
* Create all the folders required to contain
* the full path of a file
*/
extern int git_futils_mkpath2file(const char *path);
extern int git_futils_mkpath2file(const char *path, const mode_t mode);
extern int git_futils_rmdir_r(const char *path, int force);
@ -98,7 +98,7 @@ extern int git_futils_mv_atomic(const char *from, const char *to);
* Move a file on the filesystem, create the
* destination path if it doesn't exist
*/
extern int git_futils_mv_withpath(const char *from, const char *to);
extern int git_futils_mv_withpath(const char *from, const char *to, const mode_t dirmode);
/**

2
src/index.c
View File

@ -262,7 +262,7 @@ int git_index_write(git_index *index)
return git__rethrow(error, "Failed to write index");
}
if ((error = git_filebuf_commit(&file)) < GIT_SUCCESS)
if ((error = git_filebuf_commit(&file, GIT_INDEX_FILE_MODE)) < GIT_SUCCESS)
return git__rethrow(error, "Failed to write index");
if (p_stat(index->index_file_path, &indexst) == 0) {

3
src/index.h
View File

@ -14,6 +14,9 @@
#include "git2/odb.h"
#include "git2/index.h"
#define GIT_INDEX_FILE "index"
#define GIT_INDEX_FILE_MODE 0666
struct git_index {
git_repository *repository;
char *index_file_path;

2
src/indexer.c
View File

@ -272,7 +272,7 @@ int git_indexer_write(git_indexer *idx)
/* Figure out what the final name should be */
index_path(filename, idx);
/* Commit file */
error = git_filebuf_commit_at(&idx->file, filename);
error = git_filebuf_commit_at(&idx->file, filename, GIT_PACK_FILE_MODE);
cleanup:
git_mwindow_free_all(&idx->pack->mwf);

4
src/odb.h
View File

@ -14,6 +14,10 @@
#include "vector.h"
#include "cache.h"
#define GIT_OBJECTS_DIR "objects/"
#define GIT_OBJECT_DIR_MODE 0777
#define GIT_OBJECT_FILE_MODE 0444
/* DO NOT EXPORT */
typedef struct {
void *data; /**< Raw, decompressed object data. */

8
src/odb_loose.c
View File

@ -666,11 +666,11 @@ static int loose_backend__stream_fwrite(git_oid *oid, git_odb_stream *_stream)
if (object_file_name(final_path, sizeof(final_path), backend->objects_dir, oid))
return GIT_ENOMEM;
if ((error = git_futils_mkpath2file(final_path)) < GIT_SUCCESS)
if ((error = git_futils_mkpath2file(final_path, GIT_OBJECT_DIR_MODE)) < GIT_SUCCESS)
return git__rethrow(error, "Failed to write loose backend");
stream->finished = 1;
return git_filebuf_commit_at(&stream->fbuf, final_path);
return git_filebuf_commit_at(&stream->fbuf, final_path, GIT_OBJECT_FILE_MODE);
}
static int loose_backend__stream_write(git_odb_stream *_stream, const char *data, size_t len)
@ -787,10 +787,10 @@ static int loose_backend__write(git_oid *oid, git_odb_backend *_backend, const v
if ((error = object_file_name(final_path, sizeof(final_path), backend->objects_dir, oid)) < GIT_SUCCESS)
goto cleanup;
if ((error = git_futils_mkpath2file(final_path)) < GIT_SUCCESS)
if ((error = git_futils_mkpath2file(final_path, GIT_OBJECT_DIR_MODE)) < GIT_SUCCESS)
goto cleanup;
return git_filebuf_commit_at(&fbuf, final_path);
return git_filebuf_commit_at(&fbuf, final_path, GIT_OBJECT_FILE_MODE);
cleanup:
git_filebuf_cleanup(&fbuf);

2
src/pack.h
View File

@ -15,6 +15,8 @@
#include "mwindow.h"
#include "odb.h"
#define GIT_PACK_FILE_MODE 0444
#define PACK_SIGNATURE 0x5041434b /* "PACK" */
#define PACK_VERSION 2
#define pack_version_ok(v) ((v) == htonl(2) || (v) == htonl(3))

2
src/posix.c
View File

@ -17,7 +17,7 @@ int p_open(const char *path, int flags)
return open(path, flags | O_BINARY);
}
int p_creat(const char *path, int mode)
int p_creat(const char *path, mode_t mode)
{
return open(path, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, mode);
}

3
src/posix.h
View File

@ -40,9 +40,10 @@ extern int p_write(git_file fd, const void *buf, size_t cnt);
#define p_fstat(f,b) fstat(f, b)
#define p_lseek(f,n,w) lseek(f, n, w)
#define p_close(fd) close(fd)
#define p_umask(m) umask(m)
extern int p_open(const char *path, int flags);
extern int p_creat(const char *path, int mode);
extern int p_creat(const char *path, mode_t mode);
extern int p_getcwd(char *buffer_out, size_t size);
#ifndef GIT_WIN32

4
src/reflog.c
View File

@ -71,7 +71,7 @@ static int reflog_write(const char *log_path, const char *oid_old,
}
git_filebuf_write(&fbuf, log.ptr, log.size);
error = git_filebuf_commit(&fbuf);
error = git_filebuf_commit(&fbuf, GIT_REFLOG_FILE_MODE);
git_buf_free(&log);
return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to write reflog");
@ -226,7 +226,7 @@ int git_reflog_write(git_reference *ref, const git_oid *oid_old,
git_path_join_n(log_path, 3, ref->owner->path_repository, GIT_REFLOG_DIR, ref->name);
if (git_futils_exists(log_path)) {
if ((error = git_futils_mkpath2file(log_path)) < GIT_SUCCESS)
if ((error = git_futils_mkpath2file(log_path, GIT_REFLOG_DIR_MODE)) < GIT_SUCCESS)
return git__rethrow(error, "Failed to write reflog. Cannot create reflog directory");
} else if (git_futils_isfile(log_path)) {
return git__throw(GIT_ERROR, "Failed to write reflog. `%s` is directory", log_path);

2
src/reflog.h
View File

@ -12,6 +12,8 @@
#include "vector.h"
#define GIT_REFLOG_DIR "logs/"
#define GIT_REFLOG_DIR_MODE 0777
#define GIT_REFLOG_FILE_MODE 0666
#define GIT_REFLOG_SIZE_MIN (2*GIT_OID_HEXSZ+2+17)

5
src/refs.c
View File

@ -9,6 +9,7 @@
#include "hash.h"
#include "repository.h"
#include "fileops.h"
#include "pack.h"
#include <git2/tag.h>
#include <git2/object.h>
@ -357,7 +358,7 @@ static int loose_write(git_reference *ref)
goto unlock;
}
error = git_filebuf_commit(&file);
error = git_filebuf_commit(&file, GIT_REFS_FILE_MODE);
if (p_stat(ref_path, &st) == GIT_SUCCESS)
ref->mtime = st.st_mtime;
@ -870,7 +871,7 @@ 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);
error = git_filebuf_commit(&pack_file, GIT_PACK_FILE_MODE);
/* when and only when the packfile has been properly written,
* we can go ahead and remove the loose refs */

2
src/refs.h
View File

@ -16,6 +16,8 @@
#define GIT_REFS_HEADS_DIR GIT_REFS_DIR "heads/"
#define GIT_REFS_TAGS_DIR GIT_REFS_DIR "tags/"
#define GIT_REFS_REMOTES_DIR GIT_REFS_DIR "remotes/"
#define GIT_REFS_DIR_MODE 0777
#define GIT_REFS_FILE_MODE 0666
#define GIT_RENAMED_REF_FILE GIT_REFS_DIR "RENAMED-REF"

11
src/repository.c
View File

@ -609,12 +609,11 @@ static int repo_init_createhead(git_repository *repo)
static int repo_init_structure(const char *git_dir, int is_bare)
{
const int mode = 0755; /* or 0777 ? */
int error;
char temp_path[GIT_PATH_MAX];
if (git_futils_mkdir_r(git_dir, mode))
if (git_futils_mkdir_r(git_dir, is_bare ? GIT_BARE_DIR_MODE : GIT_DIR_MODE))
return git__throw(GIT_ERROR, "Failed to initialize repository structure. Could not mkdir");
/* Hides the ".git" directory */
@ -628,25 +627,25 @@ static int repo_init_structure(const char *git_dir, int is_bare)
/* Creates the '/objects/info/' directory */
git_path_join(temp_path, git_dir, GIT_OBJECTS_INFO_DIR);
error = git_futils_mkdir_r(temp_path, mode);
error = git_futils_mkdir_r(temp_path, GIT_OBJECT_DIR_MODE);
if (error < GIT_SUCCESS)
return git__rethrow(error, "Failed to initialize repository structure");
/* Creates the '/objects/pack/' directory */
git_path_join(temp_path, git_dir, GIT_OBJECTS_PACK_DIR);
error = p_mkdir(temp_path, mode);
error = p_mkdir(temp_path, GIT_OBJECT_DIR_MODE);
if (error < GIT_SUCCESS)
return git__throw(error, "Unable to create `%s` folder", temp_path);
/* Creates the '/refs/heads/' directory */
git_path_join(temp_path, git_dir, GIT_REFS_HEADS_DIR);
error = git_futils_mkdir_r(temp_path, mode);
error = git_futils_mkdir_r(temp_path, GIT_REFS_DIR_MODE);
if (error < GIT_SUCCESS)
return git__rethrow(error, "Failed to initialize repository structure");
/* Creates the '/refs/tags/' directory */
git_path_join(temp_path, git_dir, GIT_REFS_TAGS_DIR);
error = p_mkdir(temp_path, mode);
error = p_mkdir(temp_path, GIT_REFS_DIR_MODE);
if (error < GIT_SUCCESS)
return git__throw(error, "Unable to create `%s` folder", temp_path);

5
src/repository.h
View File

@ -18,11 +18,12 @@
#include "cache.h"
#include "refs.h"
#include "buffer.h"
#include "odb.h"
#define DOT_GIT ".git"
#define GIT_DIR DOT_GIT "/"
#define GIT_OBJECTS_DIR "objects/"
#define GIT_INDEX_FILE "index"
#define GIT_DIR_MODE 0755
#define GIT_BARE_DIR_MODE 0777
struct git_object {
git_cached_obj cached;

3
src/transports/http.c
View File

@ -15,6 +15,7 @@
#include "buffer.h"
#include "pkt.h"
#include "refs.h"
#include "pack.h"
#include "fetch.h"
#include "filebuf.h"
#include "repository.h"
@ -702,7 +703,7 @@ static int http_download_pack(char **out, git_transport *transport, git_reposito
}
/* A bit dodgy, but we need to keep the pack at the temporary path */
error = git_filebuf_commit_at(&file, file.path_lock);
error = git_filebuf_commit_at(&file, file.path_lock, GIT_PACK_FILE_MODE);
cleanup:
if (error < GIT_SUCCESS)

8
src/win32/posix.h
View File

@ -19,7 +19,7 @@ GIT_INLINE(int) p_link(const char *GIT_UNUSED(old), const char *GIT_UNUSED(new))
return -1;
}
GIT_INLINE(int) p_mkdir(const char *path, int GIT_UNUSED(mode))
GIT_INLINE(int) p_mkdir(const char *path, mode_t GIT_UNUSED(mode))
{
wchar_t* buf = gitwin_to_utf16(path);
int ret = _wmkdir(buf);
@ -41,12 +41,12 @@ extern int p_mkstemp(char *tmp_path);
extern int p_setenv(const char* name, const char* value, int overwrite);
extern int p_stat(const char* path, struct stat* buf);
extern int p_chdir(const char* path);
extern int p_chmod(const char* path, int mode);
extern int p_chmod(const char* path, mode_t mode);
extern int p_rmdir(const char* path);
extern int p_access(const char* path, int mode);
extern int p_access(const char* path, mode_t mode);
extern int p_fsync(int fd);
extern int p_open(const char *path, int flags);
extern int p_creat(const char *path, int mode);
extern int p_creat(const char *path, mode_t mode);
extern int p_getcwd(char *buffer_out, size_t size);
#endif

8
src/win32/posix_w32.c
View File

@ -230,7 +230,7 @@ int p_open(const char *path, int flags)
return fd;
}
int p_creat(const char *path, int mode)
int p_creat(const char *path, mode_t mode)
{
int fd;
wchar_t* buf = gitwin_to_utf16(path);
@ -268,7 +268,7 @@ int p_chdir(const char* path)
return ret;
}
int p_chmod(const char* path, int mode)
int p_chmod(const char* path, mode_t mode)
{
wchar_t* buf = gitwin_to_utf16(path);
int ret = _wchmod(buf, mode);
@ -355,7 +355,7 @@ int p_snprintf(char *buffer, size_t count, const char *format, ...)
return r;
}
extern int p_creat(const char *path, int mode);
extern int p_creat(const char *path, mode_t mode);
int p_mkstemp(char *tmp_path)
{
@ -378,7 +378,7 @@ int p_setenv(const char* name, const char* value, int overwrite)
return (SetEnvironmentVariableA(name, value) == 0 ? GIT_EOSERR : GIT_SUCCESS);
}
int p_access(const char* path, int mode)
int p_access(const char* path, mode_t mode)
{
wchar_t *buf = gitwin_to_utf16(path);
int ret;

6
tests-clay/core/dirent.c
View File

@ -20,18 +20,18 @@ static void setup(walk_data *d)
{
name_data *n;
cl_must_pass(p_mkdir(top_dir, 0755));
cl_must_pass(p_mkdir(top_dir, 0777));
cl_must_pass(p_chdir(top_dir));
if (strcmp(d->sub, ".") != 0)
cl_must_pass(p_mkdir(d->sub, 0755));
cl_must_pass(p_mkdir(d->sub, 0777));
strcpy(path_buffer, d->sub);
state_loc = d;
for (n = d->names; n->name; n++) {
git_file fd = p_creat(n->name, 0600);
git_file fd = p_creat(n->name, 0666);
cl_assert(fd >= 0);
p_close(fd);
n->count = 0;

6
tests-clay/core/filebuf.c
View File

@ -27,14 +27,14 @@ void test_core_filebuf__1(void)
int fd;
char test[] = "test";
fd = p_creat(test, 0644);
fd = p_creat(test, 0666);
cl_must_pass(fd);
cl_must_pass(p_write(fd, "libgit2 rocks\n", 14));
cl_must_pass(p_close(fd));
cl_git_pass(git_filebuf_open(&file, test, GIT_FILEBUF_APPEND));
cl_git_pass(git_filebuf_printf(&file, "%s\n", "libgit2 rocks"));
cl_git_pass(git_filebuf_commit(&file));
cl_git_pass(git_filebuf_commit(&file, 0666));
cl_must_pass(p_unlink(test));
}
@ -51,7 +51,7 @@ void test_core_filebuf__2(void)
cl_git_pass(git_filebuf_open(&file, test, 0));
cl_git_pass(git_filebuf_write(&file, buf, sizeof(buf)));
cl_git_pass(git_filebuf_commit(&file));
cl_git_pass(git_filebuf_commit(&file, 0666));
cl_must_pass(p_unlink(test));
}

14
tests-clay/core/rmdir.c
View File

@ -7,22 +7,22 @@ void test_core_rmdir__initialize(void)
{
char path[GIT_PATH_MAX];
cl_must_pass(p_mkdir(empty_tmp_dir, 0755));
cl_must_pass(p_mkdir(empty_tmp_dir, 0777));
git_path_join(path, empty_tmp_dir, "/one");
cl_must_pass(p_mkdir(path, 0755));
cl_must_pass(p_mkdir(path, 0777));
git_path_join(path, empty_tmp_dir, "/one/two_one");
cl_must_pass(p_mkdir(path, 0755));
cl_must_pass(p_mkdir(path, 0777));
git_path_join(path, empty_tmp_dir, "/one/two_two");
cl_must_pass(p_mkdir(path, 0755));
cl_must_pass(p_mkdir(path, 0777));
git_path_join(path, empty_tmp_dir, "/one/two_two/three");
cl_must_pass(p_mkdir(path, 0755));
cl_must_pass(p_mkdir(path, 0777));
git_path_join(path, empty_tmp_dir, "/two");
cl_must_pass(p_mkdir(path, 0755));
cl_must_pass(p_mkdir(path, 0777));
}
/* make sure empty dir can be deleted recusively */
@ -39,7 +39,7 @@ void test_core_rmdir__fail_to_delete_non_empty_dir(void)
git_path_join(file, empty_tmp_dir, "/two/file.txt");
fd = p_creat(file, 0755);
fd = p_creat(file, 0666);
cl_assert(fd >= 0);
cl_must_pass(p_close(fd));

2
tests-clay/status/single.c
View File

@ -10,7 +10,7 @@ cleanup__remove_file(void *_file)
static void
file_create(const char *filename, const char *content)
{
int fd = p_creat(filename, 0644);
int fd = p_creat(filename, 0666);
cl_assert(fd >= 0);
cl_must_pass(p_write(fd, content, strlen(content)));
cl_must_pass(p_close(fd));

26
tests/t00-core.c
View File

@ -250,21 +250,21 @@ static int setup(walk_data *d)
{
name_data *n;
if (p_mkdir(top_dir, 0755) < 0)
if (p_mkdir(top_dir, 0777) < 0)
return error("can't mkdir(\"%s\")", top_dir);
if (p_chdir(top_dir) < 0)
return error("can't chdir(\"%s\")", top_dir);
if (strcmp(d->sub, ".") != 0)
if (p_mkdir(d->sub, 0755) < 0)
if (p_mkdir(d->sub, 0777) < 0)
return error("can't mkdir(\"%s\")", d->sub);
strcpy(path_buffer, d->sub);
state_loc = d;
for (n = d->names; n->name; n++) {
git_file fd = p_creat(n->name, 0600);
git_file fd = p_creat(n->name, 0666);
if (fd < 0)
return GIT_ERROR;
p_close(fd);
@ -479,14 +479,14 @@ BEGIN_TEST(filebuf1, "make sure GIT_FILEBUF_APPEND works as expected")
int fd;
char test[] = "test";
fd = p_creat(test, 0644);
fd = p_creat(test, 0666);
must_pass(fd);
must_pass(p_write(fd, "libgit2 rocks\n", 14));
must_pass(p_close(fd));
must_pass(git_filebuf_open(&file, test, GIT_FILEBUF_APPEND));
must_pass(git_filebuf_printf(&file, "%s\n", "libgit2 rocks"));
must_pass(git_filebuf_commit(&file));
must_pass(git_filebuf_commit(&file, 0666));
must_pass(p_unlink(test));
END_TEST
@ -499,7 +499,7 @@ BEGIN_TEST(filebuf2, "make sure git_filebuf_write writes large buffer correctly"
memset(buf, 0xfe, sizeof(buf));
must_pass(git_filebuf_open(&file, test, 0));
must_pass(git_filebuf_write(&file, buf, sizeof(buf)));
must_pass(git_filebuf_commit(&file));
must_pass(git_filebuf_commit(&file, 0666));
must_pass(p_unlink(test));
END_TEST
@ -510,27 +510,27 @@ static int setup_empty_tmp_dir(void)
{
char path[GIT_PATH_MAX];
if (p_mkdir(empty_tmp_dir, 0755))
if (p_mkdir(empty_tmp_dir, 0777))
return -1;
git_path_join(path, empty_tmp_dir, "/one");
if (p_mkdir(path, 0755))
if (p_mkdir(path, 0777))
return -1;
git_path_join(path, empty_tmp_dir, "/one/two_one");
if (p_mkdir(path, 0755))
if (p_mkdir(path, 0777))
return -1;
git_path_join(path, empty_tmp_dir, "/one/two_two");
if (p_mkdir(path, 0755))
if (p_mkdir(path, 0777))
return -1;
git_path_join(path, empty_tmp_dir, "/one/two_two/three");
if (p_mkdir(path, 0755))
if (p_mkdir(path, 0777))
return -1;
git_path_join(path, empty_tmp_dir, "/two");
if (p_mkdir(path, 0755))
if (p_mkdir(path, 0777))
return -1;
return 0;
@ -547,7 +547,7 @@ BEGIN_TEST(rmdir1, "make sure non-empty dir cannot be deleted recusively")
must_pass(setup_empty_tmp_dir());
git_path_join(file, empty_tmp_dir, "/two/file.txt");
fd = p_creat(file, 0755);
fd = p_creat(file, 0777);
must_pass(fd);
must_pass(p_close(fd));
must_fail(git_futils_rmdir_r(empty_tmp_dir, 0));

2
tests/t03-objwrite.c
View File

@ -31,7 +31,7 @@ static char *odb_dir = "test-objects";
static int make_odb_dir(void)
{
if (p_mkdir(odb_dir, 0755) < 0) {
if (p_mkdir(odb_dir, GIT_OBJECT_DIR_MODE) < 0) {
int err = errno;
fprintf(stderr, "can't make directory \"%s\"", odb_dir);
if (err == EEXIST)

4
tests/t04-commit.c
View File

@ -690,6 +690,10 @@ BEGIN_TEST(write0, "write a new commit object from memory to disk")
must_be_true(strcmp(git_commit_message(commit), COMMIT_MESSAGE) == 0);
#ifndef GIT_WIN32
must_be_true((loose_object_mode(REPOSITORY_FOLDER, (git_object *)commit) & 0777) == GIT_OBJECT_FILE_MODE);
#endif
must_pass(remove_loose_object(REPOSITORY_FOLDER, (git_object *)commit));
git_commit_close(commit);

4
tests/t06-index.c
View File

@ -176,10 +176,10 @@ BEGIN_TEST(add0, "add a new file to the index")
must_pass(git_index_entrycount(index) == 0);
/* Create a new file in the working directory */
must_pass(git_futils_mkpath2file(TEMP_REPO_FOLDER "myrepo/test.txt"));
must_pass(git_futils_mkpath2file(TEMP_REPO_FOLDER "myrepo/test.txt", 0777));
must_pass(git_filebuf_open(&file, TEMP_REPO_FOLDER "myrepo/test.txt", 0));
must_pass(git_filebuf_write(&file, "hey there\n", 10));
must_pass(git_filebuf_commit(&file));
must_pass(git_filebuf_commit(&file, 0666));
/* Store the expected hash of the file/blob
* This has been generated by executing the following

3
tests/t08-tag.c
View File

@ -189,6 +189,9 @@ BEGIN_TEST(write0, "write a tag to the repository and read it again")
must_pass(git_reference_lookup(&ref_tag, repo, "refs/tags/the-tag"));
must_be_true(git_oid_cmp(git_reference_oid(ref_tag), &tag_id) == 0);
must_pass(git_reference_delete(ref_tag));
#ifndef GIT_WIN32
must_be_true((loose_object_mode(REPOSITORY_FOLDER, (git_object *)tag) & 0777) == GIT_OBJECT_FILE_MODE);
#endif
must_pass(remove_loose_object(REPOSITORY_FOLDER, (git_object *)tag));

4
tests/t09-tree.c
View File

@ -200,6 +200,10 @@ BEGIN_TEST(write3, "write a hierarchical tree from a memory")
// check data is correct
must_pass(git_tree_lookup(&tree, repo, &id_hiearar));
must_be_true(2 == git_tree_entrycount(tree));
#ifndef GIT_WIN32
must_be_true((loose_object_dir_mode(TEMP_REPO_FOLDER, (git_object *)tree) & 0777) == GIT_OBJECT_DIR_MODE);
must_be_true((loose_object_mode(TEMP_REPO_FOLDER, (git_object *)tree) & 0777) == GIT_OBJECT_FILE_MODE);
#endif
git_tree_close(tree);
close_temp_repo(repo);

3
tests/t10-refs.c
View File

@ -431,12 +431,11 @@ END_TEST
BEGIN_TEST(pack0, "create a packfile for an empty folder")
git_repository *repo;
char temp_path[GIT_PATH_MAX];
const int mode = 0755; /* or 0777 ? */
must_pass(open_temp_repo(&repo, REPOSITORY_FOLDER));
git_path_join_n(temp_path, 3, repo->path_repository, GIT_REFS_HEADS_DIR, "empty_dir");
must_pass(git_futils_mkdir_r(temp_path, mode));
must_pass(git_futils_mkdir_r(temp_path, GIT_REFS_DIR_MODE));
must_pass(git_reference_packall(repo));

8
tests/t12-repo.c
View File

@ -173,7 +173,7 @@ END_TEST
BEGIN_TEST(init2, "Initialize and open a bare repo with a relative path escaping out of the current working directory")
char path_repository[GIT_PATH_MAX];
char current_workdir[GIT_PATH_MAX];
const int mode = 0755; /* or 0777 ? */
const mode_t mode = 0777;
git_repository* repo;
must_pass(p_getcwd(current_workdir, sizeof(current_workdir)));
@ -232,7 +232,7 @@ BEGIN_TEST(open2, "Open a bare repository with a relative path escaping out of t
char current_workdir[GIT_PATH_MAX];
char path_repository[GIT_PATH_MAX];
const int mode = 0755; /* or 0777 ? */
const mode_t mode = 0777;
git_repository* repo;
/* Setup the repository to open */
@ -351,7 +351,7 @@ static int write_file(const char *path, const char *content)
return error;
}
file = git_futils_creat_withpath(path, 0644);
file = git_futils_creat_withpath(path, 0777, 0666);
if (file < GIT_SUCCESS)
return file;
@ -384,7 +384,7 @@ BEGIN_TEST(discover0, "test discover")
char repository_path[GIT_PATH_MAX];
char sub_repository_path[GIT_PATH_MAX];
char found_path[GIT_PATH_MAX];
int mode = 0755;
const mode_t mode = 0777;
git_futils_mkdir_r(DISCOVER_FOLDER, mode);
must_pass(append_ceiling_dir(ceiling_dirs, TEMP_REPO_FOLDER));

2
tests/t15-config.c
View File

@ -319,7 +319,7 @@ BEGIN_TEST(config16, "add a variable in a new section")
/* As the section wasn't removed, owerwrite the file */
must_pass(git_filebuf_open(&buf, CONFIG_BASE "/config10", 0));
must_pass(git_filebuf_write(&buf, "[empty]\n", strlen("[empty]\n")));
must_pass(git_filebuf_commit(&buf));
must_pass(git_filebuf_commit(&buf, 0666));
END_TEST
BEGIN_TEST(config17, "prefixes aren't broken")

4
tests/t18-status.c
View File

@ -37,7 +37,7 @@ static int file_create(const char *filename, const char *content)
{
int fd;
fd = p_creat(filename, 0644);
fd = p_creat(filename, 0666);
if (fd == 0)
return GIT_ERROR;
if (p_write(fd, content, strlen(content)) != 0)
@ -400,7 +400,7 @@ BEGIN_TEST(singlestatus3, "test retrieving status for a new file in an empty rep
must_pass(remove_placeholders(TEST_STD_REPO_FOLDER, "dummy-marker.txt"));
git_path_join(file_path, TEMP_REPO_FOLDER, filename);
fd = p_creat(file_path, 0644);
fd = p_creat(file_path, 0666);
must_pass(fd);
must_pass(p_write(fd, "new_file\n", 9));
must_pass(p_close(fd));

54
tests/test_helpers.c
View File

@ -42,7 +42,7 @@ int write_object_data(char *file, void *data, size_t len)
int write_object_files(const char *odb_dir, object_data *d)
{
if (p_mkdir(odb_dir, 0755) < 0) {
if (p_mkdir(odb_dir, GIT_OBJECT_DIR_MODE) < 0) {
int err = errno;
fprintf(stderr, "can't make directory \"%s\"", odb_dir);
if (err == EEXIST)
@ -51,7 +51,7 @@ int write_object_files(const char *odb_dir, object_data *d)
return -1;
}
if ((p_mkdir(d->dir, 0755) < 0) && (errno != EEXIST)) {
if ((p_mkdir(d->dir, GIT_OBJECT_DIR_MODE) < 0) && (errno != EEXIST)) {
fprintf(stderr, "can't make object directory \"%s\"\n", d->dir);
return -1;
}
@ -82,7 +82,7 @@ int remove_object_files(const char *odb_dir, object_data *d)
return 0;
}
int remove_loose_object(const char *repository_folder, git_object *object)
void locate_loose_object(const char *repository_folder, git_object *object, char **out, char **out_folder)
{
static const char *objects_folder = "objects/";
@ -104,6 +104,52 @@ int remove_loose_object(const char *repository_folder, git_object *object)
ptr += GIT_OID_HEXSZ + 1;
*ptr = 0;
*out = full_path;
if (out_folder)
*out_folder = top_folder;
}
int loose_object_mode(const char *repository_folder, git_object *object)
{
char *object_path;
struct stat st;
locate_loose_object(repository_folder, object, &object_path, NULL);
assert(p_stat(object_path, &st) == 0);
free(object_path);
return st.st_mode;
}
int loose_object_dir_mode(const char *repository_folder, git_object *object)
{
char *object_path;
size_t pos;
struct stat st;
locate_loose_object(repository_folder, object, &object_path, NULL);
pos = strlen(object_path);
while (pos--) {
if (object_path[pos] == '/') {
object_path[pos] = 0;
break;
}
}
assert(p_stat(object_path, &st) == 0);
free(object_path);
return st.st_mode;
}
int remove_loose_object(const char *repository_folder, git_object *object)
{
char *full_path, *top_folder;
locate_loose_object(repository_folder, object, &full_path, &top_folder);
if (p_unlink(full_path) < 0) {
fprintf(stderr, "can't delete object file \"%s\"\n", full_path);
return -1;
@ -141,7 +187,7 @@ int copy_file(const char *src, const char *dst)
if (git_futils_readbuffer(&source_buf, src) < GIT_SUCCESS)
return GIT_ENOTFOUND;
dst_fd = git_futils_creat_withpath(dst, 0644);
dst_fd = git_futils_creat_withpath(dst, 0777, 0666);
if (dst_fd < 0)
goto cleanup;

5
tests/test_helpers.h
View File

@ -63,6 +63,11 @@ extern int remove_object_files(const char *odb_dir, object_data *d);
extern int cmp_objects(git_rawobj *o, object_data *d);
extern void locate_loose_object(const char *odb_dir, git_object *object, char **out, char **out_folder);
extern int loose_object_mode(const char *odb_dir, git_object *object);
extern int loose_object_dir_mode(const char *odb_dir, git_object *object);
extern int remove_loose_object(const char *odb_dir, git_object *object);
extern int cmp_files(const char *a, const char *b);

4
tests/test_main.c
View File

@ -26,6 +26,8 @@
#include <string.h>
#include <git2.h>
#include "posix.h"
#include "test_lib.h"
#include "test_helpers.h"
@ -81,6 +83,8 @@ main(int GIT_UNUSED(argc), char *GIT_UNUSED(argv[]))
GIT_UNUSED_ARG(argc);
GIT_UNUSED_ARG(argv);
p_umask(0);
failures = 0;
for (i = 0; i < GIT_SUITE_COUNT; ++i)