438 lines
14 KiB
C++
438 lines
14 KiB
C++
// --------------------------------------------------------------------------
|
|
// Module Name: Thread.cpp
|
|
//
|
|
// Copyright (c) 1999-2000, Microsoft Corporation
|
|
//
|
|
// Base class that implements thread functionality. Subclass this class and
|
|
// implement the virtual ThreadEntry function. When you instantiate this
|
|
// class a thread gets created which will call ThreadEntry and when that
|
|
// function exits will call ThreadExit. These objects should be created using
|
|
// operator new because the default implementation of ThreadExit does
|
|
// "delete this". You should override this function if you don't want this
|
|
// behavior. The threads are also created SUSPENDED. You make any changes
|
|
// that are required in the subclass' constructor. At the end of the
|
|
// constructor or from the caller of operator new a "->Resume()" can be
|
|
// invoked to start the thread.
|
|
//
|
|
// History: 1999-08-24 vtan created
|
|
// 2000-02-01 vtan moved from Neptune to Whistler
|
|
// --------------------------------------------------------------------------
|
|
|
|
#include "StandardHeader.h"
|
|
#include "Thread.h"
|
|
|
|
#include "Access.h"
|
|
#include "Impersonation.h"
|
|
#include "StatusCode.h"
|
|
#include "TokenInformation.h"
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThread::CThread
|
|
//
|
|
// Arguments: stackSpace = Size of stack to reserve for this
|
|
// thread. Default = system default.
|
|
// createFlags = Additional flags designating how
|
|
// the thread should be created.
|
|
// Default = none.
|
|
// hToken = User token to assign to the
|
|
// thread. Default = none.
|
|
// pSecurityDescriptor = SecurityDescriptor to assign to
|
|
// thread. Default = none.
|
|
//
|
|
// Returns: <none>
|
|
//
|
|
// Purpose: Initializes the CThread object. Creates the thread SUSPENDED
|
|
// with given security attributes and assigns the hToken to the
|
|
// thread. The token need not have SecurityImpersonation as a
|
|
// duplicate is made with this access mode.
|
|
//
|
|
// History: 1999-08-24 vtan created
|
|
// 2000-02-01 vtan moved from Neptune to Whistler
|
|
// --------------------------------------------------------------------------
|
|
|
|
CThread::CThread (DWORD stackSpace, DWORD createFlags, HANDLE hToken) :
|
|
CCountedObject(),
|
|
_hThread(NULL),
|
|
_fCompleted(false)
|
|
|
|
{
|
|
DWORD dwThreadID;
|
|
|
|
// It is important to create the thread suspended. This constructor could
|
|
// get pre-empted by the system and does. If pre-empted whilst executing
|
|
// the constructor, the derived class is NOT fully constructed and the
|
|
// virtual table isn't correctly initialized.
|
|
|
|
_hThread = CreateThread(NULL,
|
|
stackSpace,
|
|
ThreadEntryProc,
|
|
this,
|
|
createFlags | CREATE_SUSPENDED,
|
|
&dwThreadID);
|
|
if (_hThread != NULL)
|
|
{
|
|
|
|
// Make a call to CCountedObject::AddRef here. This reference belongs
|
|
// to the thread. It's necessary to do it now because the creator of
|
|
// this thread can release its reference before the thread even begins
|
|
// executing which would cause the object to be released!
|
|
// CThread::ThreadEntryProc will release this reference when the
|
|
// thread's execution is finished. The creator of this thread should
|
|
// release its reference when it's done with the thread which may be
|
|
// immediately in the case of an asynhronous operation in which the
|
|
// thread cleans itself up.
|
|
|
|
AddRef();
|
|
|
|
// Impersonate the user token if given. Also grant access to the thread
|
|
// object to the user. This will allow them to query thread information.
|
|
|
|
if (hToken != NULL)
|
|
{
|
|
TSTATUS(SetToken(hToken));
|
|
}
|
|
}
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThread::~CThread
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: <none>
|
|
//
|
|
// Purpose: Releases resources used by the CThread object on thread
|
|
// termination.
|
|
//
|
|
// History: 1999-08-24 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
CThread::~CThread (void)
|
|
|
|
{
|
|
ASSERTMSG(_fCompleted, "CThread::~CThread called before ThreadEntry() completed");
|
|
ReleaseHandle(_hThread);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThread::operator HANDLE
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: <none>
|
|
//
|
|
// Purpose: Magically converts a CThread to a HANDLE
|
|
//
|
|
// History: 1999-09-21 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
CThread::operator HANDLE (void) const
|
|
|
|
{
|
|
return(_hThread);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThread::IsCreated
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: bool
|
|
//
|
|
// Purpose: Returns whether a thread was created or not.
|
|
//
|
|
// History: 2000-09-08 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
bool CThread::IsCreated (void) const
|
|
|
|
{
|
|
return(_hThread != NULL);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThread::Suspend
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: <none>
|
|
//
|
|
// Purpose: Suspends thread execution.
|
|
//
|
|
// History: 1999-08-24 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
void CThread::Suspend (void) const
|
|
|
|
{
|
|
if (SuspendThread(_hThread) == 0xFFFFFFFF)
|
|
{
|
|
DISPLAYMSG("SuspendThread failed for thread handle in CThread::Suspend");
|
|
}
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThread::Resume
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: <none>
|
|
//
|
|
// Purpose: Resumes thread execution.
|
|
//
|
|
// History: 1999-08-24 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
void CThread::Resume (void) const
|
|
|
|
{
|
|
if ((_hThread == NULL) || (ResumeThread(_hThread) == 0xFFFFFFFF))
|
|
{
|
|
DISPLAYMSG("ResumeThread failed for thread handle in CThread::Resume");
|
|
}
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThread::Terminate
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: NTSTATUS
|
|
//
|
|
// Purpose: Forcibly terminates the thread. Use this with care. It should
|
|
// only be used in case a sub-class constructor fails and the
|
|
// thread is suspended and hasn't even run yet.
|
|
//
|
|
// History: 2000-10-18 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
NTSTATUS CThread::Terminate (void)
|
|
|
|
{
|
|
NTSTATUS status;
|
|
|
|
if (TerminateThread(_hThread, 0) != FALSE)
|
|
{
|
|
_fCompleted = true;
|
|
Release();
|
|
ReleaseHandle(_hThread);
|
|
status = STATUS_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
status = CStatusCode::StatusCodeOfLastError();
|
|
}
|
|
return(status);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThread::IsCompleted
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: bool
|
|
//
|
|
// Purpose: Determines whether the thread has completed execution. This
|
|
// does not check the signaled state of the thread handle but
|
|
// rather checks member variables.
|
|
//
|
|
// History: 1999-08-24 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
bool CThread::IsCompleted (void) const
|
|
|
|
{
|
|
DWORD dwExitCode;
|
|
|
|
return((GetExitCodeThread(_hThread, &dwExitCode) != FALSE) && (dwExitCode != STILL_ACTIVE));
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThread::WaitForCompletion
|
|
//
|
|
// Arguments: dwMilliseconds = Number of milliseconds to wait for
|
|
// thread completion.
|
|
//
|
|
// Returns: DWORD
|
|
//
|
|
// Purpose: Waits for the thread handle to become signaled.
|
|
//
|
|
// History: 1999-08-24 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
DWORD CThread::WaitForCompletion (DWORD dwMilliseconds) const
|
|
|
|
{
|
|
DWORD dwWaitResult;
|
|
|
|
do
|
|
{
|
|
|
|
// When waiting for the object check to see that it's not signaled.
|
|
// If signaled then abandon the wait loop. Otherwise allow user32
|
|
// to continue processing messages for this thread.
|
|
|
|
dwWaitResult = WaitForSingleObject(_hThread, 0);
|
|
if (dwWaitResult != WAIT_OBJECT_0)
|
|
{
|
|
dwWaitResult = MsgWaitForMultipleObjects(1, &_hThread, FALSE, dwMilliseconds, QS_ALLINPUT);
|
|
if (dwWaitResult == WAIT_OBJECT_0 + 1)
|
|
{
|
|
MSG msg;
|
|
|
|
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) != FALSE)
|
|
{
|
|
(BOOL)TranslateMessage(&msg);
|
|
(LRESULT)DispatchMessage(&msg);
|
|
}
|
|
}
|
|
}
|
|
} while (dwWaitResult == WAIT_OBJECT_0 + 1);
|
|
return(dwWaitResult);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThread::GetResult
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: DWORD
|
|
//
|
|
// Purpose: Gets the thread's exit code. This assumes it has completed
|
|
// execution and returns STILL_ACTIVE if not completed.
|
|
//
|
|
// History: 1999-08-24 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
DWORD CThread::GetResult (void) const
|
|
|
|
{
|
|
DWORD dwResult;
|
|
|
|
if (GetExitCodeThread(_hThread, &dwResult) == FALSE)
|
|
{
|
|
dwResult = STILL_ACTIVE;
|
|
}
|
|
return(dwResult);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThread::GetPriority
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: int
|
|
//
|
|
// Purpose: Gets the thread's priority.
|
|
//
|
|
// History: 1999-08-24 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
int CThread::GetPriority (void) const
|
|
|
|
{
|
|
return(GetThreadPriority(_hThread));
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThread::SetPriority
|
|
//
|
|
// Arguments: newPriority = New priority for the thread.
|
|
//
|
|
// Returns: <none>
|
|
//
|
|
// Purpose: Sets the thread's priority.
|
|
//
|
|
// History: 1999-08-24 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
void CThread::SetPriority (int newPriority) const
|
|
|
|
{
|
|
if (SetThreadPriority(_hThread, newPriority) == 0)
|
|
{
|
|
DISPLAYMSG("SetThreadPriorty failed in CThread::SetPriority");
|
|
}
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThread::ThreadExit
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: <none>
|
|
//
|
|
// Purpose: Default base class implementation of thread exit. For threads
|
|
// whose execution is self contained and termination is not an
|
|
// issue then this will clean up after the thread. This function
|
|
// should be overriden if this behavior is NOT desired.
|
|
//
|
|
// History: 1999-08-24 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
void CThread::Exit (void)
|
|
|
|
{
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThread::SetToken
|
|
//
|
|
// Arguments: hToken = HANDLE to the user token to assign to this thread.
|
|
//
|
|
// Returns: NTSTATUS
|
|
//
|
|
// Purpose: Sets the impersonation token associated with this thread so
|
|
// the thread will execute in the user's context from the start.
|
|
//
|
|
// History: 1999-09-23 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
NTSTATUS CThread::SetToken (HANDLE hToken)
|
|
|
|
{
|
|
PSID pLogonSID;
|
|
CTokenInformation tokenInformation(hToken);
|
|
|
|
pLogonSID = tokenInformation.GetLogonSID();
|
|
if (pLogonSID != NULL)
|
|
{
|
|
CSecuredObject threadSecurity(_hThread, SE_KERNEL_OBJECT);
|
|
|
|
TSTATUS(threadSecurity.Allow(pLogonSID,
|
|
THREAD_GET_CONTEXT | THREAD_QUERY_INFORMATION,
|
|
0));
|
|
TSTATUS(CImpersonation::ImpersonateUser(_hThread, hToken));
|
|
}
|
|
return(STATUS_SUCCESS);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThread::ThreadEntryProc
|
|
//
|
|
// Arguments: pParameter = "this" object.
|
|
//
|
|
// Returns: DWORD
|
|
//
|
|
// Purpose: Entry procedure for the thread. This manages the type-casting
|
|
// and invokation of CThread::ThreadEntry and CThread::ThreadExit
|
|
// as well as the _fCompleted member variable.
|
|
//
|
|
// History: 1999-08-24 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
DWORD WINAPI CThread::ThreadEntryProc (void *parameter)
|
|
|
|
{
|
|
DWORD dwThreadResult;
|
|
CThread *pThread;
|
|
|
|
pThread = static_cast<CThread*>(parameter);
|
|
dwThreadResult = pThread->Entry();
|
|
pThread->_fCompleted = true;
|
|
pThread->Exit();
|
|
pThread->Release();
|
|
return(dwThreadResult);
|
|
}
|
|
|