TerminateProcess.c File Reference

#include "precomp.h"
#include <ndk/obfuncs.h>

Include dependency graph for TerminateProcess.c:

Go to the source code of this file.

Macros
#define	WaitExpectSuccess(h, ms)   WaitExpect_(h, ms, WAIT_OBJECT_0, __FILE__, __LINE__)
#define	WaitExpectTimeout(h, ms)   WaitExpect_(h, ms, WAIT_TIMEOUT, __FILE__, __LINE__)
#define	CloseProcessAndVerify(hp, pid, code)   CloseProcessAndVerify_(hp, pid, code, __FILE__, __LINE__)

Functions
static HANDLE	StartChild (_In_ PCWSTR Argument, _In_ DWORD Flags, _Out_opt_ PDWORD ProcessId)
static VOID	TraceHandleCount_ (_In_ HANDLE hObject, _In_ PCSTR File, _In_ INT Line)
static VOID	WaitExpect_ (_In_ HANDLE hWait, _In_ DWORD Milliseconds, _In_ DWORD ExpectedError, _In_ PCSTR File, _In_ INT Line)
static VOID	CloseProcessAndVerify_ (_In_ HANDLE hProcess, _In_ DWORD ProcessId, _In_ UINT ExpectedExitCode, _In_ PCSTR File, _In_ INT Line)
static VOID	TestTerminateProcess (_In_ HANDLE hEvent)
	START_TEST (TerminateProcess)

Macro Definition Documentation

CloseProcessAndVerify

#define CloseProcessAndVerify	(		hp,
			pid,
			code
	)		CloseProcessAndVerify_(hp, pid, code, __FILE__, __LINE__)

Definition at line 105 of file TerminateProcess.c.

WaitExpectSuccess

#define WaitExpectSuccess	(		h,
			ms
	)		WaitExpect_(h, ms, WAIT_OBJECT_0, __FILE__, __LINE__)

Definition at line 88 of file TerminateProcess.c.

WaitExpectTimeout

#define WaitExpectTimeout	(		h,
			ms
	)		WaitExpect_(h, ms, WAIT_TIMEOUT, __FILE__, __LINE__)

Definition at line 89 of file TerminateProcess.c.

Function Documentation

CloseProcessAndVerify_()

static VOID CloseProcessAndVerify_ ( _In_ HANDLE  hProcess, _In_ DWORD  ProcessId, _In_ UINT  ExpectedExitCode, _In_ PCSTR  File, _In_ INT  Line  )

static

Definition at line 108 of file TerminateProcess.c.

{
    int i = 0;
    DWORD Error;
    DWORD ExitCode;
    BOOL Success;
 
    WaitExpect_(hProcess, 0, WAIT_OBJECT_0, File, Line);
    Success = GetExitCodeProcess(hProcess, &ExitCode);
    ok_(File, Line)(Success, "GetExitCodeProcess failed with %lu\n", GetLastError());
    CloseHandle(hProcess);
    while ((hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, ProcessId)) != NULL)
    {
        if (++i >= 100)
        {
            TraceHandleCount_(hProcess, File, Line);
            CloseHandle(hProcess);
            break;
        }
        CloseHandle(hProcess);
        Sleep(100);
    }
    Error = GetLastError();
    ok_(File, Line)(hProcess == NULL, "OpenProcess succeeded unexpectedly for pid 0x%lx\n", ProcessId);
    ok_(File, Line)(Error == ERROR_INVALID_PARAMETER, "Error = %lu\n", Error);
    ok_(File, Line)(ExitCode == ExpectedExitCode, "Exit code is %lu but expected %u\n", ExitCode, ExpectedExitCode);
}

START_TEST()

START_TEST

(

TerminateProcess

)

Definition at line 202 of file TerminateProcess.c.

{
    HANDLE hEvent;
    BOOL Success;
    DWORD Error;
    int argc;
    char **argv;
 
    hEvent = CreateEventW(NULL, TRUE, FALSE, L"kernel32_apitest_TerminateProcess_event");
    Error = GetLastError();
    if (!hEvent)
    {
        skip("CreateEvent failed with error %lu\n", Error);
        return;
    }
    argc = winetest_get_mainargs(&argv);
    if (argc >= 3)
    {
        ok(Error == ERROR_ALREADY_EXISTS, "Error = %lu\n", Error);
        if (!strcmp(argv[2], "wait"))
        {
            WaitExpectSuccess(hEvent, 30000);
        }
        else
        {
            Success = SetEvent(hEvent);
            ok(Success, "SetEvent failed with return %d, error %lu\n", Success, GetLastError());
        }
    }
    else
    {
        ok(Error == NO_ERROR, "Error = %lu\n", Error);
        TestTerminateProcess(hEvent);
    }
    CloseHandle(hEvent);
    if (argc >= 5)
    {
        UINT ExitCode = strtol(argv[4], NULL, 10);
 
        fflush(stdout);
        if (!strcmp(argv[3], "exit"))
            ExitProcess(ExitCode);
        else if (!strcmp(argv[3], "terminate"))
            TerminateProcess(GetCurrentProcess(), ExitCode);
        else if (!strcmp(argv[3], "terminate2"))
        {
            HANDLE hProcess;
            hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, GetCurrentProcessId());
            TerminateProcess(hProcess, ExitCode);
        }
        ok(0, "Should have terminated\n");
    }
}

StartChild()

static HANDLE StartChild ( _In_ PCWSTR  Argument, _In_ DWORD  Flags, _Out_opt_ PDWORD  ProcessId  )

static

Definition at line 14 of file TerminateProcess.c.

{
    BOOL Success;
    WCHAR FileName[MAX_PATH];
    WCHAR CommandLine[MAX_PATH];
    STARTUPINFOW StartupInfo;
    PROCESS_INFORMATION ProcessInfo;
 
    GetModuleFileNameW(NULL, FileName, _countof(FileName));
    StringCbPrintfW(CommandLine,
                    sizeof(CommandLine),
                    L"\"%ls\" TerminateProcess %ls",
                    FileName,
                    Argument);
 
    RtlZeroMemory(&StartupInfo, sizeof(StartupInfo));
    StartupInfo.cb = sizeof(StartupInfo);
    /* HACK: running the test under rosautotest seems to keep another reference
     * to the child process around until the test finishes (on both ROS and
     * Windows)... I'm too lazy to investigate very much so let's just redirect
     * the child std handles to nowhere. ok() is useless in half the child
     * processes anyway.
     */
    StartupInfo.dwFlags = STARTF_USESTDHANDLES;
 
    Success = CreateProcessW(FileName,
                             CommandLine,
                             NULL,
                             NULL,
                             FALSE,
                             Flags,
                             NULL,
                             NULL,
                             &StartupInfo,
                             &ProcessInfo);
    if (!Success)
    {
        skip("CreateProcess failed with %lu\n", GetLastError());
        if (ProcessId)
            *ProcessId = 0;
        return NULL;
    }
    CloseHandle(ProcessInfo.hThread);
    if (ProcessId)
        *ProcessId = ProcessInfo.dwProcessId;
    return ProcessInfo.hProcess;
}

Referenced by TestTerminateProcess().

TestTerminateProcess()

static VOID TestTerminateProcess ( _In_ HANDLE  hEvent )

static

Definition at line 143 of file TerminateProcess.c.

{
    HANDLE hProcess;
    DWORD ProcessId;
 
    /* Regular child process that returns from the test function */
    /* HACK: These two tests don't work if stdout is a pipe. See StartChild */
    ResetEvent(hEvent);
    hProcess = StartChild(L"child", 0, &ProcessId);
    WaitExpectSuccess(hEvent, 5000);
    WaitExpectSuccess(hProcess, 5000);
    CloseProcessAndVerify(hProcess, ProcessId, 0);
 
    ResetEvent(hEvent);
    hProcess = StartChild(L"child", 0, &ProcessId);
    WaitExpectSuccess(hProcess, 5000);
    WaitExpectSuccess(hEvent, 0);
    CloseProcessAndVerify(hProcess, ProcessId, 0);
 
    /* Suspended process -- never gets a chance to initialize */
    ResetEvent(hEvent);
    hProcess = StartChild(L"child", CREATE_SUSPENDED, &ProcessId);
    WaitExpectTimeout(hEvent, 100);
    WaitExpectTimeout(hProcess, 100);
    TerminateProcess(hProcess, 123);
    WaitExpectSuccess(hProcess, 5000);
    CloseProcessAndVerify(hProcess, ProcessId, 123);
 
    /* Waiting process -- we have to terminate it */
    ResetEvent(hEvent);
    hProcess = StartChild(L"wait", 0, &ProcessId);
    WaitExpectTimeout(hProcess, 100);
    TerminateProcess(hProcess, 123);
    WaitExpectSuccess(hProcess, 5000);
    CloseProcessAndVerify(hProcess, ProcessId, 123);
 
    /* Process calls ExitProcess */
    ResetEvent(hEvent);
    hProcess = StartChild(L"child exit 456", 0, &ProcessId);
    WaitExpectSuccess(hEvent, 5000);
    WaitExpectSuccess(hProcess, 5000);
    CloseProcessAndVerify(hProcess, ProcessId, 456);
 
    /* Process calls TerminateProcess with GetCurrentProcess */
    ResetEvent(hEvent);
    hProcess = StartChild(L"child terminate 456", 0, &ProcessId);
    WaitExpectSuccess(hEvent, 5000);
    WaitExpectSuccess(hProcess, 5000);
    CloseProcessAndVerify(hProcess, ProcessId, 456);
 
    /* Process calls TerminateProcess with real handle to itself */
    ResetEvent(hEvent);
    hProcess = StartChild(L"child terminate2 456", 0, &ProcessId);
    WaitExpectSuccess(hEvent, 5000);
    WaitExpectSuccess(hProcess, 5000);
    CloseProcessAndVerify(hProcess, ProcessId, 456);
}

Referenced by START_TEST().

TraceHandleCount_()

static VOID TraceHandleCount_ ( _In_ HANDLE  hObject, _In_ PCSTR  File, _In_ INT  Line  )

static

Definition at line 67 of file TerminateProcess.c.

{
    NTSTATUS Status;
    OBJECT_BASIC_INFORMATION BasicInfo;
 
    Status = NtQueryObject(hObject,
                           ObjectBasicInformation,
                           &BasicInfo,
                           sizeof(BasicInfo),
                           NULL);
    if (!NT_SUCCESS(Status))
    {
        ok_(File, Line)(0, "NtQueryObject failed with status 0x%lx\n", Status);
        return;
    }
    ok_(File, Line)(0, "Handle %p still has %lu open handles, %lu references\n", hObject, BasicInfo.HandleCount, BasicInfo.PointerCount);
}

Referenced by CloseProcessAndVerify_().

WaitExpect_()

static VOID WaitExpect_ ( _In_ HANDLE  hWait, _In_ DWORD  Milliseconds, _In_ DWORD  ExpectedError, _In_ PCSTR  File, _In_ INT  Line  )

static

Definition at line 92 of file TerminateProcess.c.

{
    DWORD Error;
 
    Error = WaitForSingleObject(hWait, Milliseconds);
    ok_(File, Line)(Error == ExpectedError, "Wait for %p return %lu\n", hWait, Error);
}

Referenced by CloseProcessAndVerify_().