YangWX/crossdesk
1
0
Fork 0
mirror of https://github.com/kunkundi/crossdesk.git synced 2026-04-22 02:53:31 +08:00
Code Issues Packages Projects Releases Wiki Activity

[feat] add Windows secure desktop remote unlock support for locked sessions, refs #77

Browse Source
This commit is contained in:
dijunkun
2026-04-21 04:10:08 +08:00
parent e4dfb61509
commit ffa94986d5
17 changed files with 4712 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files

150
src/app/main.cpp
View File

@@ -7,15 +7,165 @@
#endif
#include <cstring>
#include <filesystem>
#include <iostream>
#include <memory>
#include <string>
#ifdef _WIN32
#include <cstdio>
#include "service_host.h"
#endif
#include "config_center.h"
#include "daemon.h"
#include "path_manager.h"
#include "render.h"
#ifdef _WIN32
namespace {
void EnsureConsoleForCli() {
static bool console_ready = false;
if (console_ready) {
return;
}
if (!AttachConsole(ATTACH_PARENT_PROCESS)) {
DWORD error = GetLastError();
if (error != ERROR_ACCESS_DENIED) {
AllocConsole();
}
}
FILE* stream = nullptr;
freopen_s(&stream, "CONOUT$", "w", stdout);
freopen_s(&stream, "CONOUT$", "w", stderr);
freopen_s(&stream, "CONIN$", "r", stdin);
SetConsoleOutputCP(CP_UTF8);
console_ready = true;
}
void PrintServiceCliUsage() {
std::cout
<< "CrossDesk service management commands\n"
<< " --service-install Install the sibling crossdesk_service.exe\n"
<< " --service-uninstall Remove the installed Windows service\n"
<< " --service-start Start the Windows service\n"
<< " --service-stop Stop the Windows service\n"
<< " --service-sas Ask the service to send Secure Attention Sequence\n"
<< " --service-ping Ping the service over named pipe IPC\n"
<< " --service-status Query service runtime status\n"
<< " --service-help Show this help\n";
}
std::wstring GetCurrentExecutablePathW() {
wchar_t path[MAX_PATH] = {0};
DWORD length = GetModuleFileNameW(nullptr, path, MAX_PATH);
if (length == 0 || length >= MAX_PATH) {
return L"";
}
return std::wstring(path, length);
}
std::filesystem::path GetSiblingServiceExecutablePath() {
std::wstring current_executable = GetCurrentExecutablePathW();
if (current_executable.empty()) {
return {};
}
return std::filesystem::path(current_executable).parent_path() /
L"crossdesk_service.exe";
}
bool IsServiceCliCommand(const char* arg) {
if (arg == nullptr) {
return false;
}
return std::strcmp(arg, "--service-install") == 0 ||
std::strcmp(arg, "--service-uninstall") == 0 ||
std::strcmp(arg, "--service-start") == 0 ||
std::strcmp(arg, "--service-stop") == 0 ||
std::strcmp(arg, "--service-sas") == 0 ||
std::strcmp(arg, "--service-ping") == 0 ||
std::strcmp(arg, "--service-status") == 0 ||
std::strcmp(arg, "--service-help") == 0;
}
int HandleServiceCliCommand(const std::string& command) {
EnsureConsoleForCli();
if (command == "--service-help") {
PrintServiceCliUsage();
return 0;
}
if (command == "--service-install") {
std::filesystem::path service_path = GetSiblingServiceExecutablePath();
if (service_path.empty()) {
std::cerr << "Failed to locate crossdesk_service.exe" << std::endl;
return 1;
}
if (!std::filesystem::exists(service_path)) {
std::cerr << "Service binary not found: " << service_path.string()
<< std::endl;
return 1;
}
bool success = crossdesk::InstallCrossDeskService(service_path.wstring());
std::cout << (success ? "install ok" : "install failed") << std::endl;
return success ? 0 : 1;
}
if (command == "--service-uninstall") {
bool success = crossdesk::UninstallCrossDeskService();
std::cout << (success ? "uninstall ok" : "uninstall failed")
<< std::endl;
return success ? 0 : 1;
}
if (command == "--service-start") {
bool success = crossdesk::StartCrossDeskService();
std::cout << (success ? "start ok" : "start failed") << std::endl;
return success ? 0 : 1;
}
if (command == "--service-stop") {
bool success = crossdesk::StopCrossDeskService();
std::cout << (success ? "stop ok" : "stop failed") << std::endl;
return success ? 0 : 1;
}
if (command == "--service-sas") {
std::cout << crossdesk::QueryCrossDeskService("sas") << std::endl;
return 0;
}
if (command == "--service-ping") {
std::cout << crossdesk::QueryCrossDeskService("ping") << std::endl;
return 0;
}
if (command == "--service-status") {
std::cout << crossdesk::QueryCrossDeskService("status") << std::endl;
return 0;
}
PrintServiceCliUsage();
return 1;
}
} // namespace
#endif
int main(int argc, char* argv[]) {
#ifdef _WIN32
if (argc > 1 && IsServiceCliCommand(argv[1])) {
return HandleServiceCliCommand(argv[1]);
}
#endif
// check if running as child process
bool is_child = false;
for (int i = 1; i < argc; i++) {

38
src/device_controller/device_controller.h
View File

@@ -7,6 +7,7 @@
#ifndef _DEVICE_CONTROLLER_H_
#define _DEVICE_CONTROLLER_H_
#include <cstring>
#include <stdio.h>
#include <nlohmann/json.hpp>
@@ -23,6 +24,8 @@ typedef enum {
audio_capture,
host_infomation,
display_id,
service_status,
service_command,
} ControlType;
typedef enum {
move = 0,
@@ -36,6 +39,7 @@ typedef enum {
wheel_horizontal
} MouseFlag;
typedef enum { key_down = 0, key_up } KeyFlag;
typedef enum { send_sas = 0 } ServiceCommandFlag;
typedef struct {
float x;
float y;
@@ -59,6 +63,15 @@ typedef struct {
int* bottom;
} HostInfo;
typedef struct {
bool available;
char interactive_stage[32];
} ServiceStatus;
typedef struct {
ServiceCommandFlag flag;
} ServiceCommand;
struct RemoteAction {
ControlType type;
union {
@@ -67,6 +80,8 @@ struct RemoteAction {
HostInfo i;
bool a;
int d;
ServiceStatus ss;
ServiceCommand c;
};
// parse
@@ -96,6 +111,14 @@ struct RemoteAction {
case ControlType::display_id:
j["display_id"] = a.d;
break;
case ControlType::service_status:
j["service_status"] = {{"available", a.ss.available},
{"interactive_stage",
a.ss.interactive_stage}};
break;
case ControlType::service_command:
j["service_command"] = {{"flag", a.c.flag}};
break;
case ControlType::host_infomation: {
json displays = json::array();
for (size_t idx = 0; idx < a.i.display_num; idx++) {
@@ -137,6 +160,21 @@ struct RemoteAction {
case ControlType::display_id:
out.d = j.at("display_id").get<int>();
break;
case ControlType::service_status: {
const auto& service_status_json = j.at("service_status");
out.ss.available = service_status_json.value("available", false);
std::string interactive_stage =
service_status_json.value("interactive_stage", std::string());
std::strncpy(out.ss.interactive_stage, interactive_stage.c_str(),
sizeof(out.ss.interactive_stage) - 1);
out.ss.interactive_stage[sizeof(out.ss.interactive_stage) - 1] =
'\0';
break;
}
case ControlType::service_command:
out.c.flag = static_cast<ServiceCommandFlag>(
j.at("service_command").at("flag").get<int>());
break;
case ControlType::host_infomation: {
std::string host_name =
j.at("host_info").at("host_name").get<std::string>();

16
src/gui/assets/localization/localization_data.h
View File

@@ -51,6 +51,22 @@ struct TranslationRow {
X(release_mouse, u8"释放", "Release", u8"Освободить") \
X(audio_capture, u8"声音", "Audio", u8"Звук") \
X(mute, u8" 静音", " Mute", u8"Без звука") \
X(send_sas, u8"发送SAS", "Send SAS", u8"Отправить SAS") \
X(remote_password_box_visible, u8"远端密码框已出现", \
"Remote password box visible", u8"Окно ввода пароля видно") \
X(remote_lock_screen_hint, u8"远端处于锁屏封面，可发送SAS", \
"Remote lock screen visible, send SAS", \
u8"Видна блокировка, отправьте SAS") \
X(remote_secure_desktop_active, u8"远端已进入安全桌面", \
"Remote secure desktop active", \
u8"Активен защищенный рабочий стол") \
X(remote_service_unavailable, u8"远端Windows服务不可用", \
"Remote Windows service unavailable", \
u8"Служба Windows на удаленной стороне недоступна") \
X(remote_unlock_requires_secure_desktop, \
u8"当前仍需要安全桌面专用采集/输入", \
"Secure desktop capture/input is still required", \
u8"По-прежнему нужен отдельный захват/ввод для защищенного рабочего стола") \
X(settings, u8"设置", "Settings", u8"Настройки") \
X(language, u8"语言:", "Language:", u8"Язык:") \
X(video_quality, u8"视频质量:", "Video Quality:", u8"Качество видео:") \

200
src/gui/render.cpp
View File

@@ -28,6 +28,10 @@
#include "screen_capturer_factory.h"
#include "version_checker.h"
#if _WIN32
#include "interactive_state.h"
#include "service_host.h"
#endif
#if defined(__APPLE__)
#include "window_util_mac.h"
@@ -75,6 +79,68 @@ HICON LoadTrayIcon() {
return LoadIconW(nullptr, IDI_APPLICATION);
}
struct WindowsServiceInteractiveStatus {
bool available = false;
unsigned int error_code = 0;
std::string interactive_stage;
std::string error;
};
constexpr uint32_t kWindowsServiceStatusIntervalMs = 1000;
constexpr DWORD kWindowsServiceQueryTimeoutMs = 100;
constexpr DWORD kWindowsServiceSasTimeoutMs = 500;
RemoteAction BuildWindowsServiceStatusAction(
const WindowsServiceInteractiveStatus& status) {
RemoteAction action{};
action.type = ControlType::service_status;
action.ss.available = status.available;
std::strncpy(action.ss.interactive_stage, status.interactive_stage.c_str(),
sizeof(action.ss.interactive_stage) - 1);
action.ss.interactive_stage[sizeof(action.ss.interactive_stage) - 1] =
'\0';
return action;
}
bool QueryWindowsServiceInteractiveStatus(
WindowsServiceInteractiveStatus* status) {
if (status == nullptr) {
return false;
}
*status = WindowsServiceInteractiveStatus{};
const std::string response =
QueryCrossDeskService("status", kWindowsServiceQueryTimeoutMs);
auto json = nlohmann::json::parse(response, nullptr, false);
if (json.is_discarded() || !json.is_object()) {
status->error = "invalid_service_status_json";
return false;
}
status->available = json.value("ok", false);
if (!status->available) {
status->error = json.value("error", std::string("service_unavailable"));
status->error_code = json.value("code", 0u);
return true;
}
status->interactive_stage = json.value("interactive_stage", std::string());
if (ShouldNormalizeUnlockToUserDesktop(
json.value("interactive_lock_screen_visible", false),
status->interactive_stage, json.value("session_locked", false),
json.value("interactive_logon_ui_visible", false),
json.value("interactive_secure_desktop_active",
json.value("secure_desktop_active", false)),
json.value("credential_ui_visible", false),
json.value("password_box_visible", false),
json.value("unlock_ui_visible", false),
json.value("last_session_event", std::string()))) {
status->interactive_stage = "user-desktop";
}
return true;
}
#endif
#if defined(__linux__) && !defined(__APPLE__)
@@ -1746,6 +1812,7 @@ void Render::MainLoop() {
HandlePendingPresenceProbe();
HandleStreamWindow();
HandleServerWindow();
HandleWindowsServiceIntegration();
DrawMainWindow();
if (stream_window_inited_) {
@@ -1772,6 +1839,139 @@ void Render::UpdateLabels() {
}
}
void Render::ResetRemoteServiceStatus(SubStreamWindowProperties& props) {
props.remote_service_status_received_ = false;
props.remote_service_available_ = false;
props.remote_interactive_stage_.clear();
}
void Render::ApplyRemoteServiceStatus(SubStreamWindowProperties& props,
const ServiceStatus& status) {
props.remote_service_status_received_ = true;
props.remote_service_available_ = status.available;
props.remote_interactive_stage_ = status.interactive_stage;
}
Render::RemoteUnlockState Render::GetRemoteUnlockState(
const SubStreamWindowProperties& props) const {
if (!props.remote_service_status_received_) {
return RemoteUnlockState::none;
}
if (!props.remote_service_available_) {
return RemoteUnlockState::service_unavailable;
}
if (props.remote_interactive_stage_ == "credential-ui") {
return RemoteUnlockState::credential_ui;
}
if (props.remote_interactive_stage_ == "lock-screen") {
return RemoteUnlockState::lock_screen;
}
if (props.remote_interactive_stage_ == "secure-desktop") {
return RemoteUnlockState::secure_desktop;
}
return RemoteUnlockState::none;
}
void Render::HandleWindowsServiceIntegration() {
#if _WIN32
static bool last_logged_service_available = true;
static unsigned int last_logged_service_error_code = 0;
static std::string last_logged_service_error;
if (!is_server_mode_ || peer_ == nullptr) {
ResetLocalWindowsServiceState(true);
return;
}
const bool has_connected_remote = std::any_of(
connection_status_.begin(), connection_status_.end(),
[](const auto& entry) {
return entry.second == ConnectionStatus::Connected;
});
if (!has_connected_remote) {
ResetLocalWindowsServiceState(false);
return;
}
bool force_broadcast = false;
if (pending_windows_service_sas_.exchange(false,
std::memory_order_relaxed)) {
const std::string response =
QueryCrossDeskService("sas", kWindowsServiceSasTimeoutMs);
auto json = nlohmann::json::parse(response, nullptr, false);
if (json.is_discarded() || !json.value("ok", false)) {
LOG_WARN("Remote SAS request failed: {}", response);
} else {
LOG_INFO("Remote SAS request forwarded to local Windows service");
}
last_windows_service_status_tick_ = 0;
force_broadcast = true;
}
const uint32_t now = static_cast<uint32_t>(SDL_GetTicks());
if (!force_broadcast && last_windows_service_status_tick_ != 0 &&
now - last_windows_service_status_tick_ <
kWindowsServiceStatusIntervalMs) {
return;
}
last_windows_service_status_tick_ = now;
WindowsServiceInteractiveStatus status;
const bool status_ok = QueryWindowsServiceInteractiveStatus(&status);
local_service_status_received_ = status_ok;
local_service_available_ = status.available;
local_interactive_stage_ = status.available ? status.interactive_stage : "";
if (status_ok) {
const bool availability_changed =
status.available != last_logged_service_available;
const bool error_changed =
!status.available &&
(status.error != last_logged_service_error ||
status.error_code != last_logged_service_error_code);
if (availability_changed || error_changed) {
if (status.available) {
LOG_INFO("Local Windows service available for secure desktop integration");
} else {
LOG_WARN(
"Local Windows service unavailable, secure desktop integration disabled: error={}, code={}",
status.error, status.error_code);
}
last_logged_service_available = status.available;
last_logged_service_error = status.error;
last_logged_service_error_code = status.error_code;
}
} else if (last_logged_service_available ||
last_logged_service_error != "invalid_service_status_json") {
LOG_WARN(
"Local Windows service status query failed, secure desktop integration disabled");
last_logged_service_available = false;
last_logged_service_error = "invalid_service_status_json";
last_logged_service_error_code = 0;
}
RemoteAction remote_action = BuildWindowsServiceStatusAction(status);
std::string msg = remote_action.to_json();
int ret = SendReliableDataFrame(peer_, msg.data(), msg.size(),
control_data_label_.c_str());
if (ret != 0) {
LOG_WARN("Broadcast Windows service status failed, ret={}", ret);
}
#endif
}
#if _WIN32
void Render::ResetLocalWindowsServiceState(bool clear_pending_sas) {
last_windows_service_status_tick_ = 0;
if (clear_pending_sas) {
pending_windows_service_sas_.store(false, std::memory_order_relaxed);
}
local_service_status_received_ = false;
local_service_available_ = false;
local_interactive_stage_.clear();
}
#endif
void Render::HandleRecentConnections() {
if (reload_recent_connections_ && main_renderer_) {
uint32_t now_time = SDL_GetTicks();

30
src/gui/render.h
View File

@@ -44,6 +44,14 @@
namespace crossdesk {
class Render {
public:
enum class RemoteUnlockState {
none,
service_unavailable,
lock_screen,
credential_ui,
secure_desktop,
};
struct FileTransferState {
std::atomic<bool> file_sending_ = false;
std::atomic<uint64_t> file_sent_bytes_ = 0;
@@ -159,6 +167,9 @@ class Render {
std::string mouse_control_button_label_ = "Mouse Control";
std::string audio_capture_button_label_ = "Audio Capture";
std::string remote_host_name_ = "";
bool remote_service_status_received_ = false;
bool remote_service_available_ = false;
std::string remote_interactive_stage_ = "";
std::vector<DisplayInfo> display_info_list_;
SDL_Texture* stream_texture_ = nullptr;
uint8_t* argb_buffer_ = nullptr;
@@ -271,6 +282,13 @@ class Render {
std::shared_ptr<SubStreamWindowProperties>& props);
void DrawReceivingScreenText(
std::shared_ptr<SubStreamWindowProperties>& props);
void DrawRemoteUnlockStateText(
std::shared_ptr<SubStreamWindowProperties>& props);
void ResetRemoteServiceStatus(SubStreamWindowProperties& props);
void ApplyRemoteServiceStatus(SubStreamWindowProperties& props,
const ServiceStatus& status);
RemoteUnlockState GetRemoteUnlockState(
const SubStreamWindowProperties& props) const;
#ifdef __APPLE__
int RequestPermissionWindow();
bool CheckScreenRecordingPermission();
@@ -359,6 +377,10 @@ class Render {
int AudioDeviceInit();
int AudioDeviceDestroy();
void HandleWindowsServiceIntegration();
#if _WIN32
void ResetLocalWindowsServiceState(bool clear_pending_sas);
#endif
private:
struct CDCache {
@@ -515,6 +537,14 @@ class Render {
SDL_Event last_mouse_event;
SDL_AudioStream* output_stream_;
uint32_t STREAM_REFRESH_EVENT = 0;
#if _WIN32
std::atomic<bool> pending_windows_service_sas_{false};
bool local_service_status_received_ = false;
bool local_service_available_ = false;
std::string local_interactive_stage_;
uint32_t last_local_secure_input_block_log_tick_ = 0;
uint32_t last_windows_service_status_tick_ = 0;
#endif
// stream window render
SDL_Window* stream_window_ = nullptr;

137
src/gui/render_callback.cpp
View File

@@ -17,11 +17,63 @@
#include "platform.h"
#include "rd_log.h"
#include "render.h"
#if _WIN32
#include "interactive_state.h"
#include "service_host.h"
#endif
#define NV12_BUFFER_SIZE 1280 * 720 * 3 / 2
namespace crossdesk {
namespace {
#if _WIN32
constexpr uint32_t kSecureDesktopInputLogIntervalMs = 2000;
bool BuildAbsoluteMousePosition(const std::vector<DisplayInfo>& displays,
int display_index, float normalized_x,
float normalized_y, int* absolute_x_out,
int* absolute_y_out) {
if (absolute_x_out == nullptr || absolute_y_out == nullptr ||
display_index < 0 ||
display_index >= static_cast<int>(displays.size())) {
return false;
}
const DisplayInfo& display = displays[display_index];
if (display.width <= 0 || display.height <= 0) {
return false;
}
const float clamped_x = std::clamp(normalized_x, 0.0f, 1.0f);
const float clamped_y = std::clamp(normalized_y, 0.0f, 1.0f);
*absolute_x_out = static_cast<int>(clamped_x * display.width) + display.left;
*absolute_y_out = static_cast<int>(clamped_y * display.height) + display.top;
return true;
}
void LogSecureDesktopInputBlocked(uint32_t* last_tick, const char* side,
const char* stage) {
if (last_tick == nullptr) {
return;
}
const uint32_t now = static_cast<uint32_t>(SDL_GetTicks());
if (*last_tick != 0 && now - *last_tick < kSecureDesktopInputLogIntervalMs) {
return;
}
*last_tick = now;
LOG_WARN(
"{} secure-desktop input blocked, stage={}, normal SendInput path "
"cannot drive the Windows password UI",
side != nullptr ? side : "unknown", stage != nullptr ? stage : "");
}
#endif
} // namespace
void Render::OnSignalMessageCb(const char* message, size_t size,
void* user_data) {
Render* render = (Render*)user_data;
@@ -709,16 +761,31 @@ void Render::OnReceiveDataBufferCb(const char* data, size_t size,
}
std::string json_str(data, size);
RemoteAction remote_action;
try {
remote_action.from_json(json_str);
} catch (const std::exception& e) {
LOG_ERROR("Failed to parse RemoteAction JSON: {}", e.what());
RemoteAction remote_action{};
if (!remote_action.from_json(json_str)) {
LOG_ERROR("Failed to parse RemoteAction JSON payload");
return;
}
std::string remote_id(user_id, user_id_size);
if (remote_action.type == ControlType::service_status) {
auto props_it = render->client_properties_.find(remote_id);
if (props_it != render->client_properties_.end()) {
render->ApplyRemoteServiceStatus(*props_it->second, remote_action.ss);
}
return;
}
if (remote_action.type == ControlType::service_command) {
#if _WIN32
if (remote_action.c.flag == ServiceCommandFlag::send_sas) {
render->pending_windows_service_sas_.store(true,
std::memory_order_relaxed);
}
#endif
return;
}
// std::shared_lock lock(render->client_properties_mutex_);
if (remote_action.type == ControlType::host_infomation) {
if (render->client_properties_.find(remote_id) !=
@@ -748,6 +815,59 @@ void Render::OnReceiveDataBufferCb(const char* data, size_t size,
}
} else {
// remote
#if _WIN32
if (render->local_service_status_received_ &&
render->local_service_available_ &&
IsSecureDesktopInteractionRequired(render->local_interactive_stage_)) {
if (remote_action.type == ControlType::mouse) {
int absolute_x = 0;
int absolute_y = 0;
if (!BuildAbsoluteMousePosition(render->display_info_list_,
render->selected_display_,
remote_action.m.x, remote_action.m.y,
&absolute_x, &absolute_y)) {
LOG_WARN(
"Secure desktop mouse injection skipped, invalid display mapping: display_index={}, x={}, y={}",
render->selected_display_, remote_action.m.x,
remote_action.m.y);
return;
}
const std::string response = SendCrossDeskSecureDesktopMouseInput(
absolute_x, absolute_y, remote_action.m.s,
static_cast<int>(remote_action.m.flag), 1000);
auto json = nlohmann::json::parse(response, nullptr, false);
if (json.is_discarded() || !json.value("ok", false)) {
LogSecureDesktopInputBlocked(
&render->last_local_secure_input_block_log_tick_, "local",
render->local_interactive_stage_.c_str());
LOG_WARN(
"Secure desktop mouse injection failed, x={}, y={}, wheel={}, flag={}, response={}",
absolute_x, absolute_y, remote_action.m.s,
static_cast<int>(remote_action.m.flag), response);
}
return;
}
if (remote_action.type == ControlType::keyboard) {
const int key_code = static_cast<int>(remote_action.k.key_value);
const bool is_down = remote_action.k.flag == KeyFlag::key_down;
const std::string response =
SendCrossDeskSecureDesktopKeyInput(key_code, is_down, 1000);
auto json = nlohmann::json::parse(response, nullptr, false);
if (json.is_discarded() || !json.value("ok", false)) {
LogSecureDesktopInputBlocked(
&render->last_local_secure_input_block_log_tick_, "local",
render->local_interactive_stage_.c_str());
LOG_WARN(
"Secure desktop keyboard injection failed, key_code={}, "
"is_down={}, response={}",
key_code, is_down, response);
}
return;
}
}
#endif
if (remote_action.type == ControlType::mouse && render->mouse_controller_) {
render->mouse_controller_->SendMouseCommand(remote_action,
render->selected_display_);
@@ -841,6 +961,7 @@ void Render::OnConnectionStatusCb(ConnectionStatus status, const char* user_id,
switch (status) {
case ConnectionStatus::Connected: {
render->ResetRemoteServiceStatus(*props);
{
RemoteAction remote_action;
remote_action.i.display_num = render->display_info_list_.size();
@@ -904,6 +1025,7 @@ void Render::OnConnectionStatusCb(ConnectionStatus status, const char* user_id,
case ConnectionStatus::Closed: {
props->connection_established_ = false;
props->enable_mouse_control_ = false;
render->ResetRemoteServiceStatus(*props);
{
std::lock_guard<std::mutex> lock(props->video_frame_mutex_);
@@ -954,6 +1076,9 @@ void Render::OnConnectionStatusCb(ConnectionStatus status, const char* user_id,
switch (status) {
case ConnectionStatus::Connected: {
#if _WIN32
render->last_windows_service_status_tick_ = 0;
#endif
{
RemoteAction remote_action;
remote_action.i.display_num = render->display_info_list_.size();

88
src/gui/toolbars/control_bar.cpp
View File

@@ -193,6 +193,94 @@ int Render::ControlBar(std::shared_ptr<SubStreamWindowProperties>& props) {
text_pos, IM_COL32(0, 0, 0, 255),
std::to_string(props->selected_display_ + 1).c_str());
if (props->remote_service_status_received_) {
ImGui::SameLine();
const RemoteUnlockState unlock_state = GetRemoteUnlockState(*props);
bool sas_button_style_pushed = false;
switch (unlock_state) {
case RemoteUnlockState::service_unavailable:
ImGui::PushStyleColor(ImGuiCol_Button,
ImVec4(185 / 255.0f, 28 / 255.0f,
28 / 255.0f, 1.0f));
sas_button_style_pushed = true;
break;
case RemoteUnlockState::credential_ui:
ImGui::PushStyleColor(ImGuiCol_Button,
ImVec4(22 / 255.0f, 163 / 255.0f,
74 / 255.0f, 1.0f));
sas_button_style_pushed = true;
break;
case RemoteUnlockState::lock_screen:
ImGui::PushStyleColor(ImGuiCol_Button,
ImVec4(202 / 255.0f, 138 / 255.0f,
4 / 255.0f, 1.0f));
sas_button_style_pushed = true;
break;
default:
break;
}
const bool can_send_sas =
props->connection_status_ == ConnectionStatus::Connected &&
props->peer_ != nullptr && props->remote_service_available_;
if (!can_send_sas) {
ImGui::BeginDisabled();
}
std::string sas_button = ICON_FA_UNLOCK_KEYHOLE;
ImGui::SetWindowFontScale(0.5f);
if (ImGui::Button(sas_button.c_str(),
ImVec2(button_width, button_height))) {
RemoteAction remote_action{};
remote_action.type = ControlType::service_command;
remote_action.c.flag = ServiceCommandFlag::send_sas;
std::string msg = remote_action.to_json();
SendReliableDataFrame(props->peer_, msg.c_str(), msg.size(),
props->control_data_label_.c_str());
}
if (!can_send_sas) {
ImGui::EndDisabled();
}
if (ImGui::IsItemHovered()) {
std::string tooltip = localization::send_sas[localization_language_index_];
switch (unlock_state) {
case RemoteUnlockState::service_unavailable:
tooltip = localization::remote_service_unavailable
[localization_language_index_];
break;
case RemoteUnlockState::credential_ui:
tooltip = localization::remote_password_box_visible
[localization_language_index_] +
"\n" +
localization::remote_unlock_requires_secure_desktop
[localization_language_index_];
break;
case RemoteUnlockState::lock_screen:
tooltip = localization::remote_lock_screen_hint
[localization_language_index_];
break;
case RemoteUnlockState::secure_desktop:
tooltip = localization::remote_secure_desktop_active
[localization_language_index_];
break;
default:
break;
}
ImGui::BeginTooltip();
ImGui::PushTextWrapPos(button_width * 8.0f);
ImGui::TextWrapped("%s", tooltip.c_str());
ImGui::PopTextWrapPos();
ImGui::EndTooltip();
}
if (sas_button_style_pushed) {
ImGui::PopStyleColor();
}
}
ImGui::SameLine();
float mouse_x = ImGui::GetCursorScreenPos().x;
float mouse_y = ImGui::GetCursorScreenPos().y;

58
src/gui/windows/stream_window.cpp
View File

@@ -59,6 +59,62 @@ void Render::DrawReceivingScreenText(
ImGui::TextColored(ImVec4(1.0f, 1.0f, 1.0f, 0.92f), "%s", text.c_str());
}
void Render::DrawRemoteUnlockStateText(
std::shared_ptr<SubStreamWindowProperties>& props) {
if (!props->remote_service_status_received_ ||
!props->connection_established_ ||
props->connection_status_ != ConnectionStatus::Connected) {
return;
}
const RemoteUnlockState unlock_state = GetRemoteUnlockState(*props);
std::string text;
ImU32 background_color = IM_COL32(37, 99, 235, 220);
switch (unlock_state) {
case RemoteUnlockState::service_unavailable:
text = localization::remote_service_unavailable
[localization_language_index_];
background_color = IM_COL32(185, 28, 28, 220);
break;
case RemoteUnlockState::credential_ui:
text = localization::remote_password_box_visible
[localization_language_index_];
background_color = IM_COL32(22, 163, 74, 220);
break;
case RemoteUnlockState::lock_screen:
text = localization::remote_lock_screen_hint
[localization_language_index_];
background_color = IM_COL32(202, 138, 4, 220);
break;
case RemoteUnlockState::secure_desktop:
text = localization::remote_secure_desktop_active
[localization_language_index_];
background_color = IM_COL32(147, 51, 234, 220);
break;
default:
return;
}
ImDrawList* draw_list = ImGui::GetWindowDrawList();
ImVec2 window_pos = ImGui::GetWindowPos();
ImVec2 window_size = ImGui::GetWindowSize();
ImVec2 text_size = ImGui::CalcTextSize(text.c_str());
float padding_x = title_bar_height_ * 0.45f;
float padding_y = title_bar_height_ * 0.18f;
float top_margin = fullscreen_button_pressed_ ? title_bar_height_ * 0.35f
: title_bar_height_ * 0.18f;
ImVec2 text_pos(window_pos.x + (window_size.x - text_size.x) * 0.5f,
window_pos.y + top_margin + padding_y);
ImVec2 rect_min(text_pos.x - padding_x, text_pos.y - padding_y);
ImVec2 rect_max(text_pos.x + text_size.x + padding_x,
text_pos.y + text_size.y + padding_y);
draw_list->AddRectFilled(rect_min, rect_max, background_color,
window_rounding_ * 0.9f);
draw_list->AddText(text_pos, IM_COL32(255, 255, 255, 255), text.c_str());
}
void Render::CloseTab(decltype(client_properties_)::iterator& it) {
// std::unique_lock lock(client_properties_mutex_);
if (it != client_properties_.end()) {
@@ -173,6 +229,7 @@ int Render::StreamWindow() {
FileTransferWindow(props);
DrawReceivingScreenText(props);
DrawRemoteUnlockStateText(props);
focused_remote_id_ = props->remote_id_;
@@ -275,6 +332,7 @@ int Render::StreamWindow() {
FileTransferWindow(props);
DrawReceivingScreenText(props);
DrawRemoteUnlockStateText(props);
ImGui::End();

513
src/screen_capturer/windows/screen_capturer_win.cpp
View File

@@ -2,22 +2,50 @@
#include <Windows.h>
#include <nlohmann/json.hpp>
#include <cmath>
#include <chrono>
#include <cstring>
#include <filesystem>
#include <memory>
#include <sstream>
#include <string>
#include <thread>
#include <utility>
#include <vector>
#include "rd_log.h"
#include "screen_capturer_dxgi.h"
#include "screen_capturer_gdi.h"
#include "interactive_state.h"
#include "service_host.h"
#include "session_helper_shared.h"
#include "wgc_plugin_api.h"
namespace crossdesk {
namespace {
using Json = nlohmann::json;
constexpr DWORD kSecureDesktopStatusIntervalMs = 250;
constexpr DWORD kSecureDesktopStatusPipeTimeoutMs = 150;
constexpr DWORD kSecureDesktopHelperPipeTimeoutMs = 120;
constexpr DWORD kSecureDesktopTransientErrorGraceMs = 1500;
constexpr DWORD kSecureDesktopTransientErrorLogIntervalMs = 5000;
constexpr int kSecureDesktopCaptureMinIntervalMs = 100;
struct SecureDesktopServiceStatus {
bool service_available = false;
bool capture_active = false;
bool helper_running = false;
DWORD active_session_id = 0xFFFFFFFF;
DWORD error_code = 0;
std::string interactive_stage;
std::string error;
};
class WgcPluginCapturer final : public ScreenCapturer {
public:
using CreateFn = ScreenCapturer* (*)();
@@ -101,6 +129,213 @@ class WgcPluginCapturer final : public ScreenCapturer {
DestroyFn destroy_fn_ = nullptr;
};
std::string BuildSecureCaptureCommand(int left, int top, int width, int height,
bool show_cursor) {
std::ostringstream stream;
stream << kCrossDeskSecureInputCaptureCommandPrefix << left << ":" << top
<< ":" << width << ":" << height << ":" << (show_cursor ? 1 : 0);
return stream.str();
}
std::string ExtractPipeTextResponse(const std::vector<uint8_t>& response) {
if (response.empty() || response.front() != '{') {
return "<non-text-response>";
}
return std::string(response.begin(), response.end());
}
bool IsTransientSecureDesktopFrameError(const std::string& error_message) {
return error_message.rfind("pipe_unavailable:", 0) == 0 ||
error_message.find("\"error\":\"bitblt_failed\"") !=
std::string::npos;
}
bool ReadPipeMessage(HANDLE pipe, std::vector<uint8_t>* response_out,
DWORD* error_code_out = nullptr) {
if (response_out == nullptr) {
return false;
}
response_out->clear();
if (error_code_out != nullptr) {
*error_code_out = 0;
}
std::vector<uint8_t> chunk(64 * 1024);
while (true) {
DWORD bytes_read = 0;
if (ReadFile(pipe, chunk.data(), static_cast<DWORD>(chunk.size()),
&bytes_read, nullptr)) {
response_out->insert(response_out->end(), chunk.begin(),
chunk.begin() + bytes_read);
return true;
}
const DWORD error = GetLastError();
response_out->insert(response_out->end(), chunk.begin(),
chunk.begin() + bytes_read);
if (error == ERROR_MORE_DATA) {
continue;
}
if (error_code_out != nullptr) {
*error_code_out = error;
}
return false;
}
}
bool ParseSecureDesktopFrameResponse(const std::vector<uint8_t>& response,
std::vector<uint8_t>* nv12_frame_out,
int* width_out, int* height_out,
std::string* error_out) {
if (nv12_frame_out == nullptr || width_out == nullptr ||
height_out == nullptr) {
return false;
}
if (response.size() < sizeof(CrossDeskSecureDesktopFrameHeader)) {
if (error_out != nullptr) {
*error_out = ExtractPipeTextResponse(response);
}
return false;
}
CrossDeskSecureDesktopFrameHeader header{};
std::memcpy(&header, response.data(), sizeof(header));
if (header.magic != kCrossDeskSecureDesktopFrameMagic ||
header.version != kCrossDeskSecureDesktopFrameVersion) {
if (error_out != nullptr) {
*error_out = ExtractPipeTextResponse(response);
}
return false;
}
const size_t expected_size = sizeof(header) + header.payload_size;
if (expected_size != response.size()) {
if (error_out != nullptr) {
*error_out = "<invalid-frame-size>";
}
return false;
}
*width_out = static_cast<int>(header.width);
*height_out = static_cast<int>(header.height);
nv12_frame_out->assign(response.begin() + sizeof(header), response.end());
return true;
}
bool QuerySecureDesktopServiceStatus(SecureDesktopServiceStatus* status) {
if (status == nullptr) {
return false;
}
*status = {};
const std::string response =
QueryCrossDeskService("status", kSecureDesktopStatusPipeTimeoutMs);
Json json = Json::parse(response, nullptr, false);
if (json.is_discarded() || !json.is_object()) {
status->error = "invalid_service_status_json";
return false;
}
status->service_available = json.value("ok", false);
if (!status->service_available) {
status->error = json.value("error", std::string("service_unavailable"));
status->error_code = json.value("code", 0u);
return true;
}
if (ShouldNormalizeUnlockToUserDesktop(
json.value("interactive_lock_screen_visible", false),
json.value("interactive_stage", std::string()),
json.value("session_locked", false),
json.value("interactive_logon_ui_visible", false),
json.value("interactive_secure_desktop_active",
json.value("secure_desktop_active", false)),
json.value("credential_ui_visible", false),
json.value("password_box_visible", false),
json.value("unlock_ui_visible", false),
json.value("last_session_event", std::string()))) {
status->active_session_id = json.value("active_session_id", 0xFFFFFFFFu);
status->interactive_stage = "user-desktop";
status->capture_active = false;
return true;
}
status->active_session_id = json.value("active_session_id", 0xFFFFFFFFu);
status->helper_running = json.value("secure_input_helper_running", false);
status->interactive_stage = json.value("interactive_stage", std::string());
const bool secure_desktop_active = json.value(
"interactive_secure_desktop_active",
json.value("secure_desktop_active", false));
status->capture_active =
status->active_session_id != 0xFFFFFFFF &&
(secure_desktop_active ||
IsSecureDesktopInteractionRequired(status->interactive_stage));
return true;
}
bool QuerySecureDesktopHelperFrame(DWORD session_id, int left, int top,
int width, int height, bool show_cursor,
std::vector<uint8_t>* nv12_frame_out,
int* captured_width_out,
int* captured_height_out,
std::string* error_out) {
if (nv12_frame_out == nullptr || captured_width_out == nullptr ||
captured_height_out == nullptr) {
return false;
}
const std::wstring pipe_name = GetCrossDeskSecureInputHelperPipeName(session_id);
if (!WaitNamedPipeW(pipe_name.c_str(), kSecureDesktopHelperPipeTimeoutMs)) {
if (error_out != nullptr) {
*error_out = "pipe_unavailable:" + std::to_string(GetLastError());
}
return false;
}
HANDLE pipe = CreateFileW(pipe_name.c_str(), GENERIC_READ | GENERIC_WRITE, 0,
nullptr, OPEN_EXISTING, 0, nullptr);
if (pipe == INVALID_HANDLE_VALUE) {
if (error_out != nullptr) {
*error_out = "pipe_connect_failed:" + std::to_string(GetLastError());
}
return false;
}
DWORD pipe_mode = PIPE_READMODE_MESSAGE;
SetNamedPipeHandleState(pipe, &pipe_mode, nullptr, nullptr);
const std::string command =
BuildSecureCaptureCommand(left, top, width, height, show_cursor);
DWORD bytes_written = 0;
if (!WriteFile(pipe, command.data(), static_cast<DWORD>(command.size()),
&bytes_written, nullptr)) {
const DWORD error = GetLastError();
CloseHandle(pipe);
if (error_out != nullptr) {
*error_out = "pipe_write_failed:" + std::to_string(error);
}
return false;
}
std::vector<uint8_t> response;
DWORD read_error = 0;
const bool read_ok = ReadPipeMessage(pipe, &response, &read_error);
CloseHandle(pipe);
if (!read_ok) {
if (error_out != nullptr) {
*error_out = "pipe_read_failed:" + std::to_string(read_error);
}
return false;
}
return ParseSecureDesktopFrameResponse(response, nv12_frame_out,
captured_width_out,
captured_height_out, error_out);
}
} // namespace
ScreenCapturerWin::ScreenCapturerWin() {}
@@ -111,6 +346,10 @@ int ScreenCapturerWin::Init(const int fps, cb_desktop_data cb) {
cb_orig_ = cb;
cb_ = [this](unsigned char* data, int size, int w, int h,
const char* display_name) {
if (secure_desktop_capture_active_.load(std::memory_order_relaxed)) {
return;
}
std::string mapped_name;
{
std::lock_guard<std::mutex> lock(alias_mutex_);
@@ -137,6 +376,8 @@ int ScreenCapturerWin::Init(const int fps, cb_desktop_data cb) {
if (ret == 0) {
LOG_INFO("Windows capturer: using WGC plugin");
BuildCanonicalFromImpl();
monitor_index_.store(0, std::memory_order_relaxed);
initial_monitor_index_ = 0;
return 0;
}
@@ -150,6 +391,8 @@ int ScreenCapturerWin::Init(const int fps, cb_desktop_data cb) {
if (ret == 0) {
LOG_INFO("Windows capturer: using DXGI Desktop Duplication");
BuildCanonicalFromImpl();
monitor_index_.store(0, std::memory_order_relaxed);
initial_monitor_index_ = 0;
return 0;
}
@@ -162,6 +405,8 @@ int ScreenCapturerWin::Init(const int fps, cb_desktop_data cb) {
if (ret == 0) {
LOG_INFO("Windows capturer: using GDI BitBlt");
BuildCanonicalFromImpl();
monitor_index_.store(0, std::memory_order_relaxed);
initial_monitor_index_ = 0;
return 0;
}
@@ -171,6 +416,10 @@ int ScreenCapturerWin::Init(const int fps, cb_desktop_data cb) {
}
int ScreenCapturerWin::Destroy() {
StopSecureCaptureThread();
running_.store(false, std::memory_order_relaxed);
paused_.store(false, std::memory_order_relaxed);
secure_desktop_capture_active_.store(false, std::memory_order_relaxed);
if (impl_) {
impl_->Destroy();
impl_.reset();
@@ -187,67 +436,100 @@ int ScreenCapturerWin::Destroy() {
int ScreenCapturerWin::Start(bool show_cursor) {
if (!impl_) return -1;
if (running_.load(std::memory_order_relaxed)) {
return 0;
}
show_cursor_.store(show_cursor, std::memory_order_relaxed);
paused_.store(false, std::memory_order_relaxed);
int ret = impl_->Start(show_cursor);
if (ret == 0) return 0;
if (ret != 0) {
LOG_WARN("Windows capturer: Start failed (ret={}), trying fallback", ret);
LOG_WARN("Windows capturer: Start failed (ret={}), trying fallback", ret);
auto try_init_start = [&](std::unique_ptr<ScreenCapturer> cand) -> bool {
int r = cand->Init(fps_, cb_);
if (r != 0) return false;
int s = cand->Start(show_cursor);
if (s == 0) {
impl_ = std::move(cand);
impl_is_wgc_plugin_ = false;
RebuildAliasesFromImpl();
return true;
}
return false;
};
auto try_init_start = [&](std::unique_ptr<ScreenCapturer> cand) -> bool {
int r = cand->Init(fps_, cb_);
if (r != 0) return false;
int s = cand->Start(show_cursor);
if (s == 0) {
impl_ = std::move(cand);
impl_is_wgc_plugin_ = false;
RebuildAliasesFromImpl();
return true;
bool fallback_started = false;
if (impl_is_wgc_plugin_) {
if (try_init_start(std::make_unique<ScreenCapturerDxgi>())) {
LOG_INFO("Windows capturer: fallback to DXGI");
fallback_started = true;
} else if (try_init_start(std::make_unique<ScreenCapturerGdi>())) {
LOG_INFO("Windows capturer: fallback to GDI");
fallback_started = true;
}
} else if (dynamic_cast<ScreenCapturerDxgi*>(impl_.get())) {
if (try_init_start(std::make_unique<ScreenCapturerGdi>())) {
LOG_INFO("Windows capturer: fallback to GDI");
fallback_started = true;
}
}
return false;
};
if (impl_is_wgc_plugin_) {
if (try_init_start(std::make_unique<ScreenCapturerDxgi>())) {
LOG_INFO("Windows capturer: fallback to DXGI");
return 0;
}
if (try_init_start(std::make_unique<ScreenCapturerGdi>())) {
LOG_INFO("Windows capturer: fallback to GDI");
return 0;
}
} else if (dynamic_cast<ScreenCapturerDxgi*>(impl_.get())) {
if (try_init_start(std::make_unique<ScreenCapturerGdi>())) {
LOG_INFO("Windows capturer: fallback to GDI");
return 0;
if (!fallback_started) {
LOG_ERROR("Windows capturer: all fallbacks failed to start");
return ret;
}
}
LOG_ERROR("Windows capturer: all fallbacks failed to start");
return ret;
running_.store(true, std::memory_order_relaxed);
secure_desktop_capture_active_.store(false, std::memory_order_relaxed);
if (!secure_capture_thread_.joinable()) {
secure_capture_thread_ =
std::thread([this]() { SecureDesktopCaptureLoop(); });
}
return 0;
}
int ScreenCapturerWin::Stop() {
if (!impl_) return 0;
return impl_->Stop();
running_.store(false, std::memory_order_relaxed);
secure_desktop_capture_active_.store(false, std::memory_order_relaxed);
int ret = 0;
if (impl_) {
ret = impl_->Stop();
}
StopSecureCaptureThread();
return ret;
}
int ScreenCapturerWin::Pause(int monitor_index) {
paused_.store(true, std::memory_order_relaxed);
if (!impl_) return -1;
return impl_->Pause(monitor_index);
}
int ScreenCapturerWin::Resume(int monitor_index) {
paused_.store(false, std::memory_order_relaxed);
if (!impl_) return -1;
return impl_->Resume(monitor_index);
}
int ScreenCapturerWin::SwitchTo(int monitor_index) {
if (!impl_) return -1;
return impl_->SwitchTo(monitor_index);
const int ret = impl_->SwitchTo(monitor_index);
if (ret == 0) {
monitor_index_.store(monitor_index, std::memory_order_relaxed);
}
return ret;
}
int ScreenCapturerWin::ResetToInitialMonitor() {
if (!impl_) return -1;
return impl_->ResetToInitialMonitor();
const int ret = impl_->ResetToInitialMonitor();
if (ret == 0) {
monitor_index_.store(initial_monitor_index_, std::memory_order_relaxed);
}
return ret;
}
std::vector<DisplayInfo> ScreenCapturerWin::GetDisplayInfoList() {
@@ -297,4 +579,171 @@ void ScreenCapturerWin::RebuildAliasesFromImpl() {
}
}
void ScreenCapturerWin::StopSecureCaptureThread() {
if (secure_capture_thread_.joinable()) {
secure_capture_thread_.join();
}
}
bool ScreenCapturerWin::GetCurrentCaptureRegion(int* left, int* top,
int* width, int* height,
std::string* display_name) {
if (left == nullptr || top == nullptr || width == nullptr ||
height == nullptr || display_name == nullptr) {
return false;
}
std::lock_guard<std::mutex> lock(alias_mutex_);
if (canonical_displays_.empty()) {
return false;
}
int current_monitor = monitor_index_.load(std::memory_order_relaxed);
if (current_monitor < 0 ||
current_monitor >= static_cast<int>(canonical_displays_.size())) {
current_monitor = 0;
}
const auto& display = canonical_displays_[current_monitor];
const int capture_width = display.width & ~1;
const int capture_height = display.height & ~1;
if (capture_width <= 0 || capture_height <= 0) {
return false;
}
*left = display.left;
*top = display.top;
*width = capture_width;
*height = capture_height;
*display_name = display.name;
return true;
}
void ScreenCapturerWin::SecureDesktopCaptureLoop() {
const int frame_interval_ms =
fps_ > 0 ? (std::max)(kSecureDesktopCaptureMinIntervalMs, 1000 / fps_)
: kSecureDesktopCaptureMinIntervalMs;
ULONGLONG last_status_tick = 0;
ULONGLONG last_error_tick = 0;
bool last_capture_active = false;
bool last_service_available = true;
std::string last_stage;
std::string last_service_error;
ULONGLONG capture_stage_started_tick = 0;
SecureDesktopServiceStatus status;
std::vector<uint8_t> secure_frame;
while (running_.load(std::memory_order_relaxed)) {
if (paused_.load(std::memory_order_relaxed)) {
std::this_thread::sleep_for(std::chrono::milliseconds(10));
continue;
}
const ULONGLONG now = GetTickCount64();
if (last_status_tick == 0 ||
now - last_status_tick >= kSecureDesktopStatusIntervalMs) {
SecureDesktopServiceStatus latest_status;
const bool status_ok = QuerySecureDesktopServiceStatus(&latest_status);
status = latest_status;
if (status_ok) {
const bool service_changed =
status.service_available != last_service_available;
const bool service_error_changed =
!status.service_available && status.error != last_service_error;
if (service_changed || service_error_changed) {
if (status.service_available) {
LOG_INFO(
"Windows capturer secure desktop service available, polling session_id={}",
status.active_session_id);
} else {
LOG_WARN(
"Windows capturer secure desktop service unavailable: error={}, code={}",
status.error, status.error_code);
}
last_service_available = status.service_available;
last_service_error = status.error;
}
} else if (last_service_available ||
last_service_error != "invalid_service_status_json") {
LOG_WARN(
"Windows capturer secure desktop service status query failed");
last_service_available = false;
last_service_error = "invalid_service_status_json";
}
secure_desktop_capture_active_.store(status.capture_active,
std::memory_order_relaxed);
if (status.capture_active != last_capture_active ||
status.interactive_stage != last_stage) {
capture_stage_started_tick = now;
LOG_INFO(
"Windows capturer secure desktop state: active={}, stage='{}', session_id={}",
status.capture_active, status.interactive_stage,
status.active_session_id);
last_capture_active = status.capture_active;
last_stage = status.interactive_stage;
}
last_status_tick = now;
}
if (!status.capture_active || status.active_session_id == 0xFFFFFFFF) {
std::this_thread::sleep_for(std::chrono::milliseconds(
status.service_available ? 50 : 200));
continue;
}
if (!status.helper_running) {
std::this_thread::sleep_for(std::chrono::milliseconds(30));
continue;
}
int left = 0;
int top = 0;
int width = 0;
int height = 0;
std::string display_name;
if (!GetCurrentCaptureRegion(&left, &top, &width, &height, &display_name)) {
std::this_thread::sleep_for(std::chrono::milliseconds(100));
continue;
}
int captured_width = 0;
int captured_height = 0;
std::string error_message;
if (QuerySecureDesktopHelperFrame(
status.active_session_id, left, top, width, height,
show_cursor_.load(std::memory_order_relaxed), &secure_frame,
&captured_width, &captured_height, &error_message)) {
if (cb_orig_ && !secure_frame.empty()) {
cb_orig_(secure_frame.data(), static_cast<int>(secure_frame.size()),
captured_width, captured_height, display_name.c_str());
}
} else {
const bool transient_error =
IsTransientSecureDesktopFrameError(error_message);
const bool in_grace_period =
capture_stage_started_tick != 0 &&
now - capture_stage_started_tick < kSecureDesktopTransientErrorGraceMs;
const DWORD log_interval = transient_error
? kSecureDesktopTransientErrorLogIntervalMs
: 1000;
if (transient_error && in_grace_period) {
std::this_thread::sleep_for(
std::chrono::milliseconds(frame_interval_ms));
continue;
}
if (now - last_error_tick >= log_interval) {
LOG_WARN(
"Windows capturer secure desktop frame query failed, stage='{}', session_id={}, error={}",
status.interactive_stage, status.active_session_id, error_message);
last_error_tick = now;
}
}
std::this_thread::sleep_for(std::chrono::milliseconds(frame_interval_ms));
}
secure_desktop_capture_active_.store(false, std::memory_order_relaxed);
}
} // namespace crossdesk

15
src/screen_capturer/windows/screen_capturer_win.h
View File

@@ -7,8 +7,12 @@
#ifndef _SCREEN_CAPTURER_WIN_H_
#define _SCREEN_CAPTURER_WIN_H_
#include <Windows.h>
#include <atomic>
#include <memory>
#include <mutex>
#include <thread>
#include <unordered_map>
#include <unordered_set>
#include <vector>
@@ -48,9 +52,20 @@ class ScreenCapturerWin : public ScreenCapturer {
std::mutex alias_mutex_;
std::vector<DisplayInfo> canonical_displays_;
std::unordered_set<std::string> canonical_labels_;
std::atomic<bool> running_{false};
std::atomic<bool> paused_{false};
std::atomic<bool> show_cursor_{true};
std::atomic<int> monitor_index_{0};
int initial_monitor_index_ = 0;
std::atomic<bool> secure_desktop_capture_active_{false};
std::thread secure_capture_thread_;
void BuildCanonicalFromImpl();
void RebuildAliasesFromImpl();
void StopSecureCaptureThread();
void SecureDesktopCaptureLoop();
bool GetCurrentCaptureRegion(int* left, int* top, int* width, int* height,
std::string* display_name);
};
} // namespace crossdesk
#endif

35
src/service/windows/interactive_state.h Normal file
View File

@@ -0,0 +1,35 @@
#ifndef _CROSSDESK_INTERACTIVE_STATE_H_
#define _CROSSDESK_INTERACTIVE_STATE_H_
#include <string>
namespace crossdesk {
inline bool IsSecureDesktopInteractionRequired(
const std::string& interactive_stage) {
return interactive_stage == "credential-ui" ||
interactive_stage == "secure-desktop";
}
inline bool ShouldNormalizeUnlockToUserDesktop(
bool interactive_lock_screen_visible,
const std::string& interactive_stage, bool session_locked,
bool interactive_logon_ui_visible, bool interactive_secure_desktop_active,
bool credential_ui_visible, bool password_box_visible,
bool unlock_ui_visible, const std::string& last_session_event) {
if (!interactive_lock_screen_visible && interactive_stage != "lock-screen") {
return false;
}
if (session_locked || interactive_logon_ui_visible ||
interactive_secure_desktop_active || credential_ui_visible ||
password_box_visible || unlock_ui_visible) {
return false;
}
return last_session_event != "session-lock";
}
} // namespace crossdesk
#endif

87
src/service/windows/main.cpp Normal file
View File

@@ -0,0 +1,87 @@
#include <Windows.h>
#include <iostream>
#include <string>
#include "service_host.h"
namespace {
std::wstring GetExecutablePath() {
wchar_t path[MAX_PATH] = {0};
DWORD length = GetModuleFileNameW(nullptr, path, MAX_PATH);
if (length == 0 || length >= MAX_PATH) {
return L"";
}
return std::wstring(path, length);
}
void PrintUsage() {
std::cout << "CrossDesk Windows service skeleton\n"
<< " --service Run under the Windows Service Control Manager\n"
<< " --console Run the service loop in console mode\n"
<< " --install Install the service for the current executable\n"
<< " --uninstall Remove the installed service\n"
<< " --start Start the installed service\n"
<< " --stop Stop the installed service\n"
<< " --sas Ask the service to send Secure Attention Sequence\n"
<< " --ping Ping the running service over named pipe IPC\n"
<< " --status Query runtime status over named pipe IPC\n";
}
} // namespace
int main(int argc, char* argv[]) {
crossdesk::CrossDeskServiceHost host;
if (argc <= 1) {
PrintUsage();
return 0;
}
std::string command = argv[1];
if (command == "--service") {
return host.RunAsService();
}
if (command == "--console") {
return host.RunInConsole();
}
if (command == "--install") {
std::wstring executable_path = GetExecutablePath();
bool success = !executable_path.empty() &&
crossdesk::InstallCrossDeskService(executable_path);
std::cout << (success ? "install ok" : "install failed") << std::endl;
return success ? 0 : 1;
}
if (command == "--uninstall") {
bool success = crossdesk::UninstallCrossDeskService();
std::cout << (success ? "uninstall ok" : "uninstall failed")
<< std::endl;
return success ? 0 : 1;
}
if (command == "--start") {
bool success = crossdesk::StartCrossDeskService();
std::cout << (success ? "start ok" : "start failed") << std::endl;
return success ? 0 : 1;
}
if (command == "--stop") {
bool success = crossdesk::StopCrossDeskService();
std::cout << (success ? "stop ok" : "stop failed") << std::endl;
return success ? 0 : 1;
}
if (command == "--sas") {
std::cout << crossdesk::QueryCrossDeskService("sas") << std::endl;
return 0;
}
if (command == "--ping") {
std::cout << crossdesk::QueryCrossDeskService("ping") << std::endl;
return 0;
}
if (command == "--status") {
std::cout << crossdesk::QueryCrossDeskService("status") << std::endl;
return 0;
}
PrintUsage();
return 1;
}

2045
src/service/windows/service_host.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

141
src/service/windows/service_host.h Normal file
View File

@@ -0,0 +1,141 @@
#ifndef _CROSSDESK_SERVICE_HOST_H_
#define _CROSSDESK_SERVICE_HOST_H_
#include <Windows.h>
#include <mutex>
#include <string>
#include <thread>
namespace crossdesk {
inline constexpr wchar_t kCrossDeskServiceName[] = L"CrossDeskService";
inline constexpr wchar_t kCrossDeskServiceDisplayName[] =
L"CrossDesk Service";
inline constexpr wchar_t kCrossDeskServicePipeName[] =
L"\\\\.\\pipe\\CrossDeskService";
class CrossDeskServiceHost {
public:
CrossDeskServiceHost();
~CrossDeskServiceHost();
int RunAsService();
int RunInConsole();
private:
int RunServiceLoop(bool as_service);
int InitializeRuntime();
void ShutdownRuntime();
void RequestStop();
void ReportServiceStatus(DWORD current_state, DWORD win32_exit_code,
DWORD wait_hint);
void IpcServerLoop();
void RefreshSessionState();
void EnsureSessionHelper();
void ReapSessionHelper();
void StopSessionHelper();
bool LaunchSessionHelper(DWORD session_id);
void ReapSecureInputHelper();
void StopSecureInputHelper();
bool LaunchSecureInputHelper(DWORD session_id);
std::wstring GetSessionHelperPath() const;
std::wstring GetSessionHelperStopEventName(DWORD session_id) const;
std::wstring GetSecureInputHelperPath() const;
std::wstring GetSecureInputHelperStopEventName(DWORD session_id) const;
void ResetSessionHelperReportedStateLocked(const char* error,
DWORD error_code);
bool GetEffectiveSessionLockedLocked() const;
bool IsHelperReportingLockScreenLocked() const;
bool HasSecureInputUiLocked() const;
bool ShouldKeepSecureInputHelperLocked(DWORD target_session_id) const;
void RefreshSessionHelperReportedState();
void RecordSessionEvent(DWORD event_type, DWORD session_id);
std::string HandleIpcCommand(const std::string& command);
std::string BuildStatusResponse();
std::string SendSecureAttentionSequence();
std::string SendSecureDesktopKeyboardInput(int key_code, bool is_down);
static void WINAPI ServiceMain(DWORD argc, LPWSTR* argv);
static BOOL WINAPI ConsoleControlHandler(DWORD control_type);
static DWORD WINAPI ServiceControlHandler(DWORD control, DWORD event_type,
LPVOID event_data,
LPVOID context);
private:
SERVICE_STATUS_HANDLE status_handle_ = nullptr;
SERVICE_STATUS service_status_{};
HANDLE stop_event_ = nullptr;
std::thread ipc_thread_;
std::mutex state_mutex_;
DWORD active_session_id_ = 0xFFFFFFFF;
DWORD process_session_id_ = 0xFFFFFFFF;
DWORD input_desktop_error_code_ = 0;
DWORD session_helper_process_id_ = 0;
DWORD session_helper_session_id_ = 0xFFFFFFFF;
DWORD session_helper_exit_code_ = 0;
DWORD session_helper_last_error_code_ = 0;
DWORD session_helper_status_error_code_ = 0;
DWORD session_helper_report_session_id_ = 0xFFFFFFFF;
DWORD session_helper_report_process_id_ = 0;
DWORD session_helper_report_input_desktop_error_code_ = 0;
DWORD secure_input_helper_process_id_ = 0;
DWORD secure_input_helper_session_id_ = 0xFFFFFFFF;
DWORD secure_input_helper_exit_code_ = 0;
DWORD secure_input_helper_last_error_code_ = 0;
DWORD last_session_event_type_ = 0;
DWORD last_session_event_session_id_ = 0xFFFFFFFF;
ULONGLONG started_at_tick_ = 0;
ULONGLONG last_sas_tick_ = 0;
ULONGLONG session_helper_started_at_tick_ = 0;
ULONGLONG session_helper_report_state_age_ms_ = 0;
ULONGLONG session_helper_report_uptime_ms_ = 0;
ULONGLONG secure_input_helper_started_at_tick_ = 0;
bool session_locked_ = false;
bool logon_ui_visible_ = false;
bool prelogin_ = false;
bool secure_desktop_active_ = false;
bool input_desktop_available_ = false;
bool session_helper_running_ = false;
bool session_helper_status_ok_ = false;
bool session_helper_report_session_locked_ = false;
bool session_helper_report_input_desktop_available_ = false;
bool session_helper_report_lock_app_visible_ = false;
bool session_helper_report_logon_ui_visible_ = false;
bool session_helper_report_secure_desktop_active_ = false;
bool session_helper_report_credential_ui_visible_ = false;
bool session_helper_report_unlock_ui_visible_ = false;
bool secure_input_helper_running_ = false;
bool console_mode_ = false;
DWORD last_sas_error_code_ = 0;
bool last_sas_success_ = false;
HANDLE session_helper_process_handle_ = nullptr;
HANDLE session_helper_stop_event_ = nullptr;
HANDLE secure_input_helper_process_handle_ = nullptr;
HANDLE secure_input_helper_stop_event_ = nullptr;
std::string input_desktop_name_;
std::string last_sas_error_;
std::string session_helper_last_error_;
std::string session_helper_status_error_;
std::string session_helper_report_input_desktop_;
std::string session_helper_report_interactive_stage_;
std::string secure_input_helper_last_error_;
static CrossDeskServiceHost* instance_;
};
bool InstallCrossDeskService(const std::wstring& binary_path);
bool UninstallCrossDeskService();
bool StartCrossDeskService();
bool StopCrossDeskService(DWORD timeout_ms = 5000);
std::string QueryCrossDeskService(const std::string& command,
DWORD timeout_ms = 1000);
std::string SendCrossDeskSecureDesktopKeyInput(int key_code, bool is_down,
DWORD timeout_ms = 1000);
std::string SendCrossDeskSecureDesktopMouseInput(int x, int y, int wheel,
int flag,
DWORD timeout_ms = 1000);
} // namespace crossdesk
#endif

1123
src/service/windows/session_helper_main.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

51
src/service/windows/session_helper_shared.h Normal file
View File

@@ -0,0 +1,51 @@
#ifndef _CROSSDESK_SESSION_HELPER_SHARED_H_
#define _CROSSDESK_SESSION_HELPER_SHARED_H_
#include <Windows.h>
#include <cstdint>
#include <string>
namespace crossdesk {
inline constexpr wchar_t kCrossDeskSessionHelperPipePrefix[] =
L"\\\\.\\pipe\\CrossDeskSessionHelper-";
inline constexpr wchar_t kCrossDeskSecureInputHelperPipePrefix[] =
L"\\\\.\\pipe\\CrossDeskSecureInputHelper-";
inline constexpr char kCrossDeskSessionHelperStatusCommand[] = "status";
inline constexpr char kCrossDeskSecureInputKeyboardCommandPrefix[] =
"keyboard:";
inline constexpr char kCrossDeskSecureInputMouseCommandPrefix[] =
"mouse:";
inline constexpr char kCrossDeskSecureInputCaptureCommandPrefix[] =
"capture:";
inline constexpr DWORD kCrossDeskSecureInputPipeBufferBytes =
16 * 1024 * 1024;
inline constexpr uint32_t kCrossDeskSecureDesktopFrameMagic = 0x50444358;
inline constexpr uint32_t kCrossDeskSecureDesktopFrameVersion = 1;
#pragma pack(push, 1)
struct CrossDeskSecureDesktopFrameHeader {
uint32_t magic;
uint32_t version;
int32_t left;
int32_t top;
uint32_t width;
uint32_t height;
uint32_t payload_size;
};
#pragma pack(pop)
inline std::wstring GetCrossDeskSessionHelperPipeName(DWORD session_id) {
return std::wstring(kCrossDeskSessionHelperPipePrefix) +
std::to_wstring(session_id);
}
inline std::wstring GetCrossDeskSecureInputHelperPipeName(DWORD session_id) {
return std::wstring(kCrossDeskSecureInputHelperPipePrefix) +
std::to_wstring(session_id);
}
} // namespace crossdesk
#endif

25
xmake/targets.lua
View File

@@ -34,7 +34,8 @@ function setup_targets()
add_files("src/screen_capturer/windows/screen_capturer_dxgi.cpp",
"src/screen_capturer/windows/screen_capturer_gdi.cpp",
"src/screen_capturer/windows/screen_capturer_win.cpp")
add_includedirs("src/screen_capturer/windows", {public = true})
add_includedirs("src/screen_capturer/windows", "src/service/windows",
{public = true})
elseif is_os("macosx") then
add_files("src/screen_capturer/macosx/*.cpp",
"src/screen_capturer/macosx/*.mm")
@@ -146,7 +147,8 @@ function setup_targets()
"src/gui/windows", {public = true})
if is_os("windows") then
add_files("src/gui/tray/*.cpp")
add_includedirs("src/gui/tray", {public = true})
add_includedirs("src/gui/tray", "src/service/windows",
{public = true})
elseif is_os("macosx") then
add_files("src/gui/windows/*.mm")
end
@@ -163,6 +165,22 @@ function setup_targets()
"src/screen_capturer/windows/wgc_plugin_entry.cpp")
add_includedirs("src/common", "src/screen_capturer",
"src/screen_capturer/windows")
target("crossdesk_service")
set_kind("binary")
add_deps("rd_log", "path_manager")
add_links("Advapi32", "Wtsapi32", "Ole32", "Userenv")
add_files("src/service/windows/main.cpp",
"src/service/windows/service_host.cpp")
add_includedirs("src/service/windows", {public = true})
target("crossdesk_session_helper")
set_kind("binary")
add_packages("libyuv")
add_deps("rd_log", "path_manager")
add_links("Advapi32", "User32", "Wtsapi32", "Gdi32")
add_files("src/service/windows/session_helper_main.cpp")
add_includedirs("src/service/windows", {public = true})
end
target("crossdesk")
@@ -171,6 +189,9 @@ function setup_targets()
add_files("src/app/*.cpp")
add_includedirs("src/app", {public = true})
if is_os("windows") then
add_files("src/service/windows/service_host.cpp")
add_includedirs("src/service/windows", {public = true})
add_links("Advapi32", "Wtsapi32", "Ole32", "Userenv")
add_deps("wgc_plugin")
add_files("scripts/windows/crossdesk.rc")
end