/*
* Copyright (C) 2026 Linux Studio Plugins Project
* (C) 2026 Vladimir Sadovnikov
*
* This file is part of lsp-runtime-lib
* Created on: 7 мар. 2019 г.
*
* lsp-runtime-lib is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* lsp-runtime-lib is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with lsp-runtime-lib. If not, see .
*/
#include
#include
#if defined(PLATFORM_WINDOWS)
#include
#include
#endif /* PLATFORM_WINDOWS */
#if defined(PLATFORM_UNIX_COMPATIBLE)
#include
#include
#include
#include
#include
#endif /* PLATFORM_UNIX_COMPATIBLE */
#define BAD_FD fhandle_t(-1)
namespace lsp
{
namespace io
{
NativeFile::NativeFile()
{
hFD = BAD_FD;
nFlags = 0;
}
NativeFile::~NativeFile()
{
if (hFD != BAD_FD)
{
if (nFlags & SF_CLOSE)
{
#if defined(PLATFORM_WINDOWS)
CloseHandle(hFD);
#else
::close(hFD);
#endif
}
hFD = BAD_FD;
}
nFlags = 0;
}
status_t NativeFile::open(const char *path, size_t mode)
{
if (path == NULL)
return set_error(STATUS_BAD_ARGUMENTS);
LSPString tmp;
if (!tmp.set_utf8(path))
return set_error(STATUS_NO_MEM);
return open(&tmp, mode);
}
#if defined(PLATFORM_WINDOWS)
status_t NativeFile::open(const LSPString *path, size_t mode)
{
if (path == NULL)
return set_error(STATUS_BAD_ARGUMENTS);
fattr_t stat;
status_t res = File::stat(path, &stat);
if (res == STATUS_OK)
{
if (stat.type == fattr_t::FT_DIRECTORY)
return (mode & FM_CREATE) ? STATUS_ALREADY_EXISTS : STATUS_IS_DIRECTORY;
}
else if (!(mode & FM_CREATE))
return set_error(res);
int oflags;
size_t fflags;
size_t cmode;
size_t atts = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS;
if (mode & FM_READ)
{
oflags = (mode & FM_WRITE) ? GENERIC_READ | GENERIC_WRITE : GENERIC_READ;
fflags = (mode & FM_WRITE) ? SF_READ | SF_WRITE : SF_READ;
}
else if (mode & FM_WRITE)
{
oflags = GENERIC_WRITE;
fflags = SF_WRITE;
}
else
return set_error(STATUS_INVALID_VALUE);
if (mode & FM_CREATE)
cmode = (mode & FM_EXCL) ? CREATE_NEW : CREATE_ALWAYS;
else if (mode & FM_TRUNC)
cmode = TRUNCATE_EXISTING;
else
cmode = OPEN_EXISTING;
if (mode & FM_DIRECT)
atts |= FILE_FLAG_NO_BUFFERING;
fhandle_t fd = CreateFileW(path->get_utf16(),
oflags,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
NULL, cmode, atts, NULL);
if (fd == INVALID_HANDLE_VALUE)
{
DWORD error = GetLastError();
res = STATUS_IO_ERROR;
switch (error)
{
case ERROR_PATH_NOT_FOUND:
case ERROR_FILE_NOT_FOUND:
case ERROR_INVALID_ACCESS:
case ERROR_INVALID_DRIVE:
case ERROR_CANNOT_MAKE:
res = STATUS_NOT_FOUND;
break;
case ERROR_ACCESS_DENIED:
res = STATUS_PERMISSION_DENIED;
break;
case ERROR_TOO_MANY_OPEN_FILES:
case ERROR_NOT_ENOUGH_MEMORY:
case ERROR_OUTOFMEMORY:
res = STATUS_NO_MEM;
break;
case ERROR_WRITE_PROTECT:
res = STATUS_READONLY;
break;
case ERROR_FILE_EXISTS:
case ERROR_ALREADY_EXISTS:
res = STATUS_ALREADY_EXISTS;
break;
case ERROR_DIRECTORY:
res = STATUS_IS_DIRECTORY;
break;
case ERROR_BUFFER_OVERFLOW:
res = STATUS_OVERFLOW;
break;
case ERROR_INVALID_NAME:
res = STATUS_INVALID_VALUE;
break;
default:
break;
}
return set_error(res);
}
// Check that we need to lock the file
if (mode & FM_LOCK)
{
OVERLAPPED ov;
ov.Internal = 0;
ov.InternalHigh = 0;
ov.Offset = 0;
ov.OffsetHigh = 0;
ov.hEvent = NULL;
const DWORD flags = (mode & FM_NOWAIT) ? LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY : LOCKFILE_EXCLUSIVE_LOCK;
if (!LockFileEx(fd, flags, 0, MAXDWORD, MAXDWORD, &ov))
{
const DWORD code = GetLastError();
status_t res = STATUS_IO_ERROR;
switch (code)
{
case ERROR_IO_PENDING: res = STATUS_LOCKED; break;
default: break;
}
return set_error(res);
}
}
hFD = fd;
nFlags = fflags | SF_CLOSE;
return set_error(STATUS_OK);
}
#else
status_t NativeFile::open(const LSPString *path, size_t mode)
{
if (path == NULL)
return set_error(STATUS_BAD_ARGUMENTS);
fattr_t stat;
if (File::stat(path, &stat) == STATUS_OK)
{
if (stat.type == fattr_t::FT_DIRECTORY)
return (mode & FM_CREATE) ? STATUS_ALREADY_EXISTS : STATUS_NOT_FOUND;
}
int oflags;
size_t fflags;
if (mode & FM_READ)
{
oflags = (mode & FM_WRITE) ? O_RDWR : O_RDONLY;
fflags = (mode & FM_WRITE) ? SF_READ | SF_WRITE : SF_READ;
}
else if (mode & FM_WRITE)
{
oflags = O_WRONLY;
fflags = SF_WRITE;
}
else
return set_error(STATUS_INVALID_VALUE);
if (mode & FM_CREATE)
oflags |= O_CREAT;
if (mode & FM_TRUNC)
oflags |= O_TRUNC;
if (mode & FM_EXCL)
oflags |= O_EXCL;
#if defined(__USE_GNU) && defined(O_DIRECT)
if (mode & FM_DIRECT)
oflags |= O_DIRECT;
#endif /* __USE_GNU */
fhandle_t fd = ::open(path->get_native(), oflags, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
if (fd < 0)
{
const int code = errno;
status_t res = STATUS_IO_ERROR;
switch (code)
{
case EPERM: case EACCES: res = STATUS_PERMISSION_DENIED; break;
case EEXIST: res = STATUS_ALREADY_EXISTS; break;
case EINVAL: res = STATUS_INVALID_VALUE; break;
case EISDIR: res = STATUS_IS_DIRECTORY; break;
case ENAMETOOLONG: res = STATUS_OVERFLOW; break;
case ENOENT: res = STATUS_NOT_FOUND; break;
case ENOMEM: res = STATUS_NO_MEM; break;
case ENOTDIR: res = STATUS_NOT_DIRECTORY; break;
case EROFS: res = STATUS_READONLY; break;
default: break;
}
return set_error(res);
}
// Check that we need to lock the file
if (mode & FM_LOCK)
{
const int lk_flags = (mode & FM_NOWAIT) ? LOCK_EX | LOCK_NB : LOCK_EX;
const int lock_res = flock(fd, lk_flags);
if (lock_res != 0)
{
const int code = errno;
::close(fd);
status_t res = STATUS_IO_ERROR;
switch (code)
{
case EINTR: res = STATUS_INTERRUPTED; break;
case ENOLCK: res = STATUS_NO_MEM; break;
case EWOULDBLOCK: res = STATUS_LOCKED; break;
default: break;
}
return set_error(res);
}
}
hFD = fd;
nFlags = fflags | SF_CLOSE;
return set_error(STATUS_OK);
}
#endif /* PLATFORM_WINDOWS */
status_t NativeFile::open(const Path *path, size_t mode)
{
if (path == NULL)
return set_error(STATUS_BAD_ARGUMENTS);
return open(path->as_string(), mode);
}
status_t NativeFile::wrap(fhandle_t fd, bool close)
{
// Check state
if (hFD != BAD_FD)
return set_error(STATUS_BAD_STATE);
hFD = fd;
nFlags = (close) ? SF_READ | SF_WRITE | SF_CLOSE : SF_READ | SF_WRITE;
return set_error(STATUS_OK);
}
status_t NativeFile::wrap(fhandle_t fd, size_t mode, bool close)
{
// Check state
if (hFD != BAD_FD)
return set_error(STATUS_BAD_STATE);
size_t flags = (close) ? SF_CLOSE : 0;
if (mode & FM_READ)
flags |= SF_READ;
if (mode & FM_WRITE)
flags |= SF_WRITE;
hFD = fd;
nFlags = flags;
return set_error(STATUS_OK);
}
ssize_t NativeFile::read(void *dst, size_t count)
{
// Check state
if (hFD == BAD_FD)
return -set_error(STATUS_BAD_STATE);
else if (!(nFlags & SF_READ))
return -set_error(STATUS_PERMISSION_DENIED);
uint8_t *ptr = reinterpret_cast(dst);
size_t bread = 0;
bool eof = false;
// Perofrm read
#ifdef PLATFORM_WINDOWS
while (bread < count)
{
size_t to_read = count - bread;
if (to_read >= 0x40000000)
to_read = 0x40000000;
DWORD n_read = 0;
if (!ReadFile(hFD, ptr, DWORD(to_read), &n_read, NULL))
break;
if (n_read <= 0)
{
eof = true;
break;
}
ptr += n_read;
bread += n_read;
}
#else
while (bread < count)
{
size_t to_read = count - bread;
size_t n_read = ::read(hFD, ptr, to_read);
if (n_read <= 0)
{
eof = true;
break;
}
ptr += n_read;
bread += n_read;
}
#endif
if ((bread > 0) || (count <= 0) || (!eof))
{
set_error(STATUS_OK);
return bread;
}
return -set_error(STATUS_EOF);
}
ssize_t NativeFile::pread(wsize_t pos, void *dst, size_t count)
{
// Check state
if (hFD == BAD_FD)
return -set_error(STATUS_BAD_STATE);
else if (!(nFlags & SF_READ))
return -set_error(STATUS_PERMISSION_DENIED);
uint8_t *ptr = reinterpret_cast(dst);
size_t bread = 0;
bool eof = false;
#ifdef PLATFORM_WINDOWS
LARGE_INTEGER off, save;
off.QuadPart = 0;
// Obtrain current file pointer
if (!SetFilePointerEx(hFD, off, &save, FILE_CURRENT))
return -set_error(STATUS_IO_ERROR);
// Change file pointer
off.QuadPart = pos;
if (!SetFilePointerEx(hFD, off, NULL, FILE_BEGIN))
return -set_error(STATUS_IO_ERROR);
// Perform positioned read
while (bread < count)
{
size_t to_read = count - bread;
if (to_read >= 0x40000000)
to_read = 0x40000000;
DWORD n_read = 0;
if (!ReadFile(hFD, ptr, DWORD(to_read), &n_read, NULL))
break;
if (n_read <= 0)
{
eof = true;
break;
}
ptr += n_read;
bread += n_read;
}
// Restore position
if (!SetFilePointerEx(hFD, save, NULL, FILE_BEGIN))
return -set_error(STATUS_IO_ERROR);
#else
// Perform positioned read
while (bread < count)
{
size_t to_read = count - bread;
size_t n_read = ::pread(hFD, ptr, to_read, pos);
if (n_read <= 0)
{
eof = true;
break;
}
ptr += n_read;
bread += n_read;
pos += n_read;
}
#endif
if ((bread > 0) || (count <= 0) || (!eof))
{
set_error(STATUS_OK);
return bread;
}
return -set_error(STATUS_EOF);
}
ssize_t NativeFile::write(const void *src, size_t count)
{
// Check state
if (hFD == BAD_FD)
return -set_error(STATUS_BAD_STATE);
else if (!(nFlags & SF_WRITE))
return -set_error(STATUS_PERMISSION_DENIED);
const uint8_t *ptr = reinterpret_cast(src);
size_t bwritten = 0;
// Perform write
#ifdef PLATFORM_WINDOWS
while (bwritten < count)
{
size_t to_write = count - bwritten;
if (to_write >= 0x40000000)
to_write = 0x40000000;
DWORD n_written = 0;
if (!WriteFile(hFD, ptr, to_write, &n_written, NULL))
break;
ptr += n_written;
bwritten += n_written;
}
#else
while (bwritten < count)
{
size_t to_write = count - bwritten;
ssize_t n_written = ::write(hFD, ptr, to_write);
if (n_written <= 0)
break;
ptr += n_written;
bwritten += n_written;
}
#endif
if ((bwritten > 0) || (count <= 0))
{
set_error(STATUS_OK);
return bwritten;
}
return -set_error(STATUS_IO_ERROR);
}
ssize_t NativeFile::pwrite(wsize_t pos, const void *src, size_t count)
{
// Check state
if (hFD == BAD_FD)
return -set_error(STATUS_BAD_STATE);
else if (!(nFlags & SF_WRITE))
return -set_error(STATUS_PERMISSION_DENIED);
const uint8_t *ptr = reinterpret_cast(src);
size_t bwritten = 0;
#ifdef PLATFORM_WINDOWS
LARGE_INTEGER off, save;
off.QuadPart = 0;
// Obtrain current file pointer
if (!SetFilePointerEx(hFD, off, &save, FILE_CURRENT))
return -set_error(STATUS_IO_ERROR);
// Change file pointer
off.QuadPart = pos;
if (!SetFilePointerEx(hFD, off, NULL, FILE_BEGIN))
return -set_error(STATUS_IO_ERROR);
// Perform positioned write
while (bwritten < count)
{
size_t to_write = count - bwritten;
if (to_write >= 0x40000000)
to_write = 0x40000000;
DWORD n_written = 0;
if (!WriteFile(hFD, ptr, to_write, &n_written, NULL))
break;
ptr += n_written;
bwritten += n_written;
}
// Restore position
if (!SetFilePointerEx(hFD, save, NULL, FILE_BEGIN))
return -set_error(STATUS_IO_ERROR);
#else
// Perform positioned write
while (bwritten < count)
{
size_t to_write = count - bwritten;
size_t n_written = ::pwrite(hFD, ptr, to_write, pos);
if (n_written <= 0)
break;
ptr += n_written;
bwritten += n_written;
pos += n_written;
}
#endif
if ((bwritten > 0) || (count <= 0))
{
set_error(STATUS_OK);
return bwritten;
}
return -set_error(STATUS_IO_ERROR);
}
status_t NativeFile::seek(wssize_t pos, size_t type)
{
if (hFD == BAD_FD)
return set_error(STATUS_BAD_STATE);
#ifdef PLATFORM_WINDOWS
DWORD method;
LARGE_INTEGER off;
switch (type)
{
case FSK_SET: method = FILE_BEGIN; break;
case FSK_CUR: method = FILE_CURRENT; break;
case FSK_END: method = FILE_END; break;
default: return set_error(STATUS_INVALID_VALUE);
}
off.QuadPart = pos;
if (!SetFilePointerEx(hFD, off, NULL, method))
return set_error(STATUS_IO_ERROR);
#else
int whence;
switch (type)
{
case FSK_SET: whence = SEEK_SET; break;
case FSK_CUR: whence = SEEK_CUR; break;
case FSK_END: whence = SEEK_END; break;
default:
return set_error(STATUS_BAD_ARGUMENTS);
}
if (lseek(hFD, pos, whence) < 0)
{
int code = errno;
if (code == ESPIPE)
return set_error(STATUS_NOT_SUPPORTED);
return set_error(STATUS_IO_ERROR);
}
#endif /* PLATFORM_WINDOWS */
return set_error(STATUS_OK);
}
wssize_t NativeFile::position()
{
if (hFD == BAD_FD)
return -set_error(STATUS_BAD_STATE);
#ifdef PLATFORM_WINDOWS
LARGE_INTEGER off, pos;
off.QuadPart = 0;
if (!SetFilePointerEx(hFD, off, &pos, FILE_CURRENT))
return -set_error(STATUS_IO_ERROR);
wssize_t result = pos.QuadPart;
#else
wssize_t result = lseek(hFD, 0, SEEK_CUR);
if (result < 0)
return -set_error(STATUS_IO_ERROR);
#endif /* PLATFORM_WINDOWS */
return result;
}
wssize_t NativeFile::size()
{
if (hFD == BAD_FD)
return -set_error(STATUS_BAD_STATE);
#ifdef PLATFORM_WINDOWS
LARGE_INTEGER sizebuf;
if (!GetFileSizeEx(hFD, &sizebuf))
return -set_error(STATUS_IO_ERROR);
wssize_t pos = sizebuf.QuadPart;
#else
struct stat statbuf;
if (fstat(hFD, &statbuf) != 0)
return -set_error(STATUS_IO_ERROR);
wssize_t pos = statbuf.st_size;
#endif /* PLATFORM_WINDOWS */
set_error(STATUS_OK);
return pos;
}
status_t NativeFile::stat(fattr_t *attr)
{
if (hFD == BAD_FD)
return -set_error(STATUS_BAD_STATE);
return set_error(File::stat(hFD, attr));
}
status_t NativeFile::truncate(wsize_t length)
{
// Check state
if (hFD == BAD_FD)
return set_error(STATUS_BAD_STATE);
else if (!(nFlags & SF_WRITE))
return set_error(STATUS_PERMISSION_DENIED);
#ifdef PLATFORM_WINDOWS
LARGE_INTEGER off, pos;
off.QuadPart = 0;
if (!SetFilePointerEx(hFD, off, &pos, FILE_CURRENT))
return -set_error(STATUS_IO_ERROR);
off.QuadPart = length;
if (!SetFilePointerEx(hFD, off, NULL, FILE_BEGIN))
return -set_error(STATUS_IO_ERROR);
status_t res = (SetEndOfFile(hFD)) ? STATUS_OK : STATUS_IO_ERROR;
if (!SetFilePointerEx(hFD, pos, NULL, FILE_BEGIN))
res = STATUS_IO_ERROR;
return set_error(res);
#else
if (ftruncate(hFD, length) != 0)
return set_error(STATUS_IO_ERROR);
return set_error(STATUS_OK);
#endif /* PLATFORM_WINDOWS */
}
status_t NativeFile::flush()
{
// Check state
if (hFD == BAD_FD)
return set_error(STATUS_BAD_STATE);
else if (!(nFlags & SF_WRITE))
return set_error(STATUS_PERMISSION_DENIED);
#ifdef PLATFORM_WINDOWS
if (!FlushFileBuffers(hFD))
return set_error(STATUS_IO_ERROR);
#else
// Not required
// if (fdatasync(hFD) != 0)
// return set_error(STATUS_IO_ERROR);
#endif /* PLATFORM_WINDOWS */
return set_error(STATUS_OK);
}
status_t NativeFile::sync()
{
// Check state
if (hFD == BAD_FD)
return set_error(STATUS_BAD_STATE);
else if (!(nFlags & SF_WRITE))
return set_error(STATUS_PERMISSION_DENIED);
#ifdef PLATFORM_WINDOWS
if (!FlushFileBuffers(hFD))
return set_error(STATUS_IO_ERROR);
#else
if (fsync(hFD) != 0)
return set_error(STATUS_IO_ERROR);
#endif /* PLATFORM_WINDOWS */
return set_error(STATUS_OK);
}
status_t NativeFile::close()
{
if (hFD != BAD_FD)
{
if (nFlags & SF_CLOSE)
{
#ifdef PLATFORM_WINDOWS
if (!CloseHandle(hFD))
return set_error(STATUS_IO_ERROR);
#else
if (::close(hFD) != 0)
return set_error(STATUS_IO_ERROR);
#endif /* PLATFORM_WINDOWS */
}
hFD = BAD_FD;
nFlags = 0;
}
return set_error(STATUS_OK);
}
status_t NativeFile::open_temp(io::Path *path, const char *prefix)
{
if (prefix == NULL)
return open_temp(path, static_cast(NULL));
LSPString p;
if (!p.set_utf8(prefix))
return STATUS_NO_MEM;
return open_temp(path, &p);
}
status_t NativeFile::open_temp(LSPString *path, const char *prefix)
{
if (prefix == NULL)
return open_temp(path, static_cast(NULL));
LSPString p;
if (!p.set_utf8(prefix))
return STATUS_NO_MEM;
return open_temp(path, &p);
}
status_t NativeFile::open_temp(LSPString *path, const LSPString *prefix)
{
if (path == NULL)
return set_error(STATUS_BAD_ARGUMENTS);
// Open file
io::Path out;
status_t res = open_temp(&out, prefix);
if (res != STATUS_OK)
return res;
if ((res = out.get(path)) != STATUS_OK)
{
// Close the file and remove it on error
close();
out.remove();
}
return res;
}
status_t NativeFile::open_temp(io::Path *path, const LSPString *prefix)
{
if (hFD != BAD_FD)
return set_error(STATUS_BAD_STATE);
else if (path == NULL)
return set_error(STATUS_BAD_ARGUMENTS);
// Make the prefix
status_t res;
LSPString name;
if (prefix != NULL)
{
if (!name.set(prefix))
return STATUS_NO_MEM;
if (!name.append('-'))
return STATUS_NO_MEM;
}
// Obtain the temporary directory
io::Path tempdir;
if ((res = system::get_temporary_dir(&tempdir)) != STATUS_OK)
return res;
// Create the file in the loop
io::Path full_path;
size_t len = name.length();
while (true)
{
// Generate the name of the file
name.set_length(len);
int seed = int(system::get_time_millis()) ^ int(rand());
if (!name.fmt_append_ascii("%08x.tmp", seed))
return STATUS_NO_MEM;
if ((res = full_path.set(&tempdir, &name)) != STATUS_OK)
return res;
// Open temporary file
res = open(&full_path, io::File::FM_WRITE_NEW | io::File::FM_EXCL);
if (res == STATUS_OK)
{
full_path.swap(path);
return res;
}
if (res != STATUS_ALREADY_EXISTS)
return res;
}
}
} /* namespace io */
} /* namespace lsp */