mirror of
https://github.com/vicliu624/trail-mate.git
synced 2026-11-11 14:47:39 +00:00
Trail Mate Dev
6e613e382e
Compose the CM0 fullscreen application and standard Debian package, align the Cardputer Zero shell, and share protocol, configuration, audio and storage services with embedded targets through existing platform seams. Add the paginated on-device TMAP creator using Center's published producer, private workspace recovery and direct keyboard shortcuts. Preserve unfinished management work behind its existing opt-in capability. Include native, ARM and shared-core regression fixtures, integration records, packaging helpers and dependency/license updates. Keep local build trees, device credentials, produced packages and validation logs outside version control. Validation before integration: ESP stack hygiene, Reticulum scope guard, staged whitespace checks and GitNexus scope audit. Prior device/build evidence and remaining hardware/package boundaries are recorded in the acceptance documents.
221 lines
10 KiB
C++
221 lines
10 KiB
C++
#include "app/linux_app_services.h"
|
|
#include "platform/linux/runtime_paths.h"
|
|
#include "platform/linux/settings_transaction.h"
|
|
#include "platform/ui/settings_reset_runtime.h"
|
|
#include "platform/ui/wifi_profile_snapshot.h"
|
|
#include "sys/event_bus.h"
|
|
#include <array>
|
|
#include <atomic>
|
|
#include <cassert>
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
#include <filesystem>
|
|
#include <sqlite3.h>
|
|
#include <sys/wait.h>
|
|
#include <thread>
|
|
#include <unistd.h>
|
|
|
|
namespace wifi = platform::ui::wifi;
|
|
namespace store = platform::ui::settings_store;
|
|
namespace native = platform::linux_runtime;
|
|
struct Snapshot
|
|
{
|
|
std::array<wifi::Config, wifi::kMaxSavedProfileCount> profiles{};
|
|
bool enabled = false;
|
|
size_t count = 0;
|
|
};
|
|
wifi::Config config(const char* ssid, const char* password, bool enabled = true)
|
|
{
|
|
wifi::Config result;
|
|
result.enabled = enabled;
|
|
std::snprintf(result.ssid, sizeof(result.ssid), "%s", ssid);
|
|
std::snprintf(result.password, sizeof(result.password), "%s", password);
|
|
return result;
|
|
}
|
|
Snapshot snapshot()
|
|
{
|
|
Snapshot result;
|
|
assert(wifi::read_saved_profiles_into(&result.enabled, &result.count, result.profiles.data(), result.profiles.size()));
|
|
return result;
|
|
}
|
|
struct Database
|
|
{
|
|
sqlite3* db = nullptr;
|
|
Database()
|
|
{
|
|
assert(sqlite3_open(native::sqlite_database_path().string().c_str(), &db) == SQLITE_OK);
|
|
assert(sqlite3_busy_timeout(db, 5000) == SQLITE_OK);
|
|
}
|
|
~Database() { sqlite3_close(db); }
|
|
void sql(const char* text) { assert(sqlite3_exec(db, text, nullptr, nullptr, nullptr) == SQLITE_OK); }
|
|
};
|
|
int main(int argc, char* argv[])
|
|
{
|
|
if (argc == 3 && !std::strcmp(argv[1], "--verify"))
|
|
{
|
|
const std::filesystem::path root(argv[2]);
|
|
setenv("TRAIL_MATE_SETTINGS_ROOT", (root / "settings").c_str(), 1);
|
|
setenv("TRAIL_MATE_CACHE_ROOT", (root / "cache").c_str(), 1);
|
|
setenv("TRAIL_MATE_SD_ROOT", (root / "sd").c_str(), 1);
|
|
const auto restored = snapshot();
|
|
assert(restored.enabled && restored.count == wifi::kMaxSavedProfileCount);
|
|
for (size_t i = 0; i < restored.count; ++i)
|
|
{
|
|
wifi::Config selected;
|
|
assert(wifi::find_saved_config(("Network-" + std::to_string(i)).c_str(), selected));
|
|
assert(selected.enabled && std::string(selected.password) == std::string(64, 'x'));
|
|
}
|
|
std::puts("Fresh process verified all ten saved Wi-Fi profiles");
|
|
return 0;
|
|
}
|
|
char pattern[] = "/tmp/trailmate-wifi-profiles-XXXXXX";
|
|
const auto* temporary = mkdtemp(pattern);
|
|
assert(temporary);
|
|
const std::filesystem::path root(temporary);
|
|
setenv("TRAIL_MATE_SETTINGS_ROOT", (root / "settings").c_str(), 1);
|
|
setenv("TRAIL_MATE_CACHE_ROOT", (root / "cache").c_str(), 1);
|
|
setenv("TRAIL_MATE_SD_ROOT", (root / "sd").c_str(), 1);
|
|
auto fresh = snapshot();
|
|
assert(fresh.enabled && fresh.count == 0);
|
|
assert(store::put_string("settings", "wifi_ssid", "Legacy"));
|
|
assert(store::put_string("settings", "wifi_password", "old-password"));
|
|
wifi::Config selected;
|
|
assert(wifi::load_config(selected) && !std::strcmp(selected.ssid, "Legacy"));
|
|
assert(snapshot().count == 1);
|
|
assert(wifi::save_config(config("Second", "second-password")));
|
|
assert(wifi::save_config(config("Third", "third-password", false)));
|
|
auto saved = snapshot();
|
|
assert(saved.count == 3 && !saved.enabled && !std::strcmp(saved.profiles[0].ssid, "Third"));
|
|
assert(wifi::find_saved_config("Legacy", selected) && !selected.enabled && !std::strcmp(selected.password, "old-password"));
|
|
assert(wifi::save_config(config("Legacy", "updated")));
|
|
assert(snapshot().count == 3 && wifi::load_config(selected) && !std::strcmp(selected.password, "updated"));
|
|
size_t visits = 0, count = 0;
|
|
bool enabled = false;
|
|
assert(wifi::visit_saved_profiles(
|
|
&enabled, &count,
|
|
[](void* context, size_t index, const wifi::Config& entry)
|
|
{
|
|
assert(index == (*static_cast<size_t*>(context))++ && entry.ssid[0]);
|
|
// A visitor can use the ordinary store after snapshot capture.
|
|
(void)store::get_bool("settings", "wifi_enabled", false);
|
|
return true;
|
|
},
|
|
&visits));
|
|
assert(enabled && visits == count && count == 3);
|
|
const std::string unicode_ssid = std::string(29, 'A') + "\xe4\xb8\xad";
|
|
assert(wifi::save_config(config(unicode_ssid.c_str(), std::string(64, 'x').c_str())));
|
|
assert(wifi::find_saved_config(unicode_ssid.c_str(), selected) && std::strlen(selected.ssid) == 32 && std::strlen(selected.password) == 64);
|
|
auto invalid_password = selected;
|
|
std::memset(invalid_password.password, 'x', sizeof(invalid_password.password));
|
|
assert(!wifi::save_config(invalid_password));
|
|
|
|
std::array<wifi::Config, wifi::kMaxSavedProfileCount> full;
|
|
for (size_t i = 0; i < full.size(); ++i)
|
|
{
|
|
full[i] = config(("Network-" + std::to_string(i)).c_str(), std::string(64, 'x').c_str());
|
|
}
|
|
assert(wifi::replace_saved_profiles(true, full.data(), full.size()));
|
|
assert(snapshot().count == full.size());
|
|
assert(wifi::save_config(config("Newest", "")));
|
|
assert(!wifi::find_saved_config("Network-9", selected) && wifi::find_saved_config("Network-0", selected));
|
|
auto duplicate = full;
|
|
duplicate[1] = duplicate[0];
|
|
assert(!wifi::replace_saved_profiles(true, duplicate.data(), duplicate.size()));
|
|
auto invalid = config("valid", "valid");
|
|
std::memset(invalid.ssid, 'x', sizeof(invalid.ssid));
|
|
assert(!wifi::save_config(invalid));
|
|
|
|
{
|
|
Database db;
|
|
db.sql("CREATE TRIGGER reject_wifi BEFORE INSERT ON settings WHEN NEW.key='wifi_password_1' BEGIN SELECT RAISE(ABORT,'injected'); END;");
|
|
const auto before = snapshot();
|
|
assert(!wifi::replace_saved_profiles(false, full.data(), 2));
|
|
const auto after = snapshot();
|
|
assert(after.enabled == before.enabled && after.count == before.count);
|
|
for (size_t i = 0; i < before.count; ++i)
|
|
assert(!std::strcmp(before.profiles[i].ssid, after.profiles[i].ssid) && !std::strcmp(before.profiles[i].password, after.profiles[i].password));
|
|
assert(wifi::load_config(selected) && !std::strcmp(selected.ssid, "Newest"));
|
|
db.sql("DROP TRIGGER reject_wifi;");
|
|
}
|
|
assert(wifi::replace_saved_profiles(true, full.data(), 1));
|
|
{
|
|
// Commit a competing raw SQLite write after the first snapshot read.
|
|
// The production read view must continue seeing the complete old set.
|
|
Database writer;
|
|
struct Reader
|
|
{
|
|
const native::SettingsReadView& view;
|
|
Database& writer;
|
|
store::ScalarReadResult read_bool_into(const char* ns, const char* key, bool* out) { return view.read_bool_into(ns, key, out); }
|
|
store::ScalarReadResult read_int_into(const char* ns, const char* key, int32_t* out)
|
|
{
|
|
const auto result = view.read_int_into(ns, key, out);
|
|
writer.sql("BEGIN IMMEDIATE; UPDATE settings SET payload=X'436F6D706574696E67' WHERE namespace='settings' AND key IN('wifi_ssid_0','wifi_ssid'); COMMIT;");
|
|
return result;
|
|
}
|
|
store::StringReadResult read_string_into(const char* ns, const char* key, char* out, size_t cap, size_t* length) { return view.read_string_into(ns, key, out, cap, length); }
|
|
};
|
|
struct Context
|
|
{
|
|
Database& writer;
|
|
Snapshot& state;
|
|
};
|
|
Snapshot old;
|
|
Context context{writer, old};
|
|
assert(native::read_settings_snapshot([](void* pointer, const native::SettingsReadView& view)
|
|
{
|
|
auto& context = *static_cast<Context*>(pointer);
|
|
Reader reader{view, context.writer};
|
|
return wifi::profile_snapshot::read_persisted_wifi_profiles(reader, &context.state.enabled, &context.state.count,
|
|
context.state.profiles.data(), context.state.profiles.size(), true); },
|
|
&context));
|
|
assert(old.count == 1 && !std::strcmp(old.profiles[0].ssid, "Network-0"));
|
|
assert(!std::strcmp(snapshot().profiles[0].ssid, "Competing"));
|
|
}
|
|
assert(wifi::replace_saved_profiles(false, nullptr, 0));
|
|
assert(snapshot().count == 0 && !snapshot().enabled);
|
|
assert(wifi::load_config(selected) && !selected.ssid[0]);
|
|
std::atomic<bool> go{false};
|
|
std::array<std::thread, wifi::kMaxSavedProfileCount> threads;
|
|
for (size_t i = 0; i < threads.size(); ++i)
|
|
threads[i] = std::thread([&, i]
|
|
{
|
|
while (!go.load()) std::this_thread::yield();
|
|
assert(wifi::save_config(full[i])); });
|
|
go = true;
|
|
for (auto& thread : threads) thread.join();
|
|
assert(snapshot().count == threads.size());
|
|
for (const auto& entry : full) assert(wifi::find_saved_config(entry.ssid, selected));
|
|
const auto verifier = fork();
|
|
assert(verifier >= 0);
|
|
if (!verifier)
|
|
{
|
|
execl("/proc/self/exe", argv[0], "--verify", root.c_str(), nullptr);
|
|
_exit(127);
|
|
}
|
|
int verified = 0;
|
|
assert(waitpid(verifier, &verified, 0) == verifier && WIFEXITED(verified) && WEXITSTATUS(verified) == 0);
|
|
store::put_uint("settings", "wifi_prof_count", 2); // Wrong persistent kind.
|
|
Snapshot bad;
|
|
bad.enabled = true;
|
|
bad.count = 99;
|
|
assert(!wifi::read_saved_profiles_into(&bad.enabled, &bad.count, bad.profiles.data(), bad.profiles.size()));
|
|
assert(!bad.enabled && !bad.count);
|
|
for (const auto& entry : bad.profiles) assert(!entry.ssid[0] && !entry.password[0]);
|
|
assert(!wifi::save_config(config("Do-not-overwrite", "unchanged")));
|
|
assert(wifi::replace_saved_profiles(true, full.data(), 1));
|
|
{
|
|
trailmate::linux_app::LinuxAppServicesOptions options;
|
|
options.runtime_mode = native::LinuxRuntimeMode::SimulatorDemo;
|
|
trailmate::linux_app::LinuxAppServices services(options);
|
|
assert(services.initialize() && platform::ui::settings_reset::begin());
|
|
assert(!wifi::save_config(full[0]) && !wifi::replace_saved_profiles(true, full.data(), 1));
|
|
assert(snapshot().count == 0);
|
|
services.shutdown();
|
|
}
|
|
sys::Event* event = nullptr;
|
|
while (sys::EventBus::subscribe(&event, 0)) delete event;
|
|
std::filesystem::remove_all(root);
|
|
std::puts("Native Wi-Fi: legacy recovery, ten profiles, lookup, MRU, atomic rollback, consistent snapshot, concurrent saves and reset fence passed");
|
|
}
|