远程桌面控制器-用c++实现 - 远程桌面 - 编程 - c++ - jdjwzx233 - 奇怪的知识 | jdjwzx233-Blog = jdjwzx233的博客 = 如期待奇迹发生，那唯有不停伸手去抓紧，去把握才行

写一个远程桌面控制器是一个非常复杂的任务，需要熟悉许多网络协议、图像处理技术以及用户界面设计等知识。这里给出的是一个基本的框架，你可以在此基础上进行扩展和完善。

首先，我们需要用到一些库来帮助我们实现远程桌面控制器。在这里，我们假设你使用的是 Windows 系统，并使用了以下几个库：

WinSock：用于实现网络通信。
GDI+：用于处理图像。
MFC：用于创建图形用户界面。

下面是使用这些库编写远程桌面控制器的基本步骤：

创建一个 MFC 应用程序。
使用 WinSock 库创建一个网络连接。
使用 GDI+ 库获取远程桌面的屏幕截图。
将屏幕截图显示在 MFC 窗口中。
为用户提供一组控制命令，例如鼠标移动、鼠标单击、键盘输入等。
使用 WinSock 库将用户的控制命令发送到远程桌面。

下面是使用这些库编写远程桌面控制器的示例代码：

#include <winsock2.h>
#include <gdiplus.h>
#include <afxwin.h> // 包含 MFC 的头文件

using namespace Gdiplus;

// 定义一个 Socket 类，用于封装网络通信相关的操作
class Socket
{
private:
	WSADATA m_wsaData;
	SOCKET m_sock;
	sockaddr_in m_serverAddr;

public:
	Socket() : m_sock(INVALID_SOCKET) {}
    // 初始化 WinSock 库
    bool Init()
    {
        if (WSAStartup(MAKEWORD(2, 2), &m_wsaData) != 0)
        {
            return false;
        }
        return true;
    }

    // 创建套接字
    bool Create(int af, int type, int protocol)
    {
        m_sock = socket(af, type, protocol);
        if (m_sock == INVALID_SOCKET)
        {
            return false;
        }
        return true;
    }

    // 连接到服务器
    bool Connect(const char* ip, unsigned short port)
    {
        m_serverAddr.sin_family = AF_INET;
        m_serverAddr.sin_port = htons(port);
        m_serverAddr.sin_addr.S_un.S_addr = inet_addr(ip);
        if (connect(m_sock, (sockaddr*)&m_serverAddr, sizeof(m_serverAddr)) == SOCKET_ERROR)
        {
            return false;
        }
        return true;
    }

    // 发送数据
    int Send(const char* buf, int len)
    {
        return send(m_sock, buf, len, 0);
    }

    // 接收数据
    int Receive(char* buf, int len)
    {
        return recv(m_sock, buf, len, 0);
    }

    // 关闭套接字
    void Close()
    {
        closesocket(m_sock);
        m_sock = INVALID_SOCKET;
    }

    // 清理 WinSock 库
    void Cleanup()
    {
        WSACleanup();
    }
};

// 定义一个 RemoteDesktop 类，用于控制远程桌面
class RemoteDesktop
{
private:
    Socket m_socket; // 用于网络通信的套接字
    Image* m_image; // 当前屏幕截图

public:
    RemoteDesktop() : m_image(NULL) {}
    // 连接到远续桌面服务器
    bool Connect(const char* ip, unsigned short port)
    {
        if (!m_socket.Init())
        {
            return false;
        }
        if (!m_socket.Create(AF_INET, SOCK_STREAM, IPPROTO_TCP))
        {
            return false;
        }
        if (!m_socket.Connect(ip, port))
        {
            return false;
        }
        return true;
    }
    // 断开与远程桌面服务器的连接
    void Disconnect()
    {
        m_socket.Close();
        m_socket.Cleanup();
        delete m_image;
        m_image = NULL;
    }

    // 获取远程桌面的屏幕截图
    bool GetScreenshot()
    {
        // 先发送获取屏幕截图的命令
        const char* cmd = "screenshot";
        m_socket.Send(cmd, strlen(cmd));

        // 接收屏幕截图的大小
        int size;
        m_socket.Receive((char*)&size, sizeof(size));

        // 分配内存空间，准备接收屏幕截图的数据
        char* data = new char[size];

        // 接收屏幕截图的数据
        int bytesReceived = 0;
        while (bytesReceived < size)
        {
            int count = m_socket.Receive(data + bytesReceived, size - bytesReceived);
            if (count <= 0)
            {
                delete[] data;
                return false;
            }
            bytesReceived += count;
        }

        // 将接收到的数据转换为 GDI+ 图像
        delete m_image;
        m_image = new Image(data, size);
        delete[] data;

        return true;
    }

    // 获取当前屏幕截图
    Image* GetImage() const
    {
        return m_image;
    }

    // 发送鼠标移动命令
    void MoveMouse(int x, int y)
    {
        // 封装命令格式，发送命令
        const char* cmd = "mouse move";
        m_socket.Send(cmd, strlen(cmd));
        m_socket.Send((char*)&x, sizeof(x));
        m_socket.Send((char*)&y, sizeof(y));
    }

    // 发送鼠标单击命令
    void ClickMouse(int x, int y)
    {
        // 封装命令格式，发送命令
        const char* cmd = "mouse click";
        m_socket.Send(cmd, strlen(cmd));
        m_socket.Send((char*)&x, sizeof(x));
        m_socket.Send((char*)&y, sizeof(y));
    }

    // 发送键盘输入命令
    void InputKey(int keyCode)
    {
        // 封装命令格式，发送命令
        const char* cmd = "key input";
        m_socket.Send(cmd, strlen(cmd));
        m_socket.Send((char*)&keyCode, sizeof(keyCode));
    }
};

// 定义一个 RemoteDesktopDialog 类，用于显示远程桌面的界面
class RemoteDesktopDialog : public CDialog
{
private:
    RemoteDesktop m_rd; // 用于控制远程桌面的对象

public:
    // 使用 MFC 对话框的基本操作
    RemoteDesktopDialog() : CDialog(IDD_DIALOG1) {}

protected:
    virtual void DoDataExchange(CDataExchange* pDX)
    {
        CDialog::DoDataExchange(pDX);
    }

public:
    // 连接到远程桌面服务器
    bool Connect(const char* ip, unsigned short port)
    {
        return m_rd.Connect(ip, port);
    }

    // 断开与远程桌面服务器的连接
    void Disconnect()
    {
        m_rd.Disconnect();
    }
protected:
    // 绘制远程桌面的界面
    afx_msg void OnPaint()
    {
        CPaintDC dc(this); // 用于绘制的设备上下文
        CRect rect;
        GetClientRect(&rect); // 获取对话框的客户区域
            // 获取屏幕截图，并绘制到界面上
        Image* image = m_rd.GetImage();
        if (image != NULL)
        {
            Graphics graphics(dc);
            graphics.DrawImage(image, rect);
        }
    }

    // 处理鼠标移动事件
    afx_msg void OnMouseMove(UINT nFlags, CPoint point)
    {
        m_rd.MoveMouse(point.x, point.y);
    }
    // 处理鼠标单击事件
    afx_msg void OnLButtonDown(UINT nFlags, CPoint point)
    {
        m_rd.ClickMouse(point.x, point.y);
    }

    // 处理键盘输入事件
    afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
    {
        m_rd.InputKey(nChar);
    }
    DECLARE_MESSAGE_MAP()
};

BEGIN_MESSAGE_MAP(RemoteDesktopDialog, CDialog)
    ON_WM_PAINT()
    ON_WM_MOUSEMOVE()
    ON_WM_LBUTTONDOWN()
    ON_WM_KEYDOWN()
END_MESSAGE_MAP()

int main()
{
    // 初始化 GDI+
    GdiplusStartupInput gdiplusStartupInput;
    ULONG_PTR gdiplusToken;
    GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
    // 创建对话框并运行
    RemoteDesktopDialog dlg;
    dlg.DoModal();

    // 清理 GDI+
    GdiplusShutdown(gdiplusToken);
    return 0;
}

在这段代码中，我们定义了三个类：Socket、RemoteDesktop 和 RemoteDesktopDialog。Socket 类封装了网络通信的相关操作，RemoteDesktop 类用于控制远程桌面，RemoteDesktopDialog 类用于显示远程桌面的界面。

使用这个远程桌面控制器的流程如下：

调用 Socket 类的 Init 函数初始化 WinSock 库。
调用 Socket 类的 Create 函数创建一个套接字。
调用 Socket 类的 Connect 函数连接到远程桌面服务器。
调用 RemoteDesktop 类的 GetScreenshot 函数获取远程桌面的屏幕截图。
调用 RemoteDesktop 类的 MoveMouse、ClickMouse 或 InputKey 函数发送控制命令。
重复步骤 4 和 5，实时更新远程桌面的屏幕截图并发送控制命令。
当远程桌面控制结束时，调用 RemoteDesktop 类的 Disconnect 函数断开与远程桌面服务器的连接，并调用 Socket 类的 Cleanup 函数清理 WinSock 库。

需要注意的是，这段代码使用了 MFC 库来绘制界面，因此需要在 Visual Studio 中创建一个 MFC 应用程序，并在对话框资源中添加一个对话框。然后将上面的代码放入主窗口类的 .cpp 文件中，并在 .h 文件中声明相应的消息映射函数。

以下是服务端代码：

#include <Windows.h>
#include <GdiPlus.h>
#include <winsock2.h>
#include<iostream>
#pragma comment(lib, "gdiplus.lib")
#pragma comment(lib, "ws2_32.lib")
using namespace std;
using namespace Gdiplus;

// 定义一个 Socket 类，用于封装网络通信相关的操作
class Socket
{
private:
	WSADATA m_wsaData;
	SOCKET m_sock;
	sockaddr_in m_serverAddr;
	sockaddr_in m_clientAddr;

public:
	Socket() : m_sock(INVALID_SOCKET) {}
    // 初始化 WinSock 库
    bool Init()
    {
        if (WSAStartup(MAKEWORD(2, 2), &m_wsaData) != 0)
        {
            return false;
        }
        return true;
    }

    // 创建套接字
    bool Create(int af, int type, int protocol)
    {
        m_sock = socket(af, type, protocol);
        if (m_sock == INVALID_SOCKET)
        {
            return false;
        }
        return true;
    }
    // 绑定套接字到本地地址和端口
    bool Bind(unsigned short port)
    {
        memset(&m_serverAddr, 0, sizeof(m_serverAddr));
        m_serverAddr.sin_family = AF_INET;
        m_serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
        m_serverAddr.sin_port = htons(port);
        if (bind(m_sock, (sockaddr*)&m_serverAddr, sizeof(m_serverAddr)) == SOCKET_ERROR)
        {
            return false;
        }
        return true;
    }
    // 监听套接字
    bool Listen(int backlog)
    {
        if (listen(m_sock, backlog) == SOCKET_ERROR)
        {
            return false;
        }
        return true;
    }

    // 接受客户端的连接
    bool Accept(Socket& client)
    {
        int addrLen = sizeof(m_clientAddr);
        client.m_sock = accept(m_sock, (sockaddr*)&m_clientAddr, &addrLen);
        if (client.m_sock == INVALID_SOCKET)
        {
            return false;
        }
        return true;
    }

    // 接收数据
    int Receive(char* buffer, int len)
    {
        return recv(m_sock, buffer, len, 0);
    }

    // 发送数据
    int Send(const char* buffer, int len)
    {
        return send(m_sock, buffer, len, 0);
    }

    // 关闭套接字
    void Close()
    {
        closesocket(m_sock);
        m_sock = INVALID_SOCKET;
    }

    // 清理 WinSock 库
    void Cleanup()
    {
        WSACleanup();
    }
};

// 定义一个 RemoteDesktopServer 类，用于提供远程桌面服务
class RemoteDesktopServer
{
private:
    Socket m_socket; // 用于网络通信的套接字

public:
    // 初始化远程桌面服务器
    bool Init(unsigned short port)
    {
        if (!m_socket.Init())
        {
            return false;
        }
        if (!m_socket.Create(AF_INET, SOCK_STREAM, IPPROTO_TCP))
        {
            return false;
        }
        if (!m_socket.Bind(port))
        {
            return false;
        }
        if (!m_socket.Listen(10))
        {
            return false;
        }
        return true;
    }
    // 运行远程桌面服务器
    void Run()
    {
        // 不断循环，接受客户端的连接
        while (true)
        {
            Socket client;
            if (!m_socket.Accept(client))
            {
                continue;
            }

            // 为客户端创建一个线程，用于处理客户端的请求
            HANDLE hThread = CreateThread(NULL, 0, ClientThreadProc, &client, 0, NULL);
            if (hThread == NULL)
            {
                client.Close();
                continue;
            }
            CloseHandle(hThread);
        }
    }
private:
    // 客户端线程的回调函数，用于处理客户端的请求
    static DWORD WINAPI ClientThreadProc(LPVOID lpParam)
    {
        Socket* pClient = (Socket*)lpParam;
        // 不断循环，处理客户端的请求
        while (true)
        {
            // 接收客户端的命令
            char cmd[256];
            int len = pClient->Receive(cmd, sizeof(cmd));
            if (len <= 0)
            {
                break;
            }

            // 根据命令类型执行相应的操作
            if (strcmp(cmd, "screenshot") == 0)
            {
                // 处理屏幕截图请求
                HandleScreenshotRequest(*pClient);
            }
            else if (strcmp(cmd, "mouse move") == 0)
            {
                // 处理鼠标移动请求
                int x, y;
                pClient->Receive((char*)&x, sizeof(x));
                pClient->Receive((char*)&y, sizeof(y));
                HandleMouseMoveRequest(x, y);
            }
            else if (strcmp(cmd, "mouse click") == 0)
            {
                // 处理鼠标单击请求
                int x, y;
                pClient->Receive((char*)&x, sizeof(x));
                pClient->Receive((char*)&y, sizeof(y));
                HandleMouseClickRequest(x, y);
            }
            else if (strcmp(cmd, "key input") == 0)
            {
                // 处理键盘输入请求
                char key;
                pClient->Receive(&key, sizeof(key));
                HandleKeyInputRequest(key);
            }
            else
            {
                break;
            }
        }
        // 关闭客户端的套接字
        pClient->Close();
        delete pClient;
        return 0;
    }

    // 处理屏幕截图请求
    static void HandleScreenshotRequest(Socket& client)
    {
        // 获取屏幕的宽高
        int width = GetSystemMetrics(SM_CXSCREEN);
        int height = GetSystemMetrics(SM_CYSCREEN);

        // 创建内存 DC
        HDC hdcMem = CreateCompatibleDC(NULL);
        if (hdcMem == NULL)
        {
            return;
        }

        // 创建位图
        HBITMAP hbm = CreateCompatibleBitmap(GetDC(NULL), width, height);
        if (hbm == NULL)
        {
            DeleteDC(hdcMem);
            return;
        }

        // 将位图选入内存 DC
        HBITMAP hbmOld = (HBITMAP)SelectObject(hdcMem, hbm);
        if (hbmOld == NULL)
        {
            DeleteObject(hbm);
            DeleteDC(hdcMem);
            return;
        }

        // 将屏幕拷贝到内存 DC
        if (!BitBlt(hdcMem, 0, 0, width, height, GetDC(NULL), 0, 0, SRCCOPY))
        {
            SelectObject(hdcMem, hbmOld);
            DeleteObject(hbm);
            DeleteDC(hdcMem);
            return;
        }

        // 将内存 DC 的图像保存到缓冲区
        BITMAPINFOHEADER bih;
        memset(&bih, 0, sizeof(bih));
        bih.biSize = sizeof(bih);
        bih.biWidth = width;
        bih.biHeight = -height;
        bih.biPlanes = 1;
        bih.biBitCount = 24;
        bih.biCompression = BI_RGB;
        BYTE* pBuf = NULL;
        HBITMAP hbmDib = CreateDIBSection(hdcMem, (BITMAPINFO*)&bih, DIB_RGB_COLORS, (void**)&pBuf, NULL, 0);
        if (hbmDib == NULL)
        {
            SelectObject(hdcMem, hbmOld);
            DeleteObject(hbm);
            DeleteDC(hdcMem);
            return;
        }
        // 将内存 DC 的图像复制到位图中
        if (!SelectObject(hdcMem, hbmDib))
        {
            DeleteObject(hbmDib);
            SelectObject(hdcMem, hbmOld);
            DeleteObject(hbm);
            DeleteDC(hdcMem);
            return;
        }
        // 将位图的图像转换为 JPEG 格式并发送到客户端
        if (!SendScreenshot(client, pBuf, width, height))
        {
            DeleteObject(hbmDib);
            SelectObject(hdcMem, hbmOld);
            DeleteObject(hbm);
            DeleteDC(hdcMem);
            return;
        }

        // 清理资源
        DeleteObject(hbmDib);
        SelectObject(hdcMem, hbmOld);
        DeleteObject(hbm);
        DeleteDC(hdcMem);
    }

    // 将位图的图像转换为 JPEG 格式并发送到客户端
    static bool SendScreenshot(Socket& client, BYTE* pBuf, int width, int height)
    {
        // 初始化 GDI+
        GdiplusStartupInput gdiplusStartupInput;
        ULONG_PTR gdiplusToken;
        GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);

        // 将位图的图像转换为 JPEG 格式
        Bitmap bmp(width, height, width * 3, PixelFormat24bppRGB, pBuf);
        CLSID clsid;
        GetEncoderClsid(L"image/jpeg", &clsid);
        IStream* pStream = NULL;
        bmp.Save(L"screenshot.jpg", &clsid, NULL);
        if (CreateStreamOnHGlobal(NULL, TRUE, &pStream) != S_OK)
        {
            GdiplusShutdown(gdiplusToken);
            return false;
        }
        bmp.Save(pStream, &clsid, NULL);
        HGLOBAL hGlobal = NULL; // 修改为 HGLOBAL 类型
        if (GetHGlobalFromStream(pStream, &hGlobal) != S_OK) // 修改为 HGLOBAL 类型
        {
            pStream->Release();
            GdiplusShutdown(gdiplusToken);
            return false;
        }
        ULONG cbSize = GlobalSize(hGlobal); // 修改为 HGLOBAL 类型
        BYTE* pJpegBuf = (BYTE*)GlobalLock(hGlobal); // 修改为 HGLOBAL 类型
        if (pJpegBuf == NULL)
        {
            pStream->Release();
            GdiplusShutdown(gdiplusToken);
            return false;
        }
        LARGE_INTEGER li;
        li.QuadPart = 0;
        if (pStream->Seek(li, STREAM_SEEK_SET, NULL) != S_OK)
        {
            GlobalFree(pJpegBuf);
            pStream->Release();
            GdiplusShutdown(gdiplusToken);
            return false;
        }
        if (pStream->Read(pJpegBuf, cbSize, NULL) != S_OK)
        {
            GlobalFree(pJpegBuf);
            pStream->Release();
            GdiplusShutdown(gdiplusToken);
            return false;
        }
        pStream->Release();
        GdiplusShutdown(gdiplusToken);
        // 将 JPEG 数据的长度发送到客户端
        if (client.Send((char*)&cbSize, sizeof(cbSize)) <= 0)
        {
            GlobalFree(pJpegBuf);
            return false;
        }

        // 将 JPEG 数据发送到客户端
        if (client.Send((char*)pJpegBuf, cbSize) <= 0)
        {
            GlobalFree(pJpegBuf);
            return false;
        }

        // 清理资源
        GlobalFree(pJpegBuf);
        return true;
    }

    // 获取图像编码器的 CLSID
    static void GetEncoderClsid(const WCHAR* format, CLSID* pClsid)
    {
        UINT num = 0, size = 0;
        GetImageEncodersSize(&num, &size);
        if (size == 0)
        {
            return;
        }
        ImageCodecInfo* pImageCodecInfo = (ImageCodecInfo*)malloc(size);
        if (pImageCodecInfo == NULL)
        {
            return;
        }
        GetImageEncoders(num, size, pImageCodecInfo);
        for (UINT i = 0; i < num; ++i)
        {
            if (wcscmp(pImageCodecInfo[i].MimeType, format) == 0)
            {
                *pClsid = pImageCodecInfo[i].Clsid;
                free(pImageCodecInfo);
                return;
            }
        }
        free(pImageCodecInfo);
    }
    // 处理鼠标移动请求
    static void HandleMouseMoveRequest(int x, int y)
    {
        // 获取屏幕的宽高
        int width = GetSystemMetrics(SM_CXSCREEN);
        int height = GetSystemMetrics(SM_CYSCREEN);

        // 计算相对于屏幕的坐标
        double fx = (double)x / 65535.0;
        // 移动鼠标
        SetCursorPos(x, y);
    }

    // 处理鼠标单击请求
    static void HandleMouseClickRequest(int x, int y)
    {
        // 获取屏幕的宽高
        int width = GetSystemMetrics(SM_CXSCREEN);
        int height = GetSystemMetrics(SM_CYSCREEN);

        // 计算相对于屏幕的坐标
        double fx = (double)x / 65535.0;
        double fy = (double)y / 65535.0;
        int cx = (int)(fx * width);
        int cy = (int)(fy * height);

        // 移动鼠标
        SetCursorPos(cx, cy);

        // 发送鼠标左键单击消息
        INPUT input;
        memset(&input, 0, sizeof(input));
        input.type = INPUT_MOUSE;
        input.mi.dwFlags = MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP;
        SendInput(1, &input, sizeof(input));
    }

    // 处理键盘输入请求
    static void HandleKeyInputRequest(char key)
    {
        // 获取键盘的输入模式
        HKL layout = GetKeyboardLayout(0);
        UINT vk = MapVirtualKeyExA(VkKeyScanExA(key, layout), 0, layout);

        // 发送键盘输入消息
        INPUT input;
        memset(&input, 0, sizeof(input));
        input.type = INPUT_KEYBOARD;
        input.ki.wVk = vk;
        SendInput(1, &input, sizeof(input));
    }
private:
    Socket m_socket; // 监听套接字
};

int main()
{
    RemoteDesktopServer server;
    if (!server.Init(5555))
    {
        cout<<"启动服务器失败！"<<endl;
        return 1;
    }
    server.Run();
    return 0;
}

希望这些代码能帮到你！

奇怪的知识 jdjwzx233 c++ 编程信息技术远程桌面控制器 WinSock GDI+ MFC

用c++写图像界面软件(QT)

将ChatGPT部署到网站上