/*
* Copyright (C) 2026 Linux Studio Plugins Project
* (C) 2026 Vladimir Sadovnikov
*
* This file is part of lsp-runtime-lib
* Created on: 6 мар. 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
#include
#include
#include
#ifdef PLATFORM_WINDOWS
#include
#endif /* PLATFORM_WINDOWS */
namespace lsp
{
namespace io
{
StdioFile::StdioFile()
{
pFD = NULL;
nFlags = 0;
}
StdioFile::~StdioFile()
{
if (pFD != NULL)
{
if (nFlags & SF_CLOSE)
fclose(pFD);
pFD = NULL;
}
nFlags = 0;
}
status_t StdioFile::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);
}
status_t StdioFile::open(const LSPString *path, size_t mode)
{
const char *fmode;
size_t flags;
// Check state
if (pFD != NULL)
return set_error(STATUS_BAD_STATE);
// Determine mode
if (mode & FM_READ)
{
if (mode & FM_WRITE)
{
flags = SF_READ | SF_WRITE;
if (mode & (FM_CREATE | FM_TRUNC))
fmode = "wb+";
else
fmode = "rb+";
}
else // "r"
{
flags = SF_READ;
fmode = "rb";
}
}
else if (mode & FM_WRITE)
{
flags = SF_WRITE;
if (mode & (FM_CREATE | FM_TRUNC))
fmode = "wb";
else
fmode = "rb+";
}
else
return set_error(STATUS_INVALID_VALUE);
// Open file
FILE *fd = fopen(path->get_native(), fmode);
if (fd == NULL)
{
int code = errno;
switch (code)
{
case EINVAL:
return set_error(STATUS_BAD_ARGUMENTS);
default:
return set_error(STATUS_UNKNOWN_ERR);
}
}
// Check that we need to lock the file
if (mode & FM_LOCK)
{
#ifdef PLATFORM_WINDOWS
const int ifd = _fileno(fd);
const HANDLE hfd = reinterpret_cast(_get_osfhandle(ifd));
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(hfd, flags, 0, MAXDWORD, MAXDWORD, &ov))
{
const DWORD code = GetLastError();
fclose(fd);
status_t res = STATUS_IO_ERROR;
switch (code)
{
case ERROR_IO_PENDING: res = STATUS_LOCKED; break;
default: break;
}
return set_error(res);
}
#else
const int lk_flags = (mode & FM_NOWAIT) ? LOCK_EX | LOCK_NB : LOCK_EX;
const int lock_res = flock(fileno(fd), lk_flags);
if (lock_res != 0)
{
const int code = errno;
fclose(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);
}
#endif /* PLATFORM_WINDOWS */
}
// Update state
pFD = fd;
nFlags = flags | SF_CLOSE;
return set_error(STATUS_OK);
}
status_t StdioFile::open(const Path *path, size_t mode)
{
if (path == NULL)
return set_error(STATUS_BAD_ARGUMENTS);
return open(path->as_string(), mode);
}
status_t StdioFile::wrap(FILE *fd, bool close)
{
// Check state
if (fd == NULL)
return set_error(STATUS_BAD_ARGUMENTS);
else if (pFD != NULL)
return set_error(STATUS_BAD_STATE);
pFD = fd;
nFlags = (close) ? SF_READ | SF_WRITE | SF_CLOSE : SF_READ | SF_WRITE;
return set_error(STATUS_OK);
}
status_t StdioFile::wrap(FILE *fd, size_t mode, bool close)
{
// Check state
if (fd == NULL)
return set_error(STATUS_BAD_ARGUMENTS);
else if (pFD != NULL)
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;
pFD = fd;
nFlags = flags;
return set_error(STATUS_OK);
}
ssize_t StdioFile::read(void *dst, size_t count)
{
// Check state
if (pFD == NULL)
return -set_error(STATUS_BAD_STATE);
else if (!(nFlags & SF_READ))
return -set_error(STATUS_PERMISSION_DENIED);
// Perform read
uint8_t *ptr = reinterpret_cast(dst);
size_t bread = 0;
bool eof = false;
while (bread < count)
{
size_t to_read = count - bread;
size_t n_read = fread(ptr, 1, to_read, pFD);
if (n_read <= 0)
{
eof = feof(pFD);
break;
}
ptr += n_read;
bread += n_read;
}
if ((bread > 0) || (count <= 0) || (!eof))
{
set_error(STATUS_OK);
return bread;
}
return -set_error(STATUS_EOF);
}
ssize_t StdioFile::pread(wsize_t pos, void *dst, size_t count)
{
// Check state
if (pFD == NULL)
return -set_error(STATUS_BAD_STATE);
else if (!(nFlags & SF_READ))
return -set_error(STATUS_PERMISSION_DENIED);
// Store previous position
wssize_t save = ftello(pFD);
if (save < 0)
return -set_error(STATUS_IO_ERROR);
// Update position
if (pos != wsize_t(save))
{
if (fseeko(pFD, pos, SEEK_SET) != 0)
return -set_error(STATUS_IO_ERROR);
}
// Perform read
uint8_t *ptr = reinterpret_cast(dst);
size_t bread = 0;
bool eof = false;
while (bread < count)
{
size_t to_read = count - bread;
size_t n_read = fread(ptr, 1, to_read, pFD);
if (n_read <= 0)
{
eof = feof(pFD);
break;
}
ptr += n_read;
bread += n_read;
}
// Restore position
if (pos != wsize_t(save))
{
if (fseeko(pFD, save, SEEK_SET) != 0)
return -set_error(STATUS_IO_ERROR);
}
if ((bread > 0) || (count <= 0) || (!eof))
{
set_error(STATUS_OK);
return bread;
}
return -set_error(STATUS_EOF);
}
ssize_t StdioFile::write(const void *src, size_t count)
{
// Check state
if (pFD == NULL)
return -set_error(STATUS_BAD_STATE);
else if (!(nFlags & SF_WRITE))
return -set_error(STATUS_PERMISSION_DENIED);
// Perform write
const uint8_t *ptr = reinterpret_cast(src);
size_t bwritten = 0;
while (bwritten < count)
{
size_t to_write = count - bwritten;
size_t n_written= fwrite(ptr, 1, to_write, pFD);
if (n_written <= 0)
break;
ptr += n_written;
bwritten += n_written;
}
if ((bwritten > 0) || (count <= 0))
{
set_error(STATUS_OK);
return bwritten;
}
return -set_error(STATUS_IO_ERROR);
}
ssize_t StdioFile::pwrite(wsize_t pos, const void *src, size_t count)
{
// Check state
if (pFD == NULL)
return -set_error(STATUS_BAD_STATE);
else if (!(nFlags & SF_WRITE))
return -set_error(STATUS_PERMISSION_DENIED);
// Store previous position
wssize_t save = ftello(pFD);
if (save < 0)
return -set_error(STATUS_IO_ERROR);
// Update position
if (pos != wsize_t(save))
{
if (fseeko(pFD, pos, SEEK_SET) != 0)
return -set_error(STATUS_IO_ERROR);
}
// Perform write
const uint8_t *ptr = reinterpret_cast(src);
size_t bwritten = 0;
while (bwritten < count)
{
size_t to_write = count - bwritten;
size_t n_written= fwrite(ptr, 1, to_write, pFD);
if (n_written <= 0)
break;
ptr += n_written;
bwritten += n_written;
}
// Restore position
if (pos != wsize_t(save))
{
if (fseeko(pFD, save, SEEK_SET) != 0)
return -set_error(STATUS_IO_ERROR);
}
if ((bwritten > 0) || (count <= 0))
{
set_error(STATUS_OK);
return bwritten;
}
return -set_error(STATUS_IO_ERROR);
}
status_t StdioFile::seek(wssize_t pos, size_t type)
{
if (pFD == NULL)
return set_error(STATUS_BAD_STATE);
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 (::fseeko(pFD, pos, whence) != 0)
{
int code = errno;
if (code == ESPIPE)
return set_error(STATUS_NOT_SUPPORTED);
return set_error(STATUS_IO_ERROR);
}
return STATUS_OK;
}
wssize_t StdioFile::position()
{
if (pFD == NULL)
return -set_error(STATUS_BAD_STATE);
wssize_t pos = ftello(pFD);
if (pos < 0)
return -set_error(STATUS_IO_ERROR);
set_error(STATUS_OK);
return pos;
}
wssize_t StdioFile::size()
{
if (pFD == NULL)
return -set_error(STATUS_BAD_STATE);
#ifdef PLATFORM_WINDOWS
LARGE_INTEGER sizebuf;
int fd = _fileno(pFD);
intptr_t hfd = _get_osfhandle(fd);
if (!GetFileSizeEx(reinterpret_cast(hfd), &sizebuf))
return -set_error(STATUS_IO_ERROR);
wssize_t pos = sizebuf.QuadPart;
#else
struct stat statbuf;
if (fstat(fileno(pFD), &statbuf) != 0)
return -set_error(STATUS_IO_ERROR);
wssize_t pos = statbuf.st_size;
#endif
set_error(STATUS_OK);
return pos;
}
status_t StdioFile::stat(fattr_t *attr)
{
if (pFD == NULL)
return -set_error(STATUS_BAD_STATE);
return set_error(File::stat(pFD, attr));
}
status_t StdioFile::truncate(wsize_t length)
{
// Check state
if (pFD == NULL)
return set_error(STATUS_BAD_STATE);
else if (!(nFlags & SF_WRITE))
return set_error(STATUS_PERMISSION_DENIED);
if (fflush(pFD) != 0)
return set_error(STATUS_IO_ERROR);
if (ftruncate(fileno(pFD), length) != 0)
return set_error(STATUS_IO_ERROR);
return set_error(STATUS_OK);
}
status_t StdioFile::flush()
{
// Check state
if (pFD == NULL)
return set_error(STATUS_BAD_STATE);
else if (!(nFlags & SF_WRITE))
return set_error(STATUS_PERMISSION_DENIED);
if (fflush(pFD) != 0)
return set_error(STATUS_IO_ERROR);
return set_error(STATUS_OK);
}
status_t StdioFile::sync()
{
// Check state
if (pFD == NULL)
return set_error(STATUS_BAD_STATE);
else if (!(nFlags & SF_WRITE))
return set_error(STATUS_PERMISSION_DENIED);
if (fflush(pFD) != 0)
return set_error(STATUS_IO_ERROR);
#ifdef PLATFORM_WINDOWS
if (_commit(_fileno(pFD)) != 0)
return set_error(STATUS_IO_ERROR);
#else
if (fsync(fileno(pFD)) != 0)
return set_error(STATUS_IO_ERROR);
#endif
return set_error(STATUS_OK);
}
status_t StdioFile::close()
{
if (pFD != NULL)
{
if (nFlags & SF_CLOSE)
{
if (fclose(pFD) != 0)
return set_error(STATUS_IO_ERROR);
}
pFD = NULL;
nFlags = 0;
}
return set_error(STATUS_OK);
}
} /* namespace io */
} /* namespace lsp */