/* * Copyright (C) 2025 Linux Studio Plugins Project * (C) 2025 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 24 окт. 2022 г. * * 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 #include #include namespace lsp { namespace lspc { //--------------------------------------------------------------------- // Allocation/deallocation LSP_RUNTIME_LIB_PUBLIC path_entry_t *alloc_path(size_t path_len) { // Allocate entry size_t hdr_size = align_size(sizeof(path_entry_t), sizeof(umword_t)); size_t path_size = align_size(path_len + 1, sizeof(umword_t)); uint8_t *bytes = static_cast(malloc(hdr_size + path_size)); if (bytes == NULL) return NULL; path_entry_t *res = reinterpret_cast(bytes); char *str = reinterpret_cast(&bytes[hdr_size]); // Fill entry with data res->path = str; res->flags = 0; res->chunk_id = 0; return res; } LSP_RUNTIME_LIB_PUBLIC path_entry_t *alloc_path(const char *path, size_t flags, chunk_id_t reference_id) { if (path == NULL) return NULL; // Allocate entry size_t path_len = strlen(path) + 1; path_entry_t *res = alloc_path(path_len); if (res == NULL) return NULL; // Fill entry with data res->flags = uint32_t(flags); res->chunk_id = reference_id; memcpy(res->path, path, path_len); return res; } LSP_RUNTIME_LIB_PUBLIC path_entry_t *alloc_path(const io::Path *path, size_t flags, chunk_id_t reference_id) { if (path == NULL) return NULL; return alloc_path(path->as_utf8(), flags, reference_id); } LSP_RUNTIME_LIB_PUBLIC path_entry_t *alloc_path(const LSPString *path, size_t flags, chunk_id_t reference_id) { if (path == NULL) return NULL; return alloc_path(path->get_utf8(), flags, reference_id); } LSP_RUNTIME_LIB_PUBLIC void free_path(path_entry_t * path) { if (path != NULL) free(path); } //--------------------------------------------------------------------- // Write operations LSP_RUNTIME_LIB_PUBLIC status_t write_path(chunk_id_t *chunk_id, File *file, const path_entry_t *path) { if (path == NULL) return STATUS_BAD_ARGUMENTS; // Create chunk and remember it's size status_t res; lspc::ChunkWriter *cw = file->write_chunk(LSPC_CHUNK_PATH); if (cw == NULL) return STATUS_BAD_STATE; lsp_finally { delete cw; }; chunk_id_t res_chunk_id = cw->unique_id(); // Create header size_t path_size = strlen(path->path); if (path_size > UINT16_MAX) return STATUS_OVERFLOW; chunk_path_t cp; bzero(&cp, sizeof(cp)); cp.common.size = sizeof(cp); cp.common.version = 0; cp.path_size = path_size; cp.flags = path->flags; cp.chunk_id = path->chunk_id; // Convert endianess cp.path_size = CPU_TO_BE(cp.path_size); cp.flags = CPU_TO_BE(cp.flags); cp.chunk_id = CPU_TO_BE(cp.chunk_id); if ((res = cw->write_header(&cp)) != STATUS_OK) return res; if ((res = cw->write(path->path, path_size)) != STATUS_OK) return res; if ((res = cw->close()) != STATUS_OK) return res; // Return result if (chunk_id != NULL) *chunk_id = res_chunk_id; return STATUS_OK; } LSP_RUNTIME_LIB_PUBLIC status_t write_path(chunk_id_t *chunk_id, File *file, const char *path, size_t flags, chunk_id_t reference_id) { if (path == NULL) return STATUS_BAD_ARGUMENTS; // Convert path to unix-like path string LSPString tmp; if (!tmp.set_utf8(path)) return STATUS_NO_MEM; tmp.replace_all('\\', '/'); // Write the entry path_entry_t pe; pe.path = const_cast(tmp.get_utf8()); pe.flags = uint32_t(flags); pe.chunk_id = reference_id; return write_path(chunk_id, file, &pe); } LSP_RUNTIME_LIB_PUBLIC status_t write_path(chunk_id_t *chunk_id, File *file, const LSPString *path, size_t flags, chunk_id_t reference_id) { if (path == NULL) return STATUS_BAD_ARGUMENTS; // Convert path to unix-like path string LSPString tmp; if (!tmp.set(path)) return STATUS_NO_MEM; tmp.replace_all('\\', '/'); // Write the entry path_entry_t pe; pe.path = const_cast(tmp.get_utf8()); pe.flags = uint32_t(flags); pe.chunk_id = reference_id; return write_path(chunk_id, file, &pe); } LSP_RUNTIME_LIB_PUBLIC status_t write_path(chunk_id_t *chunk_id, File *file, const io::Path *path, size_t flags, chunk_id_t reference_id) { if (path == NULL) return STATUS_BAD_ARGUMENTS; // Convert path to unix-like path string LSPString tmp; status_t res = path->get(&tmp); if (res != STATUS_OK) return res; tmp.replace_all('\\', '/'); // Write the entry path_entry_t pe; pe.path = const_cast(tmp.get_utf8()); pe.flags = uint32_t(flags); pe.chunk_id = reference_id; return write_path(chunk_id, file, &pe); } //--------------------------------------------------------------------- // Read operations LSP_RUNTIME_LIB_PUBLIC status_t read_path(chunk_id_t chunk_id, File *file, path_entry_t **path) { // Get the chunk if (file == NULL) return STATUS_BAD_ARGUMENTS; ChunkReader *rd = file->read_chunk(chunk_id, LSPC_CHUNK_PATH); if (rd == NULL) return STATUS_NOT_FOUND; lsp_finally { delete rd; }; // Read the header chunk_path_t hdr; ssize_t read = rd->read_header(&hdr, sizeof(hdr)); if (read < 0) return status_t(-read); else if (read != sizeof(hdr)) return STATUS_CORRUPTED; else if (hdr.common.version != 0) return STATUS_NOT_SUPPORTED; // Nothing to return? if (path == NULL) return STATUS_OK; // Convert the header hdr.path_size = BE_TO_CPU(hdr.path_size); hdr.flags = BE_TO_CPU(hdr.flags); hdr.chunk_id = BE_TO_CPU(hdr.chunk_id); // Allocate path entry path_entry_t *pe= alloc_path(hdr.path_size); if (pe == NULL) return STATUS_NO_MEM; lsp_finally { if (pe != NULL) free_path(pe); }; pe->flags = hdr.flags; pe->chunk_id = hdr.chunk_id; // Read the path string read = rd->read(pe->path, hdr.path_size); if (read < 0) return status_t(-read); else if (read != hdr.path_size) return STATUS_CORRUPTED; pe->path[hdr.path_size] = '\0'; // Do not forget the trailing zero // Close the reader status_t res = rd->close(); if (res != STATUS_OK) return res; // Return the result *path = pe; pe = NULL; return STATUS_OK; } LSP_RUNTIME_LIB_PUBLIC status_t read_path(chunk_id_t chunk_id, File *file, char **path, size_t *flags, chunk_id_t *reference_id) { // Read path entry path_entry_t *entry = NULL; status_t res = read_path(chunk_id, file, &entry); if (res != STATUS_OK) return res; else if (entry == NULL) return STATUS_NO_MEM; lsp_finally { free_path(entry); }; // Pass the arguments to the caller if (path != NULL) { char *p = strdup(entry->path); if (p == NULL) return STATUS_NO_MEM; *path = p; } if (flags != NULL) *flags = entry->flags; if (reference_id != NULL) *reference_id = entry->chunk_id; return STATUS_OK; } LSP_RUNTIME_LIB_PUBLIC status_t read_path(chunk_id_t chunk_id, File *file, io::Path *path, size_t *flags, chunk_id_t *reference_id) { // Read path entry path_entry_t *entry = NULL; status_t res = read_path(chunk_id, file, &entry); if (res != STATUS_OK) return res; else if (entry == NULL) return STATUS_NO_MEM; lsp_finally { free_path(entry); }; // Pass the arguments to the caller if (path != NULL) { if ((res = path->set(entry->path)) != STATUS_OK) return res; } if (flags != NULL) *flags = entry->flags; if (reference_id != NULL) *reference_id = entry->chunk_id; return STATUS_OK; } status_t read_path(chunk_id_t chunk_id, File *file, LSPString *path, size_t *flags, chunk_id_t *reference_id) { // Read path entry path_entry_t *entry = NULL; status_t res = read_path(chunk_id, file, &entry); if (res != STATUS_OK) return res; else if (entry == NULL) return STATUS_NO_MEM; lsp_finally { free_path(entry); }; // Pass the arguments to the caller if (path != NULL) { if (!path->set_utf8(entry->path)) return STATUS_NO_MEM; } if (flags != NULL) *flags = entry->flags; if (reference_id != NULL) *reference_id = entry->chunk_id; return STATUS_OK; } } /* namespace lspc */ } /* namespace lsp */