Windows 服务程序实现鼠标模拟

server/2025/1/23 4:13:04/

```cpp
#include <windows.h>
#include <fstream>
#include <string>
#include <tchar.h>
#include <thread>
#include <vector>

#define SERVICE_NAME _T("MouseSimulationService")

// 全局变量
SERVICE_STATUS        g_ServiceStatus = { 0 };
SERVICE_STATUS_HANDLE g_StatusHandle = NULL;
HANDLE                g_ServiceStopEvent = INVALID_HANDLE_VALUE;

// 日志类
class Logger {
private:
    std::ofstream logFile;

public:
    Logger(const std::string& filename) {
        logFile.open(filename, std::ios::app);
    }

    void Log(const std::string& message) {
        if (logFile.is_open()) {
            SYSTEMTIME st;
            GetLocalTime(&st);
            logFile << st.wYear << "-" << st.wMonth << "-" << st.wDay << " "
                   << st.wHour << ":" << st.wMinute << ":" << st.wSecond << " - "
                   << message << std::endl;
            logFile.flush();
        }
    }

    ~Logger() {
        if (logFile.is_open()) {
            logFile.close();
        }
    }
};

// 全局日志对象
Logger* g_Logger = nullptr;

// 鼠标模拟类
class MouseSimulator {
public:
    static bool MoveTo(int x, int y) {
        // 获取桌面窗口的句柄
        HWND desktopHwnd = GetDesktopWindow();
        if (!desktopHwnd) {
            if (g_Logger) g_Logger->Log("Failed to get desktop window handle");
            return false;
        }

        // 获取输入桌面
        HDESK hDesk = OpenInputDesktop(0, FALSE, DESKTOP_CREATEMENU | DESKTOP_CREATEWINDOW |
            DESKTOP_ENUMERATE | DESKTOP_HOOKCONTROL | DESKTOP_WRITEOBJECTS | DESKTOP_READOBJECTS |
            DESKTOP_SWITCHDESKTOP | GENERIC_WRITE);
        if (!hDesk) {
            if (g_Logger) g_Logger->Log("Failed to open input desktop");
            return false;
        }

        // 设置线程桌面
        if (!SetThreadDesktop(hDesk)) {
            if (g_Logger) g_Logger->Log("Failed to set thread desktop");
            CloseDesktop(hDesk);
            return false;
        }

        // 计算绝对坐标
        double screenWidth = GetSystemMetrics(SM_CXSCREEN) - 1;
        double screenHeight = GetSystemMetrics(SM_CYSCREEN) - 1;
        double dx = x * (65535.0f / screenWidth);
        double dy = y * (65535.0f / screenHeight);

        INPUT input = { 0 };
        input.type = INPUT_MOUSE;
        input.mi.dwFlags = MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_VIRTUALDESK | MOUSEEVENTF_MOVE;
        input.mi.dx = static_cast<LONG>(dx);
        input.mi.dy = static_cast<LONG>(dy);

        UINT result = SendInput(1, &input, sizeof(INPUT));
        
        CloseDesktop(hDesk);

        if (result != 1) {
            if (g_Logger) g_Logger->Log("Failed to move mouse");
            return false;
        }

        if (g_Logger) g_Logger->Log("Mouse moved to " + std::to_string(x) + "," + std::to_string(y));
        return true;
    }

    static bool Click() {
        INPUT inputs[2] = { 0 };
        inputs[0].type = INPUT_MOUSE;
        inputs[0].mi.dwFlags = MOUSEEVENTF_LEFTDOWN;
        inputs[1].type = INPUT_MOUSE;
        inputs[1].mi.dwFlags = MOUSEEVENTF_LEFTUP;

        UINT result = SendInput(2, inputs, sizeof(INPUT));
        if (result != 2) {
            if (g_Logger) g_Logger->Log("Failed to perform click");
            return false;
        }

        if (g_Logger) g_Logger->Log("Click performed");
        return true;
    }
};

// 命名管道处理类
class PipeHandler {
private:
    static const int BUFFER_SIZE = 1024;
    HANDLE pipe;

public:
    PipeHandler() : pipe(INVALID_HANDLE_VALUE) {}

    bool Create() {
        pipe = CreateNamedPipe(
            TEXT("\\\\.\\pipe\\MouseSimulationPipe"),
            PIPE_ACCESS_DUPLEX,
            PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT,
            PIPE_UNLIMITED_INSTANCES,
            BUFFER_SIZE,
            BUFFER_SIZE,
            0,
            NULL);

        if (pipe == INVALID_HANDLE_VALUE) {
            if (g_Logger) g_Logger->Log("Failed to create pipe");
            return false;
        }
        return true;
    }

    bool WaitForConnection() {
        if (!ConnectNamedPipe(pipe, NULL)) {
            if (GetLastError() != ERROR_PIPE_CONNECTED) {
                if (g_Logger) g_Logger->Log("Failed to connect to pipe");
                return false;
            }
        }
        return true;
    }

    bool ReadCommand(std::string& command) {
        char buffer[BUFFER_SIZE];
        DWORD bytesRead;

        if (ReadFile(pipe, buffer, BUFFER_SIZE, &bytesRead, NULL)) {
            buffer[bytesRead] = '\0';
            command = std::string(buffer);
            return true;
        }
        return false;
    }

    void Close() {
        if (pipe != INVALID_HANDLE_VALUE) {
            DisconnectNamedPipe(pipe);
            CloseHandle(pipe);
            pipe = INVALID_HANDLE_VALUE;
        }
    }

    ~PipeHandler() {
        Close();
    }
};

// 服务控制处理函数
VOID WINAPI ServiceCtrlHandler(DWORD CtrlCode)
{
    switch (CtrlCode)
    {
    case SERVICE_CONTROL_STOP:
        if (g_ServiceStatus.dwCurrentState != SERVICE_RUNNING)
            break;

        g_ServiceStatus.dwControlsAccepted = 0;
        g_ServiceStatus.dwCurrentState = SERVICE_STOP_PENDING;
        g_ServiceStatus.dwWin32ExitCode = 0;
        g_ServiceStatus.dwCheckPoint = 4;

        SetServiceStatus(g_StatusHandle, &g_ServiceStatus);
        SetEvent(g_ServiceStopEvent);
        break;

    default:
        break;
    }
}

// 解析命令
void ProcessCommand(const std::string& cmd) {
    try {
        size_t pos = cmd.find(' ');
        if (pos == std::string::npos) return;

        std::string action = cmd.substr(0, pos);
        std::string coords = cmd.substr(pos + 1);

        if (action == "move") {
            pos = coords.find(',');
            if (pos != std::string::npos) {
                int x = std::stoi(coords.substr(0, pos));
                int y = std::stoi(coords.substr(pos + 1));
                MouseSimulator::MoveTo(x, y);
            }
        }
        else if (action == "click") {
            MouseSimulator::Click();
        }
    }
    catch (const std::exception& e) {
        if (g_Logger) g_Logger->Log("Error processing command: " + std::string(e.what()));
    }
}

// 服务主函数
VOID WINAPI ServiceMain(DWORD argc, LPTSTR* argv)
{
    g_StatusHandle = RegisterServiceCtrlHandler(SERVICE_NAME, ServiceCtrlHandler);
    if (g_StatusHandle == NULL) return;

    g_ServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
    g_ServiceStatus.dwCurrentState = SERVICE_START_PENDING;
    g_ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;
    g_ServiceStatus.dwWin32ExitCode = 0;
    g_ServiceStatus.dwServiceSpecificExitCode = 0;
    g_ServiceStatus.dwCheckPoint = 0;

    // 初始化日志
    g_Logger = new Logger("C:\\MouseService.log");
    g_Logger->Log("Service starting...");

    // 创建停止事件
    g_ServiceStopEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
    if (g_ServiceStopEvent == NULL)
    {
        g_ServiceStatus.dwCurrentState = SERVICE_STOPPED;
        g_ServiceStatus.dwWin32ExitCode = GetLastError();
        SetServiceStatus(g_StatusHandle, &g_ServiceStatus);
        return;
    }

    // 服务已启动
    g_ServiceStatus.dwCurrentState = SERVICE_RUNNING;
    g_ServiceStatus.dwCheckPoint = 0;
    g_ServiceStatus.dwWaitHint = 0;
    SetServiceStatus(g_StatusHandle, &g_ServiceStatus);

    // 主服务循环
    PipeHandler pipe;
    while (true)
    {
        if (WaitForSingleObject(g_ServiceStopEvent, 0) == WAIT_OBJECT_0)
            break;

        if (pipe.Create())
        {
            if (pipe.WaitForConnection())
            {
                std::string command;
                if (pipe.ReadCommand(command))
                {
                    g_Logger->Log("Received command: " + command);
                    ProcessCommand(command);
                }
            }
            pipe.Close();
        }
    }

    // 清理
    if (g_ServiceStopEvent)
    {
        CloseHandle(g_ServiceStopEvent);
        g_ServiceStopEvent = NULL;
    }

    delete g_Logger;
    g_Logger = nullptr;

    g_ServiceStatus.dwCurrentState = SERVICE_STOPPED;
    g_ServiceStatus.dwCheckPoint = 0;
    g_ServiceStatus.dwWaitHint = 0;
    SetServiceStatus(g_StatusHandle, &g_ServiceStatus);
}

// 主函数
int main()
{
    SERVICE_TABLE_ENTRY ServiceTable[] =
    {
        { SERVICE_NAME, (LPSERVICE_MAIN_FUNCTION)ServiceMain },
        { NULL, NULL }
    };

    if (!StartServiceCtrlDispatcher(ServiceTable))
    {
        return GetLastError();
    }

    return 0;
}
```

**测试客户端程序**:

```cpp
#include <windows.h>
#include <iostream>
#include <string>

int main()
{
    while (true)
    {
        HANDLE hPipe = CreateFile(
            TEXT("\\\\.\\pipe\\MouseSimulationPipe"),
            GENERIC_WRITE,
            0,
            NULL,
            OPEN_EXISTING,
            0,
            NULL);

        if (hPipe != INVALID_HANDLE_VALUE)
        {
            std::string command;
            std::cout << "Enter command (move x,y or click): ";
            std::getline(std::cin, command);

            if (command == "exit")
                break;

            DWORD bytesWritten;
            WriteFile(hPipe, command.c_str(), command.length(), &bytesWritten, NULL);
            CloseHandle(hPipe);
        }
        else
        {
            std::cout << "Failed to connect to pipe. Error: " << GetLastError() << std::endl;
            Sleep(1000);
        }
    }

    return 0;
}
```

**安装和使用说明**:

1. **编译服务程序**:
```batch
cl mouse_service.cpp /EHsc /Fe:MouseService.exe
```

2. **安装服务**:
```batch
sc create MouseSimulationService binPath= "完整路径\MouseService.exe" start= auto
sc start MouseSimulationService
```

3. **注意事项**:
- 服务程序需要以 SYSTEM 账户运行
- 需要适当的权限和桌面访问权限
- 建议在服务属性中设置"允许服务与桌面交互"
- 所有操作都会记录到 C:\MouseService.log
- 服务程序需要管理员权限安装和运行

4. **主要改进**:
- 添加了适当的桌面访问权限处理
- 使用命名管道进行通信
- 完整的服务生命周期管理
- 详细的日志记录
- 错误处理和异常恢复

5. **限制**:
- 由于 Windows 安全限制，某些鼠标操作可能在某些情况下不响应
- 需要正确配置服务权限
- 在某些 Windows 版本中可能需要额外的安全配置

这个版本的程序已经适配了 Windows 服务环境，但仍然需要注意 Windows 服务的各种限制和安全考虑。建议在实际部署前进行充分测试。
 


http://www.ppmy.cn/server/160643.html

相关文章

工业网口相机：如何通过调整网口参数设置，优化图像传输和网络性能，达到最大帧率

工业网口相机：如何通过调整网口参数设置，优化图像传输和网络性能，达到最大帧率

项目场景 工业相机是常用与工业视觉领域的常用专业视觉核心部件&#xff0c;拥有多种属性&#xff0c;是机器视觉系统中的核心部件&#xff0c;具有不可替代的重要功能。 工业相机已经被广泛应用于工业生产线在线检测、智能交通,机器视觉,科研,军事科学,航天航空等众多领域 …
阅读更多...
springBoot tomcat

springBoot tomcat

一、配置文件 server:#配置端口port: 9999tomcat: #对tomcat配置threads:max: 10 #最大的工作线程&#xff0c; 默认是200min-spare: 5 #最小工作线程, 默认是10accept-count: 200 #tomcat启动的线程达到最大值, 接受排队的请求个数,默认100max-connections: 2000 #最大连接数…
阅读更多...
cmake foreach 条件判断

cmake foreach 条件判断

格式 foreach(<loop_var> <items>)<commands> endforeach()其中<items>是由空格或空白分隔的项目列表。foreach和匹配的endforeach之间的所有命令都被记录下来而不被调用。一旦计算完endforeach&#xff0c;将为<items>中的每个项目调用一次记录…
阅读更多...
WebSocket知识点笔记(一)

WebSocket知识点笔记(一)

WebSocket ​ WebSocket是一种在单个TCP连接上进行全双工通信的协议。它使得客户端和服务端之间的消息传递更加高效&#xff0c;允许服务器主动向客户端推送数据。 一.WebSocket全双工通信 WebSocket提供了真正的双向通信&#xff0c;客户端和服务端可以同时发送和接收消息 …
阅读更多...
JDBC实验测试

JDBC实验测试

一、语言和环境 实现语言&#xff1a;Java。 环境要求&#xff1a;IDEA2023.3、JDK 17 、MySQL8.0、Navicat 16 for MySQL。 二、技术要求 该系统采用 SWING 技术配合 JDBC 使用 JAVA 编程语言完成桌面应用开发。 三、功能要求 某电商公司为了方便客服查看用户的订单信…
阅读更多...
解决conda create速度过慢的问题

解决conda create速度过慢的问题

问题 构建了docker容器 想在容器中创建conda环境&#xff0c;但是conda create的时候速度一直很慢 解决办法 宿主机安装的是anaconda 能正常conda create,容器里安装的是miniforge conda create的时候速度一直很慢&#xff0c;因为容器和宿主机共享网络了&#xff0c;宿主机…
阅读更多...
PHP语言的网络编程

PHP语言的网络编程

PHP语言的网络编程 网络编程是现代软件开发中不可或缺的一部分&#xff0c;尤其是在日益发展的互联网时代。PHP&#xff08;Hypertext Preprocessor&#xff09;是一种广泛使用的开源脚本语言&#xff0c;专门用于Web开发。它的灵活性、易用性以及强大的社区支持使得PHP在网络…
阅读更多...
Java连接TDengine和MySQL双数据源

Java连接TDengine和MySQL双数据源

git文件地址&#xff1a;项目首页 - SpringBoot连接TDengine和MySQL双数据源:SpringBoot连接TDengine和MySQL双数据源 - GitCode 1、yml配置 spring:datasource:druid:mysql:driver-class-name: com.mysql.cj.jdbc.Driverurl: jdbc:mysql://localhost:3306/testusername: roo…
阅读更多...
最新文章

Copyright @ 2022~2023