/*
* Copyright (C) 2020 Linux Studio Plugins Project
* (C) 2020 Vladimir Sadovnikov
*
* This file is part of lsp-runtime-lib
* Created on: 14 янв. 2018 г.
*
* 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
#if defined(PLATFORM_WINDOWS)
#include
#define FD_INVALID(fd) ((fd) == INVALID_HANDLE_VALUE)
#else
#define FD_INVALID(fd) ((fd) < 0)
#endif /* PLATFORM_WINDOWS */
namespace lsp
{
namespace lspc
{
status_t Resource::acquire()
{
if (FD_INVALID(fd))
return STATUS_CLOSED;
++refs;
return STATUS_OK;
}
status_t Resource::release()
{
if (FD_INVALID(fd))
return STATUS_CLOSED;
if ((--refs) <= 0)
{
#if defined(PLATFORM_WINDOWS)
CloseHandle(fd);
fd = INVALID_HANDLE_VALUE;
#else
close(fd);
fd = -1;
#endif /* PLATFORM_WINDOWS */
}
return STATUS_OK;
}
status_t Resource::allocate(uint32_t *id)
{
uint32_t cid = chunk_id + 1;
if (cid == 0)
return STATUS_OVERFLOW;
*id = chunk_id = cid;
return STATUS_OK;
}
status_t Resource::write(const void *buf, size_t count)
{
if (FD_INVALID(fd))
return STATUS_CLOSED;
// Write data at the end of file
const uint8_t *bptr = static_cast(buf);
while (count > 0)
{
#if defined(PLATFORM_WINDOWS)
DWORD written = 0;
if (!WriteFile(fd, bptr, count, &written, NULL))
{
DWORD error = GetLastError();
if (error != ERROR_IO_PENDING)
{
lsp_trace("Error write: GetLastError()=%d", int(error));
return STATUS_IO_ERROR;
}
written = 0;
}
#else
errno = 0;
ssize_t written = pwrite(fd, bptr, count, length);
if (written < ssize_t(count))
{
int error = errno;
if (error != 0)
{
lsp_trace("Error write: errno=%d", error);
return STATUS_IO_ERROR;
}
}
#endif /* PLATFORM_WINDOWS */
bptr += written;
length += written;
count -= written;
}
return STATUS_OK;
}
ssize_t Resource::read(wsize_t pos, void *buf, size_t count)
{
if (FD_INVALID(fd))
return -STATUS_CLOSED;
// Write data at the end of file
uint8_t *bptr = static_cast(buf);
ssize_t total = 0;
#if defined(PLATFORM_WINDOWS)
LARGE_INTEGER set_pos;
LARGE_INTEGER seek_pos;
set_pos.QuadPart = pos;
if (!SetFilePointerEx(fd, set_pos, &seek_pos, FILE_BEGIN))
return -STATUS_IO_ERROR;
else if (seek_pos.QuadPart != set_pos.QuadPart)
return -STATUS_IO_ERROR;
#endif /* PLATFORM_WINDOWS */
while (count > 0)
{
#if defined(PLATFORM_WINDOWS)
DWORD read = 0;
if (!ReadFile(fd, bptr, count, &read, NULL))
{
DWORD error = GetLastError();
if (error != ERROR_IO_PENDING)
return -STATUS_IO_ERROR;
read = 0;
}
#else
ssize_t read = pread(fd, bptr, count, pos);
#endif /* PLATFORM_WINDOWS */
if (read < 0)
{
int error = errno;
switch (error)
{
case EISDIR: return -STATUS_IS_DIRECTORY;
case EPERM: return -STATUS_PERMISSION_DENIED;
case EINTR: continue;
case EIO: return -STATUS_IO_ERROR;
case EBADF: return -STATUS_BAD_STATE;
case EINVAL: return -STATUS_BAD_STATE;
case EAGAIN: break;
default: return -STATUS_IO_ERROR;
}
return total;
}
else if (ssize_t(read) < ssize_t(count))
return total;
bptr += read;
count -= read;
total += read;
}
return total;
}
ChunkAccessor::ChunkAccessor(Resource *fd, uint32_t magic)
{
pBuffer = NULL;
pFile = fd;
set_error((pFile != NULL) ? pFile->acquire() : STATUS_BAD_STATE);
nMagic = magic;
nBufSize = (pFile != NULL) ? pFile->bufsize : 0;
nBufPos = 0;
nUID = 0;
if (nBufSize > 0)
{
// Adjust buffer size
if (nBufSize < MIN_BUF_SIZE)
nBufSize = MIN_BUF_SIZE;
// Allocate buffer
pBuffer = static_cast(malloc(nBufSize));
if (pBuffer == NULL)
{
set_error(STATUS_NO_MEM);
return;
}
}
set_error(STATUS_OK);
}
ChunkAccessor::~ChunkAccessor()
{
do_close();
}
status_t ChunkAccessor::do_close()
{
if (pBuffer != NULL)
{
free(pBuffer);
pBuffer = NULL;
}
if (pFile == NULL)
return set_error(STATUS_CLOSED);
set_error(pFile->release());
if (pFile->refs <= 0)
delete pFile;
pFile = NULL;
return last_error();
}
status_t ChunkAccessor::close()
{
return do_close();
}
}
} /* namespace lsp */