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; }