Merged main.

1 files changed, 231 insertions, 31 deletions

diff --git a/zencore/filesystem.cpp b/zencore/filesystem.cpp
index 53e6f1f38..f850f1a80 100644
--- a/zencore/filesystem.cpp
+++ b/zencore/filesystem.cpp
@@ -174,7 +174,8 @@ CleanDirectory(const wchar_t* DirPath)
 bool
 CreateDirectories(const std::filesystem::path& Dir)
 {
-	return std::filesystem::create_directories(Dir);
+	std::error_code ErrorCode;
+	return std::filesystem::create_directories(Dir, ErrorCode);
 }
 
 bool
@@ -244,6 +245,7 @@ SupportsBlockRefCounting(std::filesystem::path Path)
 
 	return true;
 #else
+	ZEN_UNUSED(Path);
 	return false;
 #endif	// ZEN_PLATFORM_WINDOWS
 }
@@ -406,16 +408,47 @@ CloneFile(std::filesystem::path FromPath, std::filesystem::path ToPath)
 	const bool AllOk = (TRUE == SetFileInformationByHandle(TargetFile, FileDispositionInfo, &FileDisposition, sizeof FileDisposition));
 
 	return AllOk;
-#else
+#elif ZEN_PLATFORM_LINUX
+#	if 0
+	struct ScopedFd
+	{
+		~ScopedFd() { close(Fd); }
+		int Fd;
+	};
+
+	// The 'from' file
+	int FromFd = open(FromPath.c_str(), O_RDONLY|O_CLOEXEC);
+	if (FromFd < 0)
+	{
+		return false;
+	}
+	ScopedFd $From = { FromFd };
+
+	// The 'to' file
+	int ToFd = open(ToPath.c_str(), O_WRONLY|O_CREAT|O_EXCL|O_CLOEXEC, 0666);
+	if (ToFd < 0)
+	{
+		return false;
+	}
+	ScopedFd $To = { FromFd };
+
+	ioctl(ToFd, FICLONE, FromFd);
+
+	return false;
+#	endif	// 0
+	ZEN_UNUSED(FromPath, ToPath);
 	ZEN_ERROR("CloneFile() is not implemented on this platform");
 	return false;
+#elif ZEN_PLATFORM_MAC
+	/* clonefile() syscall if APFS */
+#	error not implemented
+	return false;
 #endif	// ZEN_PLATFORM_WINDOWS
 }
 
 bool
 CopyFile(std::filesystem::path FromPath, std::filesystem::path ToPath, const CopyFileOptions& Options)
 {
-#if ZEN_PLATFORM_WINDOWS
 	bool Success = false;
 
 	if (Options.EnableClone)
@@ -433,6 +466,7 @@ CopyFile(std::filesystem::path FromPath, std::filesystem::path ToPath, const Cop
 		return false;
 	}
 
+#if ZEN_PLATFORM_WINDOWS
 	BOOL CancelFlag = FALSE;
 	Success			= !!::CopyFileExW(FromPath.c_str(),
 							  ToPath.c_str(),
@@ -440,17 +474,58 @@ CopyFile(std::filesystem::path FromPath, std::filesystem::path ToPath, const Cop
 							  /* lpData */ nullptr,
 							  &CancelFlag,
 							  /* dwCopyFlags */ 0);
+#else
+	using namespace fmt::literals;
 
-	if (!Success)
+	struct ScopedFd
+	{
+		~ScopedFd() { close(Fd); }
+		int Fd;
+	};
+
+	// From file
+	int FromFd = open(FromPath.c_str(), O_RDONLY | O_CLOEXEC);
+	if (FromFd < 0)
 	{
-		throw std::system_error(std::error_code(::GetLastError(), std::system_category()), "file copy failed");
+		ThrowLastError("failed to open file {}"_format(FromPath));
 	}
+	ScopedFd $From = {FromFd};
 
-	return Success;
-#else
-	ZEN_ERROR("CopyFile() is not implemented on this platform");
-	return false;
+	// To file
+	int ToFd = open(ToPath.c_str(), O_WRONLY | O_CREAT | O_EXCL | O_CLOEXEC, 0644);
+	if (ToFd < 0)
+	{
+		ThrowLastError("failed to create file {}"_format(ToPath));
+	}
+	ScopedFd $To = {ToFd};
+
+	// Copy impl
+	static const size_t BufferSize = 64 << 10;
+	void*				Buffer	   = malloc(BufferSize);
+	while (true)
+	{
+		int BytesRead = read(FromFd, Buffer, BufferSize);
+		if (BytesRead <= 0)
+		{
+			Success = (BytesRead == 0);
+			break;
+		}
+
+		if (write(ToFd, Buffer, BytesRead) != BufferSize)
+		{
+			Success = false;
+			break;
+		}
+	}
+	free(Buffer);
 #endif	// ZEN_PLATFORM_WINDOWS
+
+	if (!Success)
+	{
+		ThrowLastError("file copy failed"sv);
+	}
+
+	return true;
 }
 
 void
@@ -474,11 +549,12 @@ WriteFile(std::filesystem::path Path, const IoBuffer* const* Data, size_t Buffer
 	}
 
 #else
-	int Fd = open(Path.c_str(), O_WRONLY);
+	int OpenFlags = O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC;
+	int Fd		  = open(Path.c_str(), OpenFlags, 0666);
 	if (Fd < 0)
 	{
 		zen::CreateDirectories(Path.parent_path());
-		Fd = open(Path.c_str(), O_WRONLY);
+		Fd = open(Path.c_str(), OpenFlags, 0666);
 	}
 
 	if (Fd < 0)
@@ -505,7 +581,7 @@ WriteFile(std::filesystem::path Path, const IoBuffer* const* Data, size_t Buffer
 				ThrowSystemException(hRes, "File write failed for '{}'"_format(Path).c_str());
 			}
 #else
-			if (write(Fd, DataPtr, WriteSize) != WriteSize)
+			if (write(Fd, DataPtr, WriteSize) != int64_t(WriteSize))
 			{
 				ThrowLastError("File write failed for '{}'"_format(Path));
 			}
@@ -569,10 +645,12 @@ ReadFile(std::filesystem::path Path)
 	FileSizeBytes = FileSize.EndOfFile.QuadPart;
 	Handle		  = FromFile.Detach();
 #else
-	int Fd = open(Path.c_str(), O_RDONLY);
+	int Fd = open(Path.c_str(), O_RDONLY | O_CLOEXEC);
 	if (Fd < 0)
 	{
-		return FileContents{.ErrorCode = std::error_code(zen::GetLastError(), std::system_category())};
+		FileContents Ret;
+		Ret.ErrorCode = std::error_code(zen::GetLastError(), std::system_category());
+		return Ret;
 	}
 
 	static_assert(sizeof(decltype(stat::st_size)) == sizeof(uint64_t), "fstat() doesn't support large files");
@@ -616,16 +694,57 @@ ScanFile(std::filesystem::path Path, const uint64_t ChunkSize, std::function<voi
 
 		ProcessFunc(ReadBuffer.data(), dwBytesRead);
 	}
+#else
+	int Fd		  = open(Path.c_str(), O_RDONLY | O_CLOEXEC);
+	if (Fd < 0)
+	{
+		return false;
+	}
+
+	bool Success = true;
+
+	void* Buffer = malloc(ChunkSize);
+	while (true)
+	{
+		int BytesRead = read(Fd, Buffer, ChunkSize);
+		if (BytesRead < 0)
+		{
+			Success = false;
+			break;
+		}
+
+		if (BytesRead == 0)
+		{
+			break;
+		}
+
+		ProcessFunc(Buffer, BytesRead);
+	}
+
+	free(Buffer);
+	close(Fd);
+
+	if (!Success)
+	{
+		ThrowLastError("file scan failed");
+	}
+#endif	// ZEN_PLATFORM_WINDOWS
 
 	return true;
+}
+
+void
+PathToUtf8(const std::filesystem::path& Path, StringBuilderBase& Out)
+{
+#if ZEN_PLATFORM_WINDOWS
+	WideToUtf8(Path.native().c_str(), Out);
 #else
-	ZEN_ERROR("ScanFile() is not implemented on this platform");
-	return false;
-#endif	// ZEN_PLATFORM_WINDOWS
+	Out << Path.c_str();
+#endif
 }
 
 std::string
-ToUtf8(const std::filesystem::path& Path)
+PathToUtf8(const std::filesystem::path& Path)
 {
 #if ZEN_PLATFORM_WINDOWS
 	return WideToUtf8(Path.native().c_str());
@@ -750,7 +869,7 @@ FileSystemTraversal::TraverseFileSystem(const std::filesystem::path& RootDir, Tr
 		ThrowLastError("Failed to open directory for traversal: {}"_format(RootDir.c_str()));
 	}
 
-	for (struct dirent* Entry; Entry = readdir(Dir);)
+	for (struct dirent* Entry; (Entry = readdir(Dir));)
 	{
 		const char* FileName = Entry->d_name;
 
@@ -806,14 +925,15 @@ PathFromHandle(void* NativeHandle)
 
 	return FullPath;
 #elif ZEN_PLATFORM_LINUX
-	char Buffer[256];
-	sprintf(Buffer, "/proc/%d/fd/%d", getpid(), int(uintptr_t(NativeHandle)));
-	ssize_t BytesRead = readlink(Buffer, Buffer, sizeof(Buffer) - 1);
+	char Link[256];
+	char Path[64];
+	sprintf(Path, "/proc/self/fd/%d", int(uintptr_t(NativeHandle)));
+	ssize_t BytesRead = readlink(Path, Link, sizeof(Link) - 1);
 	if (BytesRead <= 0)
 		return std::filesystem::path();
 
-	Buffer[BytesRead] = '\0';
-	return Buffer;
+	Link[BytesRead] = '\0';
+	return Link;
 #else
 #	error Unimplemented platform
 #endif	// ZEN_PLATFORM_WINDOWS
@@ -828,14 +948,13 @@ GetRunningExecutablePath()
 
 	return {std::wstring_view(ExePath, PathLength)};
 #elif ZEN_PLATFORM_LINUX
-	char Buffer[256];
-	sprintf(Buffer, "/proc/%d/exe", getpid());
-	ssize_t BytesRead = readlink(Buffer, Buffer, sizeof(Buffer) - 1);
+	char	Link[256];
+	ssize_t BytesRead = readlink("/proc/self/exe", Link, sizeof(Link) - 1);
 	if (BytesRead < 0)
 		return {};
 
-	Buffer[BytesRead] = '\0';
-	return Buffer;
+	Link[BytesRead] = '\0';
+	return Link;
 #else
 #	error Unimplemented platform
 #endif	// ZEN_PLATFORM_WINDOWS
@@ -859,7 +978,7 @@ TEST_CASE("filesystem")
 
 	// GetExePath -- this is not a great test as it's so dependent on where the this code gets linked in
 	path	   BinPath	   = GetRunningExecutablePath();
-	const bool ExpectedExe = ToUtf8(BinPath.stem().native()).ends_with("-test"sv) || BinPath.stem() == "zenserver";
+	const bool ExpectedExe = PathToUtf8(BinPath.stem().native()).ends_with("-test"sv) || BinPath.stem() == "zenserver";
 	CHECK(ExpectedExe);
 	CHECK(is_regular_file(BinPath));
 
@@ -869,7 +988,7 @@ TEST_CASE("filesystem")
 	Handle = CreateFileW(BinPath.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, 0, nullptr);
 	CHECK(Handle != INVALID_HANDLE_VALUE);
 #	else
-	int Fd = open(BinPath.c_str(), O_RDONLY);
+	int Fd = open(BinPath.c_str(), O_RDONLY | O_CLOEXEC);
 	CHECK(Fd >= 0);
 	Handle = (void*)uintptr_t(Fd);
 #	endif
@@ -900,6 +1019,87 @@ TEST_CASE("filesystem")
 
 	FileSystemTraversal().TraverseFileSystem(BinPath.parent_path().parent_path(), Visitor);
 	CHECK(Visitor.bFoundExpected);
+
+	// Scan/read file
+	FileContents		 BinRead = ReadFile(BinPath);
+	std::vector<uint8_t> BinScan;
+	ScanFile(BinPath, 16 << 10, [&](const void* Data, size_t Size) {
+		const auto* Ptr = (uint8_t*)Data;
+		BinScan.insert(BinScan.end(), Ptr, Ptr + Size);
+	});
+	CHECK_EQ(BinRead.Data.size(), 1);
+	CHECK_EQ(BinScan.size(), BinRead.Data[0].GetSize());
+}
+
+TEST_CASE("WriteFile")
+{
+	std::filesystem::path TempFile = GetRunningExecutablePath().parent_path();
+	TempFile /= "write_file_test";
+
+	uint64_t Magics[] = {
+		0x0'a9e'a9e'a9e'a9e'a9e,
+		0x0'493'493'493'493'493,
+	};
+
+	struct
+	{
+		const void* Data;
+		size_t		Size;
+	} MagicTests[] = {
+		{
+			Magics,
+			sizeof(Magics),
+		},
+		{
+			Magics + 1,
+			sizeof(Magics[0]),
+		},
+	};
+	for (auto& MagicTest : MagicTests)
+	{
+		WriteFile(TempFile, IoBuffer(IoBuffer::Wrap, MagicTest.Data, MagicTest.Size));
+
+		FileContents MagicsReadback = ReadFile(TempFile);
+		CHECK_EQ(MagicsReadback.Data.size(), 1);
+		CHECK_EQ(MagicsReadback.Data[0].GetSize(), MagicTest.Size);
+		CHECK_EQ(memcmp(MagicTest.Data, MagicsReadback.Data[0].Data(), MagicTest.Size), 0);
+	}
+
+	std::filesystem::remove(TempFile);
+}
+
+TEST_CASE("PathBuilder")
+{
+#	if ZEN_PLATFORM_WINDOWS
+	const char* foo_bar = "/foo\\bar";
+#	else
+	const char* foo_bar = "/foo/bar";
+#	endif
+
+	ExtendablePathBuilder<32> Path;
+	for (const char* Prefix : {"/foo", "/foo/"})
+	{
+		Path.Reset();
+		Path.Append(Prefix);
+		Path /= "bar";
+		CHECK(Path.ToPath() == foo_bar);
+	}
+
+	using fspath = std::filesystem::path;
+
+	Path.Reset();
+	Path.Append(fspath("/foo/"));
+	Path /= (fspath("bar"));
+	CHECK(Path.ToPath() == foo_bar);
+
+#	if ZEN_PLATFORM_WINDOWS
+	Path.Reset();
+	Path.Append(fspath(L"/\u0119oo/"));
+	Path /= L"bar";
+	printf("%ls\n", Path.ToPath().c_str());
+	CHECK(Path.ToView() == L"/\u0119oo/bar");
+	CHECK(Path.ToPath() == L"\\\u0119oo\\bar");
+#	endif
 }
 
 #endif