/*
* Copyright (C) 2025 Linux Studio Plugins Project
* (C) 2025 Vladimir Sadovnikov
*
* This file is part of lsp-runtime-lib
* Created on: 15 мар. 2021 г.
*
* 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
namespace lsp
{
namespace resource
{
BuiltinLoader::BuiltinLoader()
{
pData = NULL;
nDataSize = 0;
pCatalog = NULL;
nCatSize = 0;
nBufRank = 0;
}
BuiltinLoader::~BuiltinLoader()
{
pData = NULL;
nDataSize = 0;
pCatalog = NULL;
nCatSize = 0;
nBufRank = 0;
}
status_t BuiltinLoader::init(
const void *data, size_t data_size,
const raw_resource_t *catalog, size_t catalog_size,
size_t log_buf_size
)
{
pData = reinterpret_cast(data);
nDataSize = data_size;
pCatalog = catalog;
nCatSize = catalog_size;
nBufRank = log_buf_size;
return STATUS_OK;
}
status_t BuiltinLoader::find_entry(ssize_t *out, const io::Path *path)
{
status_t res;
ssize_t index = -1;
LSPString item;
io::Path tmp;
// Copy path data
if ((res = tmp.set(path)) != STATUS_OK)
return res;
while (true)
{
// Get first item and remove it
if ((res = tmp.remove_first(&item)) != STATUS_OK)
return res;
// Lookup for existing directory/create yet another one
const raw_resource_t *found = NULL;
for (size_t i=0; iparent != index) || (ent->name == NULL))
continue;
if (item.equals_utf8(ent->name))
{
found = ent;
index = i;
break;
}
}
// Check that item exists
if (found == NULL)
return STATUS_NOT_FOUND;
// Last entry?
if (tmp.is_empty())
{
*out = index;
return STATUS_OK;
}
else if (found->type != RES_DIR)
return STATUS_NOT_FOUND;
}
}
io::IInStream *BuiltinLoader::read_stream(const io::Path *name)
{
ssize_t index = 0;
// Find entry
status_t res = find_entry(&index, name);
if (res != STATUS_OK)
{
set_error(res);
return NULL;
}
// Check type
const raw_resource_t *ent = &pCatalog[index];
if (ent->type != RES_FILE)
{
set_error(STATUS_IS_DIRECTORY);
return NULL;
}
// Create decompressor
Decompressor *d = new Decompressor();
if (d == NULL)
{
set_error(STATUS_NO_MEM);
return NULL;
}
// Initialize decompressor and skip the desired amount of data to access the entry
res = d->init(&pData[ent->segment], nDataSize - ent->segment, ent->offset + ent->length, nBufRank);
if (res == STATUS_OK)
{
wssize_t skipped = d->skip(ent->offset);
if (skipped != ent->offset)
res = (skipped < 0) ? status_t(-skipped) : STATUS_CORRUPTED;
}
if (res == STATUS_OK)
return d;
delete d;
set_error(res);
return NULL;
}
ssize_t BuiltinLoader::enumerate(const io::Path *path, resource_t **list)
{
ssize_t index = 0;
lltl::darray xlist;
const raw_resource_t *ent;
// Root directory?
if ((path->is_empty()) || (path->equals(FILE_SEPARATOR_S)))
index = -1;
else
{
// Find entry and check that it is of directory type
status_t res = find_entry(&index, path);
if (res != STATUS_OK)
return -set_error(res);
ent = &pCatalog[index];
if (ent->type != RES_DIR)
return -set_error(STATUS_NOT_DIRECTORY);
}
// Now create list of nested items
for (size_t i=0; iparent != index) || (ent->name == NULL))
continue;
resource_t *item = xlist.add();
if (item == NULL)
return -set_error(STATUS_NO_MEM);
strncpy(item->name, ent->name, RESOURCE_NAME_MAX);
item->name[RESOURCE_NAME_MAX - 1] = '\0';
item->type = ent->type;
}
// Return result
index = xlist.size();
*list = xlist.release();
set_error(STATUS_OK);
return index;
}
} /* namespace resource */
} /* namespace lsp */