mkdir.c 9.13 KB
Newer Older
1 2 3 4 5 6 7 8
#include "clar_libgit2.h"
#include "fileops.h"
#include "path.h"
#include "posix.h"

static void cleanup_basic_dirs(void *ref)
{
	GIT_UNUSED(ref);
9 10 11 12 13
	git_futils_rmdir_r("d0", NULL, GIT_RMDIR_EMPTY_HIERARCHY);
	git_futils_rmdir_r("d1", NULL, GIT_RMDIR_EMPTY_HIERARCHY);
	git_futils_rmdir_r("d2", NULL, GIT_RMDIR_EMPTY_HIERARCHY);
	git_futils_rmdir_r("d3", NULL, GIT_RMDIR_EMPTY_HIERARCHY);
	git_futils_rmdir_r("d4", NULL, GIT_RMDIR_EMPTY_HIERARCHY);
14 15
}

16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
void test_core_mkdir__absolute(void)
{
	git_buf path = GIT_BUF_INIT;

	cl_set_cleanup(cleanup_basic_dirs, NULL);

	git_buf_joinpath(&path, clar_sandbox_path(), "d0");

	/* make a directory */
	cl_assert(!git_path_isdir(path.ptr));
	cl_git_pass(git_futils_mkdir(path.ptr, 0755, 0));
	cl_assert(git_path_isdir(path.ptr));

	git_buf_joinpath(&path, path.ptr, "subdir");
	cl_assert(!git_path_isdir(path.ptr));
	cl_git_pass(git_futils_mkdir(path.ptr, 0755, 0));
	cl_assert(git_path_isdir(path.ptr));

34
	/* ensure mkdir_r works for a single subdir */
35 36 37 38 39
	git_buf_joinpath(&path, path.ptr, "another");
	cl_assert(!git_path_isdir(path.ptr));
	cl_git_pass(git_futils_mkdir_r(path.ptr, 0755));
	cl_assert(git_path_isdir(path.ptr));

40
	/* ensure mkdir_r works */
41 42 43 44
	git_buf_joinpath(&path, clar_sandbox_path(), "d1/foo/bar/asdf");
	cl_assert(!git_path_isdir(path.ptr));
	cl_git_pass(git_futils_mkdir_r(path.ptr, 0755));
	cl_assert(git_path_isdir(path.ptr));
45 46 47 48 49 50

	/* ensure we don't imply recursive */
	git_buf_joinpath(&path, clar_sandbox_path(), "d2/foo/bar/asdf");
	cl_assert(!git_path_isdir(path.ptr));
	cl_git_fail(git_futils_mkdir(path.ptr, 0755, 0));
	cl_assert(!git_path_isdir(path.ptr));
Carlos Martín Nieto committed
51 52

	git_buf_free(&path);
53 54
}

55 56 57 58 59 60
void test_core_mkdir__basic(void)
{
	cl_set_cleanup(cleanup_basic_dirs, NULL);

	/* make a directory */
	cl_assert(!git_path_isdir("d0"));
61
	cl_git_pass(git_futils_mkdir("d0", 0755, 0));
62 63 64 65
	cl_assert(git_path_isdir("d0"));

	/* make a path */
	cl_assert(!git_path_isdir("d1"));
66
	cl_git_pass(git_futils_mkdir("d1/d1.1/d1.2", 0755, GIT_MKDIR_PATH));
67 68 69 70 71 72
	cl_assert(git_path_isdir("d1"));
	cl_assert(git_path_isdir("d1/d1.1"));
	cl_assert(git_path_isdir("d1/d1.1/d1.2"));

	/* make a dir exclusively */
	cl_assert(!git_path_isdir("d2"));
73
	cl_git_pass(git_futils_mkdir("d2", 0755, GIT_MKDIR_EXCL));
74 75 76
	cl_assert(git_path_isdir("d2"));

	/* make exclusive failure */
77
	cl_git_fail(git_futils_mkdir("d2", 0755, GIT_MKDIR_EXCL));
78 79 80

	/* make a path exclusively */
	cl_assert(!git_path_isdir("d3"));
81
	cl_git_pass(git_futils_mkdir("d3/d3.1/d3.2", 0755, GIT_MKDIR_PATH | GIT_MKDIR_EXCL));
82 83 84 85
	cl_assert(git_path_isdir("d3"));
	cl_assert(git_path_isdir("d3/d3.1/d3.2"));

	/* make exclusive path failure */
86
	cl_git_fail(git_futils_mkdir("d3/d3.1/d3.2", 0755, GIT_MKDIR_PATH | GIT_MKDIR_EXCL));
87 88 89 90
	/* ??? Should EXCL only apply to the last item in the path? */

	/* path with trailing slash? */
	cl_assert(!git_path_isdir("d4"));
91
	cl_git_pass(git_futils_mkdir("d4/d4.1/", 0755, GIT_MKDIR_PATH));
92 93 94 95 96 97
	cl_assert(git_path_isdir("d4/d4.1"));
}

static void cleanup_basedir(void *ref)
{
	GIT_UNUSED(ref);
98
	git_futils_rmdir_r("base", NULL, GIT_RMDIR_EMPTY_HIERARCHY);
99 100 101 102 103 104 105 106
}

void test_core_mkdir__with_base(void)
{
#define BASEDIR "base/dir/here"

	cl_set_cleanup(cleanup_basedir, NULL);

107
	cl_git_pass(git_futils_mkdir(BASEDIR, 0755, GIT_MKDIR_PATH));
108

109
	cl_git_pass(git_futils_mkdir_relative("a", BASEDIR, 0755, 0, NULL));
110 111
	cl_assert(git_path_isdir(BASEDIR "/a"));

112
	cl_git_pass(git_futils_mkdir_relative("b/b1/b2", BASEDIR, 0755, GIT_MKDIR_PATH, NULL));
113 114 115
	cl_assert(git_path_isdir(BASEDIR "/b/b1/b2"));

	/* exclusive with existing base */
116
	cl_git_pass(git_futils_mkdir_relative("c/c1/c2", BASEDIR, 0755, GIT_MKDIR_PATH | GIT_MKDIR_EXCL, NULL));
117 118

	/* fail: exclusive with duplicated suffix */
119
	cl_git_fail(git_futils_mkdir_relative("c/c1/c3", BASEDIR, 0755, GIT_MKDIR_PATH | GIT_MKDIR_EXCL, NULL));
120 121

	/* fail: exclusive with any duplicated component */
122
	cl_git_fail(git_futils_mkdir_relative("c/cz/cz", BASEDIR, 0755, GIT_MKDIR_PATH | GIT_MKDIR_EXCL, NULL));
123 124

	/* success: exclusive without path */
125
	cl_git_pass(git_futils_mkdir_relative("c/c1/c3", BASEDIR, 0755, GIT_MKDIR_EXCL, NULL));
126 127

	/* path with shorter base and existing dirs */
128
	cl_git_pass(git_futils_mkdir_relative("dir/here/d/", "base", 0755, GIT_MKDIR_PATH, NULL));
129 130 131
	cl_assert(git_path_isdir("base/dir/here/d"));

	/* fail: path with shorter base and existing dirs */
132
	cl_git_fail(git_futils_mkdir_relative("dir/here/e/", "base", 0755, GIT_MKDIR_PATH | GIT_MKDIR_EXCL, NULL));
133 134

	/* fail: base with missing components */
135
	cl_git_fail(git_futils_mkdir_relative("f/", "base/missing", 0755, GIT_MKDIR_PATH, NULL));
136 137

	/* success: shift missing component to path */
138
	cl_git_pass(git_futils_mkdir_relative("missing/f/", "base/", 0755, GIT_MKDIR_PATH, NULL));
139 140 141 142 143
}

static void cleanup_chmod_root(void *ref)
{
	mode_t *mode = ref;
144

145
	if (mode != NULL) {
146
		(void)p_umask(*mode);
147 148
		git__free(mode);
	}
149

150
	git_futils_rmdir_r("r", NULL, GIT_RMDIR_EMPTY_HIERARCHY);
151 152
}

153 154 155 156
#define check_mode(X,A) check_mode_at_line((X), (A), __FILE__, __LINE__)

static void check_mode_at_line(
	mode_t expected, mode_t actual, const char *file, int line)
157
{
158 159 160 161 162 163 164 165 166
	/* FAT filesystems don't support exec bit, nor group/world bits */
	if (!cl_is_chmod_supported()) {
		expected &= 0600;
		actual &= 0600;
	}

	clar__assert_equal(
		file, line, "expected_mode != actual_mode", 1,
		"%07o", (int)expected, (int)(actual & 0777));
167 168
}

169 170 171
void test_core_mkdir__chmods(void)
{
	struct stat st;
172 173
	mode_t *old = git__malloc(sizeof(mode_t));
	*old = p_umask(022);
174

175
	cl_set_cleanup(cleanup_chmod_root, old);
176

177
	cl_git_pass(git_futils_mkdir("r", 0777, 0));
178

179
	cl_git_pass(git_futils_mkdir_relative("mode/is/important", "r", 0777, GIT_MKDIR_PATH, NULL));
180 181

	cl_git_pass(git_path_lstat("r/mode", &st));
182
	check_mode(0755, st.st_mode);
183
	cl_git_pass(git_path_lstat("r/mode/is", &st));
184
	check_mode(0755, st.st_mode);
185
	cl_git_pass(git_path_lstat("r/mode/is/important", &st));
186
	check_mode(0755, st.st_mode);
187

188
	cl_git_pass(git_futils_mkdir_relative("mode2/is2/important2", "r", 0777, GIT_MKDIR_PATH | GIT_MKDIR_CHMOD, NULL));
189 190

	cl_git_pass(git_path_lstat("r/mode2", &st));
191
	check_mode(0755, st.st_mode);
192
	cl_git_pass(git_path_lstat("r/mode2/is2", &st));
193
	check_mode(0755, st.st_mode);
194
	cl_git_pass(git_path_lstat("r/mode2/is2/important2", &st));
195
	check_mode(0777, st.st_mode);
196

197
	cl_git_pass(git_futils_mkdir_relative("mode3/is3/important3", "r", 0777, GIT_MKDIR_PATH | GIT_MKDIR_CHMOD_PATH, NULL));
198 199

	cl_git_pass(git_path_lstat("r/mode3", &st));
200
	check_mode(0777, st.st_mode);
201
	cl_git_pass(git_path_lstat("r/mode3/is3", &st));
202
	check_mode(0777, st.st_mode);
203
	cl_git_pass(git_path_lstat("r/mode3/is3/important3", &st));
204
	check_mode(0777, st.st_mode);
205 206 207

	/* test that we chmod existing dir */

208
	cl_git_pass(git_futils_mkdir_relative("mode/is/important", "r", 0777, GIT_MKDIR_PATH | GIT_MKDIR_CHMOD, NULL));
209 210

	cl_git_pass(git_path_lstat("r/mode", &st));
211
	check_mode(0755, st.st_mode);
212
	cl_git_pass(git_path_lstat("r/mode/is", &st));
213
	check_mode(0755, st.st_mode);
214
	cl_git_pass(git_path_lstat("r/mode/is/important", &st));
215
	check_mode(0777, st.st_mode);
216 217 218

	/* test that we chmod even existing dirs if CHMOD_PATH is set */

219
	cl_git_pass(git_futils_mkdir_relative("mode2/is2/important2.1", "r", 0777, GIT_MKDIR_PATH | GIT_MKDIR_CHMOD_PATH, NULL));
220 221

	cl_git_pass(git_path_lstat("r/mode2", &st));
222
	check_mode(0777, st.st_mode);
223
	cl_git_pass(git_path_lstat("r/mode2/is2", &st));
224
	check_mode(0777, st.st_mode);
225
	cl_git_pass(git_path_lstat("r/mode2/is2/important2.1", &st));
226
	check_mode(0777, st.st_mode);
227
}
228

229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262
void test_core_mkdir__keeps_parent_symlinks(void)
{
#ifndef GIT_WIN32
	git_buf path = GIT_BUF_INIT;

	cl_set_cleanup(cleanup_basic_dirs, NULL);

	/* make a directory */
	cl_assert(!git_path_isdir("d0"));
	cl_git_pass(git_futils_mkdir("d0", 0755, 0));
	cl_assert(git_path_isdir("d0"));

	cl_must_pass(symlink("d0", "d1"));
	cl_assert(git_path_islink("d1"));

	cl_git_pass(git_futils_mkdir("d1/foo/bar", 0755, GIT_MKDIR_PATH|GIT_MKDIR_REMOVE_SYMLINKS));
	cl_assert(git_path_islink("d1"));
	cl_assert(git_path_isdir("d1/foo/bar"));
	cl_assert(git_path_isdir("d0/foo/bar"));

	cl_must_pass(symlink("d0", "d2"));
	cl_assert(git_path_islink("d2"));

	git_buf_joinpath(&path, clar_sandbox_path(), "d2/other/dir");

	cl_git_pass(git_futils_mkdir(path.ptr, 0755, GIT_MKDIR_PATH|GIT_MKDIR_REMOVE_SYMLINKS));
	cl_assert(git_path_islink("d2"));
	cl_assert(git_path_isdir("d2/other/dir"));
	cl_assert(git_path_isdir("d0/other/dir"));

	git_buf_free(&path);
#endif
}

263 264 265 266 267 268 269 270 271 272 273 274 275
void test_core_mkdir__mkdir_path_inside_unwriteable_parent(void)
{
	struct stat st;
	mode_t *old;

	/* FAT filesystems don't support exec bit, nor group/world bits */
	if (!cl_is_chmod_supported())
		return;

	cl_assert((old = git__malloc(sizeof(mode_t))) != NULL);
	*old = p_umask(022);
	cl_set_cleanup(cleanup_chmod_root, old);

276 277
	cl_git_pass(git_futils_mkdir("r", 0777, 0));
	cl_git_pass(git_futils_mkdir_relative("mode/is/important", "r", 0777, GIT_MKDIR_PATH, NULL));
278 279 280 281 282 283 284 285
	cl_git_pass(git_path_lstat("r/mode", &st));
	check_mode(0755, st.st_mode);

	cl_must_pass(p_chmod("r/mode", 0111));
	cl_git_pass(git_path_lstat("r/mode", &st));
	check_mode(0111, st.st_mode);

	cl_git_pass(
286
		git_futils_mkdir_relative("mode/is/okay/inside", "r", 0777, GIT_MKDIR_PATH, NULL));
287 288 289 290 291
	cl_git_pass(git_path_lstat("r/mode/is/okay/inside", &st));
	check_mode(0755, st.st_mode);

	cl_must_pass(p_chmod("r/mode", 0777));
}