[libgit2.git] / tests / clar / fs.h

#ifdef _WIN32

#define RM_RETRY_COUNT	5
#define RM_RETRY_DELAY	10

#ifdef __MINGW32__

/* These security-enhanced functions are not available
 * in MinGW, so just use the vanilla ones */
#define wcscpy_s(a, b, c) wcscpy((a), (c))
#define wcscat_s(a, b, c) wcscat((a), (c))

#endif /* __MINGW32__ */

static int
fs__dotordotdot(WCHAR *_tocheck)
{
	return _tocheck[0] == '.' &&
		(_tocheck[1] == '\0' ||
		 (_tocheck[1] == '.' && _tocheck[2] == '\0'));
}

static int
fs_rmdir_rmdir(WCHAR *_wpath)
{
	unsigned retries = 1;

	while (!RemoveDirectoryW(_wpath)) {
		/* Only retry when we have retries remaining, and the
		 * error was ERROR_DIR_NOT_EMPTY. */
		if (retries++ > RM_RETRY_COUNT ||
			ERROR_DIR_NOT_EMPTY != GetLastError())
			return -1;

		/* Give whatever has a handle to a child item some time
		 * to release it before trying again */
		Sleep(RM_RETRY_DELAY * retries * retries);
	}

	return 0;
}

static void
fs_rmdir_helper(WCHAR *_wsource)
{
	WCHAR buffer[MAX_PATH];
	HANDLE find_handle;
	WIN32_FIND_DATAW find_data;
	size_t buffer_prefix_len;

	/* Set up the buffer and capture the length */
	wcscpy_s(buffer, MAX_PATH, _wsource);
	wcscat_s(buffer, MAX_PATH, L"\\");
	buffer_prefix_len = wcslen(buffer);

	/* FindFirstFile needs a wildcard to match multiple items */
	wcscat_s(buffer, MAX_PATH, L"*");
	find_handle = FindFirstFileW(buffer, &find_data);
	cl_assert(INVALID_HANDLE_VALUE != find_handle);

	do {
		/* FindFirstFile/FindNextFile gives back . and ..
		 * entries at the beginning */
		if (fs__dotordotdot(find_data.cFileName))
			continue;

		wcscpy_s(buffer + buffer_prefix_len, MAX_PATH - buffer_prefix_len, find_data.cFileName);

		if (FILE_ATTRIBUTE_DIRECTORY & find_data.dwFileAttributes)
			fs_rmdir_helper(buffer);
		else {
			/* If set, the +R bit must be cleared before deleting */
			if (FILE_ATTRIBUTE_READONLY & find_data.dwFileAttributes)
				cl_assert(SetFileAttributesW(buffer, find_data.dwFileAttributes & ~FILE_ATTRIBUTE_READONLY));

			cl_assert(DeleteFileW(buffer));
		}
	}
	while (FindNextFileW(find_handle, &find_data));

	/* Ensure that we successfully completed the enumeration */
	cl_assert(ERROR_NO_MORE_FILES == GetLastError());

	/* Close the find handle */
	FindClose(find_handle);

	/* Now that the directory is empty, remove it */
	cl_assert(0 == fs_rmdir_rmdir(_wsource));
}

static int
fs_rm_wait(WCHAR *_wpath)
{
	unsigned retries = 1;
	DWORD last_error;

	do {
		if (INVALID_FILE_ATTRIBUTES == GetFileAttributesW(_wpath))
			last_error = GetLastError();
		else
			last_error = ERROR_SUCCESS;

		/* Is the item gone? */
		if (ERROR_FILE_NOT_FOUND == last_error ||
			ERROR_PATH_NOT_FOUND == last_error)
			return 0;

		Sleep(RM_RETRY_DELAY * retries * retries);	
	}
	while (retries++ <= RM_RETRY_COUNT);

	return -1;
}

static void
fs_rm(const char *_source)
{
	WCHAR wsource[MAX_PATH];
	DWORD attrs;

	/* The input path is UTF-8. Convert it to wide characters
	 * for use with the Windows API */
	cl_assert(MultiByteToWideChar(CP_UTF8,
				MB_ERR_INVALID_CHARS,
				_source,
				-1, /* Indicates NULL termination */
				wsource,
				MAX_PATH));

	/* Does the item exist? If not, we have no work to do */
	attrs = GetFileAttributesW(wsource);

	if (INVALID_FILE_ATTRIBUTES == attrs)
		return;

	if (FILE_ATTRIBUTE_DIRECTORY & attrs)
		fs_rmdir_helper(wsource);
	else {
		/* The item is a file. Strip the +R bit */
		if (FILE_ATTRIBUTE_READONLY & attrs)
			cl_assert(SetFileAttributesW(wsource, attrs & ~FILE_ATTRIBUTE_READONLY));

		cl_assert(DeleteFileW(wsource));
	}

	/* Wait for the DeleteFile or RemoveDirectory call to complete */
	cl_assert(0 == fs_rm_wait(wsource));
}

static void
fs_copydir_helper(WCHAR *_wsource, WCHAR *_wdest)
{
	WCHAR buf_source[MAX_PATH], buf_dest[MAX_PATH];
	HANDLE find_handle;
	WIN32_FIND_DATAW find_data;
	size_t buf_source_prefix_len, buf_dest_prefix_len;

	wcscpy_s(buf_source, MAX_PATH, _wsource);
	wcscat_s(buf_source, MAX_PATH, L"\\");
	buf_source_prefix_len = wcslen(buf_source);

	wcscpy_s(buf_dest, MAX_PATH, _wdest);
	wcscat_s(buf_dest, MAX_PATH, L"\\");
	buf_dest_prefix_len = wcslen(buf_dest);

	/* Get an enumerator for the items in the source. */
	wcscat_s(buf_source, MAX_PATH, L"*");
	find_handle = FindFirstFileW(buf_source, &find_data);
	cl_assert(INVALID_HANDLE_VALUE != find_handle);

	/* Create the target directory. */
	cl_assert(CreateDirectoryW(_wdest, NULL));

	do {
		/* FindFirstFile/FindNextFile gives back . and ..
		 * entries at the beginning */
		if (fs__dotordotdot(find_data.cFileName))
			continue;

		wcscpy_s(buf_source + buf_source_prefix_len, MAX_PATH - buf_source_prefix_len, find_data.cFileName);
		wcscpy_s(buf_dest + buf_dest_prefix_len, MAX_PATH - buf_dest_prefix_len, find_data.cFileName);

		if (FILE_ATTRIBUTE_DIRECTORY & find_data.dwFileAttributes)
			fs_copydir_helper(buf_source, buf_dest);
		else
			cl_assert(CopyFileW(buf_source, buf_dest, TRUE));
	}
	while (FindNextFileW(find_handle, &find_data));

	/* Ensure that we successfully completed the enumeration */
	cl_assert(ERROR_NO_MORE_FILES == GetLastError());

	/* Close the find handle */
	FindClose(find_handle);
}

static void
fs_copy(const char *_source, const char *_dest)
{
	WCHAR wsource[MAX_PATH], wdest[MAX_PATH];
	DWORD source_attrs, dest_attrs;
	HANDLE find_handle;
	WIN32_FIND_DATAW find_data;

	/* The input paths are UTF-8. Convert them to wide characters
	 * for use with the Windows API. */
	cl_assert(MultiByteToWideChar(CP_UTF8,
				MB_ERR_INVALID_CHARS,
				_source,
				-1,
				wsource,
				MAX_PATH));

	cl_assert(MultiByteToWideChar(CP_UTF8,
				MB_ERR_INVALID_CHARS,
				_dest,
				-1,
				wdest,
				MAX_PATH));

	/* Check the source for existence */
	source_attrs = GetFileAttributesW(wsource);
	cl_assert(INVALID_FILE_ATTRIBUTES != source_attrs);

	/* Check the target for existence */
	dest_attrs = GetFileAttributesW(wdest);

	if (INVALID_FILE_ATTRIBUTES != dest_attrs) {
		/* Target exists; append last path part of source to target.
		 * Use FindFirstFile to parse the path */
		find_handle = FindFirstFileW(wsource, &find_data);
		cl_assert(INVALID_HANDLE_VALUE != find_handle);
		wcscat_s(wdest, MAX_PATH, L"\\");
		wcscat_s(wdest, MAX_PATH, find_data.cFileName);
		FindClose(find_handle);

		/* Check the new target for existence */
		cl_assert(INVALID_FILE_ATTRIBUTES == GetFileAttributesW(wdest));
	}

	if (FILE_ATTRIBUTE_DIRECTORY & source_attrs)
		fs_copydir_helper(wsource, wdest);
	else
		cl_assert(CopyFileW(wsource, wdest, TRUE));
}

void
cl_fs_cleanup(void)
{
	fs_rm(fixture_path(_clar_path, "*"));
}

#else

#include <errno.h>
#include <string.h>

static int
shell_out(char * const argv[])
{
	int status, piderr;
	pid_t pid;

	pid = fork();

	if (pid < 0) {
		fprintf(stderr,
			"System error: `fork()` call failed (%d) - %s\n",
			errno, strerror(errno));
		exit(-1);
	}

	if (pid == 0) {
		execv(argv[0], argv);
	}

	do {
		piderr = waitpid(pid, &status, WUNTRACED);
	} while (piderr < 0 && (errno == EAGAIN || errno == EINTR));

	return WEXITSTATUS(status);
}

static void
fs_copy(const char *_source, const char *dest)
{
	char *argv[5];
	char *source;
	size_t source_len;

	source = strdup(_source);
	source_len = strlen(source);

	if (source[source_len - 1] == '/')
		source[source_len - 1] = 0;

	argv[0] = "/bin/cp";
	argv[1] = "-R";
	argv[2] = source;
	argv[3] = (char *)dest;
	argv[4] = NULL;

	cl_must_pass_(
		shell_out(argv),
		"Failed to copy test fixtures to sandbox"
	);

	free(source);
}

static void
fs_rm(const char *source)
{
	char *argv[4];

	argv[0] = "/bin/rm";
	argv[1] = "-Rf";
	argv[2] = (char *)source;
	argv[3] = NULL;

	cl_must_pass_(
		shell_out(argv),
		"Failed to cleanup the sandbox"
	);
}

void
cl_fs_cleanup(void)
{
	clar_unsandbox();
	clar_sandbox();
}
#endif
Commit	Line	Data
2e6f06a8 VM	1	#ifdef _WIN32
	2
	3	#define RM_RETRY_COUNT 5
	4	#define RM_RETRY_DELAY 10
	5
	6	#ifdef __MINGW32__
	7
	8	/* These security-enhanced functions are not available
	9	* in MinGW, so just use the vanilla ones */
	10	#define wcscpy_s(a, b, c) wcscpy((a), (c))
	11	#define wcscat_s(a, b, c) wcscat((a), (c))
	12
	13	#endif /* __MINGW32__ */
	14
7be88b4c	15	static int
2e6f06a8 VM	16	fs__dotordotdot(WCHAR *_tocheck)
	17	{
	18	return _tocheck[0] == '.' &&
	19	(_tocheck[1] == '\0' \|\|
	20	(_tocheck[1] == '.' && _tocheck[2] == '\0'));
	21	}
	22
	23	static int
	24	fs_rmdir_rmdir(WCHAR *_wpath)
	25	{
	26	unsigned retries = 1;
	27
	28	while (!RemoveDirectoryW(_wpath)) {
	29	/* Only retry when we have retries remaining, and the
	30	* error was ERROR_DIR_NOT_EMPTY. */
	31	if (retries++ > RM_RETRY_COUNT \|\|
	32	ERROR_DIR_NOT_EMPTY != GetLastError())
	33	return -1;
	34
	35	/* Give whatever has a handle to a child item some time
	36	* to release it before trying again */
	37	Sleep(RM_RETRY_DELAY * retries * retries);
	38	}
	39
	40	return 0;
	41	}
	42
	43	static void
	44	fs_rmdir_helper(WCHAR *_wsource)
	45	{
	46	WCHAR buffer[MAX_PATH];
	47	HANDLE find_handle;
	48	WIN32_FIND_DATAW find_data;
f3738eba	49	size_t buffer_prefix_len;
2e6f06a8 VM	50
	51	/* Set up the buffer and capture the length */
	52	wcscpy_s(buffer, MAX_PATH, _wsource);
	53	wcscat_s(buffer, MAX_PATH, L"\\");
	54	buffer_prefix_len = wcslen(buffer);
	55
	56	/* FindFirstFile needs a wildcard to match multiple items */
	57	wcscat_s(buffer, MAX_PATH, L"*");
	58	find_handle = FindFirstFileW(buffer, &find_data);
	59	cl_assert(INVALID_HANDLE_VALUE != find_handle);
	60
	61	do {
	62	/* FindFirstFile/FindNextFile gives back . and ..
	63	* entries at the beginning */
	64	if (fs__dotordotdot(find_data.cFileName))
	65	continue;
	66
	67	wcscpy_s(buffer + buffer_prefix_len, MAX_PATH - buffer_prefix_len, find_data.cFileName);
	68
	69	if (FILE_ATTRIBUTE_DIRECTORY & find_data.dwFileAttributes)
	70	fs_rmdir_helper(buffer);
	71	else {
	72	/* If set, the +R bit must be cleared before deleting */
	73	if (FILE_ATTRIBUTE_READONLY & find_data.dwFileAttributes)
	74	cl_assert(SetFileAttributesW(buffer, find_data.dwFileAttributes & ~FILE_ATTRIBUTE_READONLY));
	75
	76	cl_assert(DeleteFileW(buffer));
	77	}
	78	}
	79	while (FindNextFileW(find_handle, &find_data));
	80
	81	/* Ensure that we successfully completed the enumeration */
	82	cl_assert(ERROR_NO_MORE_FILES == GetLastError());
	83
	84	/* Close the find handle */
	85	FindClose(find_handle);
	86
	87	/* Now that the directory is empty, remove it */
	88	cl_assert(0 == fs_rmdir_rmdir(_wsource));
	89	}
	90
	91	static int
	92	fs_rm_wait(WCHAR *_wpath)
	93	{
	94	unsigned retries = 1;
	95	DWORD last_error;
	96
	97	do {
	98	if (INVALID_FILE_ATTRIBUTES == GetFileAttributesW(_wpath))
	99	last_error = GetLastError();
	100	else
	101	last_error = ERROR_SUCCESS;
	102
	103	/* Is the item gone? */
	104	if (ERROR_FILE_NOT_FOUND == last_error \|\|
	105	ERROR_PATH_NOT_FOUND == last_error)
	106	return 0;
	107
	108	Sleep(RM_RETRY_DELAY * retries * retries);
	109	}
	110	while (retries++ <= RM_RETRY_COUNT);
	111
	112	return -1;
	113	}
114
115	static void
116	fs_rm(const char *_source)
117	{
118	WCHAR wsource[MAX_PATH];
119	DWORD attrs;
120
121	/* The input path is UTF-8. Convert it to wide characters
122	* for use with the Windows API */
123	cl_assert(MultiByteToWideChar(CP_UTF8,
124	MB_ERR_INVALID_CHARS,
125	_source,
126	-1, /* Indicates NULL termination */
127	wsource,
128	MAX_PATH));
129
130	/* Does the item exist? If not, we have no work to do */
131	attrs = GetFileAttributesW(wsource);
132
133	if (INVALID_FILE_ATTRIBUTES == attrs)
134	return;
135
136	if (FILE_ATTRIBUTE_DIRECTORY & attrs)
137	fs_rmdir_helper(wsource);
138	else {
139	/* The item is a file. Strip the +R bit */
140	if (FILE_ATTRIBUTE_READONLY & attrs)
141	cl_assert(SetFileAttributesW(wsource, attrs & ~FILE_ATTRIBUTE_READONLY));
142
143	cl_assert(DeleteFileW(wsource));
144	}
145
146	/* Wait for the DeleteFile or RemoveDirectory call to complete */
147	cl_assert(0 == fs_rm_wait(wsource));
148	}
149
150	static void
151	fs_copydir_helper(WCHAR _wsource, WCHAR _wdest)
152	{
153	WCHAR buf_source[MAX_PATH], buf_dest[MAX_PATH];
154	HANDLE find_handle;
155	WIN32_FIND_DATAW find_data;
f3738eba	156	size_t buf_source_prefix_len, buf_dest_prefix_len;
2e6f06a8 VM	157
	158	wcscpy_s(buf_source, MAX_PATH, _wsource);
	159	wcscat_s(buf_source, MAX_PATH, L"\\");
	160	buf_source_prefix_len = wcslen(buf_source);
	161
	162	wcscpy_s(buf_dest, MAX_PATH, _wdest);
	163	wcscat_s(buf_dest, MAX_PATH, L"\\");
	164	buf_dest_prefix_len = wcslen(buf_dest);
	165
	166	/* Get an enumerator for the items in the source. */
	167	wcscat_s(buf_source, MAX_PATH, L"*");
	168	find_handle = FindFirstFileW(buf_source, &find_data);
	169	cl_assert(INVALID_HANDLE_VALUE != find_handle);
	170
	171	/* Create the target directory. */
	172	cl_assert(CreateDirectoryW(_wdest, NULL));
	173
	174	do {
	175	/* FindFirstFile/FindNextFile gives back . and ..
	176	* entries at the beginning */
	177	if (fs__dotordotdot(find_data.cFileName))
	178	continue;
	179
	180	wcscpy_s(buf_source + buf_source_prefix_len, MAX_PATH - buf_source_prefix_len, find_data.cFileName);
	181	wcscpy_s(buf_dest + buf_dest_prefix_len, MAX_PATH - buf_dest_prefix_len, find_data.cFileName);
	182
	183	if (FILE_ATTRIBUTE_DIRECTORY & find_data.dwFileAttributes)
	184	fs_copydir_helper(buf_source, buf_dest);
	185	else
	186	cl_assert(CopyFileW(buf_source, buf_dest, TRUE));
	187	}
	188	while (FindNextFileW(find_handle, &find_data));
	189
	190	/* Ensure that we successfully completed the enumeration */
	191	cl_assert(ERROR_NO_MORE_FILES == GetLastError());
	192
	193	/* Close the find handle */
	194	FindClose(find_handle);
	195	}
	196
	197	static void
	198	fs_copy(const char _source, const char _dest)
	199	{
	200	WCHAR wsource[MAX_PATH], wdest[MAX_PATH];
	201	DWORD source_attrs, dest_attrs;
	202	HANDLE find_handle;
	203	WIN32_FIND_DATAW find_data;
7be88b4c	204
2e6f06a8 VM	205	/* The input paths are UTF-8. Convert them to wide characters
	206	* for use with the Windows API. */
	207	cl_assert(MultiByteToWideChar(CP_UTF8,
	208	MB_ERR_INVALID_CHARS,
	209	_source,
	210	-1,
	211	wsource,
	212	MAX_PATH));
	213
	214	cl_assert(MultiByteToWideChar(CP_UTF8,
	215	MB_ERR_INVALID_CHARS,
	216	_dest,
	217	-1,
	218	wdest,
	219	MAX_PATH));
	220
	221	/* Check the source for existence */
	222	source_attrs = GetFileAttributesW(wsource);
	223	cl_assert(INVALID_FILE_ATTRIBUTES != source_attrs);
	224
	225	/* Check the target for existence */
	226	dest_attrs = GetFileAttributesW(wdest);
	227
	228	if (INVALID_FILE_ATTRIBUTES != dest_attrs) {
	229	/* Target exists; append last path part of source to target.
	230	* Use FindFirstFile to parse the path */
	231	find_handle = FindFirstFileW(wsource, &find_data);
	232	cl_assert(INVALID_HANDLE_VALUE != find_handle);
	233	wcscat_s(wdest, MAX_PATH, L"\\");
	234	wcscat_s(wdest, MAX_PATH, find_data.cFileName);
	235	FindClose(find_handle);
	236
	237	/* Check the new target for existence */
	238	cl_assert(INVALID_FILE_ATTRIBUTES == GetFileAttributesW(wdest));
	239	}
	240
	241	if (FILE_ATTRIBUTE_DIRECTORY & source_attrs)
	242	fs_copydir_helper(wsource, wdest);
	243	else
	244	cl_assert(CopyFileW(wsource, wdest, TRUE));
	245	}
	246
	247	void
	248	cl_fs_cleanup(void)
	249	{
	250	fs_rm(fixture_path(_clar_path, "*"));
	251	}
	252
	253	#else
7be88b4c RB	254
	255	#include <errno.h>
	256	#include <string.h>
	257
2e6f06a8 VM	258	static int
	259	shell_out(char * const argv[])
	260	{
7be88b4c	261	int status, piderr;
2e6f06a8 VM	262	pid_t pid;
	263
	264	pid = fork();
	265
	266	if (pid < 0) {
	267	fprintf(stderr,
7be88b4c RB	268	"System error: `fork()` call failed (%d) - %s\n",
7be88b4c RB	269	errno, strerror(errno));
2e6f06a8 VM	270	exit(-1);
	271	}
	272
	273	if (pid == 0) {
	274	execv(argv[0], argv);
	275	}
	276
7be88b4c RB	277	do {
	278	piderr = waitpid(pid, &status, WUNTRACED);
	279	} while (piderr < 0 && (errno == EAGAIN \|\| errno == EINTR));
	280
2e6f06a8 VM	281	return WEXITSTATUS(status);
	282	}
	283
	284	static void
	285	fs_copy(const char _source, const char dest)
	286	{
	287	char *argv[5];
	288	char *source;
	289	size_t source_len;
	290
	291	source = strdup(_source);
	292	source_len = strlen(source);
	293
	294	if (source[source_len - 1] == '/')
	295	source[source_len - 1] = 0;
	296
	297	argv[0] = "/bin/cp";
	298	argv[1] = "-R";
	299	argv[2] = source;
	300	argv[3] = (char *)dest;
	301	argv[4] = NULL;
	302
	303	cl_must_pass_(
	304	shell_out(argv),
	305	"Failed to copy test fixtures to sandbox"
	306	);
	307
	308	free(source);
	309	}
	310
	311	static void
	312	fs_rm(const char *source)
	313	{
	314	char *argv[4];
	315
	316	argv[0] = "/bin/rm";
	317	argv[1] = "-Rf";
	318	argv[2] = (char *)source;
	319	argv[3] = NULL;
	320
	321	cl_must_pass_(
	322	shell_out(argv),
	323	"Failed to cleanup the sandbox"
	324	);
	325	}
	326
	327	void
	328	cl_fs_cleanup(void)
	329	{
	330	clar_unsandbox();
	331	clar_sandbox();
	332	}
	333	#endif