枚舉頂層窗口
如果將枚舉進程與枚舉桌面上的頂層窗口進行比較，那么枚舉頂層窗口可能更容易一些。要枚舉頂層窗口，請使用 EnumWindows() 函數。不要使用 GetWindow() 創建自己的窗口列表，因為它可能受 z 軸次序更改和丟失窗口的干擾。
EnumWindows() 將指向某個回調函數的指針以及用戶定義的 LPARAM 值作為其參數。它對桌面上的每個窗口（或頂層窗口）分別調用一次回調函數。然后，回調函數可以對此窗口句柄進行某種處理，如將其添加到一個列表中。此方法可以保證不受窗口 z 軸次序更改等項的干擾。在獲取窗口句柄后，可以通過調用 GetWindowText() 來獲取其標題。
回到頂端
枚舉進程
在系統中創建進程列表比枚舉窗口要稍微復雜一些。這主要是因為執行此操作的 API 函數因所使用的 Win32 操作系統而異。在 Windows 95、Windows 98、Windows Millennium Edition、Windows 2000 和 Windows XP 中，可以使用 ToolHelp32 API 庫中的函數。但是，在 Windows NT 中，必須使用 PSAPI API 庫中的函數（Platform SDK 中包含該庫）。本文將討論這兩種技術，另外還提供一個稱為 EnumProcs() 的示例包裝函數，該函數可以在 Win32 操作系統中運行。
回到頂端
使用 ToolHelp32 庫枚舉進程
首先討論 ToolHelp32 方法。KERNEL32.dll 中的 ToolHelp32 函數是標準的 API 函數。注意，在 Windows NT 4.0 中不提供這些 API。
可以使用 ToolHelp32 提供的各種函數，枚舉系統中的進程和線程以及獲取內存和模塊信息。但是，在枚舉進程時，僅需要使用以下三個函數：CreateToolhelp32Snapshot()、Process32First() 和 Process32Next()。
使用 ToolHelp32 函數的第一步是創建系統信息的"快照"。可以使用 CreateToolhelp32Snapshot() 函數完成這一步。此函數允許選擇在快照中存儲的信息類型。如果您需要進程信息，則一定要包括 TH32CS_SNAPPROCESS 標志。CreateToolhelp32Snapshot() 函數返回一個句柄，在使用完該句柄后，必須將其傳遞到 CloseHandle()。
下一步，為了檢索快照中的進程列表，可以調用一次 Process32First，然后重復調用多次 Process32Next。執行此操作，直到其中的一個函數返回 FALSE 為止。這將逐個獲得快照進程列表中的進程。這兩個函數都將"快照"句柄和指向 PROCESSENTRY32 結構的指針作為其參數。
在調用 Process32First 或 Process32Next 后，PROCESSENTRY32 結構將包含系統中某個進程的有用信息。進程 ID 在該結構的 th32ProcessID 成員中。可以將它傳遞到 OpenProcess() 以獲取該進程的句柄。該進程的可執行文件和路徑存儲在結構的 szExeFile 成員中。還可以在此結構中找到其他有用的信息。
備注：切記，在調用 Process32First() 之前，將 PROCESSENTRY32 結構的 dwSize 成員設置為 sizeof(PROCESSENTRY32)。
回到頂端
使用 PSAPI 庫枚舉進程
在 Windows NT 中創建進程列表的方法是使用 PSAPI.dll 中的 PSAPI 函數。此文件是隨 Platform SDK 分發的，可以從以下 Microsoft Web 站點下載該文件：
Microsoft Platform SDK
http://www.microsoft.com/msdownload/platformsdk/sdkupdate/
所需的 PSAPI.h 和 PSAPI.lib 文件也包含在 Platform SDK 中。
要使用 PSAPI 庫中的函數，請將 PSAPI.lib 文件添加到您的項目中，并將 PSAPI.h 文件包含到任何調用 PSAPI API 的模塊中。切記，要將 PSAPI.dll 文件與使用它的任何可執行文件一起分發，因為沒有隨 Windows NT 4.0 分發該文件。可以從以下位置下載可重新分發的 PSAPI.dll 版本（如果沒有完整的 Platform SDK 的話）：
Platform SDK 可重新分發的版本：用于 Windows NT 的 PSAPI
http://www.microsoft.com/downloads/release.asp?releaseid=30337
與 ToolHelp32 函數一樣，PSAPI 也包含很多其他的有用函數。但是，本文只討論與枚舉進程有關的函數：EnumProcesses()、EnumProcessModules()、GetModuleFileNameEx() 和 GetModuleBaseName()。
創建進程列表的第一步是調用 EnumProcesses()。以下是其聲明：
BOOL EnumProcesses( DWORD *lpidProcess, DWORD cb, DWORD *cbNeeded );
需要給 EnumProcesses() 傳入三個參數：指向 DWORD 數組的指針 (lpidProcess)、該數組的大小 (cb) 以及另一個指向 DWORD 的指針 (cbNeeded)（用于獲取返回數據的長度）。使用當前所運行進程的進程 ID 數組來填充 DWORD 數組。cbNeeded 參數返回所使用數組的大小。以下計算告訴您返回了多少個進程 ID：nReturned = cbNeeded / sizeof(DWORD)。
備注：雖然本文將返回的 DWORD 命名為"cbNeeded"，但實際上無法確定在數組中傳遞的進程到底有多少。EnumProcesses() 在 cbNeeded 中返回的值絕不會大于在 cb 參數中傳遞的數組值。因此，要確保成功使用 EnumProcesses() 函數，唯一的方法是分配一個 DWORD 數組，如果返回時 cbNeeded 等于 cb，則分配較大的數組并重試，直到 cbNeeded 小于 cb 時為止。
現在，數組包含系統中的每個進程 ID。如果您的目標是獲取進程名，則必須先獲取句柄。要從進程 ID 中獲取句柄，請使用 OpenProcess()。
在獲取句柄后，需要獲取進程的第一個模塊。要獲取進程的第一個模塊，請使用以下參數調用 EnumProcessModules() API：
EnumProcessModules( hProcess, &hModule, sizeof(hModule), &cbReturned );
這將把進程第一個模塊的句柄放在 hModule 變量中。切記，進程實際上并沒有名稱，但進程中的第一個模塊是該進程的可執行文件。現在，可以將返回的模塊句柄 (hModule) 用于 GetModuleFileNameEx() 或 GetModuleBaseName() API，以獲取進程可執行文件的完整路徑名或簡單模塊名。這兩個函數需要傳入進程句柄、模塊句柄以及返回名稱的緩沖區指針，后面是緩沖區的大小。
通過對 EnumProcesses() API 返回的每個進程 ID 重復上述步驟，即可創建 Windows NT 中進程的列表。
回到頂端
16 位進程
在 Windows 95、Windows 98 和 Windows Millennium Edition 上，對 ToolHelp32 而言，所有 16 位應用程序是平等的。與 Win32 應用程序一樣，16 位應用程序也具有進程 ID 等。但是，在 Windows NT、Windows 2000 或 Windows XP 中，則不是這樣。在這些操作系統上，16 位應用程序運行在 DOS 虛擬機 (VDM) 中。
要在 Windows NT、Windows 2000 和 Windows XP 中枚舉 16 位應用程序，必須使用名為 VDMEnumTaskWOWEx() 的函數。必須在源模塊中包含 VDMDBG.h，并且 VDMDBG.lib 文件必須與項目鏈接在一起。這兩個文件包含在 Platform SDK 中。
此函數的聲明如下：
INT WINAPI VDMEnumTaskWOWEx( DWORD dwProcessId, TASKENUMPROCEX fp,
LPARAM lparam );
其中，dwProcessId 是要枚舉其 16 位任務的 NTVDM 進程的標識符。fp 參數是指向回調枚舉函數的指針。lparam 參數是要傳遞給枚舉函數的用戶定義值。
枚舉函數應當定義如下：
BOOL WINAPI Enum16( DWORD dwThreadId, WORD hMod16, WORD hTask16, PSZ
pszModName, PSZ pszFileName, LPARAM lpUserDefined );
對于傳遞到 VDMEnumTaskWOWEx() 的 NTVDM 進程中運行的每個 16 位任務，分別調用一次該函數。如果要繼續枚舉，則應該返回 FALSE，如果要結束枚舉，則應該返回 TRUE。注意，這與 EnumWindows() 正好相反。
回到頂端
示例代碼
下示例代碼將 PSAPI 和 ToolHelp32 函數封裝在名為 EnumProcs() 的函數中。此函數與 EnumWindows() 類似，因為它也接受指向某個函數的指針并重復調用它（對系統中的每個進程分別調用一次）。以下是該函數的聲明：
BOOL WINAPI EnumProcs( PROCENUMPROC lpProc, LPARAM lParam );
如果使用該函數，則將回調函數聲明如下：
BOOL CALLBACK Proc( DWORD dw, WORD w16, LPCSTR lpstr, LPARAM lParam );
其中，dw 參數將包含 ID；"w16"是 16 位任務編號或 0（如果是 32 位進程，則在 Windows 95 下始終為零）；lpstr 參數將指向文件名；lParam 是傳遞給 EnumProcs() 的用戶定義的 lParam。
EnumProcs() 函數通過顯式鏈接使用 ToolHelp32 和 PSAPI 函數，而不是通過更常用的隱式鏈接。通過使用這種技術，可以使代碼在所有 Win32 操作系統中二進制兼容。
//
// EnumProc.c
//
#include <windows.h>
#include <stdio.h>
#include <tlhelp32.h>
#include <vdmdbg.h>
typedef BOOL (CALLBACK *PROCENUMPROC)(DWORD, WORD, LPSTR, LPARAM);
typedef struct {
DWORD dwPID;
PROCENUMPROC lpProc;
DWORD lParam;
BOOL bEnd;
} EnumInfoStruct;
BOOL WINAPI EnumProcs(PROCENUMPROC lpProc, LPARAM lParam);
BOOL WINAPI Enum16(DWORD dwThreadId, WORD hMod16, WORD hTask16,
PSZ pszModName, PSZ pszFileName, LPARAM lpUserDefined);
//
// The EnumProcs function takes a pointer to a callback function
// that will be called once per process with the process filename
// and process ID.
//
// lpProc -- Address of callback routine.
//
// lParam -- A user-defined LPARAM value to be passed to
// the callback routine.
//
// Callback function definition:
// BOOL CALLBACK Proc(DWORD dw, WORD w, LPCSTR lpstr, LPARAM lParam);
//
BOOL WINAPI EnumProcs(PROCENUMPROC lpProc, LPARAM lParam) {
OSVERSIONINFO osver;
HINSTANCE hInstLib = NULL;
HINSTANCE hInstLib2 = NULL;
HANDLE hSnapShot = NULL;
LPDWORD lpdwPIDs = NULL;
PROCESSENTRY32 procentry;
BOOL bFlag;
DWORD dwSize;
DWORD dwSize2;
DWORD dwIndex;
HMODULE hMod;
HANDLE hProcess;
char szFileName[MAX_PATH];
EnumInfoStruct sInfo;
// ToolHelp Function Pointers.
HANDLE (WINAPI *lpfCreateToolhelp32Snapshot)(DWORD, DWORD);
BOOL (WINAPI *lpfProcess32First)(HANDLE, LPPROCESSENTRY32);
BOOL (WINAPI *lpfProcess32Next)(HANDLE, LPPROCESSENTRY32);
// PSAPI Function Pointers.
BOOL (WINAPI *lpfEnumProcesses)(DWORD *, DWORD, DWORD *);
BOOL (WINAPI *lpfEnumProcessModules)(HANDLE, HMODULE *, DWORD,
LPDWORD);
DWORD (WINAPI *lpfGetModuleBaseName)(HANDLE, HMODULE, LPTSTR, DWORD);
// VDMDBG Function Pointers.
INT (WINAPI *lpfVDMEnumTaskWOWEx)(DWORD, TASKENUMPROCEX, LPARAM);
// Retrieve the OS version
osver.dwOSVersionInfoSize = sizeof(osver);
if (!GetVersionEx(&osver))
return FALSE;
// If Windows NT 4.0
if (osver.dwPlatformId == VER_PLATFORM_WIN32_NT
&& osver.dwMajorVersion == 4) {
__try {
// Get the procedure addresses explicitly.We do
// this so we don't have to worry about modules
// failing to load under OSes other than Windows NT 4.0
// because references to PSAPI.DLL can't be resolved.
hInstLib = LoadLibraryA("PSAPI.DLL");
if (hInstLib == NULL)
__leave;
hInstLib2 = LoadLibraryA("VDMDBG.DLL");
if (hInstLib2 == NULL)
__leave;
// Get procedure addresses.
lpfEnumProcesses = (BOOL (WINAPI *)(DWORD *, DWORD, DWORD*))
GetProcAddress(hInstLib, "EnumProcesses");
lpfEnumProcessModules = (BOOL (WINAPI *)(HANDLE, HMODULE *,
DWORD, LPDWORD)) GetProcAddress(hInstLib,
"EnumProcessModules");
lpfGetModuleBaseName = (DWORD (WINAPI *)(HANDLE, HMODULE,
LPTSTR, DWORD)) GetProcAddress(hInstLib,
"GetModuleBaseNameA");
lpfVDMEnumTaskWOWEx = (INT (WINAPI *)(DWORD, TASKENUMPROCEX,
LPARAM)) GetProcAddress(hInstLib2, "VDMEnumTaskWOWEx");
if (lpfEnumProcesses == NULL
|| lpfEnumProcessModules == NULL
|| lpfGetModuleBaseName == NULL
|| lpfVDMEnumTaskWOWEx == NULL)
__leave;
//
// Call the PSAPI function EnumProcesses to get all of the
// ProcID's currently in the system.
//
// NOTE:In the documentation, the third parameter of
// EnumProcesses is named cbNeeded, which implies that you
// can call the function once to find out how much space to
// allocate for a buffer and again to fill the buffer.
// This is not the case.The cbNeeded parameter returns
// the number of PIDs returned, so if your buffer size is
// zero cbNeeded returns zero.
//
// NOTE:The "HeapAlloc" loop here ensures that we
// actually allocate a buffer large enough for all the
// PIDs in the system.
//
dwSize2 = 256 * sizeof(DWORD);
do {
if (lpdwPIDs) {
HeapFree(GetProcessHeap(), 0, lpdwPIDs);
dwSize2 *= 2;
}
lpdwPIDs = (LPDWORD) HeapAlloc(GetProcessHeap(), 0,
dwSize2);
if (lpdwPIDs == NULL)
__leave;
if (!lpfEnumProcesses(lpdwPIDs, dwSize2, &dwSize))
__leave;
} while (dwSize == dwSize2);
// How many ProcID's did we get?
dwSize /= sizeof(DWORD);
// Loop through each ProcID.
for (dwIndex = 0; dwIndex < dwSize; dwIndex++) {
szFileName[0] = 0;
// Open the process (if we can
security does not
// permit every process in the system to be opened).
hProcess = OpenProcess(
PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
FALSE, lpdwPIDs[dwIndex]);
if (hProcess != NULL) {
// Here we call EnumProcessModules to get only the
// first module in the process.This will be the
// EXE module for which we will retrieve the name.
if (lpfEnumProcessModules(hProcess, &hMod,
sizeof(hMod), &dwSize2)) {
// Get the module name
if (!lpfGetModuleBaseName(hProcess, hMod,
szFileName, sizeof(szFileName)))
szFileName[0] = 0;
}
CloseHandle(hProcess);
}
// Regardless of OpenProcess success or failure, we
// still call the enum func with the ProcID.
if (!lpProc(lpdwPIDs[dwIndex], 0, szFileName, lParam))
break;
// Did we just bump into an NTVDM?
if (_stricmp(szFileName, "NTVDM.EXE") == 0) {
// Fill in some info for the 16-bit enum proc.
sInfo.dwPID = lpdwPIDs[dwIndex];
sInfo.lpProc = lpProc;
sInfo.lParam = (DWORD) lParam;
sInfo.bEnd = FALSE;
// Enum the 16-bit stuff.
lpfVDMEnumTaskWOWEx(lpdwPIDs[dwIndex],
(TASKENUMPROCEX) Enum16, (LPARAM) &sInfo);
// Did our main enum func say quit?
if (sInfo.bEnd)
break;
}
}
} __finally {
if (hInstLib)
FreeLibrary(hInstLib);
if (hInstLib2)
FreeLibrary(hInstLib2);
if (lpdwPIDs)
HeapFree(GetProcessHeap(), 0, lpdwPIDs);
}
// If any OS other than Windows NT 4.0.
} else if (osver.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS
|| (osver.dwPlatformId == VER_PLATFORM_WIN32_NT
&& osver.dwMajorVersion > 4)) {
__try {
hInstLib = LoadLibraryA("Kernel32.DLL");
if (hInstLib == NULL)
__leave;
// If NT-based OS, load VDMDBG.DLL.
if (osver.dwPlatformId == VER_PLATFORM_WIN32_NT) {
hInstLib2 = LoadLibraryA("VDMDBG.DLL");
if (hInstLib2 == NULL)
__leave;
}
// Get procedure addresses.We are linking to
// these functions explicitly, because a module using
// this code would fail to load under Windows NT,
// which does not have the Toolhelp32
// functions in KERNEL32.DLL.
lpfCreateToolhelp32Snapshot =
(HANDLE (WINAPI *)(DWORD,DWORD))
GetProcAddress(hInstLib, "CreateToolhelp32Snapshot");
lpfProcess32First =
(BOOL (WINAPI *)(HANDLE,LPPROCESSENTRY32))
GetProcAddress(hInstLib, "Process32First");
lpfProcess32Next =
(BOOL (WINAPI *)(HANDLE,LPPROCESSENTRY32))
GetProcAddress(hInstLib, "Process32Next");
if (lpfProcess32Next == NULL
|| lpfProcess32First == NULL
|| lpfCreateToolhelp32Snapshot == NULL)
__leave;
if (osver.dwPlatformId == VER_PLATFORM_WIN32_NT) {
lpfVDMEnumTaskWOWEx = (INT (WINAPI *)(DWORD, TASKENUMPROCEX,
LPARAM)) GetProcAddress(hInstLib2, "VDMEnumTaskWOWEx");
if (lpfVDMEnumTaskWOWEx == NULL)
__leave;
}
// Get a handle to a Toolhelp snapshot of all processes.
hSnapShot = lpfCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (hSnapShot == INVALID_HANDLE_VALUE) {
FreeLibrary(hInstLib);
return FALSE;
}
// Get the first process' information.
procentry.dwSize = sizeof(PROCESSENTRY32);
bFlag = lpfProcess32First(hSnapShot, &procentry);
// While there are processes, keep looping.
while (bFlag) {
// Call the enum func with the filename and ProcID.
if (lpProc(procentry.th32ProcessID, 0,
procentry.szExeFile, lParam)) {
// Did we just bump into an NTVDM?
if (_stricmp(procentry.szExeFile, "NTVDM.EXE") == 0) {
// Fill in some info for the 16-bit enum proc.
sInfo.dwPID = procentry.th32ProcessID;
sInfo.lpProc = lpProc;
sInfo.lParam = (DWORD) lParam;
sInfo.bEnd = FALSE;
// Enum the 16-bit stuff.
lpfVDMEnumTaskWOWEx(procentry.th32ProcessID,
(TASKENUMPROCEX) Enum16, (LPARAM) &sInfo);
// Did our main enum func say quit?
if (sInfo.bEnd)
break;
}
procentry.dwSize = sizeof(PROCESSENTRY32);
bFlag = lpfProcess32Next(hSnapShot, &procentry);
} else
bFlag = FALSE;
}
} __finally {
if (hInstLib)
FreeLibrary(hInstLib);
if (hInstLib2)
FreeLibrary(hInstLib2);
}
} else
return FALSE;
// Free the library.
FreeLibrary(hInstLib);
return TRUE;
}
BOOL WINAPI Enum16(DWORD dwThreadId, WORD hMod16, WORD hTask16,
PSZ pszModName, PSZ pszFileName, LPARAM lpUserDefined) {
BOOL bRet;
EnumInfoStruct *psInfo = (EnumInfoStruct *)lpUserDefined;
bRet = psInfo->lpProc(psInfo->dwPID, hTask16, pszFileName,
psInfo->lParam);
if (!bRet)
psInfo->bEnd = TRUE;
return !bRet;
}
BOOL CALLBACK MyProcessEnumerator(DWORD dwPID, WORD wTask,
LPCSTR szProcess, LPARAM lParam) {
if (wTask == 0)
printf("%5u %s\n", dwPID, szProcess);
else
printf(" %5u %s\n", wTask, szProcess);
return TRUE;
}
void main() {
EnumProcs((PROCENUMPROC) MyProcessEnumerator, 0);
}
posted on 2010-04-27 12:47
小果子 閱讀(531)
評論(0) 編輯 收藏 引用 所屬分類:
Windows