myvtm/Module/mod_chromium/processControl.cpp

#include "processControl.h"
#include "baseEx.h"




#if (defined _WIN32 || defined _WIN64)
#pragma comment(lib, "User32.lib")
typedef struct
{
	HWND hwndWindow; // 窗口句柄
	DWORD dwProcessID; // 进程ID
}EnumWindowsArg;

BOOL CALLBACK EnumWindowsProc(HWND hwnd, LPARAM lParam)
{
	EnumWindowsArg* pArg = (EnumWindowsArg*)lParam;
	DWORD dwProcessID = 0;
	// 通过窗口句柄取得进程ID
	::GetWindowThreadProcessId(hwnd, &dwProcessID);
	if (dwProcessID == pArg->dwProcessID)
	{
		pArg->hwndWindow = hwnd;
		// 找到了返回FALSE
		return FALSE;
	}
	// 没找到，继续找，返回TRUE
	return TRUE;
}
///< 通过进程ID获取窗口句柄
HWND GetWindowHwndByPID(DWORD dwProcessID)
{
	HWND hwndRet = NULL;
	EnumWindowsArg ewa;
	ewa.dwProcessID = dwProcessID;
	ewa.hwndWindow = NULL;
	EnumWindows(EnumWindowsProc, (LPARAM)&ewa);
	if (ewa.hwndWindow)
		hwndRet = ewa.hwndWindow;
	else
		hwndRet = NULL;
	return hwndRet;
}

std::pair<HANDLE, int> StartProcess(std::string program, std::string args, BOOL isEnum)
{
	const int tryTimes = 10;
	std::string runInfo = program + std::string(" ") + args;
	PROCESS_INFORMATION processInfo;
	STARTUPINFO startupInfo;
	::ZeroMemory(&startupInfo, sizeof(startupInfo));
	startupInfo.cb = sizeof(startupInfo);
	startupInfo.dwFlags = STARTF_USESHOWWINDOW;
	startupInfo.wShowWindow = SW_HIDE;
	if (::CreateProcess(NULL, const_cast<char*>(runInfo.c_str()), NULL, NULL, FALSE, 0, NULL, NULL, &startupInfo, &processInfo))
	{
		for (int i = 0; isEnum && i < tryTimes; i++)
		{
			Sleep(3000);
			auto processHwnd = GetWindowHwndByPID(processInfo.dwProcessId);
			if (NULL != processHwnd)
				break;
		}
	}
	else
		return std::make_pair(nullptr, 0);
	return std::make_pair(processInfo.hProcess, processInfo.dwProcessId);
}

std::pair<bool, HANDLE> assigntoJob(HANDLE process, int pid)
{
	//创建一个job内核对象  
	HANDLE hd = CreateJobObjectA(NULL, NULL);

	if (hd)
	{
		JOBOBJECT_EXTENDED_LIMIT_INFORMATION extLimitInfo;
		extLimitInfo.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
		auto retVal = SetInformationJobObject(hd, JobObjectExtendedLimitInformation, &extLimitInfo, sizeof(extLimitInfo));

		if (!retVal)
		{
			CloseHandle(hd);
			return std::make_pair(false, (HANDLE)NULL);
		}

		//insert the process into the job 
		if (AssignProcessToJobObject(hd, process))
			return std::make_pair(true, hd);
		else
		{
			DbgEx("AssignProcessToJobObject err! process: %d, %d", process, pid);
			return std::make_pair(false, (HANDLE)NULL);
		}
	}
	else
	{
		DbgEx("CreateJobObjectA err!");
		return std::make_pair(false, (HANDLE)NULL);
	}
}

std::tuple<bool, DWORD, HANDLE, HANDLE> startProcessInJob(std::string program, std::string args)
{
	PROCESS_INFORMATION processInfo;
	ZeroMemory(&processInfo, sizeof(processInfo));

	STARTUPINFO startupInfo;
	::ZeroMemory(&startupInfo, sizeof(startupInfo));
	startupInfo.cb = sizeof(startupInfo);
	startupInfo.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
	startupInfo.wShowWindow = SW_HIDE;

	BOOL retVal = false;
	if (args.length() == 0)
	{
		retVal = ::CreateProcessA(NULL, const_cast<char*>(program.c_str()), NULL, NULL, FALSE,
			CREATE_BREAKAWAY_FROM_JOB | DETACHED_PROCESS | HIGH_PRIORITY_CLASS, NULL, NULL, &startupInfo, &processInfo);
	}
	else
	{
		retVal = ::CreateProcessA(const_cast<char*>(program.c_str()), const_cast<char*>(args.c_str()), NULL, NULL, FALSE,
			CREATE_BREAKAWAY_FROM_JOB | DETACHED_PROCESS | HIGH_PRIORITY_CLASS, NULL, NULL, &startupInfo, &processInfo);
	}
	if (!processInfo.hProcess)
	{
		DbgEx("CreateProcess failed!, %s, %s", program.c_str(), args.c_str());
		return std::make_tuple(false, 0, (HANDLE)NULL, (HANDLE)NULL);
	}

	auto ret = assigntoJob(processInfo.hProcess, processInfo.dwProcessId);

	return std::make_tuple(ret.first, processInfo.dwProcessId, ret.second, processInfo.hProcess);
}

bool KillProcessById(DWORD pID)
{
	HANDLE Hwnd;
	bool ret = false;
	Hwnd = OpenProcess(PROCESS_TERMINATE | SYNCHRONIZE, 0, pID);
	if (Hwnd)
	{
		if (TerminateProcess(Hwnd, 0))
		{
			ret = true;
		}
	}
	return ret;
}
#else

#endif