#include "evo/network/session_protocol.hpp" #include #include #include namespace evo::network { namespace { constexpr std::size_t hello_bytes = 4 + session_grant_wire_bytes; constexpr std::size_t welcome_bytes = std::size_t{8} * 8; constexpr std::size_t refresh_bytes = session_grant_wire_bytes; constexpr std::size_t refresh_result_bytes = 1 + 8; constexpr std::size_t close_bytes = 1; constexpr std::size_t intention_bytes = (std::size_t{4} * 8) + 4; constexpr std::size_t cellular_intention_bytes = (std::size_t{4} * 8) + 4 + 1 + 3 + 8; constexpr std::size_t cellular_action_bytes = (std::size_t{4} * 8) + 4 + 1 + 3 + 8; constexpr std::size_t cellular_mutation_action_bytes = (std::size_t{7} * 8) + 2 + 6; constexpr std::size_t cellular_perception_prefix_bytes = 8 + 8 + 2; constexpr std::size_t cellular_diagnostics_bytes = 64; constexpr std::size_t cellular_perception_v9_prefix_bytes = cellular_perception_prefix_bytes + cellular_diagnostics_bytes; constexpr std::size_t cellular_perceived_patch_bytes = 8 + 8 + (4 * 8); constexpr std::size_t intention_receipt_bytes = 8 + 1 + 8; constexpr std::size_t simulated_bytes = std::size_t{3} * 8; constexpr std::size_t action_bytes = (std::size_t{3} * 8) + 2 + 8; constexpr std::size_t action_receipt_bytes = 8 + 1 + 8 + 8; constexpr std::size_t action_outcome_bytes = 8 + 1 + 8 + 8; constexpr std::size_t action_query_bytes = 8; constexpr std::uint8_t max_admit_status = static_cast(AdmitStatus::not_ready); constexpr std::size_t interest_bytes = (3 * std::size_t{8}) + 2; constexpr std::size_t snapshot_ack_bytes = 2 * std::size_t{8}; constexpr std::uint8_t max_snapshot_chunks = 16; constexpr std::size_t address_bytes = 8 + (2 * session_address_bytes); constexpr std::size_t handoff_offer_bytes = 16 + address_bytes + session_grant_wire_bytes; constexpr std::size_t redirect_bytes = address_bytes; constexpr std::size_t life_request_bytes = 24; constexpr std::size_t life_receipt_bytes = 17; constexpr std::size_t life_outcome_bytes = 25; constexpr std::size_t life_query_bytes = 8; bool valid_diagnostics(const CellularLifeDiagnostics& diagnostics) { const auto movement = static_cast(diagnostics.movement); const auto intake = static_cast(diagnostics.intake); if (movement > static_cast(CellularMovementResult::insufficient_energy) || intake > static_cast(CellularIntakeResult::out_of_contact)) return false; if (!diagnostics.has_tick_effects) return diagnostics.maintenance_cost_pj == 0 && diagnostics.movement_cost_pj == 0 && diagnostics.movement == CellularMovementResult::not_reported && diagnostics.intake == CellularIntakeResult::not_reported; return diagnostics.movement != CellularMovementResult::not_reported && diagnostics.intake != CellularIntakeResult::not_reported; } void put(std::vector& out, std::uint64_t v, std::size_t count) { for (std::size_t i = 0; i < count; ++i) out.push_back(static_cast(v >> (8 * i))); } std::uint64_t get(std::span in, std::size_t at, std::size_t count) { std::uint64_t v = 0; for (std::size_t i = 0; i < count; ++i) v |= static_cast(in[at + i]) << (8 * i); return v; } std::vector header(SessionMessageType type, std::size_t payload, std::uint16_t version = session_protocol_version) { std::vector out; out.reserve(session_header_bytes + payload); put(out, session_magic, 4); put(out, version, 2); out.push_back(static_cast(type)); out.push_back(0); return out; } bool wire_reason(std::uint64_t v) { return v >= static_cast(SessionCloseReason::client_closed) && v <= static_cast(SessionCloseReason::moved); } // Printable ASCII without spaces, then zero padding to the field size. bool valid_text(const std::string& s) { return !s.empty() && s.size() <= session_address_bytes && std::ranges::all_of(s, [](char ch) { return ch > 0x20 && ch < 0x7F; }); } void put_text(std::vector& out, const std::string& s) { for (std::size_t i = 0; i < session_address_bytes; ++i) out.push_back(i < s.size() ? static_cast(s[i]) : std::uint8_t{0}); } std::optional text_at(std::span in, std::size_t at) { std::string s; std::size_t i = 0; for (; i < session_address_bytes && in[at + i] != 0; ++i) s.push_back(static_cast(in[at + i])); for (; i < session_address_bytes; ++i) if (in[at + i] != 0) return std::nullopt; // Bytes after the terminator must be padding. if (!valid_text(s)) return std::nullopt; return s; } void put_address(std::vector& out, const RegionAddress& a) { put(out, a.region, 8); put_text(out, a.endpoint); put_text(out, a.server_name); } std::optional address_at(std::span in, std::size_t at) { RegionAddress a; a.region = get(in, at, 8); auto endpoint = text_at(in, at + 8); auto name = text_at(in, at + 8 + session_address_bytes); if (a.region == 0 || !endpoint || !name) return std::nullopt; a.endpoint = std::move(*endpoint); a.server_name = std::move(*name); return a; } WireGrant grant_at(std::span in, std::size_t at) { WireGrant g{}; std::copy_n(in.begin() + static_cast(at), g.size(), g.begin()); return g; } } // namespace std::vector encode_session(const SessionMessage& message) { const auto is_life = std::holds_alternative(message) || std::holds_alternative(message) || std::holds_alternative(message) || std::holds_alternative(message); const auto version = std::holds_alternative(message) ? (std::get(message).diagnostics ? session_protocol_v9 : session_protocol_v8) : std::holds_alternative(message) ? session_protocol_v7 : std::holds_alternative(message) ? session_protocol_v10 : std::holds_alternative(message) ? session_protocol_v6 : is_life ? session_protocol_v5 : session_protocol_version; return encode_session(message, version); } std::vector encode_session(const SessionMessage& message, std::uint16_t version) { if (version != session_protocol_version && version != session_protocol_v5 && version != session_protocol_v6 && version != session_protocol_v7 && version != session_protocol_v8 && version != session_protocol_v9 && version != session_protocol_v10) return {}; if (version == session_protocol_version && (std::holds_alternative(message) || std::holds_alternative(message) || std::holds_alternative(message) || std::holds_alternative(message))) return {}; if (version != session_protocol_v6 && std::holds_alternative(message)) return {}; if (version != session_protocol_v7 && version != session_protocol_v8 && version != session_protocol_v9 && version != session_protocol_v10 && std::holds_alternative(message)) return {}; if (version != session_protocol_v7 && version != session_protocol_v8 && version != session_protocol_v9 && version != session_protocol_v10 && std::holds_alternative(message) && std::get(message).result == ActionResult::committed) return {}; if (version != session_protocol_v10 && std::holds_alternative(message)) return {}; if (version != session_protocol_v8 && version != session_protocol_v9 && version != session_protocol_v10 && std::holds_alternative(message)) return {}; if (const auto* perception = std::get_if(&message)) { if (!perception->tick || perception->patches.size() > max_cellular_perceived_patches || (!perception->life_identity && !perception->patches.empty()) || (version == session_protocol_v8 && perception->diagnostics) || ((version == session_protocol_v9 || version == session_protocol_v10) && perception->life_identity && !perception->diagnostics) || (perception->life_identity == 0 && perception->diagnostics) || (perception->diagnostics && !valid_diagnostics(*perception->diagnostics)) || !std::ranges::is_sorted(perception->patches, [](const auto& a, const auto& b) { return std::pair{a.x_um, a.y_um} < std::pair{b.x_um, b.y_um}; }) || std::adjacent_find(perception->patches.begin(), perception->patches.end(), [](const auto& a, const auto& b) { return a.x_um == b.x_um && a.y_um == b.y_um; }) != perception->patches.end()) return {}; } struct Encoder { std::uint16_t version; std::vector operator()(const SessionHello& m) const { auto out = header(SessionMessageType::hello, hello_bytes, version); put(out, m.required_features, 4); out.insert(out.end(), m.grant.begin(), m.grant.end()); return out; } std::vector operator()(const SessionWelcome& m) const { auto out = header(SessionMessageType::welcome, welcome_bytes, version); for (const auto v : {m.session, m.epoch, m.world, m.frame, m.region, m.expires_at, m.server_seconds, m.server_tick}) put(out, v, 8); return out; } std::vector operator()(const SessionRefresh& m) const { auto out = header(SessionMessageType::refresh, refresh_bytes, version); out.insert(out.end(), m.grant.begin(), m.grant.end()); return out; } std::vector operator()(const SessionRefreshResult& m) const { auto out = header(SessionMessageType::refresh_result, refresh_result_bytes, version); out.push_back(m.status); put(out, m.expires_at, 8); return out; } std::vector operator()(const SessionClose& m) const { auto out = header(SessionMessageType::close, close_bytes, version); out.push_back(static_cast(m.reason)); return out; } std::vector operator()(const SessionIntention& m) const { auto out = header(SessionMessageType::intention, intention_bytes, version); for (const auto v : {m.session, m.epoch, m.sequence, m.tick}) put(out, v, 8); put(out, static_cast(m.move_x), 2); put(out, static_cast(m.move_y), 2); return out; } std::vector operator()(const CellularIntention& m) const { auto out = header(SessionMessageType::cellular_intention, cellular_intention_bytes, version); for (const auto v : {m.session, m.epoch, m.sequence, m.tick}) put(out, v, 8); put(out, static_cast(m.move_x), 2); put(out, static_cast(m.move_y), 2); out.push_back(m.has_intake_target ? 1 : 0); put(out, 0, 3); put(out, m.intake_x_um, 4); put(out, m.intake_y_um, 4); return out; } std::vector operator()(const CellularAction& m) const { auto out = header(SessionMessageType::cellular_action, cellular_action_bytes, version); for (const auto v : {m.session, m.epoch, m.action_id, m.tick}) put(out, v, 8); put(out, static_cast(m.move_x), 2); put(out, static_cast(m.move_y), 2); out.push_back(m.has_intake_target ? 1 : 0); put(out, 0, 3); put(out, m.intake_x_um, 4); put(out, m.intake_y_um, 4); return out; } std::vector operator()(const CellularMutationAction& m) const { auto out = header(SessionMessageType::cellular_mutation_action, cellular_mutation_action_bytes, version); for (const auto value : {m.session, m.epoch, m.action_id, m.tick, m.life_identity, m.event_index, m.offer_tick}) put(out, value, 8); put(out, m.operator_id, 2); put(out, 0, 6); return out; } std::vector operator()(const CellularPerception& m) const { auto out = header(SessionMessageType::cellular_perception, (version == session_protocol_v9 || version == session_protocol_v10 ? cellular_perception_v9_prefix_bytes : cellular_perception_prefix_bytes) + m.patches.size() * cellular_perceived_patch_bytes, version); put(out, m.tick, 8); put(out, m.life_identity, 8); put(out, m.patches.size(), 2); if (version == session_protocol_v9 || version == session_protocol_v10) { const auto& d = m.diagnostics; put(out, d ? d->reserve_energy_pj : 0, 8); for (const auto value : d ? d->reserve_matter_fg : std::array{}) put(out, value, 8); put(out, d ? d->maintenance_cost_pj : 0, 8); put(out, d ? d->movement_cost_pj : 0, 8); out.push_back(d ? static_cast(d->movement) : static_cast(CellularMovementResult::not_reported)); out.push_back(d ? static_cast(d->intake) : static_cast(CellularIntakeResult::not_reported)); out.push_back(d && d->has_tick_effects ? 1 : 0); put(out, 0, 5); } for (const auto& patch : m.patches) { put(out, patch.x_um, 4); put(out, patch.y_um, 4); put(out, patch.energy_pj, 8); for (const auto matter : patch.matter_fg) put(out, matter, 8); } return out; } std::vector operator()(const IntentionReceipt& m) const { auto out = header(SessionMessageType::intention_receipt, intention_receipt_bytes, version); put(out, m.sequence, 8); out.push_back(static_cast(m.status)); put(out, m.server_tick, 8); return out; } std::vector operator()(const SimulatedThrough& m) const { auto out = header(SessionMessageType::simulated_through, simulated_bytes, version); for (const auto v : {m.epoch, m.sequence, m.tick}) put(out, v, 8); return out; } std::vector operator()(const SessionAction& m) const { auto out = header(SessionMessageType::action, action_bytes, version); for (const auto v : {m.session, m.epoch, m.action_id}) put(out, v, 8); put(out, m.kind, 2); put(out, m.tick, 8); return out; } std::vector operator()(const ActionReceipt& m) const { auto out = header(SessionMessageType::action_receipt, action_receipt_bytes, version); put(out, m.action_id, 8); out.push_back(static_cast(m.status)); put(out, m.server_tick, 8); put(out, m.tick, 8); return out; } std::vector operator()(const ActionOutcome& m) const { auto out = header(SessionMessageType::action_outcome, action_outcome_bytes, version); put(out, m.action_id, 8); out.push_back(static_cast(m.result)); put(out, m.tick, 8); put(out, m.commit_sequence, 8); return out; } std::vector operator()(const ActionQuery& m) const { auto out = header(SessionMessageType::action_query, action_query_bytes, version); put(out, m.action_id, 8); return out; } std::vector operator()(const SessionInterest& m) const { auto out = header(SessionMessageType::interest, interest_bytes, version); for (const auto v : {m.x, m.y, m.z}) put(out, static_cast(v), 8); put(out, m.radius, 2); return out; } std::vector operator()(const SnapshotChunk& m) const { auto out = header(SessionMessageType::snapshot_chunk, snapshot_chunk_header_bytes + m.records.size(), version); for (const auto v : {m.epoch, m.tick, m.baseline, m.field_revision, m.organism_revision}) put(out, v, 8); put(out, m.mask, 4); put(out, static_cast(m.slice_z), 8); out.push_back(m.index); out.push_back(m.count); out.insert(out.end(), m.records.begin(), m.records.end()); return out; } std::vector operator()(const SnapshotAck& m) const { auto out = header(SessionMessageType::snapshot_ack, snapshot_ack_bytes, version); put(out, m.epoch, 8); put(out, m.tick, 8); return out; } // Invalid text fields are encoded as given; the receiver refuses them. std::vector operator()(const HandoffOffer& m) const { auto out = header(SessionMessageType::handoff_offer, handoff_offer_bytes, version); out.insert(out.end(), m.transfer.begin(), m.transfer.end()); put_address(out, m.destination); out.insert(out.end(), m.ticket.begin(), m.ticket.end()); out.resize(session_header_bytes + handoff_offer_bytes); // Overlong text truncates. return out; } std::vector operator()(const SessionRedirect& m) const { auto out = header(SessionMessageType::redirect, redirect_bytes, version); put_address(out, m.owner); out.resize(session_header_bytes + redirect_bytes); return out; } std::vector operator()(const PrimitiveLifeRequest& m) const { auto out = header(SessionMessageType::primitive_life_request, life_request_bytes, version); put(out, m.session, 8); put(out, m.epoch, 8); put(out, m.request_id, 8); return out; } std::vector operator()(const PrimitiveLifeReceipt& m) const { auto out = header(SessionMessageType::primitive_life_receipt, life_receipt_bytes, version); put(out, m.request_id, 8); out.push_back(static_cast(m.status)); put(out, m.server_tick, 8); return out; } std::vector operator()(const PrimitiveLifeOutcome& m) const { auto out = header(SessionMessageType::primitive_life_outcome, life_outcome_bytes, version); put(out, m.request_id, 8); out.push_back(static_cast(m.result)); put(out, m.life_identity, 8); put(out, m.commit_sequence, 8); return out; } std::vector operator()(const PrimitiveLifeQuery& m) const { auto out = header(SessionMessageType::primitive_life_query, life_query_bytes, version); put(out, m.request_id, 8); return out; } }; return std::visit(Encoder{version}, message); } std::expected decode_session(std::span bytes) { return decode_session(bytes, nullptr); } std::expected decode_session(std::span bytes, std::uint16_t* version) { if (bytes.size() < session_header_bytes) return std::unexpected(SessionCodecError::truncated); if (get(bytes, 0, 4) != session_magic) return std::unexpected(SessionCodecError::bad_magic); const auto wire_version = static_cast(get(bytes, 4, 2)); if (wire_version != session_protocol_version && wire_version != session_protocol_v5 && wire_version != session_protocol_v6 && wire_version != session_protocol_v7 && wire_version != session_protocol_v8 && wire_version != session_protocol_v9 && wire_version != session_protocol_v10) return std::unexpected(SessionCodecError::unsupported_version); if (version) *version = wire_version; if (bytes[7] != 0) return std::unexpected(SessionCodecError::reserved_flags); const auto payload = bytes.subspan(session_header_bytes); const auto expect = [&](std::size_t n) { return payload.size() == n; }; switch (bytes[6]) { case static_cast(SessionMessageType::hello): { if (!expect(hello_bytes)) return std::unexpected(SessionCodecError::wrong_length); SessionHello m; m.required_features = static_cast(get(payload, 0, 4)); m.grant = grant_at(payload, 4); return m; } case static_cast(SessionMessageType::welcome): { if (!expect(welcome_bytes)) return std::unexpected(SessionCodecError::wrong_length); SessionWelcome m; std::uint64_t* fields[] = {&m.session, &m.epoch, &m.world, &m.frame, &m.region, &m.expires_at, &m.server_seconds, &m.server_tick}; for (std::size_t i = 0; i < std::size(fields); ++i) *fields[i] = get(payload, 8 * i, 8); if (m.session == 0 || m.epoch == 0) return std::unexpected(SessionCodecError::invalid_value); return m; } case static_cast(SessionMessageType::refresh): { if (!expect(refresh_bytes)) return std::unexpected(SessionCodecError::wrong_length); return SessionRefresh{grant_at(payload, 0)}; } case static_cast(SessionMessageType::refresh_result): { if (!expect(refresh_result_bytes)) return std::unexpected(SessionCodecError::wrong_length); SessionRefreshResult m{payload[0], get(payload, 1, 8)}; if (m.status != 0 && !wire_reason(m.status)) return std::unexpected(SessionCodecError::invalid_value); return m; } case static_cast(SessionMessageType::close): { if (!expect(close_bytes)) return std::unexpected(SessionCodecError::wrong_length); if (!wire_reason(payload[0])) return std::unexpected(SessionCodecError::invalid_value); return SessionClose{static_cast(payload[0])}; } case static_cast(SessionMessageType::intention): { if (!expect(intention_bytes)) return std::unexpected(SessionCodecError::wrong_length); SessionIntention m; m.session = get(payload, 0, 8); m.epoch = get(payload, 8, 8); m.sequence = get(payload, 16, 8); m.tick = get(payload, 24, 8); m.move_x = static_cast(static_cast(get(payload, 32, 2))); m.move_y = static_cast(static_cast(get(payload, 34, 2))); return m; // Ranges belong to admission, which answers with a status. } case static_cast(SessionMessageType::cellular_intention): { if (wire_version != session_protocol_v6) return std::unexpected(SessionCodecError::unsupported_version); if (!expect(cellular_intention_bytes)) return std::unexpected(SessionCodecError::wrong_length); CellularIntention m; m.session = get(payload, 0, 8); m.epoch = get(payload, 8, 8); m.sequence = get(payload, 16, 8); m.tick = get(payload, 24, 8); m.move_x = static_cast(static_cast(get(payload, 32, 2))); m.move_y = static_cast(static_cast(get(payload, 34, 2))); if (payload[36] > 1 || payload[37] != 0 || payload[38] != 0 || payload[39] != 0) return std::unexpected(SessionCodecError::invalid_value); m.has_intake_target = payload[36] != 0; m.intake_x_um = static_cast(get(payload, 40, 4)); m.intake_y_um = static_cast(get(payload, 44, 4)); if (!m.has_intake_target && (m.intake_x_um != 0 || m.intake_y_um != 0)) return std::unexpected(SessionCodecError::invalid_value); return m; } case static_cast(SessionMessageType::cellular_action): { if (wire_version != session_protocol_v7 && wire_version != session_protocol_v8 && wire_version != session_protocol_v9 && wire_version != session_protocol_v10) return std::unexpected(SessionCodecError::unsupported_version); if (!expect(cellular_action_bytes)) return std::unexpected(SessionCodecError::wrong_length); CellularAction m; m.session = get(payload, 0, 8); m.epoch = get(payload, 8, 8); m.action_id = get(payload, 16, 8); m.tick = get(payload, 24, 8); m.move_x = static_cast(static_cast(get(payload, 32, 2))); m.move_y = static_cast(static_cast(get(payload, 34, 2))); if (payload[36] > 1 || payload[37] != 0 || payload[38] != 0 || payload[39] != 0) return std::unexpected(SessionCodecError::invalid_value); m.has_intake_target = payload[36] != 0; m.intake_x_um = static_cast(get(payload, 40, 4)); m.intake_y_um = static_cast(get(payload, 44, 4)); if (!m.session || !m.epoch || !m.action_id || !m.tick || (!m.has_intake_target && (m.intake_x_um || m.intake_y_um))) return std::unexpected(SessionCodecError::invalid_value); return m; } case static_cast(SessionMessageType::cellular_mutation_action): { if (wire_version != session_protocol_v10) return std::unexpected(SessionCodecError::unsupported_version); if (!expect(cellular_mutation_action_bytes)) return std::unexpected(SessionCodecError::wrong_length); CellularMutationAction m; m.session = get(payload, 0, 8); m.epoch = get(payload, 8, 8); m.action_id = get(payload, 16, 8); m.tick = get(payload, 24, 8); m.life_identity = get(payload, 32, 8); m.event_index = get(payload, 40, 8); m.offer_tick = get(payload, 48, 8); m.operator_id = static_cast(get(payload, 56, 2)); if (!m.session || !m.epoch || !m.action_id || !m.tick || !m.life_identity || !m.event_index || !m.offer_tick || m.offer_tick >= m.tick || !m.operator_id || std::ranges::any_of(payload.subspan(58, 6), [](std::uint8_t value) { return value != 0; })) return std::unexpected(SessionCodecError::invalid_value); return m; } case static_cast(SessionMessageType::cellular_perception): { if (wire_version != session_protocol_v8 && wire_version != session_protocol_v9 && wire_version != session_protocol_v10) return std::unexpected(SessionCodecError::unsupported_version); const auto prefix = wire_version == session_protocol_v9 || wire_version == session_protocol_v10 ? cellular_perception_v9_prefix_bytes : cellular_perception_prefix_bytes; if (payload.size() < prefix) return std::unexpected(SessionCodecError::wrong_length); const auto count = static_cast(get(payload, 16, 2)); if (count > max_cellular_perceived_patches || payload.size() != prefix + count * cellular_perceived_patch_bytes) return std::unexpected(SessionCodecError::wrong_length); CellularPerception m; m.tick = get(payload, 0, 8); m.life_identity = get(payload, 8, 8); if (!m.tick || (!m.life_identity && count)) return std::unexpected(SessionCodecError::invalid_value); if (wire_version == session_protocol_v9 || wire_version == session_protocol_v10) { CellularLifeDiagnostics d; d.reserve_energy_pj = get(payload, 18, 8); for (std::size_t channel = 0; channel < d.reserve_matter_fg.size(); ++channel) d.reserve_matter_fg[channel] = get(payload, 26 + channel * 8, 8); d.maintenance_cost_pj = get(payload, 58, 8); d.movement_cost_pj = get(payload, 66, 8); if (payload[74] > static_cast(CellularMovementResult::insufficient_energy) || payload[75] > static_cast(CellularIntakeResult::out_of_contact) || payload[76] > 1 || std::ranges::any_of(payload.subspan(77, 5), [](std::uint8_t value) { return value != 0; })) return std::unexpected(SessionCodecError::invalid_value); d.movement = static_cast(payload[74]); d.intake = static_cast(payload[75]); d.has_tick_effects = payload[76] != 0; if (m.life_identity) m.diagnostics = d; else if (d.reserve_energy_pj || std::ranges::any_of(d.reserve_matter_fg, [](std::uint64_t value) { return value != 0; }) || d.maintenance_cost_pj || d.movement_cost_pj || d.has_tick_effects || d.movement != CellularMovementResult::not_reported || d.intake != CellularIntakeResult::not_reported) return std::unexpected(SessionCodecError::invalid_value); } if ((wire_version == session_protocol_v9 || wire_version == session_protocol_v10) && m.life_identity && !m.diagnostics) return std::unexpected(SessionCodecError::invalid_value); if (m.diagnostics && !valid_diagnostics(*m.diagnostics)) return std::unexpected(SessionCodecError::invalid_value); m.patches.reserve(count); std::size_t offset = prefix; for (std::size_t i = 0; i < count; ++i) { CellularPerceivedPatch patch; patch.x_um = static_cast(get(payload, offset, 4)); patch.y_um = static_cast(get(payload, offset + 4, 4)); patch.energy_pj = get(payload, offset + 8, 8); for (std::size_t channel = 0; channel < patch.matter_fg.size(); ++channel) patch.matter_fg[channel] = get(payload, offset + 16 + channel * 8, 8); if (!m.patches.empty() && !(std::pair{m.patches.back().x_um, m.patches.back().y_um} < std::pair{patch.x_um, patch.y_um})) return std::unexpected(SessionCodecError::invalid_value); m.patches.push_back(patch); offset += cellular_perceived_patch_bytes; } return m; } case static_cast(SessionMessageType::intention_receipt): { if (!expect(intention_receipt_bytes)) return std::unexpected(SessionCodecError::wrong_length); if (payload[8] > max_admit_status) return std::unexpected(SessionCodecError::invalid_value); return IntentionReceipt{get(payload, 0, 8), static_cast(payload[8]), get(payload, 9, 8)}; } case static_cast(SessionMessageType::simulated_through): { if (!expect(simulated_bytes)) return std::unexpected(SessionCodecError::wrong_length); return SimulatedThrough{get(payload, 0, 8), get(payload, 8, 8), get(payload, 16, 8)}; } case static_cast(SessionMessageType::action): { if (!expect(action_bytes)) return std::unexpected(SessionCodecError::wrong_length); SessionAction m; m.session = get(payload, 0, 8); m.epoch = get(payload, 8, 8); m.action_id = get(payload, 16, 8); m.kind = static_cast(get(payload, 24, 2)); // Admission checks it. m.tick = get(payload, 26, 8); return m; } case static_cast(SessionMessageType::action_receipt): { if (!expect(action_receipt_bytes)) return std::unexpected(SessionCodecError::wrong_length); if (payload[8] > max_admit_status) return std::unexpected(SessionCodecError::invalid_value); return ActionReceipt{get(payload, 0, 8), static_cast(payload[8]), get(payload, 9, 8), get(payload, 17, 8)}; } case static_cast(SessionMessageType::action_outcome): { if (!expect(action_outcome_bytes)) return std::unexpected(SessionCodecError::wrong_length); if (payload[8] < static_cast(ActionResult::committed_no_effect) || payload[8] > static_cast(ActionResult::committed) || (payload[8] == static_cast(ActionResult::committed) && wire_version != session_protocol_v7 && wire_version != session_protocol_v8 && wire_version != session_protocol_v9 && wire_version != session_protocol_v10)) return std::unexpected(SessionCodecError::invalid_value); const ActionOutcome m{get(payload, 0, 8), static_cast(payload[8]), get(payload, 9, 8), get(payload, 17, 8)}; if (m.result == ActionResult::committed && (!m.tick || !m.commit_sequence)) return std::unexpected(SessionCodecError::invalid_value); return m; } case static_cast(SessionMessageType::action_query): { if (!expect(action_query_bytes)) return std::unexpected(SessionCodecError::wrong_length); return ActionQuery{get(payload, 0, 8)}; } case static_cast(SessionMessageType::interest): { if (!expect(interest_bytes)) return std::unexpected(SessionCodecError::wrong_length); return SessionInterest{static_cast(get(payload, 0, 8)), static_cast(get(payload, 8, 8)), static_cast(get(payload, 16, 8)), static_cast(get(payload, 24, 2))}; } case static_cast(SessionMessageType::snapshot_chunk): { // Variable length: a fixed header and up to one datagram of records. if (payload.size() < snapshot_chunk_header_bytes || payload.size() > snapshot_chunk_header_bytes + max_snapshot_records_bytes) return std::unexpected(SessionCodecError::wrong_length); SnapshotChunk m; m.epoch = get(payload, 0, 8); m.tick = get(payload, 8, 8); m.baseline = get(payload, 16, 8); m.field_revision = get(payload, 24, 8); m.organism_revision = get(payload, 32, 8); m.mask = static_cast(get(payload, 40, 4)); m.slice_z = static_cast(get(payload, 44, 8)); m.index = payload[52]; m.count = payload[53]; if (m.epoch == 0 || m.tick == 0 || m.baseline >= m.tick || m.count == 0 || m.count > max_snapshot_chunks || m.index >= m.count) return std::unexpected(SessionCodecError::invalid_value); m.records.assign(payload.begin() + snapshot_chunk_header_bytes, payload.end()); return m; } case static_cast(SessionMessageType::snapshot_ack): { if (!expect(snapshot_ack_bytes)) return std::unexpected(SessionCodecError::wrong_length); return SnapshotAck{get(payload, 0, 8), get(payload, 8, 8)}; } case static_cast(SessionMessageType::handoff_offer): { if (!expect(handoff_offer_bytes)) return std::unexpected(SessionCodecError::wrong_length); HandoffOffer m; std::copy_n(payload.begin(), m.transfer.size(), m.transfer.begin()); auto destination = address_at(payload, 16); if (!destination || std::ranges::all_of(m.transfer, [](auto b) { return b == 0; })) return std::unexpected(SessionCodecError::invalid_value); m.destination = std::move(*destination); m.ticket = grant_at(payload, 16 + address_bytes); return m; } case static_cast(SessionMessageType::redirect): { if (!expect(redirect_bytes)) return std::unexpected(SessionCodecError::wrong_length); auto owner = address_at(payload, 0); if (!owner) return std::unexpected(SessionCodecError::invalid_value); return SessionRedirect{std::move(*owner)}; } case static_cast(SessionMessageType::primitive_life_request): { if (wire_version < session_protocol_v5) return std::unexpected(SessionCodecError::unknown_type); if (!expect(life_request_bytes)) return std::unexpected(SessionCodecError::wrong_length); PrimitiveLifeRequest m{get(payload, 0, 8), get(payload, 8, 8), get(payload, 16, 8)}; if (!m.session || !m.epoch || !m.request_id) return std::unexpected(SessionCodecError::invalid_value); return m; } case static_cast(SessionMessageType::primitive_life_receipt): { if (wire_version < session_protocol_v5) return std::unexpected(SessionCodecError::unknown_type); if (!expect(life_receipt_bytes)) return std::unexpected(SessionCodecError::wrong_length); if (payload[8] > max_admit_status) return std::unexpected(SessionCodecError::invalid_value); return PrimitiveLifeReceipt{get(payload, 0, 8), static_cast(payload[8]), get(payload, 9, 8)}; } case static_cast(SessionMessageType::primitive_life_outcome): { if (wire_version < session_protocol_v5) return std::unexpected(SessionCodecError::unknown_type); if (!expect(life_outcome_bytes)) return std::unexpected(SessionCodecError::wrong_length); if (payload[8] < 1 || payload[8] > static_cast(PrimitiveLifeResult::unknown)) return std::unexpected(SessionCodecError::invalid_value); const PrimitiveLifeOutcome m{get(payload, 0, 8), static_cast(payload[8]), get(payload, 9, 8), get(payload, 17, 8)}; if (!m.request_id || (m.result == PrimitiveLifeResult::born && (!m.life_identity || !m.commit_sequence)) || (m.result != PrimitiveLifeResult::born && (m.life_identity || m.commit_sequence))) return std::unexpected(SessionCodecError::invalid_value); return m; } case static_cast(SessionMessageType::primitive_life_query): { if (wire_version < session_protocol_v5) return std::unexpected(SessionCodecError::unknown_type); if (!expect(life_query_bytes)) return std::unexpected(SessionCodecError::wrong_length); const auto id = get(payload, 0, 8); if (!id) return std::unexpected(SessionCodecError::invalid_value); return PrimitiveLifeQuery{id}; } default: return std::unexpected(SessionCodecError::unknown_type); } } std::array encode_cellular_action_input(const CellularActionInput& input) { std::vector bytes; bytes.reserve(cellular_action_input_bytes); put(bytes, input.tick, 8); put(bytes, static_cast(input.move_x), 2); put(bytes, static_cast(input.move_y), 2); bytes.push_back(input.has_intake_target ? 1 : 0); put(bytes, 0, 3); put(bytes, input.intake_x_um, 4); put(bytes, input.intake_y_um, 4); std::array out{}; std::ranges::copy(bytes, out.begin()); return out; } std::expected decode_cellular_action_input(std::span bytes) { if (bytes.size() != cellular_action_input_bytes) return std::unexpected(SessionCodecError::wrong_length); if (bytes[12] > 1 || bytes[13] != 0 || bytes[14] != 0 || bytes[15] != 0) return std::unexpected(SessionCodecError::invalid_value); CellularActionInput input; input.tick = get(bytes, 0, 8); input.move_x = static_cast(static_cast(get(bytes, 8, 2))); input.move_y = static_cast(static_cast(get(bytes, 10, 2))); input.has_intake_target = bytes[12] != 0; input.intake_x_um = static_cast(get(bytes, 16, 4)); input.intake_y_um = static_cast(get(bytes, 20, 4)); if (input.tick == 0 || (!input.has_intake_target && (input.intake_x_um != 0 || input.intake_y_um != 0))) return std::unexpected(SessionCodecError::invalid_value); return input; } } // namespace evo::network