Method HandleDataChannelMessage

src/daemon/cloud_tunnel.cpp:1784–1858

}

void CloudTunnel::HandleDataChannelMessage(const std::string& vm_id, const nlohmann::json& message) {
    if (!message.is_object()) return;
    const std::string type = message.value("type", "");
    if (type.empty()) return;
    // Input fast-path: pointer/wheel arrive on `input-fast` (best-effort);
    // key/pointer.button arrive on `control` (reliable). Either way both
    // dispatch to the same RuntimeManager IPC.
    if (type == "pointer") {
        runtime_manager_.SendPointerEvent(
            vm_id,
            message.value("x", 0),
            message.value("y", 0),
            message.value("buttons", static_cast<uint32_t>(0)));
    } else if (type == "wheel") {
        runtime_manager_.SendWheelEvent(vm_id, message.value("delta", 0));
    } else if (type == "key") {
        runtime_manager_.SendKeyEvent(
            vm_id,
            message.value("key_code", static_cast<uint32_t>(0)),
            message.value("pressed", false));
    } else if (type == "clipboard.grab") {
        const uint32_t selection = message.value("selection", static_cast<uint32_t>(0));
        std::vector<uint32_t> codes;
        if (message.contains("types") && message["types"].is_array()) {
            for (const auto& entry : message["types"]) {
                if (!entry.is_string()) continue;
                const uint32_t code = MimeToVdAgentType(entry.get<std::string>());
                if (code) codes.push_back(code);
            }
        }
        if (!codes.empty()) runtime_manager_.SendClipboardGrabToGuest(vm_id, selection, codes);
    } else if (type == "clipboard.request") {
        const uint32_t selection = message.value("selection", static_cast<uint32_t>(0));
        const uint32_t code = MimeToVdAgentType(message.value("mime", std::string()));
        if (code) runtime_manager_.SendClipboardRequestToGuest(vm_id, selection, code);
    } else if (type == "clipboard.data") {
        const uint32_t selection = message.value("selection", static_cast<uint32_t>(0));
        const uint32_t code = MimeToVdAgentType(message.value("mime", std::string()));
        if (!code) return;
        std::vector<uint8_t> bytes = Base64Decode(message.value("bytes_base64", std::string()));
        runtime_manager_.SendClipboardDataToGuest(vm_id, selection, code, bytes);
    } else if (type == "clipboard.release") {
        const uint32_t selection = message.value("selection", static_cast<uint32_t>(0));
        runtime_manager_.SendClipboardReleaseToGuest(vm_id, selection);
    } else if (type == "vm.reboot" || type == "vm.shutdown") {
        // Guest-OS facing operations: must travel end-to-end over the
        // already-authenticated WebRTC `control` channel rather than the
        // cloud HTTP path, so the cloud never sees plaintext intent.
        std::string error;
        const bool ok = (type == "vm.reboot")
            ? runtime_manager_.RebootVm(vm_id, &error)
            : runtime_manager_.ShutdownVm(vm_id, &error);
        std::shared_ptr<WebRtcPeer> peer;
        if (auto session = remote_sessions_.GetByVm(vm_id)) {
            std::lock_guard<std::mutex> lock(remote_peers_mu_);
            auto it = remote_peers_.find(session->session_id);
            if (it != remote_peers_.end()) peer = it->second;
        }