守护进程的开发

所谓守护进程，顾名思义是通过另一个进程对某个重要的进程进行保护，防止被保护进程异常退出，与看门狗功能类似。编写此类功能，思路非常简单，首先我们需要一个定时任务对所有的进程进行扫描，然后核对需要守护的进程的相关信息如进程名，是否在系统进程列表中，如果不在则表示进程已经退出，需要通过编码方式启动被守护进程。

废话不多说，直接上代码：

首先贴上常用的线程操作工具类

#include <windows.h>

class ThreadUtils
{
public:

/** @struct ThreadUtils::Context<T>
*  @brief  线程参数上下文
*/
template<class T>
struct Context
{
T* owner;                   ///<*线程函数所属类指针
ThreadUtils* caller;        ///<*线程函数的调用者
void (T::*ThreadProc)();    ///<*类成员函数
};

template<class T>
static DWORD __stdcall s_Proc(LPVOID param)
{
if (param)
{
Context<T>* pCon = reinterpret_cast<Context<T>*>(param);
T* pType = reinterpret_cast<T*>(pCon->owner);
if (pType)
{
(pType->*(pCon->ThreadProc))();///<*调用类成员函数
}
delete pCon;
}
return 0;;
}

public:
ThreadUtils()
{
m_thread = NULL;
}
~ThreadUtils(void)
{
wait();
}

template<class T>
bool call(T* pClass, void (T::*ThreadProc)())
{
wait();
Context<T>* pcon = new(std::nothrow) Context<T>;
if (NULL == pcon)
{
return false;
}
pcon->owner = pClass;
pcon->ThreadProc = ThreadProc;
pcon->caller = this;
return 0 == CreateThread(NULL, 0, s_Proc<T>, pcon, 0, NULL);
}

void wait()
{
if (m_thread)
{
WaitForSingleObject(m_thread, 5000);
m_thread = NULL;
}
}

private:
HANDLE m_thread;
};

然后看看守护进程的管理类

class CProcessDeamon
{
public:
static CProcessDeamon* Instance()
{
static CProcessDeamon s_psDeamon;
return &s_psDeamon;
}

~CProcessDeamon();
/** @fn  bool CProcessDeamon::StartDeamonProcess(const std::string& strProcessName, const std::string& cmdLine)
*  @brief 开启进程守护
*  @param strProcessName[in] 进程名字，系统进程输入short name即可，如iexplore.exe。
*  @param cmdLine[in] 进程所需参数
*  @return 成功：true 失败：false
*/
bool StartDeamonProcess(const std::string& strProcessName, const std::string& cmdLine);

/** @fn  bool CProcessDeamon::StopDeamonProcess()
*  @brief 结束进程守护
*  @return
*/
void StopDeamonProcess();

private:
CProcessDeamon();

/// 枚举系统当前所有进程信息
void EnumProcessInfo(std::vector<std::string>& processList);

/// 进程守护
void DeamonProcess();
private:
ThreadUtils m_threadHelper;
HANDLE m_hExitSignal;
std::string m_strProcessName;
std::string m_cmdLine;
};

#include <stdio.h>
#include "DeamonProcess.h"
#include <tlhelp32.h>
#include <algorithm>
#include <ShellAPI.h>

#define MAX_BUF_SIZE 512

bool CProcessDeamon::StartDeamonProcess( const std::string& strProcessName, const std::string& cmdLine )
{
m_strProcessName = strProcessName;
m_cmdLine = cmdLine;

return m_threadHelper.call(this, &CProcessDeamon::DeamonProcess);
}

void CProcessDeamon::StopDeamonProcess()
{
m_strProcessName.clear();
m_cmdLine.clear();
if (NULL != m_hExitSignal)
{
SetEvent(m_hExitSignal);
}
m_threadHelper.wait();
m_hExitSignal = NULL;
}

void CProcessDeamon::EnumProcessInfo( std::vector<std::string>& processList )
{
// 定义进程信息结构
PROCESSENTRY32 pe32 = {sizeof(pe32)} ;

// 创建系统当前进程快照
HANDLE hProcessShot = CreateToolhelp32Snapshot ( TH32CS_SNAPPROCESS, 0 ) ;
if ( hProcessShot == INVALID_HANDLE_VALUE )
return  ;

// 循环枚举进程信息
char szBuf[MAX_BUF_SIZE] = {0} ;
if ( Process32First ( hProcessShot, &pe32 ) )
{
do {
processList.push_back(pe32.szExeFile);
}while ( Process32Next ( hProcessShot, &pe32 ) ) ;
}

CloseHandle ( hProcessShot ) ;
}

CProcessDeamon::CProcessDeamon()
{
m_hExitSignal = NULL;
}

CProcessDeamon::~CProcessDeamon()
{
StopDeamonProcess();
}

void CProcessDeamon::DeamonProcess()
{
if (m_strProcessName.empty())
{
return;
}

if (NULL == m_hExitSignal)
{
m_hExitSignal = CreateEvent(NULL, FALSE, FALSE, NULL);
}
while (WAIT_OBJECT_0 != WaitForSingleObject(m_hExitSignal, 10000))
{
std::vector<std::string> plist;
EnumProcessInfo(plist);
if (plist.empty())
{
continue;
}
std::vector<std::string>::iterator it = std::find(plist.begin(), plist.end(), m_strProcessName);
if (it != plist.end())
{
// 进程存在，不处理
continue;
}

// 进程被杀掉，重启一下
ShellExecute(0, "open", m_strProcessName.c_str(), m_cmdLine.c_str(), NULL, SW_SHOW);
//::Sleep(30000);
}
}

最后我们来测试一把：

#include "DeamonProcess.h"
#include <stdio.h>
#include <iostream>
using namespace std;

int main(int argc, char* argv[])
{
CProcessDeamon::Instance()->StartDeamonProcess("iexplore.exe", "www.baidu.com");
cout<<"开启守护成功"<<endl;
cout<<"回车关闭守护"<<endl;
getchar();
CProcessDeamon::Instance()->StopDeamonProcess();
getchar();
return 0;
}