alexpete
618 lines
19 KiB
C++
618 lines
19 KiB
C++
/*
|
|
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
|
* its licensors.
|
|
*
|
|
* For complete copyright and license terms please see the LICENSE at the root of this
|
|
* distribution (the "License"). All use of this software is governed by the License,
|
|
* or, if provided, by the license below or the license accompanying this file. Do not
|
|
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
*
|
|
*/
|
|
#include <AzCore/IO/SystemFile.h>
|
|
#include <AzCore/std/parallel/lock.h>
|
|
#include <AzCore/std/functional.h> // for function<> in the find files callback.
|
|
#include <AzCore/StringFunc/StringFunc.h>
|
|
#include <AzFramework/Archive/ArchiveFileIO.h>
|
|
#include <AzFramework/Archive/IArchive.h>
|
|
|
|
#include <cinttypes>
|
|
|
|
namespace AZ::IO
|
|
{
|
|
constexpr size_t ArchiveFileiOMaxBuffersize = 16 * 1024;
|
|
ArchiveFileIO::ArchiveFileIO(IArchive* archive)
|
|
: m_archive(archive)
|
|
{
|
|
}
|
|
|
|
ArchiveFileIO::~ArchiveFileIO()
|
|
{
|
|
// close all files. This makes it mimic the behavior of base FileIO even though it sits on archive.
|
|
decltype(m_trackedFiles) trackedFiles;
|
|
{
|
|
AZStd::lock_guard<AZStd::recursive_mutex> lock(m_operationGuard);
|
|
AZStd::swap(trackedFiles, m_trackedFiles);
|
|
}
|
|
|
|
for (const auto&[trackedFileHandle, trackedFile] : trackedFiles)
|
|
{
|
|
AZ_Warning("File IO", false, "File handle still open while ArchiveFileIO being closed: %s", trackedFile.c_str());
|
|
Close(trackedFileHandle);
|
|
}
|
|
}
|
|
|
|
void ArchiveFileIO::SetArchive(IArchive* archive)
|
|
{
|
|
m_archive = archive;
|
|
}
|
|
|
|
IArchive* ArchiveFileIO::GetArchive() const
|
|
{
|
|
return m_archive;
|
|
}
|
|
|
|
IO::Result ArchiveFileIO::Open(const char* filePath, IO::OpenMode openMode, IO::HandleType& fileHandle)
|
|
{
|
|
if (!m_archive)
|
|
{
|
|
if (GetDirectInstance())
|
|
{
|
|
return GetDirectInstance()->Open(filePath, openMode, fileHandle);
|
|
}
|
|
|
|
return IO::ResultCode::Error;
|
|
}
|
|
|
|
fileHandle = m_archive->FOpen(filePath, IO::GetStringModeFromOpenMode(openMode));
|
|
if (fileHandle == IO::InvalidHandle)
|
|
{
|
|
return IO::ResultCode::Error;
|
|
}
|
|
|
|
//track the open file handles
|
|
char resolvedPath[AZ::IO::MaxPathLength];
|
|
bool pathResolved = ResolvePath(filePath, resolvedPath, AZStd::size(resolvedPath));
|
|
AZStd::string_view trackedPath{ pathResolved ? resolvedPath : AZStd::string_view(filePath) };
|
|
AZStd::lock_guard<AZStd::recursive_mutex> lock(m_operationGuard);
|
|
m_trackedFiles.emplace(fileHandle, trackedPath);
|
|
|
|
return IO::ResultCode::Success;
|
|
}
|
|
|
|
IO::Result ArchiveFileIO::Close(IO::HandleType fileHandle)
|
|
{
|
|
if (!m_archive)
|
|
{
|
|
if (GetDirectInstance())
|
|
{
|
|
return GetDirectInstance()->Close(fileHandle);
|
|
}
|
|
return IO::ResultCode::Error; // we are likely shutting down and archive has already dropped all its handles already.
|
|
}
|
|
|
|
if (m_archive->FClose(fileHandle) == 0)
|
|
{
|
|
AZStd::lock_guard<AZStd::recursive_mutex> lock(m_operationGuard);
|
|
|
|
auto remoteFileIter = m_trackedFiles.find(fileHandle);
|
|
if (remoteFileIter != m_trackedFiles.end())
|
|
{
|
|
m_trackedFiles.erase(remoteFileIter);
|
|
}
|
|
|
|
return IO::ResultCode::Success;
|
|
}
|
|
return IO::ResultCode::Error;
|
|
}
|
|
|
|
IO::Result ArchiveFileIO::Tell(IO::HandleType fileHandle, AZ::u64& offset)
|
|
{
|
|
if (!m_archive)
|
|
{
|
|
if (GetDirectInstance())
|
|
{
|
|
return GetDirectInstance()->Tell(fileHandle, offset);
|
|
}
|
|
return IO::ResultCode::Error;
|
|
}
|
|
|
|
offset = m_archive->FTell(fileHandle);
|
|
return IO::ResultCode::Success;
|
|
}
|
|
|
|
IO::Result ArchiveFileIO::Seek(IO::HandleType fileHandle, AZ::s64 offset, IO::SeekType type)
|
|
{
|
|
if (!m_archive)
|
|
{
|
|
if (GetDirectInstance())
|
|
{
|
|
return GetDirectInstance()->Seek(fileHandle, offset, type);
|
|
}
|
|
return IO::ResultCode::Error;
|
|
}
|
|
|
|
size_t seekResult = m_archive->FSeek(fileHandle, static_cast<uint64_t>(offset), GetFSeekModeFromSeekType(type));
|
|
return seekResult == 0 ? IO::ResultCode::Success : IO::ResultCode::Error;
|
|
}
|
|
|
|
IO::Result ArchiveFileIO::Size(IO::HandleType fileHandle, AZ::u64& size)
|
|
{
|
|
if (!m_archive)
|
|
{
|
|
if (GetDirectInstance())
|
|
{
|
|
return GetDirectInstance()->Size(fileHandle, size);
|
|
}
|
|
return IO::ResultCode::Error;
|
|
}
|
|
|
|
size = m_archive->FGetSize(fileHandle);
|
|
if (size || m_archive->IsInPak(fileHandle))
|
|
{
|
|
return IO::ResultCode::Success;
|
|
}
|
|
|
|
if (GetDirectInstance())
|
|
{
|
|
return GetDirectInstance()->Size(fileHandle, size);
|
|
}
|
|
|
|
return IO::ResultCode::Error;
|
|
}
|
|
|
|
IO::Result ArchiveFileIO::Size(const char* filePath, AZ::u64& size)
|
|
{
|
|
if (!m_archive)
|
|
{
|
|
if (GetDirectInstance())
|
|
{
|
|
return GetDirectInstance()->Size(filePath, size);
|
|
}
|
|
return IO::ResultCode::Error;
|
|
}
|
|
|
|
size = m_archive->FGetSize(filePath, true);
|
|
if (!size)
|
|
{
|
|
return m_archive->IsFileExist(filePath, IArchive::eFileLocation_Any) ? IO::ResultCode::Success : IO::ResultCode::Error;
|
|
}
|
|
|
|
return IO::ResultCode::Success;
|
|
}
|
|
|
|
IO::Result ArchiveFileIO::Read(IO::HandleType fileHandle, void* buffer, AZ::u64 size, bool failOnFewerThanSizeBytesRead, AZ::u64* bytesRead)
|
|
{
|
|
if (!m_archive)
|
|
{
|
|
if (GetDirectInstance())
|
|
{
|
|
return GetDirectInstance()->Read(fileHandle, buffer, size, failOnFewerThanSizeBytesRead, bytesRead);
|
|
}
|
|
|
|
return IO::ResultCode::Error;
|
|
}
|
|
|
|
size_t result = m_archive->FReadRaw(buffer, 1, size, fileHandle);
|
|
if (bytesRead)
|
|
{
|
|
*bytesRead = static_cast<AZ::u64>(result);
|
|
}
|
|
|
|
if (failOnFewerThanSizeBytesRead)
|
|
{
|
|
return result != size ? IO::ResultCode::Error : IO::ResultCode::Success;
|
|
}
|
|
return result == 0 ? IO::ResultCode::Error : IO::ResultCode::Success;
|
|
}
|
|
|
|
IO::Result ArchiveFileIO::Write(IO::HandleType fileHandle, const void* buffer, AZ::u64 size, AZ::u64* bytesWritten)
|
|
{
|
|
if (!m_archive)
|
|
{
|
|
if (GetDirectInstance())
|
|
{
|
|
return GetDirectInstance()->Write(fileHandle, buffer, size, bytesWritten);
|
|
}
|
|
|
|
return IO::ResultCode::Error;
|
|
}
|
|
|
|
size_t result = m_archive->FWrite(buffer, 1, size, fileHandle);
|
|
if (bytesWritten)
|
|
{
|
|
*bytesWritten = static_cast<AZ::u64>(result);
|
|
}
|
|
|
|
return result != size ? IO::ResultCode::Error : IO::ResultCode::Success;
|
|
}
|
|
|
|
IO::Result ArchiveFileIO::Flush(IO::HandleType fileHandle)
|
|
{
|
|
if (!m_archive)
|
|
{
|
|
if (GetDirectInstance())
|
|
{
|
|
return GetDirectInstance()->Flush(fileHandle);
|
|
}
|
|
return IO::ResultCode::Error;
|
|
}
|
|
|
|
return m_archive->FFlush(fileHandle) == 0 ? IO::ResultCode::Success : IO::ResultCode::Error;
|
|
}
|
|
|
|
bool ArchiveFileIO::Eof(IO::HandleType fileHandle)
|
|
{
|
|
if (!m_archive)
|
|
{
|
|
if (GetDirectInstance())
|
|
{
|
|
return GetDirectInstance()->Eof(fileHandle);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
return (m_archive->FEof(fileHandle) != 0);
|
|
}
|
|
|
|
bool ArchiveFileIO::Exists(const char* filePath)
|
|
{
|
|
if (!m_archive)
|
|
{
|
|
if (GetDirectInstance())
|
|
{
|
|
return GetDirectInstance()->Exists(filePath);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
return m_archive->IsFileExist(filePath);
|
|
}
|
|
|
|
AZ::u64 ArchiveFileIO::ModificationTime(const char* filePath)
|
|
{
|
|
IO::HandleType openFile = IO::InvalidHandle;
|
|
if (!Open(filePath, IO::OpenMode::ModeRead | IO::OpenMode::ModeBinary, openFile))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
AZ::u64 result = ModificationTime(openFile);
|
|
|
|
Close(openFile);
|
|
|
|
return result;
|
|
}
|
|
|
|
AZ::u64 ArchiveFileIO::ModificationTime(IO::HandleType fileHandle)
|
|
{
|
|
if (!m_archive)
|
|
{
|
|
if (GetDirectInstance())
|
|
{
|
|
return GetDirectInstance()->ModificationTime(fileHandle);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
return m_archive->GetModificationTime(fileHandle);
|
|
}
|
|
|
|
bool ArchiveFileIO::IsDirectory(const char* filePath)
|
|
{
|
|
if (!m_archive)
|
|
{
|
|
if (GetDirectInstance())
|
|
{
|
|
return GetDirectInstance()->IsDirectory(filePath);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
return m_archive->IsFolder(filePath);
|
|
}
|
|
|
|
IO::Result ArchiveFileIO::CreatePath(const char* filePath)
|
|
{
|
|
// since you can't create a path inside a pak file
|
|
// we will pass this to the underlying real fileio!
|
|
FileIOBase* realUnderlyingFileIO = FileIOBase::GetDirectInstance();
|
|
if (!realUnderlyingFileIO)
|
|
{
|
|
return IO::ResultCode::Error;
|
|
}
|
|
|
|
return realUnderlyingFileIO->CreatePath(filePath);
|
|
}
|
|
|
|
IO::Result ArchiveFileIO::DestroyPath(const char* filePath)
|
|
{
|
|
// since you can't destroy a path inside a pak file
|
|
// we will pass this to the underlying real fileio
|
|
FileIOBase* realUnderlyingFileIO = FileIOBase::GetDirectInstance();
|
|
if (!realUnderlyingFileIO)
|
|
{
|
|
return IO::ResultCode::Error;
|
|
}
|
|
|
|
return realUnderlyingFileIO->DestroyPath(filePath);
|
|
}
|
|
|
|
IO::Result ArchiveFileIO::Remove(const char* filePath)
|
|
{
|
|
if (!m_archive)
|
|
{
|
|
if (GetDirectInstance())
|
|
{
|
|
return GetDirectInstance()->Remove(filePath);
|
|
}
|
|
return IO::ResultCode::Error;
|
|
}
|
|
|
|
return (m_archive->RemoveFile(filePath) ? IO::ResultCode::Success : IO::ResultCode::Error);
|
|
}
|
|
|
|
IO::Result ArchiveFileIO::Copy(const char* sourceFilePath, const char* destinationFilePath)
|
|
{
|
|
// you can actually copy a file from inside a pak to a destination path if you want to...
|
|
IO::HandleType sourceFile = IO::InvalidHandle;
|
|
IO::HandleType destinationFile = IO::InvalidHandle;
|
|
if (!Open(sourceFilePath, IO::OpenMode::ModeRead | IO::OpenMode::ModeBinary, sourceFile))
|
|
{
|
|
return IO::ResultCode::Error;
|
|
}
|
|
|
|
// avoid using AZStd::string if possible - use OSString instead of StringFunc
|
|
AZ::OSString destPath(destinationFilePath);
|
|
|
|
AZ::OSString::size_type pos = destPath.find_last_of(AZ_CORRECT_AND_WRONG_FILESYSTEM_SEPARATOR);
|
|
if (pos != AZ::OSString::npos)
|
|
{
|
|
destPath.resize(pos);
|
|
}
|
|
CreatePath(destPath.c_str());
|
|
|
|
if (!Open(destinationFilePath, IO::OpenMode::ModeWrite | IO::OpenMode::ModeBinary, destinationFile))
|
|
{
|
|
Close(sourceFile);
|
|
return IO::ResultCode::Error;
|
|
}
|
|
|
|
// standard buffered copy.
|
|
bool failureEncountered = false;
|
|
AZ::u64 bytesRemaining = 0;
|
|
|
|
if (!Size(sourceFilePath, bytesRemaining))
|
|
{
|
|
Close(destinationFile);
|
|
Close(sourceFile);
|
|
return IO::ResultCode::Error;
|
|
}
|
|
|
|
while (bytesRemaining > 0)
|
|
{
|
|
size_t bytesThisTime = AZStd::GetMin<size_t>(bytesRemaining, ArchiveFileIoMaxBuffersize);
|
|
|
|
if (!Read(sourceFile, m_copyBuffer.data(), bytesThisTime, true))
|
|
{
|
|
failureEncountered = true;
|
|
break;
|
|
}
|
|
|
|
AZ::u64 actualBytesWritten = 0;
|
|
|
|
if ((!Write(destinationFile, m_copyBuffer.data(), bytesThisTime, &actualBytesWritten)) || (actualBytesWritten == 0))
|
|
{
|
|
failureEncountered = true;
|
|
break;
|
|
}
|
|
bytesRemaining -= actualBytesWritten;
|
|
}
|
|
|
|
Close(sourceFile);
|
|
Close(destinationFile);
|
|
return (failureEncountered || (bytesRemaining > 0)) ? IO::ResultCode::Error : IO::ResultCode::Success;
|
|
}
|
|
|
|
|
|
bool ArchiveFileIO::IsReadOnly(const char* filePath)
|
|
{
|
|
// a tricky one! files inside a pack are technically readonly...
|
|
IO::HandleType openedHandle = IO::InvalidHandle;
|
|
|
|
if (!Open(filePath, IO::OpenMode::ModeRead | IO::OpenMode::ModeBinary, openedHandle))
|
|
{
|
|
return false; // this will also return false if there is no archive, so no need to check it again
|
|
}
|
|
|
|
bool inPak = m_archive->IsInPak(openedHandle);
|
|
Close(openedHandle);
|
|
|
|
if (inPak)
|
|
{
|
|
return true; // things inside packfiles are read only by default since you cannot modify them while pak is mounted.
|
|
}
|
|
|
|
FileIOBase* realUnderlyingFileIO = FileIOBase::GetDirectInstance();
|
|
if (!realUnderlyingFileIO)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return realUnderlyingFileIO->IsReadOnly(filePath);
|
|
}
|
|
|
|
IO::Result ArchiveFileIO::Rename(const char* sourceFilePath, const char* destinationFilePath)
|
|
{
|
|
// since you cannot perform this opearation inside a pak file, we do it on the real file
|
|
FileIOBase* realUnderlyingFileIO = FileIOBase::GetDirectInstance();
|
|
if (!realUnderlyingFileIO)
|
|
{
|
|
return IO::ResultCode::Error;
|
|
}
|
|
|
|
return realUnderlyingFileIO->Rename(sourceFilePath, destinationFilePath);
|
|
}
|
|
|
|
IO::Result ArchiveFileIO::FindFiles(const char* filePath, const char* filter, FindFilesCallbackType callback)
|
|
{
|
|
// note that the underlying findFiles takes both path and filter.
|
|
if (!filePath)
|
|
{
|
|
return IO::ResultCode::Error;
|
|
}
|
|
|
|
if (!m_archive)
|
|
{
|
|
if (GetDirectInstance())
|
|
{
|
|
return GetDirectInstance()->FindFiles(filePath, filter, callback);
|
|
}
|
|
return IO::ResultCode::Error;
|
|
}
|
|
|
|
AZStd::fixed_string<AZ_MAX_PATH_LEN> total = filePath;
|
|
if (total.empty())
|
|
{
|
|
return IO::ResultCode::Error;
|
|
}
|
|
|
|
if (!total.ends_with(AZ_CORRECT_FILESYSTEM_SEPARATOR) && !total.ends_with(AZ_WRONG_FILESYSTEM_SEPARATOR))
|
|
{
|
|
total.append(AZ_CORRECT_FILESYSTEM_SEPARATOR_STRING);
|
|
}
|
|
|
|
total.append(filter);
|
|
|
|
AZ::IO::ArchiveFileIterator fileIterator = m_archive->FindFirst(total.c_str());
|
|
if (!fileIterator)
|
|
{
|
|
return IO::ResultCode::Success; // its not an actual fatal error to not find anything.
|
|
}
|
|
for (;fileIterator; fileIterator = m_archive->FindNext(fileIterator))
|
|
{
|
|
total = AZStd::fixed_string<AZ_MAX_PATH_LEN>::format("%s/%.*s", filePath, aznumeric_cast<int>(fileIterator.m_filename.size()), fileIterator.m_filename.data());
|
|
AZStd::optional resolvedAliasLength = ConvertToAlias(total.data(), total.capacity());
|
|
if (resolvedAliasLength)
|
|
{
|
|
total.resize_no_construct(*resolvedAliasLength);
|
|
if (!callback(total.c_str()))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
m_archive->FindClose(fileIterator);
|
|
|
|
return IO::ResultCode::Success;
|
|
}
|
|
|
|
bool ArchiveFileIO::GetFilename(IO::HandleType fileHandle, char* filename, AZ::u64 filenameSize) const
|
|
{
|
|
// because we sit on archive we need to keep track of archive files too.
|
|
AZStd::lock_guard<AZStd::recursive_mutex> lock(m_operationGuard);
|
|
const auto fileIt = m_trackedFiles.find(fileHandle);
|
|
if (fileIt != m_trackedFiles.end())
|
|
{
|
|
AZ_Assert(filenameSize >= fileIt->second.length(), "Filename size %" PRIu64 " is larger than the size of the tracked file %s:%zu", fileIt->second.c_str(), fileIt->second.size());
|
|
azstrncpy(filename, filenameSize, fileIt->second.c_str(), fileIt->second.length());
|
|
return true;
|
|
}
|
|
|
|
if (GetDirectInstance())
|
|
{
|
|
return GetDirectInstance()->GetFilename(fileHandle, filename, filenameSize);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// the rest of these functions just pipe through to the underlying real file IO, since
|
|
// archive doesn't know about any of this.
|
|
void ArchiveFileIO::SetAlias(const char* alias, const char* path)
|
|
{
|
|
FileIOBase* realUnderlyingFileIO = FileIOBase::GetDirectInstance();
|
|
if (!realUnderlyingFileIO)
|
|
{
|
|
return;
|
|
}
|
|
realUnderlyingFileIO->SetAlias(alias, path);
|
|
}
|
|
|
|
const char* ArchiveFileIO::GetAlias(const char* alias) const
|
|
{
|
|
FileIOBase* realUnderlyingFileIO = FileIOBase::GetDirectInstance();
|
|
if (!realUnderlyingFileIO)
|
|
{
|
|
return nullptr;
|
|
}
|
|
return realUnderlyingFileIO->GetAlias(alias);
|
|
}
|
|
|
|
void ArchiveFileIO::ClearAlias(const char* alias)
|
|
{
|
|
FileIOBase* realUnderlyingFileIO = FileIOBase::GetDirectInstance();
|
|
if (!realUnderlyingFileIO)
|
|
{
|
|
return;
|
|
}
|
|
realUnderlyingFileIO->GetAlias(alias);
|
|
}
|
|
|
|
AZStd::optional<AZ::u64> ArchiveFileIO::ConvertToAlias(char* inOutBuffer, AZ::u64 bufferLength) const
|
|
{
|
|
if ((!inOutBuffer) || (bufferLength == 0))
|
|
{
|
|
return 0;
|
|
}
|
|
FileIOBase* realUnderlyingFileIO = FileIOBase::GetDirectInstance();
|
|
if (!realUnderlyingFileIO)
|
|
{
|
|
inOutBuffer[0] = 0;
|
|
return AZStd::nullopt;
|
|
}
|
|
return realUnderlyingFileIO->ConvertToAlias(inOutBuffer, bufferLength);
|
|
}
|
|
|
|
bool ArchiveFileIO::ConvertToAlias(AZ::IO::FixedMaxPath& convertedPath, const AZ::IO::PathView& path) const
|
|
{
|
|
FileIOBase* realUnderlyingFileIO = FileIOBase::GetDirectInstance();
|
|
if (!realUnderlyingFileIO)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return realUnderlyingFileIO->ConvertToAlias(convertedPath, path);
|
|
}
|
|
|
|
bool ArchiveFileIO::ResolvePath(const char* path, char* resolvedPath, AZ::u64 resolvedPathSize) const
|
|
{
|
|
FileIOBase* realUnderlyingFileIO = FileIOBase::GetDirectInstance();
|
|
if (!realUnderlyingFileIO)
|
|
{
|
|
return false;
|
|
}
|
|
return realUnderlyingFileIO->ResolvePath(path, resolvedPath, resolvedPathSize);
|
|
}
|
|
|
|
bool ArchiveFileIO::ResolvePath(AZ::IO::FixedMaxPath& resolvedPath, const AZ::IO::PathView& path) const
|
|
{
|
|
FileIOBase* realUnderlyingFileIO = FileIOBase::GetDirectInstance();
|
|
if (!realUnderlyingFileIO)
|
|
{
|
|
return false;
|
|
}
|
|
return realUnderlyingFileIO->ResolvePath(resolvedPath, path);
|
|
}
|
|
|
|
bool ArchiveFileIO::ReplaceAlias(AZ::IO::FixedMaxPath& replacedAliasPath, const AZ::IO::PathView& path) const
|
|
{
|
|
FileIOBase* realUnderlyingFileIO = FileIOBase::GetDirectInstance();
|
|
if (!realUnderlyingFileIO)
|
|
{
|
|
return false;
|
|
}
|
|
return realUnderlyingFileIO->ReplaceAlias(replacedAliasPath, path);
|
|
}
|
|
}//namespace AZ:IO
|