BlockStorage/repertory
1
0
Fork 0
Code Issues 8 Pull Requests Releases 6 Wiki Activity

Compare commits

base: BlockStorage:136f76c5759eecd063db0d08cea452aead648133
Branches Tags
BlockStorage:v2.0.6-release-develop BlockStorage:master BlockStorage:v2.1.0-rc-develop
BlockStorage:v2.0.5-rc BlockStorage:v2.0.4-rc BlockStorage:v2.0.3-rc BlockStorage:v2.0.2-rc BlockStorage:v2.0.1-rc BlockStorage:v2.0.0-rc
...
compare: BlockStorage:04daf393d7e423ecb739cd2ae425ad7f2ecb59a6
Branches Tags
BlockStorage:v2.0.6-release-develop BlockStorage:master BlockStorage:v2.1.0-rc-develop
BlockStorage:v2.0.5-rc BlockStorage:v2.0.4-rc BlockStorage:v2.0.3-rc BlockStorage:v2.0.2-rc BlockStorage:v2.0.1-rc BlockStorage:v2.0.0-rc

3 Commits
136f76c575 ... 04daf393d7

Author SHA1 Message Date
Scott E. Graves
04daf393d7 winfsp unit tests and fixes
Some checks failed
BlockStorage/repertory/pipeline/head There was a failure building this commit
Details
2024-11-09 12:07:00 -06:00
Scott E. Graves
e62477a38e winfsp unit tests and fixes 2024-11-09 12:06:17 -06:00
Scott E. Graves
3338fcf91f winfsp unit tests and fixes 2024-11-09 11:50:27 -06:00
2 changed files with 148 additions and 142 deletions
Expand all files Collapse all files

27
repertory/librepertory/src/drives/winfsp/winfsp_drive.cpp
View File

@ -848,6 +848,10 @@ auto winfsp_drive::Read(PVOID /*file_node*/, PVOID file_desc, PVOID buffer,
api_path = file->get_api_path(); api_path = file->get_api_path();
if (offset >= file->get_file_size()) {
return STATUS_END_OF_FILE;
}
if (length == 0U) { if (length == 0U) {
return handle_error(api_error::success); return handle_error(api_error::success);
} }
@ -859,19 +863,22 @@ auto winfsp_drive::Read(PVOID /*file_node*/, PVOID file_desc, PVOID buffer,
} }
*bytes_transferred = static_cast<ULONG>(data.size()); *bytes_transferred = static_cast<ULONG>(data.size());
if ((length > 0) && (data.size() != length)) {
auto short_read = data.size() != length;
if (not data.empty()) {
::CopyMemory(buffer, data.data(), data.size());
data.clear();
}
auto ret = handle_error(provider_.set_item_meta(
api_path, META_ACCESSED, std::to_string(utils::time::get_time_now())));
if (short_read) {
::SetLastError(ERROR_HANDLE_EOF); ::SetLastError(ERROR_HANDLE_EOF);
} }
if (data.empty()) { return ret;
return handle_error(api_error::success);
}
::CopyMemory(buffer, data.data(), data.size());
data.clear();
return handle_error(provider_.set_item_meta(
api_path, META_ACCESSED, std::to_string(utils::time::get_time_now())));
} }
auto winfsp_drive::ReadDirectory(PVOID /*file_node*/, PVOID file_desc, auto winfsp_drive::ReadDirectory(PVOID /*file_node*/, PVOID file_desc,

263
repertory/repertory_test/src/winfsp_drive_rdrw_test.cpp
View File

@ -290,115 +290,124 @@ static void test_overlapped_file(auto mount_location, auto &&file_path,
EXPECT_TRUE(ret || ERROR_IO_PENDING == ::GetLastError()); EXPECT_TRUE(ret || ERROR_IO_PENDING == ::GetLastError());
EXPECT_TRUE(::GetOverlappedResult(handle, &overlapped, &bytes_written, TRUE)); EXPECT_TRUE(::GetOverlappedResult(handle, &overlapped, &bytes_written, TRUE));
EXPECT_EQ(bytes_per_sector, bytes_written); EXPECT_EQ(bytes_per_sector, bytes_written);
//
// Overlapped.Offset = 2 * BytesPerSector; overlapped.Offset = 2U * bytes_per_sector;
// Success = WriteFile(Handle, Buffer[0], BytesPerSector, &BytesTransferred, ret = ::WriteFile(handle, write_buffer.data(), bytes_per_sector,
// &Overlapped); &bytes_written, &overlapped);
// ASSERT(Success || ERROR_IO_PENDING == GetLastError()); EXPECT_TRUE(ret || ERROR_IO_PENDING == ::GetLastError());
// Success = GetOverlappedResult(Handle, &Overlapped, &BytesTransferred, EXPECT_TRUE(::GetOverlappedResult(handle, &overlapped, &bytes_written, TRUE));
// TRUE); ASSERT(Success); ASSERT(BytesPerSector == BytesTransferred); EXPECT_EQ(bytes_per_sector, bytes_written);
//
// Overlapped.Offset = 0; data_buffer read_buffer{};
// memset(AllocBuffer[1], 0, AllocBufferSize); read_buffer.resize(buffer_size);
// Success = ReadFile(Handle, Buffer[1], BytesPerSector, &BytesTransferred, overlapped.Offset = 0U;
// &Overlapped); DWORD bytes_read{};
// ASSERT(Success || ERROR_IO_PENDING == GetLastError()); ret = ::ReadFile(handle, read_buffer.data(), bytes_per_sector, &bytes_read,
// Success = GetOverlappedResult(Handle, &Overlapped, &BytesTransferred, &overlapped);
// TRUE); ASSERT(Success); ASSERT(BytesPerSector == BytesTransferred);
// ASSERT(0 == memcmp(Buffer[0], Buffer[1], BytesTransferred)); EXPECT_TRUE(ret || ERROR_IO_PENDING == ::GetLastError());
// EXPECT_TRUE(::GetOverlappedResult(handle, &overlapped, &bytes_read, TRUE));
// Overlapped.Offset = 2 * BytesPerSector;
// memset(AllocBuffer[1], 0, AllocBufferSize); EXPECT_EQ(bytes_per_sector, bytes_read);
// Success = ReadFile(Handle, Buffer[1], BytesPerSector, &BytesTransferred, EXPECT_EQ(0,
// &Overlapped); std::memcmp(write_buffer.data(), read_buffer.data(), bytes_read));
// ASSERT(Success || ERROR_IO_PENDING == GetLastError());
// Success = GetOverlappedResult(Handle, &Overlapped, &BytesTransferred, read_buffer.clear();
// TRUE); ASSERT(Success); ASSERT(BytesPerSector == BytesTransferred); read_buffer.resize(buffer_size);
// ASSERT(0 == memcmp(Buffer[0], Buffer[1], BytesTransferred)); overlapped.Offset = 2U * bytes_per_sector;
// ret = ::ReadFile(handle, read_buffer.data(), bytes_per_sector, &bytes_read,
// Overlapped.Offset = 2 * BytesPerSector; &overlapped);
// memset(AllocBuffer[1], 0, AllocBufferSize); EXPECT_TRUE(ret || ERROR_IO_PENDING == ::GetLastError());
// Success = ReadFile(Handle, Buffer[1], 2 * BytesPerSector, EXPECT_TRUE(::GetOverlappedResult(handle, &overlapped, &bytes_read, TRUE));
// &BytesTransferred, EXPECT_EQ(bytes_per_sector, bytes_read);
// &Overlapped); EXPECT_EQ(0,
// ASSERT(Success || ERROR_IO_PENDING == GetLastError()); std::memcmp(write_buffer.data(), read_buffer.data(), bytes_read));
// Success = GetOverlappedResult(Handle, &Overlapped, &BytesTransferred,
// TRUE); ASSERT(Success); ASSERT(BytesPerSector == BytesTransferred); read_buffer.clear();
// ASSERT(0 == memcmp(Buffer[0], Buffer[1], BytesTransferred)); read_buffer.resize(buffer_size);
// overlapped.Offset = 2U * bytes_per_sector;
// Overlapped.Offset = 3 * BytesPerSector; ret = ::ReadFile(handle, read_buffer.data(), 2U * bytes_per_sector,
// memset(AllocBuffer[1], 0, AllocBufferSize); &bytes_read, &overlapped);
// Success = ReadFile(Handle, Buffer[1], BytesPerSector, &BytesTransferred, EXPECT_TRUE(ret || ERROR_IO_PENDING == ::GetLastError());
// &Overlapped); EXPECT_TRUE(::GetOverlappedResult(handle, &overlapped, &bytes_read, TRUE));
// ASSERT(Success || ERROR_IO_PENDING == GetLastError() || EXPECT_EQ(bytes_per_sector, bytes_read);
// ERROR_HANDLE_EOF == GetLastError()); EXPECT_EQ(0,
// if (ERROR_HANDLE_EOF != GetLastError()) { std::memcmp(write_buffer.data(), read_buffer.data(), bytes_read));
// Success = GetOverlappedResult(Handle, &Overlapped, &BytesTransferred,
// TRUE); ASSERT(!Success && ERROR_HANDLE_EOF == GetLastError()); read_buffer.clear();
// } read_buffer.resize(buffer_size);
// ASSERT(0 == BytesTransferred); overlapped.Offset = 3U * bytes_per_sector;
// ASSERT(0 == memcmp(Buffer[0], Buffer[1], BytesTransferred)); ret = ::ReadFile(handle, read_buffer.data(), bytes_per_sector, &bytes_read,
// &overlapped);
// Overlapped.Offset = 0; EXPECT_TRUE(ret || ERROR_IO_PENDING == ::GetLastError() ||
// Success = WriteFile(Handle, Buffer[0], 2 * SystemInfo.dwPageSize, ERROR_HANDLE_EOF == ::GetLastError());
// &BytesTransferred, &Overlapped); if (ERROR_HANDLE_EOF != ::GetLastError()) {
// ASSERT(Success || ERROR_IO_PENDING == GetLastError()); ret = ::GetOverlappedResult(handle, &overlapped, &bytes_read, TRUE);
// Success = GetOverlappedResult(Handle, &Overlapped, &BytesTransferred, EXPECT_FALSE(ret);
// TRUE); ASSERT(Success); ASSERT(2 * SystemInfo.dwPageSize == EXPECT_EQ(ERROR_HANDLE_EOF, ::GetLastError());
// BytesTransferred); }
// EXPECT_EQ(0U, bytes_read);
// Overlapped.Offset = 0; EXPECT_EQ(0,
// memset(AllocBuffer[1], 0, AllocBufferSize); std::memcmp(write_buffer.data(), read_buffer.data(), bytes_read));
// Success = ReadFile(Handle, Buffer[1], 2 * SystemInfo.dwPageSize,
// &BytesTransferred, &Overlapped); overlapped.Offset = 0U;
// ASSERT(Success || ERROR_IO_PENDING == GetLastError()); ret = ::WriteFile(handle, write_buffer.data(), 2U * sys_info.dwPageSize,
// Success = GetOverlappedResult(Handle, &Overlapped, &BytesTransferred, &bytes_written, &overlapped);
// TRUE); ASSERT(Success); ASSERT(2 * SystemInfo.dwPageSize == EXPECT_TRUE(ret || ERROR_IO_PENDING == ::GetLastError());
// BytesTransferred); ASSERT(0 == memcmp(Buffer[0], Buffer[1], EXPECT_TRUE(::GetOverlappedResult(handle, &overlapped, &bytes_written, TRUE));
// BytesTransferred)); EXPECT_EQ(2U * sys_info.dwPageSize, bytes_written);
//
// Buffer[0] = AllocBuffer[0]; read_buffer.clear();
// Buffer[1] = AllocBuffer[0]; read_buffer.resize(buffer_size);
// overlapped.Offset = 0U;
// Overlapped.Offset = 0; ret = ::ReadFile(handle, read_buffer.data(), 2U * sys_info.dwPageSize,
// Success = WriteFile(Handle, Buffer[0], 2 * SystemInfo.dwPageSize, &bytes_read, &overlapped);
// &BytesTransferred, &Overlapped); EXPECT_TRUE(ret || ERROR_IO_PENDING == ::GetLastError());
// ASSERT(Success || ERROR_IO_PENDING == GetLastError()); EXPECT_TRUE(::GetOverlappedResult(handle, &overlapped, &bytes_read, TRUE));
// Success = GetOverlappedResult(Handle, &Overlapped, &BytesTransferred, EXPECT_EQ(2U * sys_info.dwPageSize, bytes_read);
// TRUE); ASSERT(Success); ASSERT(2 * SystemInfo.dwPageSize == EXPECT_EQ(0,
// BytesTransferred); std::memcmp(write_buffer.data(), read_buffer.data(), bytes_read));
//
// Overlapped.Offset = 0; write_buffer = utils::generate_secure_random<data_buffer>(buffer_size);
// memset(AllocBuffer[1], 0, AllocBufferSize);
// Success = ReadFile(Handle, Buffer[1], 2 * SystemInfo.dwPageSize, overlapped.Offset = 0U;
// &BytesTransferred, &Overlapped); ret = ::WriteFile(handle, write_buffer.data(), 2U * sys_info.dwPageSize,
// ASSERT(Success || ERROR_IO_PENDING == GetLastError()); &bytes_written, &overlapped);
// Success = GetOverlappedResult(Handle, &Overlapped, &BytesTransferred, EXPECT_TRUE(ret || ERROR_IO_PENDING == ::GetLastError());
// TRUE); ASSERT(Success); ASSERT(2 * SystemInfo.dwPageSize == EXPECT_TRUE(::GetOverlappedResult(handle, &overlapped, &bytes_written, TRUE));
// BytesTransferred); ASSERT(0 == memcmp(Buffer[0], Buffer[1], EXPECT_EQ(2U * sys_info.dwPageSize, bytes_written);
// BytesTransferred));
// read_buffer.clear();
// Overlapped.Offset = 0; read_buffer.resize(buffer_size);
// Success = overlapped.Offset = 0U;
// WriteFile(Handle, Buffer[0], 2 * SystemInfo.dwPageSize + ret = ::ReadFile(handle, read_buffer.data(), 2U * sys_info.dwPageSize,
// BytesPerSector, &bytes_read, &overlapped);
// &BytesTransferred, &Overlapped); EXPECT_TRUE(ret || ERROR_IO_PENDING == ::GetLastError());
// ASSERT(Success || ERROR_IO_PENDING == GetLastError()); EXPECT_TRUE(::GetOverlappedResult(handle, &overlapped, &bytes_read, TRUE));
// Success = GetOverlappedResult(Handle, &Overlapped, &BytesTransferred, EXPECT_EQ(2U * sys_info.dwPageSize, bytes_read);
// TRUE); ASSERT(Success); ASSERT(2 * SystemInfo.dwPageSize + BytesPerSector EXPECT_EQ(0,
// == BytesTransferred); std::memcmp(write_buffer.data(), read_buffer.data(), bytes_read));
//
// Overlapped.Offset = 0; overlapped.Offset = 0U;
// memset(AllocBuffer[1], 0, AllocBufferSize); ret = ::WriteFile(handle, write_buffer.data(),
// Success = 2U * sys_info.dwPageSize + bytes_per_sector, &bytes_written,
// ReadFile(Handle, Buffer[1], 2 * SystemInfo.dwPageSize + BytesPerSector, &overlapped);
// &BytesTransferred, &Overlapped); EXPECT_TRUE(ret || ERROR_IO_PENDING == ::GetLastError());
// ASSERT(Success || ERROR_IO_PENDING == GetLastError()); EXPECT_TRUE(::GetOverlappedResult(handle, &overlapped, &bytes_written, TRUE));
// Success = GetOverlappedResult(Handle, &Overlapped, &BytesTransferred, EXPECT_EQ(2U * sys_info.dwPageSize + bytes_per_sector, bytes_written);
// TRUE); ASSERT(Success); ASSERT(2 * SystemInfo.dwPageSize + BytesPerSector
// == BytesTransferred); ASSERT(0 == memcmp(Buffer[0], Buffer[1], read_buffer.clear();
// BytesTransferred)); read_buffer.resize(buffer_size);
// overlapped.Offset = 0U;
ret = ::ReadFile(handle, read_buffer.data(),
2U * sys_info.dwPageSize + bytes_per_sector, &bytes_read,
&overlapped);
EXPECT_TRUE(ret || ERROR_IO_PENDING == ::GetLastError());
EXPECT_TRUE(::GetOverlappedResult(handle, &overlapped, &bytes_read, TRUE));
EXPECT_EQ(2U * sys_info.dwPageSize + bytes_per_sector, bytes_read);
EXPECT_EQ(0,
std::memcmp(write_buffer.data(), read_buffer.data(), bytes_read));
EXPECT_TRUE(::CloseHandle(handle)); EXPECT_TRUE(::CloseHandle(handle));
handle = ::CreateFileA(file_path.c_str(), GENERIC_READ | GENERIC_WRITE, handle = ::CreateFileA(file_path.c_str(), GENERIC_READ | GENERIC_WRITE,
@ -408,32 +417,22 @@ static void test_overlapped_file(auto mount_location, auto &&file_path,
nullptr); nullptr);
ASSERT_NE(INVALID_HANDLE_VALUE, handle); ASSERT_NE(INVALID_HANDLE_VALUE, handle);
// Overlapped.Offset = 0; read_buffer.clear();
// memset(AllocBuffer[1], 0, AllocBufferSize); read_buffer.resize(buffer_size);
// Success = overlapped.Offset = 0U;
// ReadFile(Handle, Buffer[1], 2 * SystemInfo.dwPageSize + BytesPerSector, ret = ::ReadFile(handle, read_buffer.data(),
// &BytesTransferred, &Overlapped); 2U * sys_info.dwPageSize + bytes_per_sector, &bytes_read,
// ASSERT(Success || ERROR_IO_PENDING == GetLastError()); &overlapped);
// Success = GetOverlappedResult(Handle, &Overlapped, &BytesTransferred, EXPECT_TRUE(ret || ERROR_IO_PENDING == ::GetLastError());
// TRUE); ASSERT(Success); ASSERT(2 * SystemInfo.dwPageSize + BytesPerSector EXPECT_TRUE(::GetOverlappedResult(handle, &overlapped, &bytes_read, TRUE));
// == BytesTransferred); ASSERT(0 == memcmp(Buffer[0], Buffer[1], EXPECT_EQ(2U * sys_info.dwPageSize + bytes_per_sector, bytes_read);
// BytesTransferred)); EXPECT_EQ(0,
// std::memcmp(write_buffer.data(), read_buffer.data(), bytes_read));
// Success = CloseHandle(Handle);
// ASSERT(Success);
//
// Handle =
// CreateFileW(FilePath, GENERIC_READ | GENERIC_WRITE,
// FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0,
// 0);
// ASSERT(INVALID_HANDLE_VALUE == Handle);
// ASSERT(ERROR_FILE_NOT_FOUND == GetLastError());
//
// Success = CloseHandle(Overlapped.hEvent);
// ASSERT(Success);
EXPECT_TRUE(::CloseHandle(handle)); EXPECT_TRUE(::CloseHandle(handle));
EXPECT_TRUE(::CloseHandle(overlapped.hEvent));
handle = ::CreateFileA(file_path.c_str(), GENERIC_READ | GENERIC_WRITE, handle = ::CreateFileA(file_path.c_str(), GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr,
OPEN_EXISTING, 0, nullptr); OPEN_EXISTING, 0, nullptr);