AuroraRuntime/Source/IO/FS/FileStream.Unix.cpp

311 lines
6.9 KiB
C++

#define _FILE_OFFSET_BITS 64
#define _LARGEFILE64_SOURCE
#include <Source/RuntimeInternal.hpp>
#include "FS.hpp"
#include "FileStream.Generic.hpp"
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#if !defined(_AURUNTIME_GENERICFILESTREAM)
namespace Aurora::IO::FS
{
static const AuUInt64 kFileCopyBlock = 0x4000; // 16KiB
static bool PosixLseek63(int fd, AuUInt64 offset, int whence, AuUInt64 *pOffset)
{
if (offset > std::numeric_limits<off_t>::max())
{
SysPushErrorIO("int overflow exploit?");
return false;
}
#if defined(AURORA_IS_LINUX_DERIVED)
auto ret = lseek64(fd, offset, whence);
#elif defined(AURORA_IS_64BIT)
static_assert(std::numeric_limits<off_t>::max() >= std::numeric_limits<AuInt64>::max(), "unsupported posix os");
auto ret = lseek(fd, offset, whence);
#else
#error accient 32-bit posix operating systems require 64-bit file awareness
#endif
if (ret < 0)
{
LogWarn("PosixLseek63 IO Error %i", ret);
SysPushErrorIO("PosixLseek63: %i", ret);
return false;
}
if (pOffset)
{
*pOffset = ret;
}
return true;
}
static AuUInt64 PosixGetOffset(int fd)
{
AuUInt64 ret;
if (!PosixLseek63(fd, 0, SEEK_SET, &ret))
{
return 0;
}
return ret;
}
static bool PosixSetOffset(int fd, AuUInt64 offset)
{
return PosixLseek63(fd, offset, SEEK_SET, nullptr);
}
static AuUInt64 PosixGetLength(int fd)
{
AuUInt64 ret {}, old {};
bool status {};
if (!PosixLseek63(fd, 0, SEEK_SET, &old))
{
return 0;
}
status = PosixLseek63(fd, 0, SEEK_END, &ret);
status &= PosixLseek63(fd, old, SEEK_SET, nullptr);
return status ? ret : 0;
}
static bool PosixRead(int fd, void *buf, AuUInt32 count, AuUInt32 *pRead)
{
auto ret = read(fd, buf, count);
if (ret < 0)
{
LogWarn("PosixRead IO Error %i", ret);
SysPushErrorIO("PosixRead: %i", ret);
return false;
}
if (pRead)
{
*pRead = ret;
}
return true;
}
static bool PosixWrite(int fd, const void *buf, AuUInt32 count, AuUInt32 *pWritten)
{
auto ret = write(fd, buf, count);
if (ret < 0)
{
LogWarn("PosixWrite IO Error %i", ret);
SysPushErrorIO("PosixWrite: %i", ret);
return false;
}
if (pWritten)
{
*pWritten = ret;
}
return true;
}
PosixFileStream::~PosixFileStream()
{
Close();
}
void PosixFileStream::Init(int handle, const AuString &path)
{
handle_ = handle;
path_ = path;
}
AuUInt64 PosixFileStream::GetOffset()
{
if (handle_ == -1)
{
SysPushErrorUninitialized();
return 0;
}
return PosixGetOffset(handle_);
}
bool PosixFileStream::SetOffset(AuUInt64 offset)
{
if (handle_ == -1)
{
SysPushErrorUninitialized();
return 0;
}
return PosixSetOffset(handle_, offset);
}
AuUInt64 PosixFileStream::GetLength()
{
if (handle_ == -1)
{
SysPushErrorUninitialized();
return 0;
}
return PosixGetLength(handle_);
}
bool PosixFileStream::Read(const Memory::MemoryViewStreamWrite &parameters)
{
if (handle_ == -1)
{
SysPushErrorUninitialized();
return 0;
}
auto length = parameters.length;
AuUInt offset {0};
while (length)
{
AuUInt32 read;
int blockSize = std::min(kFileCopyBlock, length);
if (!PosixRead(handle_, &reinterpret_cast<char *>(parameters.ptr)[offset], blockSize, &read))
{
SysPushErrorNested("File Error: {}", path_);
break;
}
if (read == 0)
{
break;
}
offset += read;
length -= read;
}
if (!offset)
{
return false;
}
parameters.outVariable = offset;
return true;
}
bool PosixFileStream::Write(const Memory::MemoryViewStreamRead &parameters)
{
if (handle_ == -1)
{
SysPushErrorUninitialized();
return 0;
}
auto length = parameters.length;
AuUInt offset {0};
while (length)
{
AuUInt32 written;
int blockSize = std::min(kFileCopyBlock, length);
if (!PosixWrite(handle_, &reinterpret_cast<const char *>(parameters.ptr)[offset], blockSize, &written))
{
SysPushErrorNested("File Error: {}", path_);
return false;
}
if (written != blockSize)
{
SysPushErrorIO();
SysPushErrorNested("File Error: {}", path_);
break;
}
offset += written;
length -= written;
}
if (!offset)
{
return false;
}
parameters.outVariable = offset;
return true;
}
void PosixFileStream::Close()
{
int handle;
if ((handle = std::exchange(handle_, -1)) != -1)
{
::close(handle);
}
}
void PosixFileStream::Flush()
{
fsync(handle_);
}
static IFileStream *OpenNew(const AuString &path, bool read)
{
auto pathex = NormalizePathRet(path);
if (!read)
{
CreateDirectories(pathex, true);
}
auto fileHandle = open(pathex.c_str(), read ? O_RDONLY : O_RDWR);
if (fileHandle < 0)
{
LogWarn("Couldn't open file: {}", path);
SysPushErrorIO("Couldn't open file: {}", path);
return nullptr;
}
auto stream = _new PosixFileStream();
if (!stream)
{
close(fileHandle);
return nullptr;
}
stream->Init(fileHandle, pathex);
return stream;
}
AUKN_SYM IFileStream *OpenReadNew(const AuString &path)
{
return OpenNew(path, true);
}
AUKN_SYM void OpenReadRelease(IFileStream * that)
{
SafeDelete<PosixFileStream *>(that);
}
AUKN_SYM IFileStream *OpenWriteNew(const AuString &path)
{
return OpenNew(path, false);
}
AUKN_SYM void OpenWriteRelease(IFileStream * that)
{
SafeDelete<PosixFileStream *>(that);
}
}
#endif