[fix] fix Windows input forwarding and allow debug builds to run without admin, fixes #82

src/device_controller/mouse/windows/mouse_controller.cpp

@@ -1,5 +1,7 @@
 #include "mouse_controller.h"
 
+#include <Windows.h>
+
 #include "rd_log.h"
 
 namespace crossdesk {
@@ -18,7 +20,14 @@ int MouseController::Destroy() { return 0; }
 
 int MouseController::SendMouseCommand(RemoteAction remote_action,
                                       int display_index) {
-  INPUT ip;
+  if (display_index < 0 ||
+      display_index >= static_cast<int>(display_info_list_.size())) {
+    LOG_WARN("Mouse command skipped, invalid display_index={}, displays={}",
+             display_index, display_info_list_.size());
+    return -1;
+  }
+
+  INPUT ip = {0};
 
   if (remote_action.type == ControlType::mouse) {
     ip.type = INPUT_MOUSE;
@@ -63,13 +72,25 @@ int MouseController::SendMouseCommand(RemoteAction remote_action,
 
     ip.mi.time = 0;
 
-    SetCursorPos(ip.mi.dx, ip.mi.dy);
+    if (!SetCursorPos(ip.mi.dx, ip.mi.dy)) {
+      LOG_WARN("SetCursorPos failed for mouse x={}, y={}, flag={}, err={}",
+               ip.mi.dx, ip.mi.dy, static_cast<int>(remote_action.m.flag),
+               GetLastError());
+      return -1;
+    }
 
     if (ip.mi.dwFlags != MOUSEEVENTF_MOVE) {
-      SendInput(1, &ip, sizeof(INPUT));
+      UINT sent = SendInput(1, &ip, sizeof(INPUT));
+      if (sent != 1) {
+        LOG_WARN(
+            "SendInput failed for mouse x={}, y={}, wheel={}, flag={}, err={}",
+            ip.mi.dx, ip.mi.dy, remote_action.m.s,
+            static_cast<int>(remote_action.m.flag), GetLastError());
+        return -1;
+      }
     }
   }
 
   return 0;
 }
-}  // namespace crossdesk
+}  // namespace crossdesk

src/service/windows/service_host.cpp

@@ -46,6 +46,13 @@ struct InputDesktopInfo {
   std::string name;
 };
 
+struct SecureDesktopMouseRequest {
+  int x = 0;
+  int y = 0;
+  int wheel = 0;
+  int flag = 0;
+};
+
 struct ScopedEnvironmentBlock {
   ~ScopedEnvironmentBlock() {
     if (environment != nullptr) {
@@ -339,6 +346,14 @@ std::string BuildSecureInputHelperKeyboardCommand(int key_code, bool is_down,
   return stream.str();
 }
 
+std::string BuildSecureInputHelperMouseCommand(int x, int y, int wheel,
+                                               int flag) {
+  std::ostringstream stream;
+  stream << kCrossDeskSecureInputMouseCommandPrefix << x << ":" << y << ":"
+         << wheel << ":" << flag;
+  return stream.str();
+}
+
 bool ParseSecureDesktopKeyboardIpcCommand(const std::string& command,
                                           int* key_code_out, bool* is_down_out,
                                           uint32_t* scan_code_out,
@@ -412,6 +427,57 @@ bool ParseSecureDesktopKeyboardIpcCommand(const std::string& command,
   return false;
 }
 
+bool ParseSecureDesktopMouseIpcCommand(const std::string& command,
+                                       SecureDesktopMouseRequest* request_out) {
+  if (request_out == nullptr) {
+    return false;
+  }
+
+  if (command.rfind(kSecureDesktopMouseIpcCommandPrefix, 0) != 0) {
+    return false;
+  }
+
+  const size_t x_begin = sizeof(kSecureDesktopMouseIpcCommandPrefix) - 1;
+  size_t separator = command.find(':', x_begin);
+  if (separator == std::string::npos) {
+    return false;
+  }
+
+  try {
+    request_out->x = std::stoi(command.substr(x_begin, separator - x_begin));
+  } catch (...) {
+    return false;
+  }
+
+  const size_t y_begin = separator + 1;
+  separator = command.find(':', y_begin);
+  if (separator == std::string::npos) {
+    return false;
+  }
+
+  try {
+    request_out->y = std::stoi(command.substr(y_begin, separator - y_begin));
+  } catch (...) {
+    return false;
+  }
+
+  const size_t wheel_begin = separator + 1;
+  separator = command.find(':', wheel_begin);
+  if (separator == std::string::npos) {
+    return false;
+  }
+
+  try {
+    request_out->wheel =
+        std::stoi(command.substr(wheel_begin, separator - wheel_begin));
+    request_out->flag = std::stoi(command.substr(separator + 1));
+  } catch (...) {
+    return false;
+  }
+
+  return true;
+}
+
 bool CreateSessionSystemToken(DWORD session_id, HANDLE* token_out,
                               DWORD* error_code_out = nullptr) {
   if (token_out == nullptr) {
@@ -1759,7 +1825,13 @@ std::string CrossDeskServiceHost::HandleIpcCommand(const std::string& command) {
   if (ParseSecureDesktopKeyboardIpcCommand(normalized, &key_code, &is_down,
                                            &scan_code, &extended)) {
     return SendSecureDesktopKeyboardInput(key_code, is_down, scan_code,
-                                          extended);
+                                           extended);
+  }
+  SecureDesktopMouseRequest mouse_request;
+  if (ParseSecureDesktopMouseIpcCommand(normalized, &mouse_request)) {
+    return SendSecureDesktopMouseInput(mouse_request.x, mouse_request.y,
+                                       mouse_request.wheel,
+                                       mouse_request.flag);
   }
   return BuildErrorJson("unknown_command");
 }
@@ -2014,6 +2086,45 @@ std::string CrossDeskServiceHost::SendSecureDesktopKeyboardInput(
       1000);
 }
 
+std::string CrossDeskServiceHost::SendSecureDesktopMouseInput(int x, int y,
+                                                              int wheel,
+                                                              int flag) {
+  RefreshSessionState();
+  ReapSecureInputHelper();
+  EnsureSessionHelper();
+
+  DWORD target_session_id = 0xFFFFFFFF;
+  bool helper_running = false;
+  bool can_inject = false;
+  {
+    std::lock_guard<std::mutex> lock(state_mutex_);
+    target_session_id = active_session_id_;
+    helper_running = secure_input_helper_running_ &&
+                     secure_input_helper_session_id_ == target_session_id;
+    can_inject = GetEffectiveSessionLockedLocked() || HasSecureInputUiLocked();
+  }
+
+  if (target_session_id == 0xFFFFFFFF) {
+    return BuildErrorJson("no_active_console_session");
+  }
+  if (!can_inject) {
+    return BuildErrorJson("secure_input_not_active");
+  }
+
+  if (!helper_running) {
+    StopSecureInputHelper();
+    if (!LaunchSecureInputHelper(target_session_id)) {
+      std::lock_guard<std::mutex> lock(state_mutex_);
+      return BuildErrorJson(secure_input_helper_last_error_.c_str(),
+                            secure_input_helper_last_error_code_);
+    }
+  }
+
+  return QueryNamedPipeMessage(
+      GetCrossDeskSecureInputHelperPipeName(target_session_id),
+      BuildSecureInputHelperMouseCommand(x, y, wheel, flag), 1000);
+}
+
 bool InstallCrossDeskService(const std::wstring& binary_path) {
   SC_HANDLE manager = OpenSCManagerW(nullptr, nullptr, SC_MANAGER_ALL_ACCESS);
   if (manager == nullptr) {
@@ -2238,4 +2349,4 @@ std::string SendCrossDeskSecureDesktopMouseInput(int x, int y, int wheel,
       BuildSecureDesktopMouseIpcCommand(x, y, wheel, flag), timeout_ms);
 }
 
-}  // namespace crossdesk
+}  // namespace crossdesk

src/service/windows/service_host.h

@@ -64,6 +64,7 @@ class CrossDeskServiceHost {
   std::string SendSecureDesktopKeyboardInput(int key_code, bool is_down,
                                              uint32_t scan_code = 0,
                                              bool extended = false);
+  std::string SendSecureDesktopMouseInput(int x, int y, int wheel, int flag);
 
   static void WINAPI ServiceMain(DWORD argc, LPWSTR* argv);
   static BOOL WINAPI ConsoleControlHandler(DWORD control_type);
@@ -150,4 +151,4 @@ std::string SendCrossDeskSecureDesktopMouseInput(int x, int y, int wheel,
 
 }  // namespace crossdesk
 
-#endif
+#endif