From 1819ebc0ab7649081dc8cb9bdb3e9946a4f32b33 Mon Sep 17 00:00:00 2001 From: dingo Date: Tue, 6 Oct 2026 11:57:07 -0400 Subject: [PATCH] Switch the engineering client to M10 sessions (M10.5c) evo-client's remote mode now runs over RegionSessionClient (QUIC, session v2): snapshot-fed environment and organism views, the camera following the server's view until the user moves it and then driving the interest, intention records with a simulated state, and reconnects with the next grant of a bundle. The launcher reads 160-byte M10 grants and defaults to the dev route. - quic::resolve_ipv4 shared by the client and evo-session-probe - evo-session-probe grants: owner-only bundles of 1-64 grants - evo-server --m10-max-grant-lifetime (dev only, 60..3600 s) - presets client-network/client-package build QUIC; msquic links the CRT fully static; msquic.dll and msquic/OpenSSL licences in the Windows package - client-remote-session test against a loopback region - ADR-0093/0091/0086 amendments, M10_CLIENT_SESSIONS guide, validation Co-Authored-By: Claude Opus 5.5 --- CMakeLists.txt | 11 +- CMakePresets.json | 10 +- README.md | 6 +- apps/evo-client/main.cpp | 9 + apps/evo-client/panels.cpp | 14 +- apps/evo-client/remote_session.hpp | 453 +++++++++++++----- apps/evo-server/m10_bridge.hpp | 10 +- apps/evo-server/main.cpp | 5 +- apps/evo-session-probe/main.cpp | 164 ++++--- cmake/ClientProbe.cmake | 22 +- cmake/Quic.cmake | 7 +- docs/ROADMAP.md | 8 +- docs/STATUS.md | 9 +- docs/adr/0083-dev-region-sessions.md | 2 + docs/adr/0086-windows-client-package.md | 13 + .../0091-m10-session-identity-and-control.md | 15 + docs/adr/0093-m10-snapshots-and-interest.md | 29 ++ docs/engineering/CLIENT.md | 13 +- docs/engineering/CLIENT_PACKAGING.md | 16 +- docs/engineering/VALIDATION.md | 73 +++ docs/networking/M10_CLIENT_SESSIONS.md | 39 ++ include/evo/client/launcher.hpp | 11 +- include/evo/client/outcome_log.hpp | 8 +- include/evo/network/quic_transport.hpp | 4 + src/client/ui/launcher.cpp | 6 +- src/network/transport/host_lookup.cpp | 47 ++ tests/client_remote_session.cpp | 288 +++++++++++ tests/client_ui_model.cpp | 5 +- tests/region_m10_session_tests.cpp | 33 +- tools/client/README-package.txt | 10 +- tools/client/THIRD-PARTY-NOTICES.txt | 4 + tools/client/package-common.ps1 | 19 +- tools/client/package-selftest.ps1 | 5 +- tools/client/package-windows.ps1 | 19 +- tools/client/verify-windows-package.ps1 | 2 +- 35 files changed, 1119 insertions(+), 270 deletions(-) create mode 100644 docs/networking/M10_CLIENT_SESSIONS.md create mode 100644 src/network/transport/host_lookup.cpp create mode 100644 tests/client_remote_session.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index d697d9c..d301e20 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -140,9 +140,13 @@ if(EVO_BUILD_QUIC) endif() include(cmake/Quic.cmake) # M10.2b transport: bounded channels and exact CA pinning over msquic. - add_library(evo_network_quic STATIC src/network/transport/quic_endpoint.cpp) + add_library(evo_network_quic STATIC src/network/transport/quic_endpoint.cpp + src/network/transport/host_lookup.cpp) target_include_directories(evo_network_quic PUBLIC "${PROJECT_SOURCE_DIR}/include") target_link_libraries(evo_network_quic PUBLIC evo_msquic PRIVATE mbedtls) + if(WIN32) + target_link_libraries(evo_network_quic PRIVATE ws2_32) # Host name lookup. + endif() evo_owned_target(evo_network_quic) # M10.3b session login over QUIC (ADR-0091): region side and client side. add_library(evo_session_server STATIC src/server/session/region_sessions.cpp) @@ -154,9 +158,6 @@ if(EVO_BUILD_QUIC) # M10.4c headless session client (development and test only; ADR-0092). add_executable(evo-session-probe apps/evo-session-probe/main.cpp) target_link_libraries(evo-session-probe PRIVATE evo_session_client evo_network_tls) - if(WIN32) - target_link_libraries(evo-session-probe PRIVATE ws2_32) # Host name lookup. - endif() evo_owned_target(evo-session-probe) evo_msquic_runtime(evo-session-probe) if(BUILD_TESTING) @@ -183,7 +184,7 @@ if(EVO_BUILD_QUIC) evo_owned_target(evo-quic-session-tests) evo_msquic_runtime(evo-quic-session-tests) add_test(NAME quic-sessions COMMAND evo-quic-session-tests) - set_tests_properties(quic-sessions PROPERTIES TIMEOUT 120 LABELS "quic") + set_tests_properties(quic-sessions PROPERTIES TIMEOUT 120 LABELS "quic;quic-session") add_executable(evo-quic-smoke-tests tests/quic_smoke.cpp) target_link_libraries(evo-quic-smoke-tests PRIVATE evo_msquic evo_network_tls) evo_owned_target(evo-quic-smoke-tests) diff --git a/CMakePresets.json b/CMakePresets.json index 91c27a3..124dbfd 100644 --- a/CMakePresets.json +++ b/CMakePresets.json @@ -11,7 +11,7 @@ {"name": "client", "inherits": "release", "cacheVariables": {"EVO_BUILD_CLIENT": "ON"}}, {"name": "client-probe", "inherits": "release", "cacheVariables": {"EVO_BUILD_CLIENT_PROBE": "ON"}}, {"name": "network", "inherits": "release", "cacheVariables": {"EVO_BUILD_NETWORK": "ON"}}, - {"name": "client-network", "inherits": "release", "cacheVariables": {"EVO_BUILD_CLIENT": "ON", "EVO_BUILD_NETWORK": "ON"}}, + {"name": "client-network", "inherits": "release", "cacheVariables": {"EVO_BUILD_CLIENT": "ON", "EVO_BUILD_NETWORK": "ON", "EVO_BUILD_QUIC": "ON"}}, {"name": "quic", "inherits": "network", "cacheVariables": {"EVO_BUILD_QUIC": "ON"}}, {"name": "client-package", "inherits": "client-network", "cacheVariables": {"CMAKE_MSVC_RUNTIME_LIBRARY": "MultiThreaded", "EVO_REPRODUCIBLE": "ON"}} ], @@ -25,8 +25,8 @@ {"name": "client-probe", "configurePreset": "client-probe", "targets": ["evo-client-probe"]}, {"name": "network", "configurePreset": "network", "targets": ["evo-client-state-tests", "evo-network-tests", "evo-dev-session"]}, {"name": "quic", "configurePreset": "quic", "targets": ["evo-quic-smoke-tests", "evo-quic-transport-tests", "evo-quic-session-tests", "evo-quic-hol-measure", "evo-session-probe", "evo-network-tests"]}, - {"name": "client-network", "configurePreset": "client-network", "targets": ["evo-client-state-tests", "evo-client", "evo-client-lifecycle-tests", "evo-client-environment-tests", "evo-client-organism-tests", "evo-client-ui-model-tests", "evo-client-panel-tests", "evo-client-bindings-tests", "evo-network-tests", "evo-dev-session"]}, - {"name": "client-package", "configurePreset": "client-package", "targets": ["evo-client-state-tests", "evo-client", "evo-client-lifecycle-tests", "evo-client-environment-tests", "evo-client-organism-tests", "evo-client-ui-model-tests", "evo-client-panel-tests", "evo-client-bindings-tests", "evo-network-tests", "evo-dev-session"]} + {"name": "client-network", "configurePreset": "client-network", "targets": ["evo-client-state-tests", "evo-client", "evo-client-lifecycle-tests", "evo-client-environment-tests", "evo-client-organism-tests", "evo-client-ui-model-tests", "evo-client-panel-tests", "evo-client-bindings-tests", "evo-network-tests", "evo-dev-session", "evo-quic-session-tests", "evo-client-remote-tests", "evo-session-probe"]}, + {"name": "client-package", "configurePreset": "client-package", "targets": ["evo-client-state-tests", "evo-client", "evo-client-lifecycle-tests", "evo-client-environment-tests", "evo-client-organism-tests", "evo-client-ui-model-tests", "evo-client-panel-tests", "evo-client-bindings-tests", "evo-network-tests", "evo-dev-session", "evo-quic-session-tests", "evo-client-remote-tests"]} ], "testPresets": [ {"name": "debug", "configurePreset": "debug", "output": {"outputOnFailure": true}}, @@ -38,7 +38,7 @@ {"name": "client-probe", "configurePreset": "client-probe", "filter": {"include": {"label": "client"}}, "output": {"outputOnFailure": true}}, {"name": "network", "configurePreset": "network", "filter": {"include": {"label": "network"}}, "output": {"outputOnFailure": true}}, {"name": "quic", "configurePreset": "quic", "filter": {"include": {"label": "quic|network"}}, "output": {"outputOnFailure": true}}, - {"name": "client-network", "configurePreset": "client-network", "filter": {"include": {"label": "client|network"}}, "output": {"outputOnFailure": true}}, - {"name": "client-package", "configurePreset": "client-package", "filter": {"include": {"label": "client|network"}}, "output": {"outputOnFailure": true}} + {"name": "client-network", "configurePreset": "client-network", "filter": {"include": {"label": "client|network|quic-session"}}, "output": {"outputOnFailure": true}}, + {"name": "client-package", "configurePreset": "client-package", "filter": {"include": {"label": "client|network|quic-session"}}, "output": {"outputOnFailure": true}} ] } diff --git a/README.md b/README.md index 669724d..fbce6d5 100644 --- a/README.md +++ b/README.md @@ -190,8 +190,10 @@ ctest --preset network ``` See [DEV_SESSION_PROTOCOL](docs/networking/DEV_SESSION_PROTOCOL.md) and ADR-0082. -M9.7 connects `evo-client` (preset `client-network`) to a dev region running -`evo-server --session-listen ...`; see [DEV_SESSION_OPERATIONS](docs/networking/DEV_SESSION_OPERATIONS.md). +`evo-client` (preset `client-network`, which includes QUIC) connects to a dev region over +M10 sessions; see [M10_CLIENT_SESSIONS](docs/networking/M10_CLIENT_SESSIONS.md). The M9.7 +path ([DEV_SESSION_OPERATIONS](docs/networking/DEV_SESSION_OPERATIONS.md)) is no longer used +by the client. Windows: `tools/windows-check.ps1 -Preset network -Action check`. diff --git a/apps/evo-client/main.cpp b/apps/evo-client/main.cpp index ce64a66..85fb44b 100644 --- a/apps/evo-client/main.cpp +++ b/apps/evo-client/main.cpp @@ -456,6 +456,15 @@ int main(int argc, char** argv) try { if (!intention) return 1; host.step(now, *intention, ui); // Only while connecting or connected. + // M10.5c: the camera follows the server's view until the user moves it; from then + // on its centre is the session's interest (the server clamps and filters it). + if (auto* remote = host.session(); remote && mode() == Mode::remote) { + if (const auto centre = remote->take_recentre()) + if (auto moved = evo::client::Camera::create(camera->viewport(), *centre, + camera->units_per_mm())) + *camera = *moved; + remote->focus(camera->centre()); + } // The fixture authority advances at its own cadence. Presentations refresh // every N authority ticks; in between the advanced watermark shows as stale. if (mode() == Mode::fixture && count % frames_per_authority_tick == 0) { diff --git a/apps/evo-client/panels.cpp b/apps/evo-client/panels.cpp index aa47a00..95fbc7f 100644 --- a/apps/evo-client/panels.cpp +++ b/apps/evo-client/panels.cpp @@ -53,6 +53,8 @@ const char* outcome_name(client::OutcomeState s) { return "not committed"; case client::OutcomeState::unknown: return "UNKNOWN (connection lost)"; + case client::OutcomeState::simulated: + return "simulated (not durable)"; } return "?"; } @@ -343,8 +345,16 @@ void session(const PanelView& v) { row("Connection", s.phase); row("Session / epoch", std::to_string(s.session) + " / " + std::to_string(s.epoch)); row("Server tick", std::to_string(s.server_tick)); - row("Durable watermark", std::to_string(s.commit_watermark)); + row("Simulated through", std::to_string(s.simulated_tick)); row("Grants left", std::to_string(s.grants_left)); + row("Snapshot", s.snapshot_tick == 0 ? std::string{"none yet"} + : "tick " + std::to_string(s.snapshot_tick) + ", " + + std::to_string(s.cells) + " cells, " + + std::to_string(s.organisms) + " organisms"); + if (s.focused) + row("Interest", std::to_string(s.focus_x) + ", " + std::to_string(s.focus_y) + ", z " + + std::to_string(s.focus_z) + " (radius 7)"); + row("Snapshot bytes", std::to_string(s.snapshot_bytes)); ImGui::EndTable(); } disabled_wrapped("Intentions (newest first; this is the record, toasts expire):"); @@ -364,6 +374,8 @@ void session(const PanelView& v) { static_cast(it->commit_sequence)); else if (it->state == client::OutcomeState::rejected) ImGui::Text("status %u", static_cast(it->detail)); + else if (it->tick != 0) + ImGui::Text("tick %llu", static_cast(it->tick)); } ImGui::EndTable(); } diff --git a/apps/evo-client/remote_session.hpp b/apps/evo-client/remote_session.hpp index e049c60..c77897a 100644 --- a/apps/evo-client/remote_session.hpp +++ b/apps/evo-client/remote_session.hpp @@ -1,8 +1,16 @@ #pragma once -// M9.7/M9.8c remote dev session for the engineering client (ADR-0083). Without -// EVO_CLIENT_NETWORK (a build without EVO_BUILD_NETWORK) remote mode is unavailable. -// The client only presents copies and sends bounded intentions; it never predicts. -// Grant bytes stay inside the session client: never printed, shown or persisted. +// M10.5c remote dev session for the engineering client (ADR-0093, over ADR-0091/0092 +// sessions). Without EVO_CLIENT_NETWORK (a build without EVO_BUILD_QUIC) remote mode is +// unavailable. The client only presents copies of replicated snapshots and sends bounded +// intentions; it never predicts. Grant bytes stay inside the session: each is handed to +// one connection and wiped here; never printed, shown or persisted. +// +// One connection per grant (ADR-0089): a lost or closed session reconnects with the next +// grant of the bundle after a growing pause (2 s .. 30 s, reset by a Welcome), which keeps +// a reconnect loop inside the region's per-account attempt limit. Views come from the +// newest applied snapshot. The camera follows the server's default view until the user +// moves it; from then on it drives the interest (radius 7), at most every 250 ms. +#include "evo/client/camera.hpp" #include "evo/client/environment_view.hpp" #include "evo/client/input.hpp" #include "evo/client/launcher.hpp" @@ -17,172 +25,357 @@ #include #ifdef EVO_CLIENT_NETWORK -#include "evo/network/session_client.hpp" +#include "evo/client/region_session.hpp" +#include "evo/network/quic_transport.hpp" +#include "evo/world/coordinates.hpp" +#include +#include +#include #include +#include +#include #endif namespace evo::client_app { struct RemoteStatus { std::string phase; // connecting / connected / reconnecting / out of grants - std::uint64_t session{}, epoch{}, server_tick{}, commit_watermark{}; + std::uint64_t session{}, epoch{}, server_tick{}, simulated_tick{}; std::size_t grants_left{}; bool welcomed{}; + // Newest applied snapshot and the interest last asked for (ADR-0093). + std::uint64_t snapshot_tick{}, snapshot_bytes{}; + std::size_t cells{}, organisms{}; + std::int64_t focus_x{}, focus_y{}, focus_z{}; + bool focused{}; }; #ifdef EVO_CLIENT_NETWORK inline constexpr bool remote_available = true; -static_assert(std::is_same_v, +static_assert(std::is_same_v, "the launcher's grant record is the session's grant"); class RemoteSession { public: + static constexpr std::uint16_t interest_radius = 7; + static constexpr std::uint64_t intention_lead = 2; // Ticks ahead of the server tick. + // Looks the endpoint up once (blocking); nothing connects until the first step(). static std::optional open(const client::ConnectMaterial& m) { - network::SessionClientConfig config; - config.host = m.endpoint.host; - config.port = m.endpoint.port; - config.trust = {m.authority_pem, m.server_name}; - config.grants = m.grants; - auto made = network::SessionClient::create(std::move(config)); - if (!made) + const auto address = network::quic::resolve_ipv4(m.endpoint.host); + if (!address || m.grants.empty()) return std::nullopt; RemoteSession session; - session.client_ = std::move(*made); + session.transport_.server_address = *address; + session.transport_.port = m.endpoint.port; + session.transport_.server_name = m.server_name; + session.transport_.authority_pem = m.authority_pem; + session.transport_.authority_pem_file = m.authority_path; + session.grants_ = m.grants; return session; } + RemoteSession(RemoteSession&&) noexcept = default; + RemoteSession& operator=(RemoteSession&&) noexcept = default; + RemoteSession(const RemoteSession&) = delete; + RemoteSession& operator=(const RemoteSession&) = delete; + ~RemoteSession() { + if (client_) + client_->close(); // Close{client_closed}; unresolved intentions stay unknown. + for (auto& g : grants_) + g.fill(0); + } [[nodiscard]] const client::EnvironmentLayer& environment() const noexcept { - return client_->environment(); + return environment_; } [[nodiscard]] const client::OrganismLayer& organisms() const noexcept { - return client_->organisms(); + return organisms_; } [[nodiscard]] const client::OutcomeLog& outcomes() const noexcept { return log_; } [[nodiscard]] RemoteStatus status() const { - using network::SessionPhase; RemoteStatus s; - const auto phase = client_->phase(); - s.phase = phase == SessionPhase::established ? "connected" - : phase == SessionPhase::exhausted ? "out of grants" - : welcomed_ ? "reconnecting" - : "connecting"; - if (const auto w = client_->welcome()) { - s.session = w->session; - s.epoch = w->epoch; - } - if (const auto v = client_->latest_view()) { - s.server_tick = v->server_tick; - s.commit_watermark = v->commit_watermark; - } - s.grants_left = client_->grants_left(); + const bool live = client_ && client_->state() == client::RegionSessionState::established; + s.phase = live ? "connected" + : exhausted_ ? "out of grants" + : welcomed_ ? "reconnecting" + : "connecting"; + s.session = session_; + s.epoch = epoch_; + s.server_tick = server_tick_; + s.simulated_tick = simulated_tick_; + s.grants_left = grants_.size() - next_; s.welcomed = welcomed_; + s.snapshot_tick = seen_snapshot_; + s.snapshot_bytes = snapshot_bytes_ + (client_ ? client_->snapshot_bytes() : 0); + if (const auto* e = environment_.current()) + s.cells = e->cells().size(); + if (const auto* o = organisms_.current()) + s.organisms = o->cells().size(); + if (sent_interest_) { + s.focused = true; + s.focus_x = sent_interest_->x; + s.focus_y = sent_interest_->y; + s.focus_z = sent_interest_->z; + } return s; } + // Where the camera should be while it follows the server's view: the middle of the + // newest snapshot's square, offered whenever it changes (the first snapshots may still + // be filling in, nearest cells first). + [[nodiscard]] std::optional take_recentre() { + return std::exchange(recentre_, std::nullopt); + } + // Called every frame with the camera centre. While following, a centre other than the + // one offered means the user moved the camera: from then on the camera's voxel is the + // interest of the next sends. + void focus(client::WorldPoint centre) { + if (!std::isfinite(centre.x_mm) || !std::isfinite(centre.y_mm)) + return; + if (following_) { + if (!offered_ || (centre.x_mm == offered_->x_mm && centre.y_mm == offered_->y_mm)) + return; // Nothing shown yet, or still where the view put it. + following_ = false; + recentre_.reset(); + } + constexpr auto pitch = static_cast(world::cell_pitch_mm); + constexpr double limit = 9.0e15; // Well inside int64 and the camera's own range. + const double x = std::floor(centre.x_mm / pitch), y = std::floor(centre.y_mm / pitch); + if (std::abs(x) > limit || std::abs(y) > limit) + return; + wanted_ = network::SessionInterest{static_cast(x), + static_cast(y), slice_z_, interest_radius}; + } // Services the connection; sends the intention when its vector changed, at most once - // per received server tick (the server also rate-limits). Session events update the - // outcome log (the durable record), short notifications and the launcher. + // per server tick. Session events update the outcome log (the record), short + // notifications and the launcher. void step(std::chrono::steady_clock::time_point now, const client::Intention& intention, client::UiState& ui, client::Launcher& launcher) { - client_->poll(now); - const auto view = client_->latest_view(); - const bool changed = intention.move_x != sent_x_ || intention.move_y != sent_y_; - if (view && changed && (!sent_tick_ || view->server_tick > *sent_tick_) && - client_->send(intention)) { - sent_x_ = intention.move_x; - sent_y_ = intention.move_y; - sent_tick_ = view->server_tick; - log_.record({intention.sequence, client::OutcomeState::sent}); + if (!client_ && !start(now, launcher)) + return; + auto& c = *client_; + c.poll(now); + if (c.state() == client::RegionSessionState::closed) { + end(now, ui, launcher); + return; } - for (const auto& e : client_->take_events()) - report(e, ui, launcher); - // Refused TCP or failed TLS produce no event; each still counts toward the - // launcher's bounded "server unreachable" before a first Welcome. - for (; unreachable_ < client_->unreachable_attempts(); ++unreachable_) - launcher.observe(client::ConnectSignal::lost); - } - - private: - static void notify(client::UiState& ui, const char* text, client::NoticeLevel level) { - static_cast(ui.notify(text, level).has_value()); // Bounded; overflow evicts. - } - void report(const network::ClientEvent& e, client::UiState& ui, client::Launcher& launcher) { - using Kind = network::ClientEvent::Kind; - using network::CloseReason; - switch (e.kind) { - case Kind::welcome: - welcomed_ = true; - sent_tick_.reset(); // New session: resend the current intention. - sent_x_ = sent_y_ = 0; - launcher.observe(client::ConnectSignal::welcome); - notify(ui, "Connected to the dev region (fresh baseline).", client::NoticeLevel::info); - std::printf("session welcome session=%llu epoch=%llu tick=%llu commit=%llu\n", - static_cast(e.welcome.session), - static_cast(e.welcome.epoch), - static_cast(e.welcome.server_tick), - static_cast(e.welcome.commit_watermark)); - break; - case Kind::closed: { - const bool retry = - e.reason == CloseReason::server_shutdown || e.reason == CloseReason::capacity; - const bool lost = e.reason == CloseReason::timeout || - e.reason == CloseReason::stale_epoch || - e.reason == CloseReason::rate_limited; - launcher.observe(retry ? client::ConnectSignal::not_ready - : lost ? client::ConnectSignal::lost - : client::ConnectSignal::refused); - notify(ui, retry ? "Server not ready; retrying." : "Session closed by the server.", - retry ? client::NoticeLevel::info : client::NoticeLevel::warning); - std::printf("session closed reason=%u\n", static_cast(e.reason)); - break; - } - case Kind::lost: - launcher.observe(client::ConnectSignal::lost); - notify(ui, "Connection lost; views are stale.", client::NoticeLevel::warning); - std::puts("session lost (reconnecting with a fresh grant)"); - break; - case Kind::result: - log_.record({e.sequence, - e.result.status == network::IntentStatus::admitted - ? client::OutcomeState::admitted - : client::OutcomeState::rejected, - static_cast(e.result.status)}); - std::printf("intent %llu status=%u\n", static_cast(e.sequence), - static_cast(e.result.status)); - break; - case Kind::outcome: - log_.record({e.sequence, - e.outcome.finality == network::IntentFinality::committed_no_effect - ? client::OutcomeState::durable - : client::OutcomeState::not_committed, - 0, e.outcome.tick, e.outcome.commit_sequence}); - std::printf("intent %llu final=%u tick=%llu commit=%llu\n", - static_cast(e.sequence), - static_cast(e.outcome.finality), - static_cast(e.outcome.tick), - static_cast(e.outcome.commit_sequence)); - break; - case Kind::unknown: - log_.record({e.sequence, client::OutcomeState::unknown}); - std::printf("intent %llu outcome unknown (connection lost)\n", - static_cast(e.sequence)); - break; - case Kind::backpressure: - notify(ui, "Session event backlog; reconnecting after draining.", - client::NoticeLevel::warning); - std::puts("session event backlog: disconnected; draining before reconnect"); - break; - case Kind::exhausted: - launcher.observe(client::ConnectSignal::exhausted); - std::puts("session grants exhausted; issue a new bundle to reconnect"); - break; + if (c.state() != client::RegionSessionState::established) + return; + if (!established_) + welcome(ui, launcher); + server_tick_ = c.server_tick(); + send(intention); + receipts(); + snapshot(); + if (wanted_ && (!sent_interest_ || *wanted_ != *sent_interest_) && + now - interest_at_ >= std::chrono::milliseconds{250} && c.set_interest(*wanted_)) { + sent_interest_ = wanted_; + interest_at_ = now; } std::fflush(stdout); } - std::unique_ptr client_; + + private: + using Clock = std::chrono::steady_clock; + // Session sequences restart with each session; the log numbers intentions itself. + struct Pending { + std::uint64_t sequence{}, entry{}, tick{}; + bool admitted{}; + }; + static constexpr std::size_t max_pending = client::OutcomeLog::capacity; + RemoteSession() = default; + static void notify(client::UiState& ui, const char* text, client::NoticeLevel level) { + static_cast(ui.notify(text, level).has_value()); // Bounded; overflow evicts. + } + // Opens the next connection with the next grant; false while pausing or out of grants. + bool start(Clock::time_point now, client::Launcher& launcher) { + if (now < retry_at_) + return false; + if (next_ >= grants_.size()) { + if (!exhausted_) { + exhausted_ = true; + launcher.observe(client::ConnectSignal::exhausted); + std::puts("session grants exhausted; issue a new bundle to reconnect"); + } + return false; + } + client::RegionSessionClientConfig config; + config.transport = transport_; + config.grant = grants_[next_]; + grants_[next_].fill(0); + ++next_; + auto made = client::RegionSessionClient::connect(std::move(config), now); + if (!made) { + launcher.observe(client::ConnectSignal::lost); + pause(now); + return false; + } + client_ = std::move(*made); + established_ = false; + return true; + } + void pause(Clock::time_point now) { + retry_at_ = now + backoff_; + backoff_ = std::min(backoff_ * 2, std::chrono::seconds{30}); + } + void welcome(client::UiState& ui, client::Launcher& launcher) { + const auto& w = *client_->welcome(); + established_ = true; + welcomed_ = true; + backoff_ = std::chrono::seconds{2}; + if (w.epoch != epoch_) { // Another authority lineage: start the views afresh. + environment_.reset(); + organisms_.reset(); + seen_snapshot_ = 0; + } + session_ = w.session; + epoch_ = w.epoch; + sent_tick_.reset(); // New session: resend the current intention. + sent_x_ = sent_y_ = 0; + sent_interest_.reset(); // The server starts from its default interest. + launcher.observe(client::ConnectSignal::welcome); + notify(ui, "Connected to the dev region (fresh baseline).", client::NoticeLevel::info); + std::printf("session welcome session=%llu epoch=%llu tick=%llu\n", + static_cast(w.session), + static_cast(w.epoch), + static_cast(w.server_tick)); + } + void send(const client::Intention& intention) { + const bool changed = intention.move_x != sent_x_ || intention.move_y != sent_y_; + if (!changed || server_tick_ == 0 || (sent_tick_ && server_tick_ <= *sent_tick_)) + return; + const auto tick = server_tick_ + intention_lead; + // Refused until the datagram extension is negotiated: retried next frame. + const auto sequence = client_->send_intention(tick, intention.move_x, intention.move_y); + if (!sequence) + return; + sent_x_ = intention.move_x; + sent_y_ = intention.move_y; + sent_tick_ = server_tick_; + const auto entry = next_entry_++; + log_.record({entry, client::OutcomeState::sent, 0, tick}); + if (pending_.size() == max_pending) + pending_.pop_front(); // Its log entry was evicted with it. + pending_.push_back({*sequence, entry, tick, false}); + } + void receipts() { + for (const auto& r : client_->take_intention_receipts()) { + const auto it = std::find_if(pending_.begin(), pending_.end(), [&](const Pending& p) { + return p.sequence == r.sequence; + }); + if (it == pending_.end()) + continue; // Evicted from the bounded record already. + std::printf("intent %llu status=%u\n", static_cast(it->entry), + static_cast(r.status)); + if (r.status == network::AdmitStatus::admitted) { + log_.record({it->entry, client::OutcomeState::admitted, 0, it->tick}); + it->admitted = true; + } else { + log_.record({it->entry, client::OutcomeState::rejected, + static_cast(r.status), it->tick}); + pending_.erase(it); + } + } + const auto s = client_->simulated(); + if (!s) + return; + simulated_tick_ = s->tick; + // Cumulative: every admitted intention up to the sequence, at or before the tick. + std::erase_if(pending_, [&](const Pending& p) { + if (!p.admitted || p.sequence > s->sequence || p.tick > s->tick) + return false; + log_.record({p.entry, client::OutcomeState::simulated, 0, p.tick}); + return true; + }); + } + void snapshot() { + const auto* v = client_->view(); + if (v == nullptr || v->tick == seen_snapshot_) + return; + seen_snapshot_ = v->tick; + slice_z_ = v->slice_z; + if (auto e = client_->environment()) { + if (!environment_.accept(*e)) { // E.g. regressed after a restore: start afresh. + environment_.reset(); + static_cast(environment_.accept(std::move(*e)).has_value()); + } + } + if (auto o = client_->organisms()) { + if (!organisms_.accept(*o)) { + organisms_.reset(); + static_cast(organisms_.accept(std::move(*o)).has_value()); + } + } + if (!following_ || v->environment.empty()) + return; + const auto [lx, hx] = + std::minmax_element(v->environment.begin(), v->environment.end(), + [](const auto& a, const auto& b) { return a.voxel.x < b.voxel.x; }); + const auto [ly, hy] = + std::minmax_element(v->environment.begin(), v->environment.end(), + [](const auto& a, const auto& b) { return a.voxel.y < b.voxel.y; }); + constexpr auto pitch = static_cast(world::cell_pitch_mm); + const client::WorldPoint middle{ + (static_cast(lx->voxel.x) + static_cast(hx->voxel.x) + 1) * pitch / 2, + (static_cast(ly->voxel.y) + static_cast(hy->voxel.y) + 1) * pitch / 2}; + if (!offered_ || middle.x_mm != offered_->x_mm || middle.y_mm != offered_->y_mm) + recentre_ = offered_ = middle; + } + // The connection ended: decide what the launcher hears and pause before the next grant. + void end(Clock::time_point now, client::UiState& ui, client::Launcher& launcher) { + using network::SessionCloseReason; + const auto reason = client_->close_reason().value_or(SessionCloseReason::connection_lost); + const bool was_established = established_; + snapshot_bytes_ += client_->snapshot_bytes(); + for (const auto& p : pending_) + log_.record({p.entry, client::OutcomeState::unknown, 0, p.tick}); + pending_.clear(); + environment_.mark_stale(); + organisms_.mark_stale(); + client_.reset(); + established_ = false; + const bool not_ready = + reason == SessionCloseReason::shutdown || reason == SessionCloseReason::capacity; + const bool lost = reason == SessionCloseReason::connection_lost || + reason == SessionCloseReason::timeout || + reason == SessionCloseReason::rate_limited || + reason == SessionCloseReason::stale_epoch || + (was_established && reason == SessionCloseReason::expired); + if (reason == SessionCloseReason::superseded) { + // Another client holds this account's newer grant: never fight it. + launcher.fail(client::LaunchError::grant_refused); + notify(ui, "Another client opened a session with this account.", + client::NoticeLevel::warning); + } else { + launcher.observe(not_ready ? client::ConnectSignal::not_ready + : lost ? client::ConnectSignal::lost + : client::ConnectSignal::refused); + notify(ui, + not_ready ? "Server not ready; retrying." + : was_established ? "Session ended; reconnecting with the next grant." + : "Connection attempt failed.", + not_ready ? client::NoticeLevel::info : client::NoticeLevel::warning); + } + std::printf("session closed reason=%u\n", static_cast(reason)); + pause(now); + } + network::quic::ClientConfig transport_; + std::vector grants_; + std::size_t next_{}; + std::unique_ptr client_; + client::EnvironmentLayer environment_; + client::OrganismLayer organisms_; client::OutcomeLog log_; + std::deque pending_; + std::uint64_t next_entry_{1}; + Clock::time_point retry_at_{}, interest_at_{}; + std::chrono::seconds backoff_{2}; + std::uint64_t session_{}, epoch_{}, server_tick_{}, simulated_tick_{}, seen_snapshot_{}, + snapshot_bytes_{}; std::optional sent_tick_; - std::uint64_t unreachable_{}; + std::optional wanted_, sent_interest_; + std::optional recentre_, offered_; + std::int64_t slice_z_{}; std::int16_t sent_x_{}, sent_y_{}; - bool welcomed_{}; + bool established_{}, welcomed_{}, exhausted_{}; + bool following_{true}; // The camera follows the server's (default) view. }; #else inline constexpr bool remote_available = false; @@ -203,6 +396,10 @@ class RemoteSession { [[nodiscard]] RemoteStatus status() const { return {"unavailable in this build"}; } + [[nodiscard]] std::optional take_recentre() { + return std::nullopt; + } + void focus(client::WorldPoint) {} void step(std::chrono::steady_clock::time_point, const client::Intention&, client::UiState&, client::Launcher&) {} diff --git a/apps/evo-server/m10_bridge.hpp b/apps/evo-server/m10_bridge.hpp index eeaa826..efda408 100644 --- a/apps/evo-server/m10_bridge.hpp +++ b/apps/evo-server/m10_bridge.hpp @@ -38,9 +38,11 @@ namespace evo::server_app { struct M10Options { std::string listen, certificate, key, issuer, environment, session_window; + // M10.5c: dev only, 60..3600 s; 0 keeps the default (300 s, ADR-0091). + std::uint64_t max_grant_lifetime{}; [[nodiscard]] bool any() const noexcept { return !listen.empty() || !certificate.empty() || !key.empty() || !issuer.empty() || - !environment.empty() || !session_window.empty(); + !environment.empty() || !session_window.empty() || max_grant_lifetime != 0; } [[nodiscard]] bool complete() const noexcept { return !listen.empty() && !certificate.empty() && !key.empty() && !issuer.empty() && @@ -86,6 +88,12 @@ template class M10Bridge { : o.environment == "stage" ? network::DeploymentEnvironment::stage : network::DeploymentEnvironment::world0; + if (o.max_grant_lifetime != 0) { + // Longer grants let a tester's bundle outlive a coffee break; never outside dev. + if (config.control.environment != network::DeploymentEnvironment::dev) + return fail("error m10-grant-lifetime"); + config.control.max_grant_lifetime = o.max_grant_lifetime; + } config.control.world = {key.world, frame}; config.control.region = key.region; config.control.epoch = 1; // Follows the host's epoch from the first poll. diff --git a/apps/evo-server/main.cpp b/apps/evo-server/main.cpp index 07bfb6b..0b062f9 100644 --- a/apps/evo-server/main.cpp +++ b/apps/evo-server/main.cpp @@ -229,6 +229,8 @@ std::optional parse(int argc, char** argv) { o.m10.environment = value; else if (flag == "--session-window") o.m10.session_window = value; + else if (flag == "--m10-max-grant-lifetime" && n && *n >= 60 && *n <= 3600) + o.m10.max_grant_lifetime = *n; else if (flag == "--crash-at") { const auto colon = value.find(':'); const auto ordinal = @@ -593,7 +595,8 @@ int main(int argc, char** argv) { "--session-cert F --session-key F --session-grant-key F " "--session-grant-ledger F --session-environment dev]] [--m10-listen " "ADDRESS:PORT --m10-cert F --m10-key F --m10-issuer F " - "--m10-environment dev|stage|world0 --session-window ACTIVATION:UTC_EXPIRY]\n", + "--m10-environment dev|stage|world0 --session-window ACTIVATION:UTC_EXPIRY " + "[--m10-max-grant-lifetime 60..3600]]\n", stderr); return 2; } diff --git a/apps/evo-session-probe/main.cpp b/apps/evo-session-probe/main.cpp index 5534069..24c9499 100644 --- a/apps/evo-session-probe/main.cpp +++ b/apps/evo-session-probe/main.cpp @@ -3,6 +3,14 @@ // evo-session-probe keys --out DIR // Writes a fresh dev issuer key pair: DIR/issuer.key (32-byte P-256 scalar, owner-only) // and DIR/issuer.pub (65-byte public key for evo-server --m10-issuer). +// evo-session-probe grants --issuer-key FILE --world N --frame N --region N +// --account HEX32 --out FILE [--serial N] [--count 1..64] [--lifetime 60..3600] +// M10.5c (ADR-0093): writes COUNT 160-byte grants for one account (the engineering +// client's grant bundle), serials SERIAL..SERIAL+COUNT-1, all issued now. Without +// --serial the first is 64 x the issue time in seconds, so a later bundle for the same +// account supersedes an earlier one without bookkeeping. The file is created new and +// owner-only (a credential: never commit or share it); the issuer key stays here. +// The region refuses grants longer than its --m10-max-grant-lifetime (default 300). // evo-session-probe run --connect HOST:PORT --server-name NAME --ca FILE --issuer-key FILE // --world N --frame N --region N --account HEX32 --serial N [--lifetime S] // [--intents N] [--actions N --action-base ID] [--query ID]... [--timeout-ms N] @@ -21,22 +29,6 @@ // action is final and every query answered, 1 on timeout, 3 when the server closes. // The issuer key is a development credential: the probe refuses any environment but dev. #include "evo/client/region_session.hpp" -#ifdef _WIN32 -#ifndef WIN32_LEAN_AND_MEAN -#define WIN32_LEAN_AND_MEAN -#endif -#ifndef NOMINMAX -#define NOMINMAX -#endif -#include -// After . -#include -#else -#include -#include -#include -#include -#endif #include "evo/network/session_grant.hpp" #include #include @@ -91,28 +83,6 @@ std::optional account_of(std::string_view hex) { return id.valid() ? std::optional{id} : std::nullopt; } -// The QUIC endpoint takes a numeric address (the server name is verified separately): -// look a host name up once, IPv4, and print what DNS answered. -std::optional resolve(const std::string& host) { -#ifdef _WIN32 - WSADATA data{}; - if (WSAStartup(MAKEWORD(2, 2), &data) != 0) - return std::nullopt; -#endif - addrinfo hints{}; - hints.ai_family = AF_INET; - hints.ai_socktype = SOCK_DGRAM; - addrinfo* found = nullptr; - if (getaddrinfo(host.c_str(), nullptr, &hints, &found) != 0 || found == nullptr) - return std::nullopt; - char text[INET_ADDRSTRLEN] = {}; - const auto* address = reinterpret_cast(found->ai_addr); - const bool ok = inet_ntop(AF_INET, &address->sin_addr, text, sizeof text) != nullptr; - freeaddrinfo(found); - if (!ok) - return std::nullopt; - return std::string{text}; -} const char* cause_name(std::optional c) { if (!c) return "none"; @@ -134,6 +104,33 @@ const char* cause_name(std::optional c) { } } +std::uint64_t now_seconds() { + return static_cast(std::chrono::duration_cast( + std::chrono::system_clock::now().time_since_epoch()) + .count()); +} +std::optional issuer(const std::string& path) { + const auto scalar = read(path); + auto key = GrantSigningKey::import( + DeploymentEnvironment::dev, 1, + std::span{reinterpret_cast(scalar.data()), scalar.size()}); + if (!key) + return std::nullopt; + return std::move(*key); +} +std::optional sign(const GrantSigningKey& key, GrantClaims claims) { + std::array id{}; + if (!random_bytes(id)) + return std::nullopt; + for (std::size_t i = 0; i < id.size(); ++i) + claims.grant_id |= static_cast(id.at(i)) << (8U * i); + claims.grant_id = std::max(claims.grant_id, 1); + const auto grant = key.sign(claims); + if (!grant) + return std::nullopt; + return *grant; +} + int keys(const std::filesystem::path& out) { std::filesystem::create_directories(out); for (int attempt = 0; attempt < 8; ++attempt) { @@ -182,42 +179,74 @@ std::optional interest_of(std::string_view v) { return SessionInterest{parts[0], parts[1], parts[2], static_cast(parts[3])}; } -int run(const RunOptions& o) { - const auto scalar = read(o.issuer_key); - const auto key = GrantSigningKey::import( - DeploymentEnvironment::dev, 1, - std::span{reinterpret_cast(scalar.data()), scalar.size()}); - if (!key) { +// Exclusive create, owner-only on POSIX: a bundle is a credential. +bool write_new(const std::filesystem::path& path, std::span bytes) { + if (std::filesystem::exists(path)) + return false; + if (!write(path, bytes)) + return false; + std::filesystem::permissions( + path, std::filesystem::perms::owner_read | std::filesystem::perms::owner_write, + std::filesystem::perm_options::replace); + return true; +} + +int grants(const RunOptions& o, const std::string& out, std::uint64_t count) { + const auto key = issuer(o.issuer_key); + if (!key || !o.account) { std::puts("error issuer-key"); return 2; } GrantClaims claims; - std::array id{}; - if (!random_bytes(id)) { - std::puts("error random"); + claims.account = *o.account; + claims.world = {o.world, o.frame}; + claims.region = o.region; + claims.issued_at = now_seconds(); + claims.expires_at = claims.issued_at + o.lifetime; + const auto first = o.serial != 0 ? o.serial : claims.issued_at * 64; + std::vector bundle; + for (std::uint64_t i = 0; i < count; ++i) { + claims.serial = first + i; + const auto grant = sign(*key, claims); + if (!grant) { + std::puts("error grant"); + return 2; + } + bundle.insert(bundle.end(), grant->begin(), grant->end()); + } + if (!write_new(out, bundle)) { + std::puts("error out (exists or unwritable)"); + return 1; + } + std::printf("wrote %llu grants serial %llu..%llu valid %llu s\n", + static_cast(count), static_cast(first), + static_cast(first + count - 1), + static_cast(o.lifetime)); + return 0; +} + +int run(const RunOptions& o) { + const auto key = issuer(o.issuer_key); + if (!key) { + std::puts("error issuer-key"); return 2; } - for (std::size_t i = 0; i < id.size(); ++i) - claims.grant_id |= static_cast(id.at(i)) << (8U * i); - claims.grant_id = std::max(claims.grant_id, 1); if (!o.account) return 2; // Required at parse time. + GrantClaims claims; claims.account = *o.account; claims.serial = o.serial; claims.world = {o.world, o.frame}; claims.region = o.region; - claims.issued_at = - static_cast(std::chrono::duration_cast( - std::chrono::system_clock::now().time_since_epoch()) - .count()); + claims.issued_at = now_seconds(); claims.expires_at = claims.issued_at + o.lifetime; - const auto grant = key->sign(claims); + const auto grant = sign(*key, claims); if (!grant) { std::puts("error grant"); return 2; } client::RegionSessionClientConfig config; - const auto address = resolve(o.host); + const auto address = quic::resolve_ipv4(o.host); if (!address) { std::puts("error resolve"); return 2; @@ -340,7 +369,12 @@ int main(int argc, char** argv) { if (args.size() == 3 && args[0] == "keys" && args[1] == "--out") return keys(std::filesystem::path{std::string{args[2]}}); RunOptions o; - bool ok = !args.empty() && args[0] == "run" && args.size() % 2 == 1; + const bool bundle = !args.empty() && args[0] == "grants"; + std::string out; + std::uint64_t count = 1; + if (bundle) + o.lifetime = 300; // The region's default maximum. + bool ok = !args.empty() && (args[0] == "run" || bundle) && args.size() % 2 == 1; for (std::size_t i = 1; ok && i + 1 < args.size(); i += 2) { const auto flag = args[i]; const auto value = args[i + 1]; @@ -386,12 +420,22 @@ int main(int argc, char** argv) { o.snapshots = *n; else if (flag == "--interest") ok = (o.interest = interest_of(value)).has_value(); + else if (bundle && flag == "--out") + out = value; + else if (bundle && n && flag == "--count" && *n >= 1 && *n <= 64) + count = *n; else ok = false; } - if (!ok || o.host.empty() || o.server_name.empty() || o.ca.empty() || o.issuer_key.empty() || - !o.account || o.world == 0 || o.frame == 0 || o.region == 0 || o.serial == 0) { - std::fputs("usage: evo-session-probe keys --out DIR | run --connect HOST:PORT " + if (bundle && ok && !o.issuer_key.empty() && o.account && o.world != 0 && o.frame != 0 && + o.region != 0 && !out.empty() && o.lifetime >= 60 && o.host.empty()) + return grants(o, out, count); + if (bundle || !ok || o.host.empty() || o.server_name.empty() || o.ca.empty() || + o.issuer_key.empty() || !o.account || o.world == 0 || o.frame == 0 || o.region == 0 || + o.serial == 0) { + std::fputs("usage: evo-session-probe keys --out DIR | grants --issuer-key FILE " + "--world N --frame N --region N --account HEX32 --out FILE [--serial N] " + "[--count 1..64] [--lifetime 60..3600] | run --connect HOST:PORT " "--server-name NAME --ca FILE --issuer-key FILE --world N --frame N " "--region N --account HEX32 --serial N [--lifetime S] [--intents N] " "[--actions N --action-base ID] [--query ID]... [--timeout-ms N] " diff --git a/cmake/ClientProbe.cmake b/cmake/ClientProbe.cmake index 7d16d05..1602c4b 100644 --- a/cmake/ClientProbe.cmake +++ b/cmake/ClientProbe.cmake @@ -69,13 +69,29 @@ if(EVO_BUILD_CLIENT) add_executable(evo-client apps/evo-client/main.cpp apps/evo-client/panels.cpp) target_link_libraries(evo-client PRIVATE evo_client_platform evo_client_ui evo_imgui) target_compile_definitions(evo-client PRIVATE EVO_BUILD_IDENTITY="${EVO_BUILD_IDENTITY}") - if(EVO_BUILD_NETWORK) - # M9.7 remote dev session mode (ADR-0083). - target_link_libraries(evo-client PRIVATE evo_network_session) + if(EVO_BUILD_QUIC) + # M10.5c remote dev session mode over M10 QUIC sessions (ADR-0093); replaces the M9.7 + # TCP session (ADR-0083), whose dev route is gone (ADR-0087). + target_link_libraries(evo-client PRIVATE evo_session_client) target_compile_definitions(evo-client PRIVATE EVO_CLIENT_NETWORK=1) endif() evo_owned_target(evo-client) evo_client_runtime(evo-client) + if(EVO_BUILD_QUIC) + evo_msquic_runtime(evo-client) + if(BUILD_TESTING) + # The client's remote session (apps/evo-client/remote_session.hpp) against a loopback + # region: snapshots, camera interest, intentions, reconnects, refusals (M10.5c). + add_executable(evo-client-remote-tests tests/client_remote_session.cpp) + target_include_directories(evo-client-remote-tests PRIVATE "${PROJECT_SOURCE_DIR}/apps/evo-client") + target_compile_definitions(evo-client-remote-tests PRIVATE EVO_CLIENT_NETWORK=1) + target_link_libraries(evo-client-remote-tests PRIVATE evo_client_ui evo_session_client evo_session_server) + evo_owned_target(evo-client-remote-tests) + evo_msquic_runtime(evo-client-remote-tests) + add_test(NAME client-remote-session COMMAND evo-client-remote-tests) + set_tests_properties(client-remote-session PROPERTIES TIMEOUT 120 LABELS "client;quic-session") + endif() + endif() if(BUILD_TESTING) add_executable(evo-client-lifecycle-tests tests/client_lifecycle.cpp tests/client_controls.cpp) target_include_directories(evo-client-lifecycle-tests PRIVATE "${PROJECT_SOURCE_DIR}/src") diff --git a/cmake/Quic.cmake b/cmake/Quic.cmake index 374c4bf..a2deb07 100644 --- a/cmake/Quic.cmake +++ b/cmake/Quic.cmake @@ -1,6 +1,8 @@ # M10.2 QUIC transport (ADR-0090): pinned msquic 2.6.2 with its OpenSSL TLS provider # (OpenSSL 3.5.9 LTS, TLS 1.3 only, built static inside the msquic shared library). -# Explicit preparation only: cmake -P tools/prepare-msquic.cmake. Windows builds need a +# Explicit preparation only: cmake -P tools/prepare-msquic.cmake. On Windows msquic.dll +# links the whole C runtime statically (M10.5c): the client package ships it and allows +# no runtime DLL imports (ADR-0086), including the UCRT forwarders. Windows builds need a # native Perl (Strawberry Perl) and NASM for OpenSSL, plus nmake from the MSVC shell. include_guard(GLOBAL) include("${PROJECT_SOURCE_DIR}/tools/msquic-pin.cmake") @@ -22,7 +24,8 @@ endif() enable_language(C) foreach(setting IN ITEMS "QUIC_TLS_LIB=openssl" "QUIC_BUILD_SHARED=ON" "QUIC_BUILD_TEST=OFF" "QUIC_BUILD_TOOLS=OFF" "QUIC_BUILD_PERF=OFF" "QUIC_ENABLE_LOGGING=OFF" "QUIC_EMBED_GIT_HASH=OFF" - "QUIC_SOURCE_LINK=OFF" "QUIC_USE_EXTERNAL_OPENSSL=OFF" "QUIC_CODE_CHECK=OFF") + "QUIC_SOURCE_LINK=OFF" "QUIC_USE_EXTERNAL_OPENSSL=OFF" "QUIC_CODE_CHECK=OFF" + "QUIC_STATIC_LINK_CRT=ON" "QUIC_STATIC_LINK_PARTIAL_CRT=OFF") string(REPLACE "=" ";" pair "${setting}") list(GET pair 0 name) list(GET pair 1 value) diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md index ecdd2f4..6a545ab 100644 --- a/docs/ROADMAP.md +++ b/docs/ROADMAP.md @@ -524,10 +524,10 @@ session control done; 10.3b QUIC session login (schemas/network/session-v1.md) d 10.3c durable per-world account control (schema v10) done. 10.4 split (ADR-0092): 10.4a intention/action protocol and admission done; 10.4b durable action records (schema v11, same transaction as the checkpoint) done; 10.4c evo-server QUIC listener and -headless client with process kill tests done. The engineering GUI client still uses the -M9 dev path. 10.5 split (ADR-0093): 10.5a session protocol v2 and the replication core -done; 10.5b wiring (sessions, evo-server, client, probe) with process evidence done; 10.5c -the GUI client switch follows. +headless client with process kill tests done. 10.5 split (ADR-0093): 10.5a session +protocol v2 and the replication core done; 10.5b wiring (sessions, evo-server, client, +probe) with process evidence done; 10.5c engineering client switched to M10 sessions +(snapshot views, camera interest, grant bundles, msquic.dll in the Windows package) done. 10.6-10.9 planned. **Entry:** M9 client/session evidence and M7/M8 dev/stage durability. Read diff --git a/docs/STATUS.md b/docs/STATUS.md index 2d131c6..36019b9 100644 --- a/docs/STATUS.md +++ b/docs/STATUS.md @@ -35,8 +35,7 @@ from the durable record after crashes before or after a commit, unknown publicat cross-region moves. M10.4c adds the opt-in evo-server QUIC listener (session control and action records under the host's lease) and the headless `evo-session-probe`, with real-process tests including SIGKILL before and after -an action's commit. M10.4 is complete; the GUI client still uses the M9 dev path. Next: -M10.5 bounded snapshots and spatial interest. +an action's commit. M10.4 is complete. Next: M10.5 bounded snapshots and spatial interest. Deployment (2026-10-05): the maintainer deployed the M10 QUIC listener to evolution-dev behind the ADR-0087 route; session protocol v1 is therefore frozen. The route admitted only TCP 7400 while QUIC is UDP, so it is changed to UDP 7400 (ADR-0087 amendment). The @@ -48,7 +47,11 @@ entity deltas against the acknowledged baseline, nearest first within 16 KiB per a slower distant tier, datagram chunks and client assembly. M10.5b wires it end to end: evo-server replicates the region's environment for each session's interest (default: the first habitat site), the client assembles and acknowledges snapshots, and the probe prints -them. Next: the GUI client switch (10.5c). +them. M10.5c switches the engineering client to M10 sessions: snapshot-fed views, the camera +driving the interest after the user moves it, grant bundles (`evo-session-probe grants`, +evo-server `--m10-max-grant-lifetime` for dev), and `msquic.dll` in the Windows package. +M10.5 is complete. Deploying the v2 server to evolution-dev (the dev server still runs v1) +is a maintainer step. Next: M10.6 movement prediction and reconciliation. ## Previous gate - 2026-10-02 diff --git a/docs/adr/0083-dev-region-sessions.md b/docs/adr/0083-dev-region-sessions.md index aa243fe..50025f3 100644 --- a/docs/adr/0083-dev-region-sessions.md +++ b/docs/adr/0083-dev-region-sessions.md @@ -1,6 +1,8 @@ # ADR-0083: Dev region sessions, no-effect intentions and the session drill ## Status +The engineering client's remote mode moved to M10 sessions in M10.5c (ADR-0093); this +ADR's server path and `evo-dev-session` remain for their own tests. Listener/Service rule narrowly superseded for evolution-dev by ADR-0087 (dev session route), effective only when that route is enabled; until then this ADR applies as is. Accepted for M9.7 (engineering client to one authoritative **dev** region). Decisions diff --git a/docs/adr/0086-windows-client-package.md b/docs/adr/0086-windows-client-package.md index cda1eed..d7ee865 100644 --- a/docs/adr/0086-windows-client-package.md +++ b/docs/adr/0086-windows-client-package.md @@ -51,3 +51,16 @@ Static runtime: each image has its own CRT state; SDL's C API passes no CRT obje across the DLL boundary. Package and verification scripts change with the file list. Clean-machine/VM runs and minimum hardware remain M9.8g qualification. The notice inventory is an engineering record, not a legal review. + +## Amendment (M10.5c, 2026-10-06): msquic.dll +- The package adds `msquic.dll` (msquic 2.6.2, MIT, with OpenSSL 3.5.9 built static inside, + Apache-2.0; pins and sources as in ADR-0090) and `LICENSES/msquic.txt` and + `LICENSES/OpenSSL.txt`, copied from the verified sources. BUILD-INFO lists both pins. +- msquic links the whole C runtime statically (`QUIC_STATIC_LINK_PARTIAL_CRT=OFF`; its + default imported the UCRT forwarders). Allowed imports add `msquic.dll` and the system + DLLs it needs: `crypt32`, `iphlpapi`, `ncrypt`, `ntdll`. All three images are checked. +- Determinism: OpenSSL is built by msquic with nmake, outside CMake's `/Brepro`; the package + script sets `CL=/Brepro` (cl.exe reads options from it) and `SOURCE_DATE_EPOCH` (the + commit time, used by OpenSSL's build-date string) for the build. +- The package CTest run adds the label `quic-session` (QUIC session and client remote + session tests). diff --git a/docs/adr/0091-m10-session-identity-and-control.md b/docs/adr/0091-m10-session-identity-and-control.md index 26524c7..4d72902 100644 --- a/docs/adr/0091-m10-session-identity-and-control.md +++ b/docs/adr/0091-m10-session-identity-and-control.md @@ -133,3 +133,18 @@ only through `claim_account_control`, `renew_account_control` and by a later migration when organisms arrive, under the same row and fencing. - Not yet wired into evo-server or the engineering client (both keep the M9 dev path); that integration comes with 10.4, so nothing deploys M10 sessions yet. + +## Amendment (M10.5c, 2026-10-06): grant bundles and a dev grant lifetime +- **Bundles.** `evo-session-probe grants` signs 1-64 grants for one account in one file + (concatenated 160-byte grants, created new, owner-only), all issued now with consecutive + serials. Without `--serial` the first serial is 64 x the issue time in seconds, so a later + bundle for the account supersedes an earlier one without bookkeeping. The issuer key stays + with the operator; testers receive only the bundle and the dev CA. Grants cannot be dated + ahead (clock skew 30 s), so a bundle expires as a whole. +- **Lifetime.** The 300 s maximum would make a bundle unusable after five minutes. The + evo-server flag `--m10-max-grant-lifetime 60..3600` raises the region's maximum, refused + at startup outside `dev`; without it the 300 s default stands. A session ends when its + grant expires; the client then reconnects with the next grant of the bundle, which + succeeds only while that grant is still valid. +- Not changed: World0/stage issuance (no production identity provider yet), refresh within + a session, durable serial rules. diff --git a/docs/adr/0093-m10-snapshots-and-interest.md b/docs/adr/0093-m10-snapshots-and-interest.md index 5ba5df8..7761596 100644 --- a/docs/adr/0093-m10-snapshots-and-interest.md +++ b/docs/adr/0093-m10-snapshots-and-interest.md @@ -81,3 +81,32 @@ are ignored; malformed records, a slice mismatch or disagreeing chunk headers ar - Evidence: the test region's default interest holds one habitat site, so the process test shows a one-cell view refreshed every tick (40 chunks, 8,888 bytes in 40 ticks); the 225-cell and 32-session figures come from synthetic sources. + +## M10.5c engineering client switch (2026-10-06) +- **Remote mode is M10 only.** `evo-client` builds its remote mode with `EVO_BUILD_QUIC` + (presets `client-network` and `client-package` now enable it) over `RegionSessionClient`; + the M9.7 TCP session path is no longer used by the GUI (`evo-dev-session` and the M9 + server path keep their own tests). The launcher reads 160-byte M10 grants and defaults to + the dev route `void.aeternalisgames.com:7400` (ADR-0087); the endpoint is looked up once + (IPv4) when Connect is pressed. +- **One connection per grant.** A lost or closed session reconnects with the bundle's next + grant after a pause that grows from 2 s to 30 s and resets on Welcome (inside the + per-account attempt limit). Shutdown or capacity: retry. Refusals before any Welcome + (scope, signature, stale or expired grant) fail the launcher; `superseded` (another client + opened a session with a newer grant for the account) fails it at once instead of fighting + back; no grant left fails it as exhausted. A new epoch resets the views. +- **Views.** The newest applied snapshot feeds the environment and organism layers; a lost + session marks them stale. The camera follows the server's default view (re-centred on + its square while it fills in, nearest cells first) until the user pans or zooms; from then + on the camera centre's voxel, radius 7, in the snapshot's slice is the interest, sent at + most every 250 ms and again after each reconnect. +- **Intentions.** Sent as datagrams for server tick + 2 when the movement vector changes, + at most once per server tick. The Session panel's record shows sent, admitted, rejected, + **simulated** (the watermark covered it: final, never durable, ADR-0092) and unknown + (the session ended first). Entries are numbered by the client, since session sequences + restart with each session. The panel also shows the simulated watermark, the snapshot + (tick, cells, organisms), the interest and snapshot bytes. +- Evidence: `client-remote-session` drives `apps/evo-client/remote_session.hpp` against a + loopback region (launcher flow, 225-cell default view, following and the camera interest, + admitted then simulated intentions, epoch change with unknown outcomes and reconnect with + the next grant, superseded, wrong region, exhausted bundle, unresolvable endpoint). diff --git a/docs/engineering/CLIENT.md b/docs/engineering/CLIENT.md index 640eb9f..9e464e3 100644 --- a/docs/engineering/CLIENT.md +++ b/docs/engineering/CLIENT.md @@ -8,21 +8,22 @@ Contract: [client architecture](../architecture/CLIENT_ARCHITECTURE.md), ADR-007 Camera/input: [contracts and limits](CAMERA_INPUT.md), ADR-0079. Environment: [presentation and encodings](ENVIRONMENT_RENDERING.md), ADR-0080. Organisms/inspector: [encodings and budget](ORGANISM_RENDERING.md), ADR-0081. -Remote dev region: [operations](../networking/DEV_SESSION_OPERATIONS.md), ADR-0083. +Remote dev region: [M10 client sessions](../networking/M10_CLIENT_SESSIONS.md), ADR-0093 +(the M9.7 path, ADR-0083, is no longer used by the client). Engineering panels and launcher: [UI state](CLIENT_UI_STATE.md), ADR-0084. Without arguments a launcher opens. **Local fixture** is labelled as an in-memory -stand-in, never as a server or ecosystem. **Connect** (preset `client-network`) -reads the endpoint, server name, dev CA file and grant bundle file when pressed; +stand-in, never as a server or ecosystem. **Connect** (preset `client-network`, with QUIC) +reads the endpoint, server name, dev CA file and M10 grant bundle file when pressed; nothing is saved and no path, certificate or grant byte is shown or logged. Errors use fixed wording. A connection with no Welcome after three failed attempts (refused, TLS failure or timeout) or a refused grant fails with Retry/Cancel. `--fixture` or `--connect HOST:PORT --server-name NAME --ca FILE --grants FILE` skip the launcher (an unreadable file then exits 1). While running, a banner names the mode (LOCAL FIXTURE or DEV REGION with its phase); Disconnect asks for -confirmation. The Session panel shows session/epoch, server tick, durable -watermark, grants left and the last ten intentions with their outcome (sent, -admitted, rejected, durable, not committed, unknown). That list is the record; +confirmation. The Session panel shows session/epoch, server tick, simulated +watermark, grants left, the snapshot, interest and snapshot bytes, and the last ten +intentions with their outcome (sent, admitted, rejected, simulated, unknown; M10.5c). That list is the record; short notifications expire and can be dismissed. ## Build and run diff --git a/docs/engineering/CLIENT_PACKAGING.md b/docs/engineering/CLIENT_PACKAGING.md index a3eb43f..9b9265d 100644 --- a/docs/engineering/CLIENT_PACKAGING.md +++ b/docs/engineering/CLIENT_PACKAGING.md @@ -1,9 +1,10 @@ # Windows client package (M9.8e) Decision: [ADR-0086](../adr/0086-windows-client-package.md). Windows development host -only; requires Visual Studio 2022 C++ tools and prepared SDL, Dear ImGui and Mbed TLS -sources (`cmake -P tools/prepare-sdl3.cmake`, `prepare-imgui.cmake`, -`prepare-mbedtls.cmake`). +only; requires Visual Studio 2022 C++ tools and prepared SDL, Dear ImGui, Mbed TLS and +msquic sources (`cmake -P tools/prepare-sdl3.cmake`, `prepare-imgui.cmake`, +`prepare-mbedtls.cmake`, `prepare-msquic.cmake`), plus Strawberry Perl and NASM for +msquic's OpenSSL build (ADR-0090). ## Build a package @@ -13,15 +14,15 @@ powershell -NoProfile -ExecutionPolicy Bypass -File tools\client\package-windows It refuses uncommitted tracked changes (`-AllowDirty` packages them with a `-dirty` identity), configures `client-package` with `EVO_BUILD_IDENTITY=g<12 hex>`, builds, -runs the client/network CTest suite, stages the allowlisted files and writes +runs the client/network/quic-session CTest suite, stages the allowlisted files and writes `build/packages/evo-client-windows-x64-.zip` and `.zip.sha256`. The staged folder stays next to the ZIP. `-Clean` deletes `build/client-package` first; the build log is `build/client-package.log` (+ `.err`). -Package content (exact): `evo-client.exe`, `SDL3.dll`, `README.txt`, +Package content (exact): `evo-client.exe`, `SDL3.dll`, `msquic.dll`, `README.txt`, `BUILD-INFO.txt`, `THIRD-PARTY-NOTICES.txt`, `SHA256SUMS.txt` and `LICENSES/` (SDL3, its HIDAPI, yuv2rgb, stb_image and Khronos notices, Apache-2.0, Mbed TLS, -Dear ImGui with fonts and stb notices). The tester README template is +Dear ImGui with fonts and stb notices, msquic, OpenSSL). The tester README template is `tools/client/README-package.txt`; the notice index is `tools/client/THIRD-PARTY-NOTICES.txt`. No credentials, grant bundles, CA files or settings are ever packaged; dev CA and grants are issued to testers separately. @@ -34,7 +35,8 @@ powershell -NoProfile -ExecutionPolicy Bypass -File tools\client\package-selftes ``` Verification works without Visual Studio (copy `tools/client` with the ZIP): digest, -exact content and SHA256SUMS, PE imports limited to system DLLs plus `SDL3.dll`, +exact content and SHA256SUMS, PE imports of all three images limited to system DLLs plus +`SDL3.dll` and `msquic.dll` (no C runtime DLLs), credential and profile-path scan, then the extracted client runs with only the Windows system directories on PATH. `-Interactive` opens a real window for 3 s. The self-test proves each guard refuses its defect. diff --git a/docs/engineering/VALIDATION.md b/docs/engineering/VALIDATION.md index 530e9c2..8669773 100644 --- a/docs/engineering/VALIDATION.md +++ b/docs/engineering/VALIDATION.md @@ -4406,3 +4406,76 @@ tests; clang-tidy 19 on sessions, client, replication, bridge, probe and tests; checked). The repository format check fails only on `include/evo/server/session_window.hpp` (already on main, not part of this change). Not done: the GUI client (10.5c); deployment of v2 (the dev server still runs v1). + +## 2026-10-06 — M10.5c engineering client on M10 sessions (ADR-0093, ADR-0091, ADR-0086) + +Implemented the client's remote mode over `RegionSessionClient` +(`apps/evo-client/remote_session.hpp`): +- snapshot-fed views; +- the camera follows the default view, then drives the interest; +- intention record states, including `simulated`; +- reconnect with the bundle's next grant, with a growing pause. + +Supporting changes: +- the launcher reads 160-byte grants, takes `authority_path`, and defaults to the dev route; +- `quic::resolve_ipv4`; +- `evo-session-probe grants`; +- evo-server `--m10-max-grant-lifetime` (dev only); +- presets `client-network` and `client-package` with QUIC; +- msquic with a fully static CRT; +- `msquic.dll` and the msquic and OpenSSL licences in the Windows package; +- `CL=/Brepro` and `SOURCE_DATE_EPOCH` for the package's OpenSSL build. + +New test `client-remote-session` (labels client and quic-session) runs against a loopback +region: +- launcher flow and the 225-cell default view; +- following, then the camera interest (144 cells clipped); +- admitted then simulated intentions; +- an epoch change: unknown outcomes, stale views, reconnect with the next grant and the + views restored; +- client-side numbering across sessions; +- superseded, wrong region, an exhausted bundle, and an unresolvable endpoint. + +The process test now runs evo-server with `--m10-max-grant-lifetime 900` and the probe with +a 900 s grant. + +Found during development: +- test cells requesting water without moisture (the client refused the snapshot and closed); +- a budget-cut first snapshot skewed a one-time recentre, so the camera now follows until + the user moves it; +- session sequences collided in the outcome record, so the record now numbers entries + itself; +- msquic's default partial-static CRT imported the UCRT forwarders; +- a clang-tidy optional-access finding. + +Executed: +- **Linux GCC 14** + - preset `client-network` (with QUIC): CTest 14/14; `client-remote-session` passed 5 times + in a row; + - preset `quic`: 4/4; + - `postgres-check.sh` with EVO_BUILD_QUIC: 20 suites, including the region m10 session + integration. +- **Linux Clang 19:** clang-tidy 19 on the client app, remote test, host lookup, probe, + launcher and UI-model test; clang-format 19 on the changed files. +- **Windows MSVC 19.44** (binaries rebuilt, timestamps checked): + - preset `client-network`: 12/12; + - preset `quic`: 4/4. +- **Windows package:** + - `package-windows.ps1`: client-package CTest 12/12; + - `verify-windows-package.ps1` passed; + - `package-selftest.ps1`: 10 refusals, including the missing `msquic.dll` and the + dynamic-runtime image; + - `msquic.dll` imports only advapi32, bcrypt, crypt32, iphlpapi, kernel32, ncrypt, ntdll, + user32, winmm and ws2_32; + - two `-Clean` builds gave identical ZIPs (sha256 `aaabc228…312cb2`, identity + `g33e91458e7ee-dirty`), the same as the earlier incremental build. +- `evo-session-probe grants`, checked by hand: + - 8 grants, 1280 bytes, mode 0600; + - refuses an existing file, a lifetime under 60 s, a count over 64 and connect flags; + - `--serial` respected. + +Not done: +- a GUI run against evolution-dev (the dev server still runs session v1 and the flag is + not in the dev manifest); +- ASan of the client remote test (msquic under sanitizers is still open); +- a clean-VM package run. diff --git a/docs/networking/M10_CLIENT_SESSIONS.md b/docs/networking/M10_CLIENT_SESSIONS.md new file mode 100644 index 0000000..7196410 --- /dev/null +++ b/docs/networking/M10_CLIENT_SESSIONS.md @@ -0,0 +1,39 @@ +# Engineering client over M10 sessions (M10.5c) + +Decisions: ADR-0091 (grants, bundles, grant lifetime), ADR-0092 (intentions), ADR-0093 +(snapshots, interest, client behaviour), ADR-0087 (dev route). **evolution-dev only.** + +## Operator: issue a grant bundle + +On a machine that holds the dev issuer key (never give the key to testers): + +```sh +evo-session-probe grants --issuer-key issuer.key --world 100 --frame 9 --region 1 \ + --account <32 hex digits, one per tester> --count 16 --lifetime 3600 --out tester.grants +``` + +The file is created new and owner-only; it holds 16 single-use grants, valid together for +the lifetime. A lifetime above 300 s needs the region to run with +`--m10-max-grant-lifetime` at least that long (dev only); otherwise every grant is refused. +Issue a new bundle (same account; newer serials are automatic) when one runs out or +expires. Give the tester the bundle and the public dev CA (`dev-ca.pem`). + +## Tester: connect + +Run `evo-client`, choose **Connect to a dev region** and fill in the endpoint (default +`void.aeternalisgames.com:7400`, UDP; reachable only from 172.10.1.0/24), the server name +on the dev certificate, `dev-ca.pem` and the bundle. Or: + +```sh +evo-client --connect void.aeternalisgames.com:7400 --server-name NAME --ca dev-ca.pem \ + --grants tester.grants +``` + +- The view follows the region's default view until you pan or zoom; then the 15 x 15 + cells around the camera centre are replicated (radius 7). +- W A S D send movement intentions; the Session panel lists each as sent, admitted, + rejected, simulated (final; intentions are never durable) or unknown. +- Each reconnect uses the next grant. A second client with a bundle for the same account + takes the session over; the first stops (do not share bundles). +- A server still on session protocol v1 refuses the client (`unsupported_version`): + deploy the v2 server first. diff --git a/include/evo/client/launcher.hpp b/include/evo/client/launcher.hpp index 1d217c0..115685f 100644 --- a/include/evo/client/launcher.hpp +++ b/include/evo/client/launcher.hpp @@ -9,11 +9,13 @@ // M9.8c launcher model (toolkit- and network-independent). Validates what the user // typed, loads the two credential files within bounds, and tracks the connect flow. +// M10.5c (ADR-0093): grant records are M10 session grants (network::session_grant_bytes), +// issued by `evo-session-probe grants`; the default endpoint is the dev route (ADR-0087). // Error texts are fixed: they never contain file contents, grant bytes or keys, and // nothing here is persisted or logged. namespace evo::client { -inline constexpr std::size_t grant_record_bytes = 108; // network::dev_grant_bytes. -inline constexpr std::size_t max_grant_records = 64; // As issued by evo-dev-session. +inline constexpr std::size_t grant_record_bytes = 160; // network::session_grant_bytes. +inline constexpr std::size_t max_grant_records = 64; // As issued by the probe. inline constexpr std::size_t max_authority_bytes = 65536; // One small PEM CA. inline constexpr std::size_t max_field_bytes = 1024; // Every text field. using GrantRecord = std::array; @@ -35,7 +37,7 @@ enum class LaunchError : std::uint8_t { [[nodiscard]] std::string_view launch_error_text(LaunchError error) noexcept; struct ConnectForm { - std::string endpoint{"127.0.0.1:17400"}, server_name{"dev-region.evolution.test"}; + std::string endpoint{"void.aeternalisgames.com:7400"}, server_name{"dev-region.evolution.test"}; std::string authority_path, grants_path; }; struct Endpoint { @@ -45,6 +47,7 @@ struct Endpoint { struct ConnectMaterial { Endpoint endpoint; std::string server_name, authority_pem; + std::string authority_path; // The same CA as a file (the QUIC stack loads it too). std::vector grants; }; // "host:port", "[ipv6]:port" or "a.b.c.d:port"; plain DNS host names only. @@ -56,7 +59,7 @@ enum class ConnectSignal : std::uint8_t { welcome, // A session was opened. lost, // Transport/TLS failure or deadline before a Close. refused, // Closed as unauthenticated/expired/duplicate: this grant cannot work. - not_ready, // Closed as server_shutdown/capacity: the server will retry later. + not_ready, // Closed as shutdown/capacity: the session retries later with the next grant. exhausted // No unused grant remains. }; enum class LaunchPhase : std::uint8_t { choosing, fixture, connecting, connected, failed }; diff --git a/include/evo/client/outcome_log.hpp b/include/evo/client/outcome_log.hpp index 7962c4c..b2bda21 100644 --- a/include/evo/client/outcome_log.hpp +++ b/include/evo/client/outcome_log.hpp @@ -9,17 +9,19 @@ namespace evo::client { enum class OutcomeState : std::uint8_t { sent, // Queued to the server; no reply yet. - admitted, // Accepted for scheduling; not yet durable. + admitted, // Accepted for scheduling; not yet simulated or durable. rejected, // IntentResult other than admitted (final). durable, // Committed with no biological effect (final). not_committed, // The carrying input was dropped (final). - unknown // The connection ended first; the outcome is not known (final). + unknown, // The connection ended first; the outcome is not known (final). + simulated // M10 realtime intention: the region simulated its tick (final; never + // durable, ADR-0092). }; struct OutcomeEntry { std::uint64_t sequence{}; OutcomeState state{}; std::uint8_t detail{}; // IntentStatus code for rejections. - std::uint64_t tick{}, commit_sequence{}; // For durable outcomes. + std::uint64_t tick{}, commit_sequence{}; // Intended/simulated tick; commit when durable. }; class OutcomeLog { public: diff --git a/include/evo/network/quic_transport.hpp b/include/evo/network/quic_transport.hpp index a3bfd55..a28c273 100644 --- a/include/evo/network/quic_transport.hpp +++ b/include/evo/network/quic_transport.hpp @@ -23,6 +23,7 @@ #include #include #include +#include #include #include #include @@ -139,4 +140,7 @@ class MessageReassembler { std::vector buffer_; }; [[nodiscard]] std::vector frame_message(std::span payload); +// The endpoint takes a numeric address (the pinned server name is checked separately): +// looks a host name up once, IPv4 only, blocking. A numeric address comes back unchanged. +[[nodiscard]] std::optional resolve_ipv4(const std::string& host); } // namespace evo::network::quic diff --git a/src/client/ui/launcher.cpp b/src/client/ui/launcher.cpp index d31ba39..87b8f3b 100644 --- a/src/client/ui/launcher.cpp +++ b/src/client/ui/launcher.cpp @@ -46,7 +46,7 @@ std::string_view launch_error_text(LaunchError error) noexcept { case LaunchError::authority_path: return "Choose the dev CA certificate file (dev-ca.pem)."; case LaunchError::grants_path: - return "Choose a grant bundle file issued by evo-dev-session grants."; + return "Choose a grant bundle file issued by evo-session-probe grants."; case LaunchError::authority_unreadable: return "The dev CA file could not be read."; case LaunchError::authority_invalid: @@ -116,7 +116,7 @@ std::expected load_connect(const ConnectForm& form return std::unexpected(bundle.error()); if (bundle->size() % grant_record_bytes != 0) return std::unexpected(LaunchError::grants_invalid); - ConnectMaterial material{*endpoint, form.server_name, std::move(pem), {}}; + ConnectMaterial material{*endpoint, form.server_name, std::move(pem), form.authority_path, {}}; for (std::size_t at = 0; at < bundle->size(); at += grant_record_bytes) { GrantRecord grant{}; std::copy_n(bundle->begin() + static_cast(at), grant.size(), grant.begin()); @@ -167,7 +167,7 @@ void Launcher::observe(ConnectSignal signal) noexcept { phase_ = LaunchPhase::connecting; return; case ConnectSignal::not_ready: - return; // The session retries with the same grant. + return; // The session retries after a pause. case ConnectSignal::exhausted: fail(LaunchError::grants_exhausted); return; diff --git a/src/network/transport/host_lookup.cpp b/src/network/transport/host_lookup.cpp new file mode 100644 index 0000000..43ea766 --- /dev/null +++ b/src/network/transport/host_lookup.cpp @@ -0,0 +1,47 @@ +// M10.5c host name lookup for QUIC clients (ADR-0093). Kept apart from the msquic +// endpoint so the platform socket headers never meet msquic's own Windows includes. +#ifdef _WIN32 +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN +#endif +#ifndef NOMINMAX +#define NOMINMAX +#endif +#include +// After . +#include +#else +#include +#include +#include +#include +#endif +#include "evo/network/quic_transport.hpp" + +namespace evo::network::quic { +std::optional resolve_ipv4(const std::string& host) { +#ifdef _WIN32 + static const bool started = [] { + WSADATA data{}; + return WSAStartup(MAKEWORD(2, 2), &data) == 0; // Process lifetime; never cleaned up. + }(); + if (!started) + return std::nullopt; +#endif + if (host.empty()) + return std::nullopt; + addrinfo hints{}; + hints.ai_family = AF_INET; + hints.ai_socktype = SOCK_DGRAM; + addrinfo* found = nullptr; + if (getaddrinfo(host.c_str(), nullptr, &hints, &found) != 0 || found == nullptr) + return std::nullopt; + char text[INET_ADDRSTRLEN] = {}; + const auto* address = reinterpret_cast(found->ai_addr); + const bool ok = inet_ntop(AF_INET, &address->sin_addr, text, sizeof text) != nullptr; + freeaddrinfo(found); + if (!ok) + return std::nullopt; + return std::string{text}; +} +} // namespace evo::network::quic diff --git a/tests/client_remote_session.cpp b/tests/client_remote_session.cpp new file mode 100644 index 0000000..1e8f862 --- /dev/null +++ b/tests/client_remote_session.cpp @@ -0,0 +1,288 @@ +// M10.5c: the engineering client's remote session (apps/evo-client/remote_session.hpp) +// against a loopback region (ADR-0093): the launcher's connect flow, snapshot-fed views, +// the camera recentre and interest, intention outcomes (simulated, unknown), reconnects +// with the next grant of the bundle, and refusals (scope, superseded, exhausted). +#include "evo/client/session_host.hpp" +#include "evo/network/dev_credentials.hpp" +#include "evo/network/session_grant.hpp" +#include "evo/server/region_sessions.hpp" +#include "remote_session.hpp" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace { +using namespace evo; +using namespace evo::network; +using client::LaunchError; +using client::LaunchPhase; +using client::OutcomeState; +using client_app::RemoteSession; +using Clock = std::chrono::steady_clock; + +void check(bool ok, std::source_location at = std::source_location::current()) { + if (!ok) + throw std::runtime_error("client remote session line " + std::to_string(at.line())); +} +#define CHECK(...) check(static_cast(__VA_ARGS__)) +constexpr std::string_view name = "dev-region.evolution.test"; +constexpr world::WorldIdentity world_id{7, 3}; +constexpr std::uint64_t region = 12; +constexpr std::uint64_t start = 1'800'000'000; + +struct Files { + std::filesystem::path dir, ca, certificate, key; + std::string ca_pem; +}; +Files credentials() { + const auto made = generate_dev_credentials(DeploymentEnvironment::dev, name, 1, + std::chrono::system_clock::now()); + CHECK(made.has_value()); + Files f; + f.dir = std::filesystem::temp_directory_path() / "evo-client-remote-session"; + std::filesystem::remove_all(f.dir); + std::filesystem::create_directories(f.dir); + f.ca_pem = made->authority_pem; + f.ca = f.dir / "ca.pem"; + f.certificate = f.dir / "server.pem"; + f.key = f.dir / "server.key"; + for (const auto& [path, text] : {std::pair{f.ca, made->authority_pem}, + std::pair{f.certificate, made->server_certificate_pem}, + std::pair{f.key, made->server_key_pem}}) { + std::ofstream out{path, std::ios::binary | std::ios::trunc}; + out << text; + CHECK(out.good()); + } + return f; +} +AccountId account(std::uint8_t tag) { + AccountId a; + a.bytes.fill(tag); + return a; +} +std::array scalar() { + std::array s{}; + s.back() = 0x2B; + return s; +} +client::EnvironmentCell cell(std::int64_t x, std::int64_t y, std::uint64_t quantity) { + client::EnvironmentCell c; + c.voxel = {x, y, -7}; + c.chunk_revision = 40; + c.habitat = {{100}, {200}, {0}, {1000}, {500}, {10}}; + c.volume = {1000ULL * 500 * 10}; + c.substrate = {1}; + c.terrain_material = {2}; + c.terrain_fill = 1000; + c.presence[0] = client::FieldPresence::present; + c.quantity[0] = quantity; + c.presence[1] = client::FieldPresence::missing; + c.presence[7] = client::FieldPresence::present; + c.quantity[7] = 5; + c.moisture_status = world::MoistureStatus::available; // Water is requested. + c.moisture = {3, 50}; + return c; +} + +// A region on loopback with a 21 x 21 slice (x, y in -10..10 at z -7), one snapshot per tick. +struct Region { + explicit Region(const Files& f) : files{f} { + server::RegionSessionsConfig c; + c.transport.certificate_pem_file = f.certificate.string(); + c.transport.key_pem_file = f.key.string(); + c.control.environment = DeploymentEnvironment::dev; + c.control.world = world_id; + c.control.region = region; + c.control.epoch = epoch; + c.control.max_account_attempts = 16; + c.issuer_keys.push_back({1, *key.public_key()}); + auto made = server::RegionSessions::create(std::move(c)); + CHECK(made.has_value()); + sessions = std::move(*made); + sessions->set_default_interest({3, 3, -7, 7}); + } + WireGrant grant(const AccountId& who, std::uint64_t serial, + std::uint64_t in_region = region) const { + GrantClaims c; + c.grant_id = 900 + serial; + c.account = who; + c.serial = serial; + c.world = world_id; + c.region = in_region; + c.issued_at = start; + c.expires_at = start + 120; + const auto g = key.sign(c); + CHECK(g.has_value()); + return *g; + } + // The launcher's material: the endpoint by host name, as a tester types it. + client::ConnectMaterial material(std::vector grants) const { + return {{"localhost", sessions->port()}, + std::string{name}, + files.ca_pem, + files.ca.string(), + std::move(grants)}; + } + void pump() { + sessions->poll({true, epoch, tick}, start + 1, Clock::now()); + if (tick != replicated) { + replicated = tick; + sessions->replicate(tick, [&](const SessionInterest&) { + ReplicationSource s; + s.identity = world_id; + s.field_revision = tick; + s.mask = (1U << 0) | (1U << 1) | (1U << 7); + for (std::int64_t x = -10; x <= 10; ++x) + for (std::int64_t y = -10; y <= 10; ++y) + s.environment.push_back(cell(x, y, 30)); + return s; + }); + } + static_cast(sessions->take_events()); + } + const Files& files; + GrantSigningKey key = *GrantSigningKey::import(DeploymentEnvironment::dev, 1, scalar()); + std::unique_ptr sessions; + std::uint64_t epoch{3}, tick{100}, replicated{}; +}; + +struct Client { + client::SessionHost host; + client::UiState ui; + client::Intention intention; + // Steps the region and the client together (one region tick every `tick_every` + // iterations, 0: none) until `done` or the limit. + bool until(Region& r, const std::function& done, int tick_every = 0, + std::chrono::milliseconds limit = std::chrono::milliseconds{15000}) { + const auto end = Clock::now() + limit; + for (int i = 1; Clock::now() < end; ++i) { + r.pump(); + if (tick_every != 0 && i % tick_every == 0) + ++r.tick; + host.step(Clock::now(), intention, ui); + if (done()) + return true; + std::this_thread::sleep_for(std::chrono::milliseconds{1}); + } + return done(); + } + [[nodiscard]] LaunchPhase phase() const { + return host.launcher().phase(); + } + [[nodiscard]] std::size_t cells() const { + const auto* s = host.session(); + const auto* e = s ? s->environment().current() : nullptr; + return e ? e->cells().size() : 0; + } + [[nodiscard]] bool has(OutcomeState state) const { + const auto* s = host.session(); + return s && std::ranges::any_of(s->outcomes().entries(), + [&](const auto& e) { return e.state == state; }); + } +}; + +void views_interest_and_intentions(Region& r) { + Client c; + CHECK(c.host.connect( + RemoteSession::open(r.material({r.grant(account(1), 1), r.grant(account(1), 2)})))); + CHECK(c.until(r, [&] { return c.phase() == LaunchPhase::connected; })); + // The default interest (3, 3, radius 7) arrives as the copied view. + CHECK(c.until(r, [&] { return c.cells() == 225; }, 20)); + auto& s = *c.host.session(); + const auto* view = s.environment().current(); + CHECK(view != nullptr && view->slice_z() == -7 && + std::ranges::all_of(view->cells(), [](const auto& e) { + return e.voxel.x >= -4 && e.voxel.x <= 10 && e.voxel.y >= -4 && e.voxel.y <= 10; + })); + CHECK(s.environment().freshness() == client::Freshness::current); + // The camera follows the view: the middle of its square, offered once per change. + const auto centre = s.take_recentre().value_or(client::WorldPoint{-1, -1}); + CHECK(centre.x_mm == 3500 && centre.y_mm == 3500 && !s.take_recentre()); + s.focus(centre); // Where the view put it: still following, no interest sent. + static_cast(c.until(r, [] { return false; }, 20, std::chrono::milliseconds{300})); + CHECK(!s.status().focused && c.cells() == 225); // 300 ms of ticks: the same view. + // The user moves the camera: its centre's voxel becomes the interest (clipped). + s.focus({-5500, -5200}); + CHECK(c.until(r, [&] { return c.cells() == 144; }, 20)); // x, y in -10..1. + const auto status = s.status(); + CHECK(status.focused && status.focus_x == -6 && status.focus_y == -6 && status.focus_z == -7 && + status.phase == "connected" && status.grants_left == 1 && status.snapshot_bytes > 0); + // An intention: sent once per change, admitted, then simulated (never durable). + c.intention.move_x = 700; + CHECK(c.until(r, [&] { return c.has(OutcomeState::admitted); })); + CHECK(c.until(r, [&] { return c.has(OutcomeState::simulated); }, 20)); + const auto& first = s.outcomes().entries().front(); + CHECK(first.sequence == 1 && first.tick != 0 && s.status().simulated_tick >= first.tick); + // A new epoch closes the session: the open intention is unknown, the views are stale, + // and the session reconnects with the bundle's next grant after its pause. + const auto old_session = s.status().session; + c.intention.move_x = -700; + CHECK(c.until(r, [&] { return c.has(OutcomeState::admitted) || c.has(OutcomeState::sent); })); + r.epoch = 4; + CHECK(c.until(r, [&] { return c.has(OutcomeState::unknown); })); + CHECK(s.environment().freshness() == client::Freshness::stale); + CHECK(s.outcomes().entries().size() == 2 && s.outcomes().entries()[1].sequence == 2 && + s.outcomes().entries()[1].state == OutcomeState::unknown); + CHECK(c.until(r, [&] { return s.status().phase == "connected"; }, 20)); + CHECK(s.status().epoch == 4 && s.status().session != old_session && + s.status().grants_left == 0 && c.phase() == LaunchPhase::connected); + // Views restart for the new epoch, at the camera's interest (sent again). + CHECK(c.until(r, [&] { return c.cells() == 144 && s.status().snapshot_tick > 0; }, 20)); + // The current intention is sent again in the new session; the record numbers it on + // (session sequences restart) and keeps the earlier entries. + CHECK(c.until(r, [&] { return s.outcomes().entries().size() == 3; })); + CHECK(s.outcomes().entries()[0].state == OutcomeState::simulated && + s.outcomes().entries()[2].sequence == 3); + // Another client with a newer grant for the account supersedes this one: no fight back. + Client other; + CHECK(other.host.connect(RemoteSession::open(r.material({r.grant(account(1), 9)})))); + CHECK(other.until(r, [&] { + c.host.step(Clock::now(), c.intention, c.ui); + return c.phase() == LaunchPhase::failed && other.phase() == LaunchPhase::connected; + })); + CHECK(c.host.launcher().error() == LaunchError::grant_refused && !c.host.session()); +} + +void refusals(Region& r) { + // A grant for another region: refused before any Welcome; the launcher stops. + Client wrong; + CHECK(wrong.host.connect(RemoteSession::open(r.material({r.grant(account(2), 1, 99)})))); + CHECK(wrong.until(r, [&] { return wrong.phase() == LaunchPhase::failed; })); + CHECK(wrong.host.launcher().error() == LaunchError::grant_refused); + // One grant: once its session ends there is nothing to reconnect with. + Client one; + CHECK(one.host.connect(RemoteSession::open(r.material({r.grant(account(3), 1)})))); + CHECK(one.until(r, [&] { return one.phase() == LaunchPhase::connected; })); + r.epoch = 5; + CHECK(one.until(r, [&] { return one.phase() == LaunchPhase::failed; })); + CHECK(one.host.launcher().error() == LaunchError::grants_exhausted); + // Nothing to open: an unresolvable endpoint or an empty bundle. + auto bad = r.material({r.grant(account(4), 1)}); + bad.endpoint.host = "no-such-host.invalid"; + CHECK(!RemoteSession::open(bad)); + CHECK(!RemoteSession::open(r.material({}))); +} +} // namespace + +int main() try { + const auto files = credentials(); + { + Region r{files}; + views_interest_and_intentions(r); + refusals(r); + } + std::filesystem::remove_all(files.dir); + std::puts("client remote session tests passed"); + return 0; +} catch (const std::exception& e) { + std::fprintf(stderr, "%s\n", e.what()); + return 1; +} diff --git a/tests/client_ui_model.cpp b/tests/client_ui_model.cpp index 0727cea..99a5b4d 100644 --- a/tests/client_ui_model.cpp +++ b/tests/client_ui_model.cpp @@ -163,7 +163,10 @@ void launcher() { write("ca.pem", "-----BEGIN CERTIFICATE-----\nMIIB\n-----END CERTIFICATE-----\n"); form.grants_path = write("grants.bin", std::string(grant_record_bytes * 3, '\x01')); const auto loaded = load_connect(form); - CHECK(loaded && loaded->grants.size() == 3 && loaded->endpoint.port == 17400); + // The default endpoint is the dev route (ADR-0087); records are M10 grants (160 bytes). + CHECK(loaded && loaded->grants.size() == 3 && loaded->endpoint.port == 7400 && + loaded->endpoint.host == "void.aeternalisgames.com" && grant_record_bytes == 160 && + loaded->authority_path == form.authority_path); const auto refused_with = [&](const ConnectForm& f, LaunchError e) { const auto r = load_connect(f); return !r && r.error() == e; diff --git a/tests/region_m10_session_tests.cpp b/tests/region_m10_session_tests.cpp index b917423..fac5243 100644 --- a/tests/region_m10_session_tests.cpp +++ b/tests/region_m10_session_tests.cpp @@ -92,22 +92,22 @@ struct Setup { } [[nodiscard]] std::vector args() const { return server_args( - region, - {"--synthetic-inputs", "development-v1", "--m10-listen", "127.0.0.1:0", "--m10-cert", - (region.root / "server.pem").string(), "--m10-key", - (region.root / "server.key").string(), "--m10-issuer", - (region.root / "issuer.pub").string(), "--m10-environment", "dev", "--session-window", - "test-" + - std::to_string(static_cast( - std::chrono::duration_cast( - std::chrono::system_clock::now().time_since_epoch()) - .count())) + - ":" + - std::to_string(static_cast( - std::chrono::duration_cast( - std::chrono::system_clock::now().time_since_epoch()) - .count()) + - 1200)}); + region, {"--synthetic-inputs", "development-v1", "--m10-listen", "127.0.0.1:0", + "--m10-cert", (region.root / "server.pem").string(), "--m10-key", + (region.root / "server.key").string(), "--m10-issuer", + (region.root / "issuer.pub").string(), "--m10-environment", "dev", + "--m10-max-grant-lifetime", "900", "--session-window", + "test-" + + std::to_string(static_cast( + std::chrono::duration_cast( + std::chrono::system_clock::now().time_since_epoch()) + .count())) + + ":" + + std::to_string(static_cast( + std::chrono::duration_cast( + std::chrono::system_clock::now().time_since_epoch()) + .count()) + + 1200)}); } [[nodiscard]] WireGrant grant(const AccountId& who, std::uint64_t serial) const { GrantClaims c; @@ -315,6 +315,7 @@ void end_to_end() { "--region", "151", "--account", hex(bob), "--serial", "1", + "--lifetime", "900", // Over the default 300 s: allowed by the server flag. "--intents", "3", "--actions", "2", "--action-base", "10", diff --git a/tools/client/README-package.txt b/tools/client/README-package.txt index cd45713..431f2cd 100644 --- a/tools/client/README-package.txt +++ b/tools/client/README-package.txt @@ -13,7 +13,7 @@ Requirements ------------ Windows 10 or 11, x64. No installer and no Visual C++ redistributable is needed: the client uses the static Microsoft C++ runtime and only Windows system DLLs plus -the bundled SDL3.dll. Minimum hardware is not yet qualified. +the bundled SDL3.dll and msquic.dll. Minimum hardware is not yet qualified. Running ------- @@ -21,10 +21,14 @@ Extract the whole folder anywhere and run evo-client.exe. A launcher opens: * Local fixture - an in-memory stand-in for an environment with static organisms. It is not a server, not an ecosystem and not authoritative. -* Connect to a dev region - needs an endpoint, the server name, the dev CA file +* Connect to a dev region - needs an endpoint (default: the dev route, + void.aeternalisgames.com:7400, UDP), the server name, the dev CA file (dev-ca.pem) and a grant bundle file. These are issued separately by the development team and are never part of this package. Files are read when you - press Connect; nothing is saved. Do not share grant bundles. + press Connect; nothing is saved. Do not share grant bundles: each grant opens one + session, a bundle expires as a whole, and a second client using the same bundle + takes the session over. The view follows the region until you pan; then it + follows the camera (15 x 15 cells around it). Controls (defaults, rebindable in Controls...): W A S D move, arrow keys pan, mouse wheel zooms, left click selects, Tab toggles UI capture. Key names refer to diff --git a/tools/client/THIRD-PARTY-NOTICES.txt b/tools/client/THIRD-PARTY-NOTICES.txt index 3bc016e..a3fae26 100644 --- a/tools/client/THIRD-PARTY-NOTICES.txt +++ b/tools/client/THIRD-PARTY-NOTICES.txt @@ -21,6 +21,10 @@ Mbed TLS (statically linked) Apache-2.0 (chosen from Apache-2.0 OR GPL-2.0-or-later) LICENSES/MbedTLS.txt, LICENSES/Apache-2.0.txt +MsQuic (msquic.dll) MIT License LICENSES/msquic.txt + Compiled into msquic.dll: + - OpenSSL (TLS 1.3 provider) Apache-2.0 LICENSES/OpenSSL.txt + Dear ImGui (statically linked) MIT License LICENSES/DearImGui.txt - Embedded fonts ProggyClean and ProggyForever (MIT) LICENSES/DearImGui-embedded-fonts.txt, diff --git a/tools/client/package-common.ps1 b/tools/client/package-common.ps1 index 4d58ceb..e7e1d74 100644 --- a/tools/client/package-common.ps1 +++ b/tools/client/package-common.ps1 @@ -12,23 +12,30 @@ $script:PackageFiles = @( 'LICENSES/DearImGui.txt', 'LICENSES/Khronos.txt', 'LICENSES/MbedTLS.txt', + 'LICENSES/OpenSSL.txt', 'LICENSES/SDL3-hidapi.txt', 'LICENSES/SDL3-stb_image.txt', 'LICENSES/SDL3-yuv2rgb.txt', 'LICENSES/SDL3.txt', + 'LICENSES/msquic.txt', 'README.txt', 'SDL3.dll', 'SHA256SUMS.txt', 'THIRD-PARTY-NOTICES.txt', - 'evo-client.exe' + 'evo-client.exe', + 'msquic.dll' ) -# Imports allowed for the executables: Windows system DLLs and the bundled SDL3.dll. -# The C/C++ runtime is static (no MSVCP/VCRUNTIME/api-ms-win-crt/ucrtbase). +# Imports allowed for the executables: Windows system DLLs and the bundled SDL3.dll and +# msquic.dll (M10.5c). The C/C++ runtime is static (no MSVCP/VCRUNTIME/api-ms-win-crt/ +# ucrtbase), in msquic.dll too. $script:AllowedImports = @( - 'advapi32.dll', 'bcrypt.dll', 'gdi32.dll', 'imm32.dll', 'kernel32.dll', 'ole32.dll', - 'oleaut32.dll', 'sdl3.dll', 'setupapi.dll', 'shell32.dll', 'user32.dll', 'version.dll', - 'winmm.dll', 'ws2_32.dll' + 'advapi32.dll', 'bcrypt.dll', 'crypt32.dll', 'gdi32.dll', 'imm32.dll', 'iphlpapi.dll', + 'kernel32.dll', 'msquic.dll', 'ncrypt.dll', 'ntdll.dll', 'ole32.dll', 'oleaut32.dll', + 'sdl3.dll', 'setupapi.dll', 'shell32.dll', 'user32.dll', 'version.dll', 'winmm.dll', + 'ws2_32.dll' ) +# Every shipped image whose imports are checked. +$script:PackageImages = @('evo-client.exe', 'SDL3.dll', 'msquic.dll') function Get-Sha256([string]$Path) { (Get-FileHash -Algorithm SHA256 -LiteralPath $Path).Hash.ToLowerInvariant() diff --git a/tools/client/package-selftest.ps1 b/tools/client/package-selftest.ps1 index 0078cf6..9822dbd 100644 --- a/tools/client/package-selftest.ps1 +++ b/tools/client/package-selftest.ps1 @@ -26,13 +26,14 @@ $secrets = { param($p) Assert-NoSecrets $p } # Baseline: the untouched copy passes every guard. Assert-PackageContent $Staged Assert-NoSecrets $Staged -foreach ($binary in @('evo-client.exe', 'SDL3.dll')) { Assert-AllowedImports (Join-Path $Staged $binary) } +foreach ($binary in $script:PackageImages) { Assert-AllowedImports (Join-Path $Staged $binary) } Expect-Refused 'extra file' { param($p) [IO.File]::WriteAllText((Join-Path $p 'notes.txt'), 'x', $utf8) } $content Expect-Refused 'missing file' { param($p) Remove-Item -LiteralPath (Join-Path $p 'LICENSES\SDL3.txt') } $content +Expect-Refused 'missing msquic.dll' { param($p) Remove-Item -LiteralPath (Join-Path $p 'msquic.dll') } $content Expect-Refused 'checksum mismatch' { param($p) [IO.File]::AppendAllText((Join-Path $p 'README.txt'), ' ', $utf8) } $content Expect-Refused 'credential file type' { param($p) [IO.File]::WriteAllText((Join-Path $p 'dev-ca.pem'), 'x', $utf8) } $secrets -Expect-Refused 'grant bundle file type' { param($p) [IO.File]::WriteAllBytes((Join-Path $p 'client-grants.bin'), [byte[]]::new(108)) } $secrets +Expect-Refused 'grant bundle file type' { param($p) [IO.File]::WriteAllBytes((Join-Path $p 'client-grants.bin'), [byte[]]::new(160)) } $secrets Expect-Refused 'private key text' { param($p) [IO.File]::AppendAllText((Join-Path $p 'README.txt'), "-----BEGIN EC PRIVATE KEY-----`nMHcCAQEEIBbF0p3l9QpKl2+abcdefghijklmnopqrstuvwxyzABCDEFG`n", $utf8) } $secrets diff --git a/tools/client/package-windows.ps1 b/tools/client/package-windows.ps1 index affd924..d4c0482 100644 --- a/tools/client/package-windows.ps1 +++ b/tools/client/package-windows.ps1 @@ -59,6 +59,10 @@ $build = Join-Path $root 'build\client-package' if ($Clean -and (Test-Path -LiteralPath $build)) { Remove-Item -LiteralPath $build -Recurse -Force } $log = Join-Path $root 'build\client-package.log' New-Item -ItemType Directory -Force (Split-Path -Parent $log) | Out-Null +# msquic builds OpenSSL with nmake, outside CMake's /Brepro (M10.5c): cl.exe also reads +# options from CL, and OpenSSL's build-date string honours SOURCE_DATE_EPOCH (commit time). +$env:CL = '/Brepro' +$env:SOURCE_DATE_EPOCH = "$epoch" # A separate process (stderr in its own file): Windows PowerShell 5.1 would turn # harmless native stderr lines into terminating errors here. $check = Start-Process -FilePath 'powershell.exe' -NoNewWindow -Wait -PassThru ` @@ -68,7 +72,7 @@ $check = Start-Process -FilePath 'powershell.exe' -NoNewWindow -Wait -PassThru ` if ($check.ExitCode -ne 0) { throw "Package build or tests failed; see $log and $log.err" } $summary = Select-String -LiteralPath $log -Pattern '(\d+)% tests passed, (\d+) tests failed out of (\d+)' | Select-Object -Last 1 if (!$summary -or $summary.Matches[0].Groups[2].Value -ne '0') { throw "No passing test summary in $log" } -$tests = "client-package CTest (labels client|network): $($summary.Matches[0].Groups[3].Value) passed, 0 failed" +$tests = "client-package CTest (labels client|network|quic-session): $($summary.Matches[0].Groups[3].Value) passed, 0 failed" $exe = Join-Path $build 'evo-client.exe' $version = (& $exe --version | Out-String).Trim() @@ -88,10 +92,13 @@ $compiler = $matches[1] $sdlVersion = Read-Pin 'sdl3-pin.cmake' 'EVO_SDL_VERSION' $imguiVersion = Read-Pin 'imgui-pin.cmake' 'EVO_IMGUI_VERSION' $mbedVersion = Read-Pin 'mbedtls-pin.cmake' 'EVO_MBEDTLS_VERSION' +$msquicVersion = Read-Pin 'msquic-pin.cmake' 'EVO_MSQUIC_VERSION' +$opensslVersion = Read-Pin 'msquic-pin.cmake' 'EVO_OPENSSL_VERSION' $sdl = Join-Path $root "build\external\sdl3\SDL3-$sdlVersion" $imgui = Join-Path $root "build\external\imgui\imgui-$imguiVersion" $mbed = Join-Path $root "build\external\mbedtls\mbedtls-$mbedVersion" -foreach ($source in @($sdl, $imgui, $mbed)) { +$msquic = Join-Path $root "build\external\msquic\msquic-$msquicVersion" +foreach ($source in @($sdl, $imgui, $mbed, $msquic)) { if (!(Test-Path -LiteralPath (Join-Path $source 'evo-verified.sha256'))) { throw "Unverified dependency source: $source" } } @@ -102,6 +109,7 @@ $licenses = Join-Path $stage 'LICENSES' New-Item -ItemType Directory -Force $licenses | Out-Null Copy-Item -LiteralPath $exe -Destination $stage Copy-Item -LiteralPath (Join-Path $build 'SDL3.dll') -Destination $stage +Copy-Item -LiteralPath (Join-Path $build 'msquic.dll') -Destination $stage # Repository templates are re-written with CRLF so checkout line-ending settings # cannot change the package bytes. Write-Text (Join-Path $stage 'THIRD-PARTY-NOTICES.txt') ([IO.File]::ReadAllLines((Join-Path $PSScriptRoot 'THIRD-PARTY-NOTICES.txt'))) @@ -127,6 +135,9 @@ Write-Text (Join-Path $licenses 'Khronos.txt') $khronosLines Write-Text (Join-Path $licenses 'Apache-2.0.txt') ( Get-Block (Join-Path $mbed 'LICENSE') '^\s+Apache License\s*$' 'END OF TERMS AND CONDITIONS') Copy-Item -LiteralPath (Join-Path $mbed 'LICENSE') -Destination (Join-Path $licenses 'MbedTLS.txt') +# msquic.dll (MIT) with OpenSSL (Apache-2.0) built static inside it (ADR-0090). +Copy-Item -LiteralPath (Join-Path $msquic 'LICENSE') -Destination (Join-Path $licenses 'msquic.txt') +Copy-Item -LiteralPath (Join-Path $msquic 'submodules\openssl\LICENSE.txt') -Destination (Join-Path $licenses 'OpenSSL.txt') Copy-Item -LiteralPath (Join-Path $imgui 'LICENSE.txt') -Destination (Join-Path $licenses 'DearImGui.txt') Copy-Item -LiteralPath (Join-Path $imgui 'docs\FONTS.md') -Destination (Join-Path $licenses 'DearImGui-FONTS.md') $draw = Join-Path $imgui 'imgui_draw.cpp' @@ -159,6 +170,8 @@ Write-Text (Join-Path $stage 'BUILD-INFO.txt') @( "sdl3: $sdlVersion sha256=$(& $pin 'sdl3-pin.cmake' 'EVO_SDL_SHA256')", "dear_imgui: $imguiVersion sha256=$(& $pin 'imgui-pin.cmake' 'EVO_IMGUI_SHA256')", "mbedtls: $mbedVersion sha256=$(& $pin 'mbedtls-pin.cmake' 'EVO_MBEDTLS_SHA256')", + "msquic: $msquicVersion sha256=$(& $pin 'msquic-pin.cmake' 'EVO_MSQUIC_SHA256')", + "openssl: $opensslVersion sha256=$(& $pin 'msquic-pin.cmake' 'EVO_OPENSSL_SHA256')", "tests: $tests", "version_output: $version") @@ -169,7 +182,7 @@ $sums = foreach ($relative in (Get-RelativeFiles $stage)) { Assert-PackageContent $stage Assert-NoSecrets $stage -foreach ($binary in @('evo-client.exe', 'SDL3.dll')) { Assert-AllowedImports (Join-Path $stage $binary) } +foreach ($binary in $script:PackageImages) { Assert-AllowedImports (Join-Path $stage $binary) } # Deterministic ZIP: sorted entries under one top folder, commit time stamps. Add-Type -AssemblyName System.IO.Compression diff --git a/tools/client/verify-windows-package.ps1 b/tools/client/verify-windows-package.ps1 index a843f82..bb85e5a 100644 --- a/tools/client/verify-windows-package.ps1 +++ b/tools/client/verify-windows-package.ps1 @@ -23,7 +23,7 @@ try { $folder = $top[0].FullName Assert-PackageContent $folder Assert-NoSecrets $folder - foreach ($binary in @('evo-client.exe', 'SDL3.dll')) { Assert-AllowedImports (Join-Path $folder $binary) } + foreach ($binary in $script:PackageImages) { Assert-AllowedImports (Join-Path $folder $binary) } $identity = ([IO.File]::ReadAllLines((Join-Path $folder 'BUILD-INFO.txt')) | Where-Object { $_ -like 'identity: *' }) -replace '^identity: ', '' if ($top[0].Name -ne "evo-client-windows-x64-$identity") { throw 'Folder name does not match BUILD-INFO identity' }