mirror of
https://github.com/torlando-tech/pyxis.git
synced 2026-08-25 03:59:49 +00:00
400 lines
16 KiB
C++
400 lines
16 KiB
C++
#include "NomadNetLibrary.h"
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <cctype>
|
|
#include <limits>
|
|
|
|
namespace UI::LXMF::NomadNet {
|
|
namespace {
|
|
|
|
bool is_hex32(const std::string& value) {
|
|
if (value.size() != 32) return false;
|
|
for (const unsigned char c : value)
|
|
if (!std::isxdigit(c)) return false;
|
|
return true;
|
|
}
|
|
|
|
std::string lower_hex(std::string value) {
|
|
for (char& c : value) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
|
|
return value;
|
|
}
|
|
|
|
std::string utf8_prefix(const std::string& value, std::size_t max_bytes);
|
|
|
|
bool valid_page_url(const std::string& value) {
|
|
if (value.size() > Library::MAX_URL_BYTES || value.size() <= 39 ||
|
|
!is_hex32(value.substr(0, 32)) || value[32] != ':' ||
|
|
value.compare(33, 6, "/page/") != 0) return false;
|
|
if (utf8_prefix(value, value.size()) != value) return false;
|
|
return std::none_of(value.begin() + 33, value.end(), [](unsigned char c) {
|
|
return c < 0x20 || c == 0x7f;
|
|
});
|
|
}
|
|
|
|
std::string utf8_prefix(const std::string& value, std::size_t max_bytes) {
|
|
std::size_t i = 0;
|
|
while (i < value.size() && i < max_bytes) {
|
|
const uint8_t c = static_cast<uint8_t>(value[i]);
|
|
std::size_t length = 1;
|
|
if (c < 0x80) length = 1;
|
|
else if (c >= 0xc2 && c <= 0xdf) length = 2;
|
|
else if (c >= 0xe0 && c <= 0xef) length = 3;
|
|
else if (c >= 0xf0 && c <= 0xf4) length = 4;
|
|
else break;
|
|
if (i + length > value.size() || i + length > max_bytes) break;
|
|
bool continuation = true;
|
|
for (std::size_t j = 1; j < length; ++j)
|
|
continuation = continuation &&
|
|
((static_cast<uint8_t>(value[i + j]) & 0xc0) == 0x80);
|
|
if (continuation && length == 3) {
|
|
const uint8_t second = static_cast<uint8_t>(value[i + 1]);
|
|
if ((c == 0xe0 && second < 0xa0) || (c == 0xed && second >= 0xa0)) continuation = false;
|
|
} else if (continuation && length == 4) {
|
|
const uint8_t second = static_cast<uint8_t>(value[i + 1]);
|
|
if ((c == 0xf0 && second < 0x90) || (c == 0xf4 && second >= 0x90)) continuation = false;
|
|
}
|
|
if (!continuation) break;
|
|
i += length;
|
|
}
|
|
return value.substr(0, i);
|
|
}
|
|
|
|
char nibble(uint8_t value) { return value < 10 ? static_cast<char>('0' + value) : static_cast<char>('a' + value - 10); }
|
|
|
|
std::string hex_encode(const std::string& value) {
|
|
std::string encoded;
|
|
encoded.reserve(value.size() * 2);
|
|
for (const uint8_t c : value) {
|
|
encoded.push_back(nibble(c >> 4));
|
|
encoded.push_back(nibble(c & 0x0f));
|
|
}
|
|
return encoded;
|
|
}
|
|
|
|
int hex_value(char c) {
|
|
if (c >= '0' && c <= '9') return c - '0';
|
|
if (c >= 'a' && c <= 'f') return 10 + c - 'a';
|
|
if (c >= 'A' && c <= 'F') return 10 + c - 'A';
|
|
return -1;
|
|
}
|
|
|
|
bool hex_decode(const std::string& encoded, std::string& value, std::size_t max_bytes) {
|
|
if ((encoded.size() & 1) != 0 || encoded.size() / 2 > max_bytes) return false;
|
|
value.clear();
|
|
value.reserve(encoded.size() / 2);
|
|
for (std::size_t i = 0; i < encoded.size(); i += 2) {
|
|
const int high = hex_value(encoded[i]);
|
|
const int low = hex_value(encoded[i + 1]);
|
|
if (high < 0 || low < 0) return false;
|
|
value.push_back(static_cast<char>((high << 4) | low));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool parse_u64(const std::string& value, uint64_t& parsed) {
|
|
if (value.empty()) return false;
|
|
parsed = 0;
|
|
for (const char c : value) {
|
|
if (c < '0' || c > '9') return false;
|
|
const uint64_t digit = static_cast<uint64_t>(c - '0');
|
|
if (parsed > (std::numeric_limits<uint64_t>::max() - digit) / 10) return false;
|
|
parsed = parsed * 10 + digit;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
std::vector<std::string> split_tabs(const std::string& line) {
|
|
std::vector<std::string> fields;
|
|
std::size_t start = 0;
|
|
while (true) {
|
|
const auto next = line.find('\t', start);
|
|
fields.push_back(line.substr(start, next == std::string::npos ? next : next - start));
|
|
if (next == std::string::npos) break;
|
|
start = next + 1;
|
|
}
|
|
return fields;
|
|
}
|
|
|
|
template <typename Record>
|
|
void move_to_front(std::vector<Record>& records, std::size_t index) {
|
|
if (index == 0) return;
|
|
Record record = std::move(records[index]);
|
|
records.erase(records.begin() + static_cast<std::ptrdiff_t>(index));
|
|
records.insert(records.begin(), std::move(record));
|
|
}
|
|
|
|
template <typename Record>
|
|
bool make_room(std::vector<Record>& records, std::size_t limit) {
|
|
if (records.size() < limit) return true;
|
|
for (std::size_t i = records.size(); i-- > 0;) {
|
|
if (!records[i].saved) {
|
|
records.erase(records.begin() + static_cast<std::ptrdiff_t>(i));
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void sort_nodes(std::vector<NodeRecord>& records) {
|
|
std::stable_sort(records.begin(), records.end(), [](const NodeRecord& left, const NodeRecord& right) {
|
|
return left.last_heard > right.last_heard;
|
|
});
|
|
}
|
|
|
|
void sort_pages(std::vector<PageRecord>& records) {
|
|
std::stable_sort(records.begin(), records.end(), [](const PageRecord& left, const PageRecord& right) {
|
|
return left.last_opened > right.last_opened;
|
|
});
|
|
}
|
|
|
|
} // namespace
|
|
|
|
std::string sanitize_directory_name(const uint8_t* data, std::size_t size) {
|
|
if (!data || size == 0) return {};
|
|
const std::size_t bounded = std::min(size, Library::MAX_NAME_BYTES);
|
|
std::string value(reinterpret_cast<const char*>(data), bounded);
|
|
value = utf8_prefix(value, Library::MAX_NAME_BYTES);
|
|
for (char& c : value) {
|
|
const uint8_t byte = static_cast<uint8_t>(c);
|
|
if (byte < 0x20 || byte == 0x7f) c = ' ';
|
|
}
|
|
while (!value.empty() && value.back() == ' ') value.pop_back();
|
|
std::size_t first = 0;
|
|
while (first < value.size() && value[first] == ' ') ++first;
|
|
return value.substr(first);
|
|
}
|
|
|
|
std::string page_title(const std::string& fallback, const std::vector<std::string>& heading_runs) {
|
|
std::string title;
|
|
for (const auto& run : heading_runs) title += run;
|
|
title = sanitize_directory_name(reinterpret_cast<const uint8_t*>(title.data()), title.size());
|
|
if (title.empty()) title = fallback;
|
|
return utf8_prefix(title, Library::MAX_TITLE_BYTES);
|
|
}
|
|
|
|
bool Library::hear_node(const std::string& destination_hex, const std::string& name,
|
|
uint64_t timestamp, uint8_t hops) {
|
|
if (!is_hex32(destination_hex)) return false;
|
|
const std::string normalized = lower_hex(destination_hex);
|
|
const std::string safe_name = sanitize_directory_name(
|
|
reinterpret_cast<const uint8_t*>(name.data()), name.size());
|
|
for (std::size_t i = 0; i < _nodes.size(); ++i) {
|
|
if (_nodes[i].destination_hex != normalized) continue;
|
|
const bool changed = timestamp > _nodes[i].last_heard || _nodes[i].hops != hops ||
|
|
(!safe_name.empty() && _nodes[i].name != safe_name);
|
|
if (!changed) return false;
|
|
_nodes[i].last_heard = std::max(_nodes[i].last_heard, timestamp);
|
|
_nodes[i].hops = hops;
|
|
if (!safe_name.empty()) _nodes[i].name = safe_name;
|
|
move_to_front(_nodes, i);
|
|
sort_nodes(_nodes);
|
|
return true;
|
|
}
|
|
if (!make_room(_nodes, MAX_NODES)) return false;
|
|
_nodes.insert(_nodes.begin(), NodeRecord{normalized, safe_name, timestamp, hops, false});
|
|
sort_nodes(_nodes);
|
|
return true;
|
|
}
|
|
|
|
bool Library::record_page(const std::string& url, const std::string& title, uint64_t timestamp) {
|
|
if (!valid_page_url(url)) return false;
|
|
const std::string normalized = lower_hex(url.substr(0, 32)) + url.substr(32);
|
|
const std::string safe_title = utf8_prefix(sanitize_directory_name(
|
|
reinterpret_cast<const uint8_t*>(title.data()), title.size()), MAX_TITLE_BYTES);
|
|
for (std::size_t i = 0; i < _pages.size(); ++i) {
|
|
if (_pages[i].url != normalized) continue;
|
|
const bool changed = timestamp > _pages[i].last_opened ||
|
|
(!safe_title.empty() && _pages[i].title != safe_title);
|
|
if (!changed) return false;
|
|
_pages[i].last_opened = std::max(_pages[i].last_opened, timestamp);
|
|
if (!safe_title.empty()) _pages[i].title = safe_title;
|
|
move_to_front(_pages, i);
|
|
sort_pages(_pages);
|
|
return true;
|
|
}
|
|
if (!make_room(_pages, MAX_PAGES)) return false;
|
|
_pages.insert(_pages.begin(), PageRecord{normalized, safe_title, timestamp, false});
|
|
sort_pages(_pages);
|
|
return true;
|
|
}
|
|
|
|
bool Library::set_node_saved(const std::string& destination_hex, bool saved) {
|
|
if (!is_hex32(destination_hex)) return false;
|
|
const std::string normalized = lower_hex(destination_hex);
|
|
for (auto& node : _nodes) {
|
|
if (node.destination_hex == normalized) { node.saved = saved; return true; }
|
|
}
|
|
if (!saved || !make_room(_nodes, MAX_NODES)) return false;
|
|
_nodes.insert(_nodes.begin(), NodeRecord{normalized, {}, 0, 0, true});
|
|
sort_nodes(_nodes);
|
|
return true;
|
|
}
|
|
|
|
bool Library::set_node_identified(const std::string& destination_hex, bool identified) {
|
|
if (!is_hex32(destination_hex)) return false;
|
|
const std::string normalized = lower_hex(destination_hex);
|
|
for (auto& node : _nodes) {
|
|
if (node.destination_hex != normalized) continue;
|
|
node.identify_on_connect = identified;
|
|
return true;
|
|
}
|
|
if (!identified || !make_room(_nodes, MAX_NODES)) return false;
|
|
_nodes.insert(_nodes.begin(), NodeRecord{normalized, {}, 0, 0, false, true});
|
|
sort_nodes(_nodes);
|
|
return true;
|
|
}
|
|
|
|
bool Library::set_page_saved(const std::string& url, bool saved) {
|
|
if (!valid_page_url(url)) return false;
|
|
const std::string normalized = lower_hex(url.substr(0, 32)) + url.substr(32);
|
|
for (auto& page : _pages) {
|
|
if (page.url != normalized) continue;
|
|
if (saved && !set_node_saved(normalized.substr(0, 32), true)) return false;
|
|
page.saved = saved;
|
|
if (!saved) {
|
|
const std::string destination = normalized.substr(0, 32);
|
|
const bool another_saved_page = std::any_of(_pages.begin(), _pages.end(),
|
|
[&](const PageRecord& candidate) {
|
|
return candidate.saved && candidate.url.compare(0, 32, destination) == 0;
|
|
});
|
|
if (!another_saved_page) set_node_saved(destination, false);
|
|
}
|
|
return true;
|
|
}
|
|
if (!saved) return false;
|
|
// Saving an unrecorded page is transactional: node admission and page
|
|
// eviction must either both succeed or leave the live library untouched.
|
|
Library candidate = *this;
|
|
if (!candidate.set_node_saved(normalized.substr(0, 32), true) ||
|
|
!candidate.record_page(normalized, {}, 0)) return false;
|
|
for (auto& page : candidate._pages) {
|
|
if (page.url == normalized) {
|
|
page.saved = true;
|
|
*this = std::move(candidate);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Library::remove_heard_node(const std::string& destination_hex) {
|
|
if (!is_hex32(destination_hex)) return false;
|
|
const std::string normalized = lower_hex(destination_hex);
|
|
const auto found = std::find_if(_nodes.begin(), _nodes.end(), [&](const NodeRecord& node) {
|
|
return node.destination_hex == normalized;
|
|
});
|
|
if (found == _nodes.end() || found->saved) return false;
|
|
_nodes.erase(found);
|
|
return true;
|
|
}
|
|
|
|
bool Library::node_saved(const std::string& destination_hex) const {
|
|
if (!is_hex32(destination_hex)) return false;
|
|
const std::string normalized = lower_hex(destination_hex);
|
|
return std::any_of(_nodes.begin(), _nodes.end(), [&](const NodeRecord& node) {
|
|
return node.destination_hex == normalized && node.saved;
|
|
});
|
|
}
|
|
|
|
bool Library::node_identified(const std::string& destination_hex) const {
|
|
if (!is_hex32(destination_hex)) return false;
|
|
const std::string normalized = lower_hex(destination_hex);
|
|
return std::any_of(_nodes.begin(), _nodes.end(), [&](const NodeRecord& node) {
|
|
return node.destination_hex == normalized && node.identify_on_connect;
|
|
});
|
|
}
|
|
|
|
bool Library::page_saved(const std::string& url) const {
|
|
if (!valid_page_url(url)) return false;
|
|
const std::string normalized = lower_hex(url.substr(0, 32)) + url.substr(32);
|
|
return std::any_of(_pages.begin(), _pages.end(), [&](const PageRecord& page) {
|
|
return page.url == normalized && page.saved;
|
|
});
|
|
}
|
|
|
|
ExternalVector<uint8_t> Library::encode() const {
|
|
ExternalVector<uint8_t> output;
|
|
output.reserve(4096);
|
|
const auto append = [&](const std::string& value) {
|
|
output.insert(output.end(), value.begin(), value.end());
|
|
};
|
|
append("PXNN2\n");
|
|
for (const auto& node : _nodes) {
|
|
append("N\t" + node.destination_hex + "\t" + hex_encode(node.name) + "\t" +
|
|
std::to_string(node.last_heard) + "\t" + std::to_string(node.hops) + "\t" +
|
|
(node.saved ? "1\t" : "0\t") +
|
|
(node.identify_on_connect ? "1\n" : "0\n"));
|
|
if (output.size() > MAX_ENCODED_BYTES) return {};
|
|
}
|
|
for (const auto& page : _pages) {
|
|
append("P\t" + hex_encode(page.url) + "\t" + hex_encode(page.title) + "\t" +
|
|
std::to_string(page.last_opened) + "\t" + (page.saved ? "1\n" : "0\n"));
|
|
if (output.size() > MAX_ENCODED_BYTES) return {};
|
|
}
|
|
return output;
|
|
}
|
|
|
|
bool Library::decode(const uint8_t* data, std::size_t size) {
|
|
if (!data || size < 6 || size > MAX_ENCODED_BYTES) return false;
|
|
const bool legacy = std::equal(data, data + 6,
|
|
reinterpret_cast<const uint8_t*>("PXNN1\n"));
|
|
const bool current = std::equal(data, data + 6,
|
|
reinterpret_cast<const uint8_t*>("PXNN2\n"));
|
|
if ((!legacy && !current) || data[size - 1] != '\n') return false;
|
|
|
|
Library candidate;
|
|
std::size_t start = 6;
|
|
while (start < size) {
|
|
std::size_t end = start;
|
|
while (end < size && data[end] != '\n') ++end;
|
|
if (end == size || end - start > 1400) return false;
|
|
const std::string line(reinterpret_cast<const char*>(data + start), end - start);
|
|
start = end + 1;
|
|
if (line.empty()) continue;
|
|
const auto fields = split_tabs(line);
|
|
if (fields[0] == "N") {
|
|
const std::size_t expected_fields = legacy ? 6 : 7;
|
|
if (fields.size() != expected_fields || candidate._nodes.size() >= MAX_NODES ||
|
|
!is_hex32(fields[1]) || (fields[5] != "0" && fields[5] != "1") ||
|
|
(!legacy && fields[6] != "0" && fields[6] != "1")) return false;
|
|
std::string name;
|
|
uint64_t timestamp = 0, hops = 0;
|
|
if (!hex_decode(fields[2], name, MAX_NAME_BYTES) ||
|
|
!parse_u64(fields[3], timestamp) || !parse_u64(fields[4], hops) || hops > 255) return false;
|
|
const std::string destination = lower_hex(fields[1]);
|
|
if (candidate.node_saved(destination) || std::any_of(candidate._nodes.begin(), candidate._nodes.end(),
|
|
[&](const NodeRecord& node) { return node.destination_hex == destination; })) return false;
|
|
const std::string canonical_name = sanitize_directory_name(
|
|
reinterpret_cast<const uint8_t*>(name.data()), name.size());
|
|
if (canonical_name != name) return false;
|
|
candidate._nodes.push_back(NodeRecord{destination, canonical_name, timestamp,
|
|
static_cast<uint8_t>(hops), fields[5] == "1", !legacy && fields[6] == "1"});
|
|
} else if (fields[0] == "P") {
|
|
if (fields.size() != 5 || candidate._pages.size() >= MAX_PAGES ||
|
|
(fields[4] != "0" && fields[4] != "1")) return false;
|
|
std::string url, title;
|
|
uint64_t timestamp = 0;
|
|
if (!hex_decode(fields[1], url, MAX_URL_BYTES) || !valid_page_url(url) ||
|
|
!hex_decode(fields[2], title, MAX_TITLE_BYTES) || !parse_u64(fields[3], timestamp)) return false;
|
|
const std::string normalized = lower_hex(url.substr(0, 32)) + url.substr(32);
|
|
if (std::any_of(candidate._pages.begin(), candidate._pages.end(),
|
|
[&](const PageRecord& page) { return page.url == normalized; })) return false;
|
|
const std::string canonical_title = sanitize_directory_name(
|
|
reinterpret_cast<const uint8_t*>(title.data()), title.size());
|
|
if (canonical_title != title) return false;
|
|
candidate._pages.push_back(PageRecord{normalized, canonical_title, timestamp, fields[4] == "1"});
|
|
} else return false;
|
|
}
|
|
_nodes = std::move(candidate._nodes);
|
|
_pages = std::move(candidate._pages);
|
|
return true;
|
|
}
|
|
|
|
void Library::clear() {
|
|
_nodes.clear();
|
|
_pages.clear();
|
|
}
|
|
|
|
} // namespace UI::LXMF::NomadNet
|