C/C++ Windows API——线程挂起、唤醒与终止

最新推荐文章于 2024-07-05 11:24:47 发布
福州司马懿
最新推荐文章于 2024-07-05 11:24:47 发布
阅读量5.4k
点赞数 1
分类专栏： # Windows API
转载请注明出处——https://blog.csdn.net/chy555chy
本文链接：https://blog.csdn.net/chy555chy/article/details/52896653
版权
Windows API 专栏收录该内容
16 篇文章 11 订阅
订阅专栏
// ThreadDemo.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <Windows.h>
#include <TlHelp32.h>
#include <Psapi.h>//GetModuleFileNameEx

int main()
{
    BOOL ret;
    DWORD dwFlags = TH32CS_SNAPTHREAD;
    HANDLE snapshotHandle = CreateToolhelp32Snapshot(dwFlags, 0);
    if (snapshotHandle == NULL || snapshotHandle == INVALID_HANDLE_VALUE) {
        printf("CreateToolhelp32Snapshot -> processHandle=%p(NULL or INVALID_HANDLE_VALUE) -> fail(%ld)\n", snapshotHandle, GetLastError());
    }
    else {
        printf("CreateToolhelp32Snapshot -> processHandle=%p -> succ\n", snapshotHandle);

        /*
        typedef struct tagTHREADENTRY32 {
        DWORD   dwSize;             //指定结构的长度，以字节为单位。如果你不初始化的dwSize，Thread32First将调用失败。
        DWORD   cntUsage;           //deprecated, always zero
        DWORD   th32ThreadID;       // this thread
        DWORD   th32OwnerProcessID; // Process this thread is associated with
        LONG    tpBasePri;          //线程在内核中分配的优先级，tpBasePri值为0到31, 0为最低优先级，更多的信息请看KeQueryPriorityThread
        LONG    tpDeltaPri;         //deprecated, always zero
        DWORD   dwFlags;            //deprecated, always zero
        } THREADENTRY32;
        */
        THREADENTRY32 threadEntry32 = { 0 };
        threadEntry32.dwSize = sizeof(THREADENTRY32);
        /*
        BOOL WINAPI Thread32First(
        HANDLE hSnapshot,
        LPTHREADENTRY32 lpte
        );
        */
        BOOL hasNext = Thread32First(snapshotHandle, &threadEntry32);
        if (!hasNext) {
            printf("Thread32First processHandle=%p -> fail(%ld)\n", snapshotHandle, GetLastError());
        }
        while (hasNext) {
            printf("Thread32Next -> th32ThreadID=%ld, th32OwnerProcessID=%ld, tpBasePri=%ld -> succ\n", threadEntry32.th32ThreadID, threadEntry32.th32OwnerProcessID, threadEntry32.tpBasePri);

            /*
            WINBASEAPI HANDLE WINAPI OpenProcess(
            _In_ DWORD dwDesiredAccess,
            _In_ BOOL bInheritHandle,
            _In_ DWORD dwProcessId
            );

            #define PROCESS_TERMINATE                  (0x0001)
            #define PROCESS_CREATE_THREAD              (0x0002)
            #define PROCESS_SET_SESSIONID              (0x0004)
            #define PROCESS_VM_OPERATION               (0x0008)
            #define PROCESS_VM_READ                    (0x0010)
            #define PROCESS_VM_WRITE                   (0x0020)
            #define PROCESS_DUP_HANDLE                 (0x0040)
            #define PROCESS_CREATE_PROCESS             (0x0080)
            #define PROCESS_SET_QUOTA                  (0x0100)
            #define PROCESS_SET_INFORMATION            (0x0200)
            #define PROCESS_QUERY_INFORMATION          (0x0400)
            #define PROCESS_SUSPEND_RESUME             (0x0800)
            #define PROCESS_QUERY_LIMITED_INFORMATION  (0x1000)
            #define PROCESS_SET_LIMITED_INFORMATION    (0x2000)
            #if (NTDDI_VERSION >= NTDDI_VISTA)
            #define PROCESS_ALL_ACCESS        (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | \ 0xFFFF)
            #else
            #define PROCESS_ALL_ACCESS        (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | \ 0xFFF)
            #endif
            */
            DWORD dwProcessDesiredAccess = PROCESS_ALL_ACCESS;
            BOOL bInheritHandle = FALSE;
            DWORD dwProcessID = threadEntry32.th32OwnerProcessID;
            HANDLE processHandle = OpenProcess(dwProcessDesiredAccess, bInheritHandle, dwProcessID);
            if (processHandle == NULL || processHandle == INVALID_HANDLE_VALUE) {
                printf("OpenProcess dwProcessID=%ld -> processHandle=%p(NULL or INVALID_HANDLE_VALUE) -> fail(%ld)\n", dwProcessID, processHandle, GetLastError());
            }
            else {
                printf("OpenProcess dwProcessID=%ld -> processHandle=%p -> succ\n", dwProcessID, processHandle);

                /*
                _Success_(return != 0)
                _Ret_range_(1, nSize)
                DWORD WINAPI GetModuleFileNameExW(
                    _In_opt_ HANDLE hProcess,
                    _In_opt_ HMODULE hModule,
                    _When_(return < nSize, _Out_writes_to_(nSize, return + 1))
                    _When_(return == nSize, _Out_writes_all_(nSize))
                    LPTSTR lpFilename,
                    _In_ DWORD nSize
                );

                If the function succeeds, the return value specifies the length of the string copied to the buffer.
                If the function fails, the return value is zero. To get extended error information, call GetLastError.
                */
                HMODULE hModule = NULL;
                const DWORD nSize = MAX_PATH;
                TCHAR lpFilename[nSize];
                DWORD dwRet = GetModuleFileNameEx(processHandle, hModule, lpFilename, nSize);
                if (dwRet == 0) {
                    printf("GetModuleFileNameEx processHandle=%p -> fail(%ld)\n", processHandle, GetLastError());
                }
                else {
                    _tprintf(_T("GetModuleFileNameEx processHandle=%p -> fileName=%s\n"), processHandle, lpFilename);
                }

                if (_tcsstr(lpFilename, _T("notepad.exe"))) {
                    /*
                    WINBASEAPI _Ret_maybenull_ HANDLE WINAPI OpenThread(
                    _In_ DWORD dwDesiredAccess,
                    _In_ BOOL bInheritHandle,
                    _In_ DWORD dwThreadId
                    );

                    dwDesiredAccess可以是如下值(OpenThread和OpenProcess类似)
                    #define THREAD_TERMINATE                 (0x0001)
                    #define THREAD_SUSPEND_RESUME            (0x0002)
                    #define THREAD_GET_CONTEXT               (0x0008)
                    #define THREAD_SET_CONTEXT               (0x0010)
                    #define THREAD_QUERY_INFORMATION         (0x0040)
                    #define THREAD_SET_INFORMATION           (0x0020)
                    #define THREAD_SET_THREAD_TOKEN          (0x0080)
                    #define THREAD_IMPERSONATE               (0x0100)
                    #define THREAD_DIRECT_IMPERSONATION      (0x0200)
                    // begin_wdm
                    #define THREAD_SET_LIMITED_INFORMATION   (0x0400)  // winnt
                    #define THREAD_QUERY_LIMITED_INFORMATION (0x0800)  // winnt
                    #define THREAD_RESUME                    (0x1000)  // winnt
                    #if (NTDDI_VERSION >= NTDDI_VISTA)
                    #define THREAD_ALL_ACCESS         (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | \ 0xFFFF)
                    #else
                    #define THREAD_ALL_ACCESS         (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | \ 0x3FF)
                    #endif
                    */
                    DWORD dwDesiredAccess = THREAD_TERMINATE | THREAD_SUSPEND_RESUME | THREAD_QUERY_INFORMATION;
                    BOOL bInheritHandle = FALSE;
                    DWORD dwThreadId = threadEntry32.th32ThreadID;
                    //打开句柄后都要记得关闭
                    HANDLE threadHandle = OpenThread(dwDesiredAccess, bInheritHandle, dwThreadId);
                    if (threadHandle == NULL || threadHandle == INVALID_HANDLE_VALUE) {
                        printf("OpenThread dwThreadId=%ld -> threadHandle=%p(NULL or INVALID_HANDLE_VALUE) -> fail(%ld)\n", dwThreadId, threadHandle, GetLastError());
                    }
                    else {
                        printf("OpenThread -> threadHandle=%p -> succ\n", threadHandle);
                        /*
                        WINBASEAPI DWORD WINAPI SuspendThread(
                        _In_ HANDLE hThread
                        );

                        If the function succeeds, the return value is the thread's previous suspend count;
                        otherwise, it is (DWORD) -1. To get extended error information, use the GetLastError function.
                        */
                        DWORD preSuspendCnt = SuspendThread(threadHandle);
                        if (preSuspendCnt == -1) {
                            printf("SuspendThread -> fail(%ld)\n", GetLastError());
                        }
                        else {
                            printf("SuspendThread -> preSuspendCnt=%d -> succ\n", preSuspendCnt);
                        }

                        /*
                        WINBASEAPI DWORD WINAPI ResumeThread(
                        _In_ HANDLE hThread
                        );

                        If the function succeeds, the return value is the thread's previous suspend count.
                        If the function fails, the return value is (DWORD) -1. To get extended error information, call GetLastError.
                        */
                        preSuspendCnt = ResumeThread(threadHandle);
                        if (preSuspendCnt == -1) {
                            printf("ResumeThread -> fail(%ld)\n", GetLastError());
                        }
                        else {
                            printf("ResumeThread -> preSuspendCnt=%d -> succ\n", preSuspendCnt);
                        }
                        /*
                        WINBASEAPI BOOL WINAPI TerminateThread(
                        _In_ HANDLE hThread,
                        _In_ DWORD dwExitCode
                        );
                        */
                        ret = TerminateThread(threadHandle, 0);
                        if (ret) {
                            printf("TerminateThread -> succ\n");
                        }
                        else {
                            printf("TerminateThread -> fail(%ld)\n", GetLastError());
                        }

                        ret = CloseHandle(threadHandle);
                        if (ret) {
                            printf("CloseHandle thread -> ret=%d\n", ret);
                        }
                        else {
                            printf("CloseHandle thread -> ret=%d -> fail(%ld)\n", ret, GetLastError());
                        }
                    }
                }
                CloseHandle(processHandle);
            }
            hasNext = Thread32Next(snapshotHandle, &threadEntry32);
            if (!hasNext) {
                //遍历完线程的时候Thread32Next会设置错误码10,为环境错误
                printf("Thread32Next handle=%p -> fail(%ld)\n", snapshotHandle, GetLastError());
            }
        }
        ret = CloseHandle(snapshotHandle);
    }

    system("pause");
    return 0;
}