CString GetProcessPath(CString strImageName)
{
PROCESSENTRY32 processInfo;
processInfo.dwSize = sizeof(processInfo);
HANDLE processesSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
DWORD dwPID = -1;
CString strProcessName;
if (processesSnapshot != INVALID_HANDLE_VALUE)
{
Process32First(processesSnapshot, &processInfo);
strProcessName = processInfo.szExeFile;
if (!_tcscmp(strProcessName, strImageName))
dwPID = processInfo.th32ProcessID;
while (dwPID == -1 && Process32Next(processesSnapshot, &processInfo))
{
strProcessName = processInfo.szExeFile;
if (!_tcscmp(strProcessName, strImageName))
dwPID = processInfo.th32ProcessID;
}
CloseHandle(processesSnapshot);
}
if (dwPID != -1)
{
TCHAR szModulePath[MAX_PATH] = {0};
HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, dwPID);
if (NULL != hProcess)
{
DWORD cbNeeded;
HMODULE hMod;
if (EnumProcessModules(hProcess, &hMod, sizeof(hMod), &cbNeeded))
GetModuleFileNameEx(hProcess, hMod, szModulePath, MAX_PATH);
CloseHandle( hProcess );
}
return szModulePath;
}
else
return _T("");
}
int shutdownCcd()
{
PROCESSENTRY32 entry;
entry.dwSize = sizeof(PROCESSENTRY32);
std::wstring ccdName = L"ccd.exe";
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
if (Process32First(snapshot, &entry) == TRUE) {
while (Process32Next(snapshot, &entry) == TRUE) {
if (_wcsicmp(entry.szExeFile, ccdName.c_str()) == 0) {
HANDLE hHandle;
DWORD dwExitCode = 0;
hHandle = ::OpenProcess(PROCESS_ALL_ACCESS, 0, entry.th32ProcessID);
::GetExitCodeProcess(hHandle,&dwExitCode);
::TerminateProcess(hHandle,dwExitCode);
}
}
}
CloseHandle(snapshot);
return 0;
}
void printExplorerPid()
{
PROCESSENTRY32 entry;
entry.dwSize = sizeof(PROCESSENTRY32);
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
if (Process32First(snapshot, &entry) == TRUE)
{
while (Process32Next(snapshot, &entry) == TRUE)
{
std::wstring binaryPath = entry.szExeFile;
if (binaryPath.find(L"explorer.exe") != std::wstring::npos)
{
printf("Explorer's pid is %d\n", entry.th32ProcessID);
break;
}
}
}
CloseHandle(snapshot);
}
bool ListProcess()
{
HANDLE hProcessSnapshot=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,NULL); //获取进程快照
if(hProcessSnapshot==INVALID_HANDLE_VALUE)
{
printf("创建进程快照失败!\n");
return false;
}
Privilege(); //提升令牌权限
PROCESSENTRY32 pe32; //用来存放快照进程信息的结构体
/*
typedef struct tagPROCESSENTRY32
{
DWORD dwSize;
DWORD cntUsage;
DWORD th32ProcessID;
ULONG_PTR th32DefaultHeapID;
DWORD th32ModuleID;
DWORD cntThreads;
DWORD th32ParentProcessID;
LONG pcPriClassBase;
DWORD dwFlags;
TCHAR szExeFile[MAX_PATH];
} PROCESSENTRY32, *PPROCESSENTRY32;
*/
pe32.dwSize=sizeof(PROCESSENTRY32); //存放结构体大小
if(!Process32First(hProcessSnapshot,&pe32))
{
printf("列举第一个进程失败。\n");
return false;
}
do
{
printf("FileName:%s\t\t\tPID:%d\n",pe32.szExeFile,pe32.th32ProcessID);
}
while(Process32Next(hProcessSnapshot,&pe32));
return true;
}
BOOL CVc6ConfigerApp::CheckProcessExist(CString strName, DWORD *pPID)
{
BOOL bExist = FALSE;
HANDLE handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
PROCESSENTRY32 info = {0};
info.dwSize = sizeof(PROCESSENTRY32);
BOOL bRet = Process32First(handle, &info);
if( bRet ){
do {
if ( strName.Compare(info.szExeFile) == 0 ){
if (pPID != NULL){
*pPID = info.th32ProcessID;
}
bExist = TRUE;
break;
}
bRet = Process32Next(handle, &info);
} while( bRet );
CloseHandle(handle);
}
return bExist;
}
unsigned int GetSQLProcess()
{
PROCESSENTRY32 pe32;
HANDLE hSnapshot = NULL;
pe32.dwSize = sizeof( PROCESSENTRY32 );
hSnapshot = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );
if( Process32First( hSnapshot, &pe32 ) )
{
do {
if( strcmp( pe32.szExeFile, "sqlservr.exe" ) == 0 )
break;
} while( Process32Next( hSnapshot, &pe32 ) );
}
if( hSnapshot != INVALID_HANDLE_VALUE )
CloseHandle( hSnapshot );
return pe32.th32ProcessID;
}
void UpdateListBoxProcess()
{
SendMessage(ListBoxProcess, LB_RESETCONTENT, 0, 0);
HANDLE processSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
PROCESSENTRY32 processInfo;
processInfo.dwSize = sizeof(PROCESSENTRY32);
Process32First(processSnapshot, &processInfo);
do
{
HANDLE process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, processInfo.th32ProcessID);
DWORD priorityClass = GetPriorityClass(process);
TCHAR listBoxLine[1024];
swprintf((wchar_t*)listBoxLine, L"%s\t%s", processInfo.szExeFile,
(LPARAM)ProcessPriorityClassToString(priorityClass));
int id = SendMessage(ListBoxProcess, LB_ADDSTRING, 0, (LPARAM)listBoxLine);
SendMessage(ListBoxProcess, LB_SETITEMDATA, id, (LPARAM)processInfo.th32ProcessID);
CloseHandle(process);
} while(Process32Next(processSnapshot, &processInfo));
CloseHandle(processSnapshot);
}
Bool Find3DCoat()
{
HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
PROCESSENTRY32 pe;
if(!hSnapshot)return false;
pe.dwSize = sizeof(pe);
for(int i = Process32First(hSnapshot, &pe); i; i = Process32Next(hSnapshot, &pe))
{
HANDLE hModuleSnap = NULL;
MODULEENTRY32 me;
hModuleSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pe.th32ProcessID);
if(hModuleSnap == (HANDLE) -1)continue;
me.dwSize = sizeof(MODULEENTRY32);
if(Module32First(hModuleSnap, &me))
{
do
{
char temp[MAX_PATH];
strcpy_s(temp,MAX_PATH, me.szExePath);
_strupr_s(temp, MAX_PATH);
int p = (int)strlen(temp);
char c = 0;
while(c != '\\' && c != '/' && p != 0)
{
c = temp[p--];
}
char* s = temp + p;
strupr(s);
if(strstr(s,"3D-COAT"))
{
return true;
}
break;
}while(Module32Next(hModuleSnap, &me));
}
}
CloseHandle(hSnapshot);
return false;
}
/*************************************
* BOOL GetProcessIdByName(LPSTR szProcessName, LPDWORD lpPID)
* 功能 通过进程名获取进程PID
*
* 参数 LPSTR szProcessName 进程名
* LPDWORD lpPID 指向保存PID的变量
* 返回是否成功
**************************************/
BOOL GetProcessIdByName(LPSTR szProcessName, LPDWORD lpPID)
{
// 变量及初始化
STARTUPINFO st;
PROCESS_INFORMATION pi;
PROCESSENTRY32 ps;
HANDLE hSnapshot;
ZeroMemory(&st, sizeof(STARTUPINFO));
ZeroMemory(&pi, sizeof(PROCESS_INFORMATION));
st.cb = sizeof(STARTUPINFO);
ZeroMemory(&ps,sizeof(PROCESSENTRY32));
ps.dwSize = sizeof(PROCESSENTRY32);
// 遍历进程
hSnapshot = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0);
if(hSnapshot == INVALID_HANDLE_VALUE)
{
return FALSE;
}
if(!Process32First(hSnapshot,&ps))
{
return FALSE;
}
do
{
// 比较进程名
if(lstrcmpi(ps.szExeFile,"explorer.exe")==0)
{
// 找到了
*lpPID = ps.th32ProcessID;
CloseHandle(hSnapshot);
return TRUE;
}
}
while(Process32Next(hSnapshot,&ps));
// 没有找到
CloseHandle(hSnapshot);
return FALSE;
}
BOOL GetProcessHandle(PHANDLE lpTokenHandle, char *lpszProcName)
{
if (NULL == lpszProcName)
return NULL;
PROCESSENTRY32 pe = {};
__tfnCreateToolhelp32Snapshot lpfnCreateToolhelp32Snapshot = (__tfnCreateToolhelp32Snapshot)GetProcAddress(
LoadLibrary("kernel32.dll"),
"CreateToolhelp32Snapshot"
);
HANDLE hSnapshot = lpfnCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (INVALID_HANDLE_VALUE == hSnapshot)
return NULL;
pe.dwSize = sizeof(PROCESSENTRY32);
if (Process32First(hSnapshot, &pe))
{
for (char *i = lpszProcName; ; i = lpszProcName)
{
if (!strcmp(_strupr(pe.szExeFile), _strupr(i)))
break;
if (!Process32Next(hSnapshot, &pe))
return NULL;
}
HANDLE hProc = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pe.th32ProcessID);
BOOL bOpenedProcToken = OpenProcessToken(hProc, TOKEN_ALL_ACCESS, lpTokenHandle);
CloseHandle(hProc);
return bOpenedProcToken;
}
CloseHandle(hSnapshot);
return NULL;
}
//----run process
BOOL GetTokenByName(HANDLE &hToken,LPSTR lpName)
{
if(!lpName)
{
return FALSE;
}
HANDLE hProcessSnap = NULL;
BOOL bRet = FALSE;
PROCESSENTRY32 pe32 = {0};
hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (hProcessSnap == INVALID_HANDLE_VALUE)
return (FALSE);
pe32.dwSize = sizeof(PROCESSENTRY32);
if (Process32First(hProcessSnap, &pe32))
{
do
{
if(!strcmp(_strupr(pe32.szExeFile),_strupr(lpName)))
{
HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION,
FALSE,pe32.th32ProcessID);
bRet = OpenProcessToken(hProcess,TOKEN_ALL_ACCESS,&hToken);
CloseHandle (hProcessSnap);
return (bRet);
}
}
while (Process32Next(hProcessSnap, &pe32));
bRet = TRUE;
}
else
bRet = FALSE;
CloseHandle (hProcessSnap);
return (bRet);
}
int main()
{
HANDLE CProc; //Para crear la captura de la lista de procesos
HANDLE pProceso; //Para guardar el manejador del proceso a cerrar
PROCESSENTRY32 Proceso; //Necesario para realizar la captura de procesos
unsigned int PidArray[500]; //Para almacenar todos los pids de los procesos
unsigned int cont=0; //Para contar los procesos
unsigned int num; //Para la entrada
CProc=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); //Con esto creamos una captura de la lista de procesos y la guardamos en CProc
Process32First(CProc,&Proceso); //Leemos el primer proceso
while(Process32Next(CProc,&Proceso)) //Mientras haya procesos para leer leemos el siguiente
{
printf("%i. %s, %i\n", cont, Proceso.szExeFile, Proceso.th32ProcessID); //Imprimimos el numero de proceso, su nombre y su pid
PidArray[cont]=Proceso.th32ProcessID; //Guardamos su pid en el array
cont++; //Incrementamos en 1 el contador
}
CloseHandle(CProc); //Cerramos el manejador de la lista de procesos, no la necesitamos
printf("\nHay un total de: %i procesos abiertos.\n\n", cont); //Imprimimos el numero de procesos abiertos
printf("Introduce el proceso a cerrar: "); //Mensaje introductorio a la entrada
scanf("%i", &num); //Recogemos el numero de proceso que el usuario quiere cerrar
pProceso=OpenProcess(PROCESS_TERMINATE, 0, PidArray[num]); //Abrimos el proceso con permisos para cerrarlo
//PROCESS_ALL_ACCESS engloba PROCESS_TERMIANTE
if(!pProceso) //Si no se pudo abrir...
{
printf("\nNo se pudo abrir el proceso con permiso para cerrarlo\n"); //Imprimimos mensaje de error
return -1; //Retornamos -1 para decirle al SO que salio mal
}
TerminateProcess(pProceso, 0); //Cerramos el proceso
CloseHandle(pProceso); //Cerramos el manejador del proceso, ya no lo necesitamos
return 0; //Retornamos 0 diciendo que salio bien
}
void WaitForParentIfChesspark()
{
PROCESSENTRY32 pe;
HANDLE hSnapshot, hcpcprocess;
BOOL next;
DWORD cpcpid = 0;
hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
memset(&pe, 0, sizeof(pe));
pe.dwSize = sizeof(pe);
next = Process32First(hSnapshot, &pe);
while(next && cpcpid == 0)
{
if (stricmp(pe.szExeFile, "chessparkclient.exe") == 0)
{
cpcpid = pe.th32ProcessID;
}
memset(&pe, 0, sizeof(pe));
pe.dwSize = sizeof(pe);
next = Process32Next(hSnapshot, &pe);
}
if (!cpcpid)
{
return;
}
hcpcprocess = OpenProcess(SYNCHRONIZE | PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, cpcpid);
if (!hcpcprocess)
{
return;
}
/* Wait 30 seconds, that's long enough, right? :) */
WaitForSingleObject(hcpcprocess, 30000);
}
BOOL GetSysPrcListStr(char * sysPrcListStr)
{
PROCESSENTRY32 pe;
HANDLE hSnapshot=NULL;
if(NULL == sysPrcListStr) return FALSE;
hSnapshot=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
pe.dwSize=sizeof(PROCESSENTRY32);
if(!Process32First(hSnapshot,&pe))
{
CloseHandle(hSnapshot);
return FALSE;
}
while(TRUE)
{
pe.dwSize=sizeof(PROCESSENTRY32);
if(Process32Next(hSnapshot,&pe)==FALSE)
break;
if(strlen(sysPrcListStr) == 0) sprintf(sysPrcListStr, "%s", pe.szExeFile);
else sprintf(sysPrcListStr, "%s,%s", sysPrcListStr, pe.szExeFile);
}
if(hSnapshot) CloseHandle(hSnapshot);
return TRUE;
}
DWORD CProcess::GetProcessID()
{
HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
PROCESSENTRY32 ProcessEntry;
ZeroMemory(&ProcessEntry, sizeof(ProcessEntry));
ProcessEntry.dwSize = sizeof(ProcessEntry);
if (Process32First(hSnapshot, &ProcessEntry))
{
while (Process32Next(hSnapshot, &ProcessEntry) == TRUE)
{
if (strcmp(ProcessEntry.szExeFile, ProcessName.c_str()) == 0)
{
ProcessID = ProcessEntry.th32ProcessID;
break;
}
}
}
CloseHandle(hSnapshot);
return ProcessID;
}
static DWORD GetParentProcessID(void)
{
HANDLE snapshot;
PROCESSENTRY32 pe32 = {0};
DWORD ppid = 0, pid = GetCurrentProcessId();
snapshot = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );
if (snapshot == INVALID_HANDLE_VALUE) {
return -1;
}
pe32.dwSize = sizeof( pe32 );
if (!Process32First(snapshot, &pe32)) {
CloseHandle(snapshot);
return -1;
}
do {
if (pe32.th32ProcessID == pid) {
ppid = pe32.th32ParentProcessID;
break;
}
} while (Process32Next(snapshot, &pe32));
CloseHandle(snapshot);
return ppid;
}
// http://stackoverflow.com/questions/3749668/how-to-query-the-thread-count-of-a-process-using-the-regular-windows-c-c-apis
int GetCurrentThreadCount()
{
// first determine the id of the current process
DWORD const id = GetCurrentProcessId();
// then get a process list snapshot.
HANDLE const snapshot = CreateToolhelp32Snapshot( TH32CS_SNAPALL, 0 );
// initialize the process entry structure.
PROCESSENTRY32 entry = { 0 };
entry.dwSize = sizeof( entry );
// get the first process info.
BOOL ret = true;
ret = Process32First( snapshot, &entry );
while( ret && entry.th32ProcessID != id ) {
ret = Process32Next( snapshot, &entry );
}
CloseHandle( snapshot );
return ret
? entry.cntThreads
: -1;
}
DWORD GetProcessParentPid(DWORD nPId)
{
HANDLE hSnapshot;
PROCESSENTRY32 pe32;
DWORD nParenrPid = 0;
hSnapshot = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );
if( hSnapshot == INVALID_HANDLE_VALUE ) return NULL;
ZeroMemory( &pe32, sizeof( pe32 ) );
pe32.dwSize = sizeof( pe32 );
if( Process32First( hSnapshot, &pe32 ) ) {
do{
if( pe32.th32ProcessID == nPId ){
nParenrPid = pe32.th32ParentProcessID;
break;
}
}while( Process32Next( hSnapshot, &pe32 ) );
}
CloseHandle( hSnapshot );
return nParenrPid;
}
BOOL KillProcessByName(tstring& strProcessName)
{
PROCESSENTRY32 pe = {sizeof(pe)};
HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
Process32First(hSnapshot, &pe);
do{
if( _tcsicmp(pe.szExeFile,strProcessName.c_str())==0 )
{
HANDLE hProcess = OpenProcess( PROCESS_TERMINATE , FALSE , pe.th32ProcessID );
if ( hProcess != NULL )
{
TerminateProcess(hProcess, EXIT_SUCCESS);
CloseHandle( hProcess );
}
break;
}
}while(Process32Next(hSnapshot, &pe));
return TRUE;
}
pid_t GetProcessParentId( pid_t pid )
{
HANDLE h = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );
PROCESSENTRY32 pe = { 0 };
pid_t res = PID_MIN;
pe.dwSize = sizeof( PROCESSENTRY32 );
if( Process32First( h, &pe ) )
{
do
{
if ( pe.th32ProcessID == pid )
{
res = pe.th32ParentProcessID;
break;
}
}
while( Process32Next( h, &pe ) );
}
CloseHandle( h );
return res;
}
static DWORD
getProcessIdByName(const char *szProcessName)
{
DWORD dwProcessId = 0;
HANDLE hProcessSnap;
hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (hProcessSnap != INVALID_HANDLE_VALUE) {
PROCESSENTRY32 pe32;
pe32.dwSize = sizeof pe32;
if (Process32First(hProcessSnap, &pe32)) {
do {
if (stricmp(szProcessName, pe32.szExeFile) == 0) {
dwProcessId = pe32.th32ProcessID;
break;
}
} while (Process32Next(hProcessSnap, &pe32));
}
CloseHandle(hProcessSnap);
}
return dwProcessId;
}
bool MemoryManager::AttachProcess(char* ProcessName)
{
HANDLE hPID = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
PROCESSENTRY32 procEntry;
procEntry.dwSize = sizeof(procEntry);
const WCHAR* procNameChar;
int nChars = MultiByteToWideChar(CP_ACP, 0, ProcessName, -1, NULL, 0);
procNameChar = new WCHAR[nChars];
MultiByteToWideChar(CP_ACP, 0, ProcessName, -1, (LPWSTR)procNameChar, nChars);
do
if (!wcscmp(procEntry.szExeFile, procNameChar))
{
dwPID = procEntry.th32ProcessID;
CloseHandle(hPID);
hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID);
return true;
}
while (Process32Next(hPID, &procEntry));
return false;
}
bool isproc(const char *name)
/* determine if a process is running or not */
{
HANDLE hProcess;
PROCESSENTRY32 pe32;
if((hProcess = CreateToolhelp32Snapshot(2, 0)) != INVALID_HANDLE_VALUE)
{
pe32.dwSize = sizeof(PROCESSENTRY32);
if(Process32First(hProcess, &pe32))
{
while(Process32Next(hProcess, &pe32))
{
if(!stricmp(pe32.szExeFile, name))
{
CloseHandle(hProcess);
return true;
}
}
}
CloseHandle(hProcess);
}
return false;
}
/// 查看进程数
int PSAdb(void)
{
HANDLE hSnapShot=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
PROCESSENTRY32 oProcessInfo;
oProcessInfo.dwSize=sizeof(PROCESSENTRY32);
//这里我们将快照句柄和PROCESSENTRY32结构传给Process32Next()。
//执行之后，PROCESSENTRY32 结构将获得进程的信息。我们循环遍历，直到函数返回FALSE。
int nCounter =0;
while(Process32Next(hSnapShot, & oProcessInfo)!=FALSE)
{
char * ch = oProcessInfo.szExeFile;
{
if(strstr(ch,"adb.exe"))//使用这段代码的时候只需要改变"cmd.exe".将其改成你要结束的进程名就可以了。
{
nCounter++;
}
}
}
CloseHandle(hSnapShot);
return nCounter;
}
int listProcesses_matchFirst(char *strToMatch)
{
HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
PROCESSENTRY32 pe32;
memset(&pe32,0,sizeof(pe32));
pe32.dwSize = sizeof(pe32);
int bCont = Process32First(hSnap,&pe32);
while(bCont == TRUE)
{
if (strToMatch != NULL && pe32.szExeFile != NULL)
{
if(strstr(pe32.szExeFile,strToMatch) != NULL)
{
printf(" %04x : %s\n",pe32.th32ProcessID,pe32.szExeFile );
return pe32.th32ProcessID;
}
}
bCont = Process32Next(hSnap,&pe32);
}
return 0;
}
bool HasAppInstance(const wchar_t *processName)
{
bool exists = false;
PROCESSENTRY32 entry;
entry.dwSize = sizeof(PROCESSENTRY32);
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
int instance_count = 0;
if (Process32First(snapshot, &entry)) {
while (Process32Next(snapshot, &entry)) {
QString _qstr = QString::fromUtf8(entry.szExeFile);
//qDebug() << Q_FUNC_INFO << _qstr;
if (!wcsicmp(_qstr.toStdWString().c_str(), processName)) {
//exists = true;
instance_count++;
}
}
}
CloseHandle(snapshot);
return (instance_count > 1);
}
/// Helper function for enumerating all active processes on the system
Status getProcList(std::set<long>& pids) {
auto procSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (procSnap == INVALID_HANDLE_VALUE) {
return Status(1, "Failed to open process snapshot");
}
PROCESSENTRY32 procEntry;
procEntry.dwSize = sizeof(PROCESSENTRY32);
auto ret = Process32First(procSnap, &procEntry);
if (ret == FALSE) {
CloseHandle(procSnap);
return Status(1, "Failed to open first process");
}
while (ret != FALSE) {
pids.insert(procEntry.th32ProcessID);
ret = Process32Next(procSnap, &procEntry);
}
CloseHandle(procSnap);
return Status(0, "Ok");
}
DWORD GetProcessIdFromName(LPCTSTR szProcessName)
{
PROCESSENTRY32 pe;
DWORD id = 0;
HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
pe.dwSize = sizeof(PROCESSENTRY32);
if( !Process32First(hSnapshot,&pe) )
return 0;
while(1)
{
pe.dwSize = sizeof(PROCESSENTRY32);
if( Process32Next(hSnapshot,&pe)==FALSE )
break;
if(wcscmp(pe.szExeFile,szProcessName) == 0)
{
id = pe.th32ProcessID;
break;
}
}
CloseHandle(hSnapshot);
return id;
}
long CProcessTools::KillProcess(LPCTSTR processName,long lWhich)
//强行关闭任务管理器中映像名称为processName的进程
//lWhich:关闭第几个映像名称为processName的进程，-1表示全部，0表示第一个
//返回成功关闭的个数
{
ASSERT(processName && _tcslen(processName));
if(!processName || _tcslen(processName)<1) return 0;
HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (hProcessSnap == INVALID_HANDLE_VALUE) return 0;
PROCESSENTRY32 pe32 = {0};
pe32.dwSize = sizeof(PROCESSENTRY32);
if(!Process32First(hProcessSnap, &pe32))
{
CloseHandle(hProcessSnap);
return 0;
}
HANDLE hProcess=NULL;
long ret=0;
long count=0;
do
{
hProcess = OpenProcess (PROCESS_ALL_ACCESS, FALSE, pe32.th32ProcessID);
if(_tcsicmp(pe32.szExeFile,processName)) CloseHandle (hProcess);
else
{
if(count==lWhich || lWhich==-1)//需要关闭
{
if(TerminateProcess(hProcess,0)) ret++;
}
CloseHandle(hProcess);
if(lWhich!=-1) break;//不是关闭所有,停止枚举
}
}
while(Process32Next(hProcessSnap, &pe32));
CloseHandle (hProcessSnap);
return ret;
}
DWORD CAppreciation::GetProcessIDForProcessName(LPCTSTR lpProcessName)
{
HANDLE hProcess=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
HANDLE hModule;
PROCESSENTRY32* pinfo=new PROCESSENTRY32;
MODULEENTRY32* minfo=new MODULEENTRY32;
pinfo->dwSize=sizeof(PROCESSENTRY32);
minfo->dwSize=sizeof(MODULEENTRY32);
BOOL report;
TCHAR szName[MAX_PATH] = {0};
_tcscpy_s(szName,lpProcessName);
_tcsupr_s(szName);
// printf("ShowProcessPath with [ToolHelp API]\n\n");
report=Process32First(hProcess,pinfo);
while(report)
{
hModule=CreateToolhelp32Snapshot(TH32CS_SNAPMODULE,pinfo->th32ProcessID);
//Module32First(hModule, minfo);
_tcsupr_s(pinfo->szExeFile);
if (NULL != _tcsstr(pinfo->szExeFile,szName))
return pinfo->th32ProcessID;
report=Process32Next(hProcess, pinfo);
}
CloseHandle(hProcess);
CloseHandle(hModule);
delete minfo;
delete pinfo;
return 0;
}
