/*
* Copyright (C) 2025 Linux Studio Plugins Project
* (C) 2025 Vladimir Sadovnikov
*
* This file is part of lsp-runtime-lib
* Created on: 12 авг. 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
#include
namespace lsp
{
namespace bookmarks
{
static inline status_t read_exact(io::IInStream *is, void *dst, size_t count, status_t code)
{
wssize_t res = is->read_fully(dst, count);
if (res < 0)
return status_t(-res);
return (res == wssize_t(count)) ? STATUS_OK : code;
}
static inline status_t skip_exact(io::IInStream *is, size_t count, status_t code)
{
wssize_t res = is->skip(count);
if (res < 0)
return status_t(-res);
return (res == wssize_t(count)) ? STATUS_OK : code;
}
static inline size_t utf16_nlen(const lsp_utf16_t *s, size_t limit)
{
for (size_t i=0; iclear();
return STATUS_OK;
}
// Read in unicode mode
if (unicode)
{
size_t ubytes = length * sizeof(lsp_utf16_t);
lsp_utf16_t *us = reinterpret_cast(malloc(ubytes));
if (us == NULL)
return STATUS_NO_MEM;
lsp_finally { free(us); };
if ((res = read_exact(is, us, ubytes, STATUS_CORRUPTED)) != STATUS_OK)
return res;
return (s->set_utf16le(us, length)) ? STATUS_OK : STATUS_NO_MEM;
}
// Read in OEM encoding
char *os = reinterpret_cast(malloc(length));
if (os == NULL)
return STATUS_NO_MEM;
lsp_finally { free(os); };
if ((res = read_exact(is, os, length, STATUS_CORRUPTED)) != STATUS_OK)
return res;
return (s->set_native(os, length)) ? STATUS_OK : STATUS_NO_MEM;
}
static status_t fetch_bookmark_path(LSPString *path, const io::Path *location, io::IInStream *is)
{
status_t res;
LSPString li_base, li_ubase, name, rel_path, work_dir, arguments, icon_location;
io::Path xpath;
// Read LNK header
lnk::shlink_header_t hdr;
if ((res = read_exact(is, &hdr, sizeof(hdr), STATUS_BAD_FORMAT)) != STATUS_OK)
return res;
// Validate LNK header and signature
if (LE_TO_CPU(hdr.size) != sizeof(hdr))
return STATUS_BAD_FORMAT;
if ((LE_TO_CPU(hdr.clsid.parts[0]) != lnk::SHLINK_FILE_HEADER_GUID.parts[0]) ||
(LE_TO_CPU(hdr.clsid.parts[1]) != lnk::SHLINK_FILE_HEADER_GUID.parts[1]) ||
(LE_TO_CPU(hdr.clsid.parts[2]) != lnk::SHLINK_FILE_HEADER_GUID.parts[2]) ||
(LE_TO_CPU(hdr.clsid.parts[3]) != lnk::SHLINK_FILE_HEADER_GUID.parts[3]))
return STATUS_BAD_FORMAT;
uint32_t flags = LE_TO_CPU(hdr.flags);
// Skip the record if it doesn't reference the directory
if (!(LE_TO_CPU(hdr.file_attributes) & lnk::SHLINK_FILE_ATTRIBUTE_DIRECTORY))
return STATUS_SKIP;
// Skip the IDList if it is present
if (flags & lnk::SHLINK_HAS_LINK_TARGET_IDLIST)
{
lnk::shlink_idlist_t idlist;
if ((res = read_exact(is, &idlist, sizeof(idlist), STATUS_CORRUPTED)) != STATUS_OK)
return res;
if ((res = skip_exact(is, LE_TO_CPU(idlist.size), STATUS_CORRUPTED)) != STATUS_OK)
return res;
}
// Process the LINKINFO structure
if (flags & lnk::SHLINK_HAS_LINK_INFO)
{
lnk::shlink_link_info_t li;
lnk::shlink_link_info_opt_t lio;
size_t li_offset = 0;
bzero(&lio, sizeof(lio));
// Mandatory header
if ((res = read_exact(is, &li, sizeof(li), STATUS_CORRUPTED)) != STATUS_OK)
return res;
li_offset += sizeof(li);
// Parse fields of mandatory header and read optional header
uint32_t li_size = LE_TO_CPU(li.size);
uint32_t li_hdr_size = LE_TO_CPU(li.header_size);
uint32_t li_flags = LE_TO_CPU(li.flags);
if (li_size < sizeof(li))
return STATUS_CORRUPTED;
if (li_hdr_size < sizeof(li))
return STATUS_CORRUPTED;
else if (li_hdr_size > sizeof(li))
{
// Read optional header
size_t left = li_hdr_size - sizeof(li);
size_t extra = lsp_min(left, sizeof(lio));
if ((res = read_exact(is, &lio, extra, STATUS_CORRUPTED)) != STATUS_OK)
return res;
if ((res = skip_exact(is, left - extra, STATUS_CORRUPTED)) != STATUS_OK)
return res;
li_offset += left;
}
// Read the rest data from the link info
const size_t li_rest = li_size - li_offset;
uint8_t *li_data = reinterpret_cast(malloc(li_rest));
if (li_data == NULL)
return STATUS_NO_MEM;
lsp_finally { free(li_data); };
if ((res = read_exact(is, li_data, li_rest, STATUS_CORRUPTED)) != STATUS_OK)
return res;
// Process the link info data suffix paths
LSPString li_suffix, li_usuffix;
if (li_flags & lnk::SHLINK_LINK_INFO_COMMON_NETWORK_RELATIVE_LINK_AND_PATH_SUFFIX)
{
// Read the CommonPathSuffixOffset
uint32_t li_suffix_off = LE_TO_CPU(li.common_path_suffix_offset);
if (li_suffix_off != 0)
{
if (li_suffix_off < li_offset)
return STATUS_CORRUPTED;
const char *li_suffix_ptr = reinterpret_cast(&li_data[li_suffix_off - li_offset]);
size_t li_suffix_len = strnlen(li_suffix_ptr, li_rest);
if (!li_suffix.set_native(li_suffix_ptr, li_suffix_len))
return STATUS_NO_MEM;
}
// Read the CommonPathSuffixUnicode
uint32_t li_usuffix_off = LE_TO_CPU(lio.local_base_path_suffix_offset_unicode);
if (li_usuffix_off != 0)
{
if (li_usuffix_off < li_offset)
return STATUS_CORRUPTED;
const lsp_utf16_t *li_usuffix_ptr = reinterpret_cast(&li_data[li_usuffix_off - li_offset]);
size_t li_usuffix_len = utf16_nlen(li_usuffix_ptr, li_rest/sizeof(lsp_utf16_t));
if (!li_suffix.set_utf16le(li_usuffix_ptr, li_usuffix_len))
return STATUS_NO_MEM;
}
}
// Process the link info data base paths
if (li_flags & lnk::SHLINK_LINK_INFO_VOLUME_ID_AND_LOCAL_BASE_PATH)
{
// Read the LocalBasePath
uint32_t li_base_off = LE_TO_CPU(li.local_base_path_offset);
if (li_base_off != 0)
{
if (li_base_off < li_offset)
return STATUS_CORRUPTED;
const char *li_base_ptr = reinterpret_cast(&li_data[li_base_off - li_offset]);
size_t li_base_len = strnlen(li_base_ptr, li_rest);
if (!li_base.set_native(li_base_ptr, li_base_len))
return STATUS_NO_MEM;
if (!li_base.append(&li_suffix))
return STATUS_NO_MEM;
}
// Read the LocalBasePathUnicode
uint32_t li_ubase_off = LE_TO_CPU(lio.local_base_path_offset_unicode);
if (li_ubase_off != 0)
{
if (li_ubase_off < li_offset)
return STATUS_CORRUPTED;
const lsp_utf16_t *li_ubase_ptr = reinterpret_cast(&li_data[li_ubase_off - li_offset]);
size_t li_ubase_len = utf16_nlen(li_ubase_ptr, li_rest/sizeof(lsp_utf16_t));
if (!li_ubase.set_utf16le(li_ubase_ptr, li_ubase_len))
return STATUS_NO_MEM;
if (!li_ubase.append(&li_usuffix))
return STATUS_NO_MEM;
}
}
} // SHLINK_HAS_LINK_INFO
// Process the STRING_DATA section
const bool unicode = flags & lnk:: SHLINK_IS_UNICODE;
if (flags & lnk::SHLINK_HAS_NAME)
{
if ((res = read_string_data(is, &name, unicode)) != STATUS_OK)
return res;
}
if (flags & lnk::SHLINK_HAS_RELATIVE_PATH)
{
if ((res = read_string_data(is, &rel_path, unicode)) != STATUS_OK)
return res;
}
if (flags & lnk::SHLINK_HAS_WORKING_DIR)
{
if ((res = read_string_data(is, &work_dir, unicode)) != STATUS_OK)
return res;
}
if (flags & lnk::SHLINK_HAS_ARGUMENTS)
{
if ((res = read_string_data(is, &arguments, unicode)) != STATUS_OK)
return res;
}
if (flags & lnk::SHLINK_HAS_ICON_LOCATION)
{
if ((res = read_string_data(is, &icon_location, unicode)) != STATUS_OK)
return res;
}
// We don't need to parse the rest data, just analyze what we got
// Check that unicode LocalBasePath is present
if (li_ubase.length() > 0)
{
li_ubase.swap(path);
return STATUS_OK;
}
// Check that OEM LocalBasePath is present
if (li_base.length() > 0)
{
li_base.swap(path);
return STATUS_OK;
}
// Check if some string data has been present...
if (work_dir.length() > 0)
{
if (!work_dir.append(&rel_path))
return STATUS_NO_MEM;
if ((res = xpath.set(&work_dir)) != STATUS_OK)
return res;
if ((res = xpath.canonicalize()) != STATUS_OK)
return res;
return xpath.get(path);
}
if (rel_path.length() > 0)
{
if ((res = location->get_parent(&xpath)) != STATUS_OK)
return res;
if ((res = xpath.append_child(&rel_path)) != STATUS_OK)
return res;
if ((res = xpath.canonicalize()) != STATUS_OK)
return res;
return xpath.get(path);
}
// Actually, we didn't find any proper fields to fetch the path to the bookmarks
return STATUS_SKIP;
}
static status_t read_bookmark_path(LSPString *path, io::Dir *dh, LSPString *child)
{
status_t res;
io::InFileStream is;
io::Path p;
if ((res = dh->get_path(&p)) != STATUS_OK)
return res;
if ((res = p.append_child(child)) != STATUS_OK)
return res;
if ((res = is.open(&p)) != STATUS_OK)
return res;
res = fetch_bookmark_path(path, &p, &is);
status_t res2 = is.close();
return (res != STATUS_OK) ? res : res2;
}
static status_t read_bookmarks_lnk(lltl::parray *dst, io::Dir *dh)
{
LSPString fname;
status_t res;
lltl::parray list;
lsp_finally { destroy_bookmarks(&list); };
// Read directory entries
while ((res = dh->read(&fname)) == STATUS_OK)
{
if (!fname.ends_with_ascii_nocase(".lnk"))
continue;
// Create bookmark
bookmark_t *bm = new bookmark_t();
if (bm == NULL)
return STATUS_NO_MEM;
lsp_finally {
if (bm != NULL)
delete bm;
};
// Set the value
bm->origin = BM_LNK;
if (!bm->name.set(&fname, 0, fname.length() - 4)) // All except the '.lnk' extension
return STATUS_NO_MEM;
if ((res = read_bookmark_path(&bm->path, dh, &fname)) != STATUS_OK)
{
if ((res == STATUS_BAD_FORMAT) ||
(res == STATUS_CORRUPTED) ||
(res == STATUS_SKIP))
continue;
return res;
}
// Add bookmark to list if we have successfully read the path
if (!list.add(bm))
return STATUS_NO_MEM;
bm = NULL; // Release reference to avoid bookmark object deletion
}
// Commit result and return
if (res != STATUS_EOF)
return res;
list.swap(dst);
return STATUS_OK;
}
status_t read_bookmarks_lnk(lltl::parray *dst, const char *path)
{
io::Dir dh;
status_t res = dh.open(path);
if (res != STATUS_OK)
return res;
lsp_finally { dh.close(); };
return read_bookmarks_lnk(dst, &dh);
}
status_t read_bookmarks_lnk(lltl::parray *dst, const LSPString *path)
{
io::Dir dh;
status_t res = dh.open(path);
if (res != STATUS_OK)
return res;
lsp_finally { dh.close(); };
return read_bookmarks_lnk(dst, &dh);
}
status_t read_bookmarks_lnk(lltl::parray *dst, const io::Path *path)
{
io::Dir dh;
status_t res = dh.open(path);
if (res != STATUS_OK)
return res;
lsp_finally { dh.close(); };
return read_bookmarks_lnk(dst, &dh);
}
} /* namespace bookmarks */
} /* namespace lsp */