|
|
// --------------------------------------------------------------------------
// Module Name: GracefulTerminateApplication.cpp
//
// Copyright (c) 2000, Microsoft Corporation
//
// Class to manager terminating applications gracefully.
//
// History: 2000-10-27 vtan created
// 2000-11-04 vtan split into separate file
// --------------------------------------------------------------------------
#ifdef _X86_
#include "StandardHeader.h"
#include "GracefulTerminateApplication.h"
#include "KernelResources.h"
#include "Thread.h"
#include "WarningDialog.h"
// --------------------------------------------------------------------------
// CProgressDialog
//
// Purpose: A class to manage displaying a progress dialog on a separate
// thread if a certain period of time elapses. This is so that
// in case the process doesn't terminate in a period of time
// a dialog indicating wait is shown so the user is not left
// staring at a blank screen.
//
// History: 2000-11-04 vtan created
// --------------------------------------------------------------------------
class CProgressDialog : public CThread{ private: CProgressDialog (void); public: CProgressDialog (CWarningDialog *pWarningDialog); virtual ~CProgressDialog (void);
void SignalTerminated (void); protected: virtual DWORD Entry (void); private: CWarningDialog* _pWarningDialog; CEvent _event;};
// --------------------------------------------------------------------------
// CProgressDialog::CProgressDialog
//
// Arguments: <none>
//
// Returns: <none>
//
// Purpose: Constructor for CProgressDialog. Keeps a reference to the
// given CWarningDialog.
//
// History: 2000-11-04 vtan created
// --------------------------------------------------------------------------
CProgressDialog::CProgressDialog (CWarningDialog *pWarningDialog) : _pWarningDialog(NULL), _event(NULL)
{ if (IsCreated()) { pWarningDialog->AddRef(); _pWarningDialog = pWarningDialog; Resume(); }}
// --------------------------------------------------------------------------
// CProgressDialog::~CProgressDialog
//
// Arguments: <none>
//
// Returns: <none>
//
// Purpose: Releases the CWarningDialog reference.
//
// History: 2000-11-04 vtan created
// --------------------------------------------------------------------------
CProgressDialog::~CProgressDialog (void)
{ _pWarningDialog->Release(); _pWarningDialog = NULL;}
// --------------------------------------------------------------------------
// CProgressDialog::SignalTerminated
//
// Arguments: <none>
//
// Returns: <none>
//
// Purpose: Signals the internal event that the process being watched is
// termination. This is necessary because there is no handle to
// the actual process to watch as it's kept on the server side
// and not given to us the client. However, the result of the
// termination is. Signaling this object will release the waiting
// thread and cause it to exit.
//
// History: 2000-11-04 vtan created
// --------------------------------------------------------------------------
void CProgressDialog::SignalTerminated (void)
{ TSTATUS(_event.Set());}
// --------------------------------------------------------------------------
// CProgressDialog::Entry
//
// Arguments: <none>
//
// Returns: DWORD
//
// Purpose: Thread which waits for the internal event to be signaled. If
// the event is signaled it will "cancel" the 3 second wait and
// the thread will exit. Otherwise the wait times out and the
// progress dialog is shown - waiting for termination.
//
// History: 2000-11-04 vtan created
// --------------------------------------------------------------------------
DWORD CProgressDialog::Entry (void)
{ DWORD dwWaitResult;
// Wait for the event to be signaled or for it to timeout. If signaled
// then the process is terminated and no progress is required. Otherwise
// prepare to show progress while the process is being terminated.
if (NT_SUCCESS(_event.Wait(2000, &dwWaitResult)) && (WAIT_TIMEOUT == dwWaitResult)) { _pWarningDialog->ShowProgress(100, 7500); } return(0);}
// --------------------------------------------------------------------------
// CGracefulTerminateApplication::CGracefulTerminateApplication
//
// Arguments: <none>
//
// Returns: <none>
//
// Purpose: Constructor for CGracefulTerminateApplication.
//
// History: 2000-10-27 vtan created
// --------------------------------------------------------------------------
CGracefulTerminateApplication::CGracefulTerminateApplication (void) : _dwProcessID(0), _fFoundWindow(false)
{}
// --------------------------------------------------------------------------
// CGracefulTerminateApplication::~CGracefulTerminateApplication
//
// Arguments: <none>
//
// Returns: <none>
//
// Purpose: Destructor for CGracefulTerminateApplication.
//
// History: 2000-10-27 vtan created
// --------------------------------------------------------------------------
CGracefulTerminateApplication::~CGracefulTerminateApplication (void)
{}
// --------------------------------------------------------------------------
// CGracefulTerminateApplication::Terminate
//
// Arguments: dwProcessID = Process ID of process to terminate.
//
// Returns: <none>
//
// Purpose: Walk the window list for top level windows that correspond
// to this process ID and are visible. Close them. The callback
// handles the work and this function returns the result in the
// process exit code which the server examines.
//
// History: 2000-10-27 vtan created
// --------------------------------------------------------------------------
void CGracefulTerminateApplication::Terminate (DWORD dwProcessID)
{ DWORD dwExitCode;
_dwProcessID = dwProcessID; TBOOL(EnumWindows(EnumWindowsProc, reinterpret_cast<LPARAM>(this))); if (_fFoundWindow) { dwExitCode = WAIT_WINDOWS_FOUND; } else { dwExitCode = NO_WINDOWS_FOUND; } ExitProcess(dwExitCode);}
// --------------------------------------------------------------------------
// CGracefulTerminateApplication::Prompt
//
// Arguments: hInstance = HINSTANCE of this DLL.
// hProcess = Inherited handle to parent process.
//
// Returns: <none>
//
// Purpose: Shows a prompt that handles termination of the parent of this
// process. The parent is assumed to be a bad application type 1
// that caused this stub to be executed via the
// "rundll32 shsvcs.dll,FUSCompatibilityEntry prompt" command.
// Because there can only be a single instance of the type 1
// application running and the parent of this process hasn't
// registered yet querying for this process by image name will
// always find the correct process.
//
// History: 2000-11-03 vtan created
// --------------------------------------------------------------------------
void CGracefulTerminateApplication::Prompt (HINSTANCE hInstance, HANDLE hProcess)
{ bool fTerminated; ULONG ulReturnLength; PROCESS_BASIC_INFORMATION processBasicInformation;
// Read the parent's image name from the RTL_USER_PROCESS_PARAMETERS.
fTerminated = false; if (hProcess != NULL) { if (NT_SUCCESS(NtQueryInformationProcess(hProcess, ProcessBasicInformation, &processBasicInformation, sizeof(processBasicInformation), &ulReturnLength))) { SIZE_T dwNumberOfBytesRead; PEB peb;
if (ReadProcessMemory(hProcess, processBasicInformation.PebBaseAddress, &peb, sizeof(peb), &dwNumberOfBytesRead) != FALSE) { RTL_USER_PROCESS_PARAMETERS processParameters;
if (ReadProcessMemory(hProcess, peb.ProcessParameters, &processParameters, sizeof(processParameters), &dwNumberOfBytesRead) != FALSE) { WCHAR *pszImageName;
pszImageName = static_cast<WCHAR*>(LocalAlloc(LMEM_FIXED, processParameters.ImagePathName.Length + (sizeof('\0') * sizeof(WCHAR)))); if (pszImageName != NULL) { if (ReadProcessMemory(hProcess, processParameters.ImagePathName.Buffer, pszImageName, processParameters.ImagePathName.Length, &dwNumberOfBytesRead) != FALSE) { pszImageName[processParameters.ImagePathName.Length / sizeof(WCHAR)] = L'\0';
// And show a prompt for this process.
fTerminated = ShowPrompt(hInstance, pszImageName); } (HLOCAL)LocalFree(pszImageName); } } } } TBOOL(CloseHandle(hProcess)); } ExitProcess(fTerminated);}
// --------------------------------------------------------------------------
// CGracefulTerminateApplication::ShowPrompt
//
// Arguments: hInstance = HINSTANCE of this DLL.
// pszImagename = Image name of process to terminate.
//
// Returns: bool
//
// Purpose: Shows the appropriate prompt for termination of the first
// instance of a BAM type 1 process. If the current user does
// not have administrator privileges then a "STOP" dialog is
// shown that the user must get the other user to close the
// program. Otherwise the "PROMPT" dialog is shown which gives
// the user the option to terminate the process.
//
// If termination is requested and the termatinion fails the
// another warning dialog to that effect is shown.
//
// History: 2000-11-03 vtan created
// --------------------------------------------------------------------------
bool CGracefulTerminateApplication::ShowPrompt (HINSTANCE hInstance, const WCHAR *pszImageName)
{ bool fTerminated; ULONG ulConnectionInfoLength; HANDLE hPort; UNICODE_STRING portName; SECURITY_QUALITY_OF_SERVICE sqos; WCHAR szConnectionInfo[32];
fTerminated = false; RtlInitUnicodeString(&portName, FUS_PORT_NAME); sqos.Length = sizeof(sqos); sqos.ImpersonationLevel = SecurityImpersonation; sqos.ContextTrackingMode = SECURITY_DYNAMIC_TRACKING; sqos.EffectiveOnly = TRUE; lstrcpyW(szConnectionInfo, FUS_CONNECTION_REQUEST); ulConnectionInfoLength = sizeof(szConnectionInfo); if (NT_SUCCESS(NtConnectPort(&hPort, &portName, &sqos, NULL, NULL, NULL, szConnectionInfo, &ulConnectionInfoLength))) { bool fCanTerminateFirstInstance; CWarningDialog *pWarningDialog; WCHAR szUser[256];
// Get the user's privilege level for this operation. This API also
// returns the current user for the BAM type 1 process.
fCanTerminateFirstInstance = CanTerminateFirstInstance(hPort, pszImageName, szUser, ARRAYSIZE(szUser)); pWarningDialog = new CWarningDialog(hInstance, NULL, pszImageName, szUser); if (pWarningDialog != NULL) {
// Show the appropriate dialog based on the privilege level.
if (pWarningDialog->ShowPrompt(fCanTerminateFirstInstance) == IDOK) { CProgressDialog *pProgressDialog;
// Create a progress dialog object in case of delayed termination.
// This will create the watcher thread.
pProgressDialog = new CProgressDialog(pWarningDialog); if ((pProgressDialog != NULL) && !pProgressDialog->IsCreated()) { pProgressDialog->Release(); pProgressDialog = NULL; }
// Attempt to terminate the process if requested by the user.
fTerminated = TerminatedFirstInstance(hPort, pszImageName);
// Once this function returns signal the event (in case the
// thread is still waiting). If the thread is still waiting this
// effectively cancels the dialog. Either way if the dialog is
// shown then close it, wait for the thread to exit and release
// the reference to destroy the object.
if (pProgressDialog != NULL) { pProgressDialog->SignalTerminated(); pWarningDialog->CloseDialog(); pProgressDialog->WaitForCompletion(INFINITE); pProgressDialog->Release(); }
// If there was some failure then let the user know.
if (!fTerminated) { pWarningDialog->ShowFailure(); } } pWarningDialog->Release(); } TBOOL(CloseHandle(hPort)); } return(fTerminated);}
// --------------------------------------------------------------------------
// CGracefulTerminateApplication::CanTerminateFirstInstance
//
// Arguments: hPort = Port to server.
// pszImageName = Image name of process to terminate.
// pszUser = User of process (returned).
// cchUser = Count of characters for buffer.
//
// Returns: bool
//
// Purpose: Asks the server whether the current user has privileges to
// terminate the BAM type 1 process of the given image name
// which is known to be running. The API returns whether the
// operation is allowed and who the current user of the process
// is.
//
// History: 2000-11-03 vtan created
// --------------------------------------------------------------------------
bool CGracefulTerminateApplication::CanTerminateFirstInstance (HANDLE hPort, const WCHAR *pszImageName, WCHAR *pszUser, int cchUser)
{ bool fCanTerminate;
fCanTerminate = false; if ((hPort != NULL) && (pszImageName != NULL)) { FUSAPI_PORT_MESSAGE portMessageIn, portMessageOut;
ZeroMemory(&portMessageIn, sizeof(portMessageIn)); ZeroMemory(&portMessageOut, sizeof(portMessageOut)); portMessageIn.apiBAM.apiGeneric.ulAPINumber = API_BAM_QUERYUSERPERMISSION; portMessageIn.apiBAM.apiSpecific.apiQueryUserPermission.in.pszImageName = pszImageName; portMessageIn.apiBAM.apiSpecific.apiQueryUserPermission.in.cchImageName = lstrlen(pszImageName) + sizeof('\0'); portMessageIn.apiBAM.apiSpecific.apiQueryUserPermission.in.pszUser = pszUser; portMessageIn.apiBAM.apiSpecific.apiQueryUserPermission.in.cchUser = cchUser; portMessageIn.portMessage.u1.s1.DataLength = sizeof(API_BAM); portMessageIn.portMessage.u1.s1.TotalLength = static_cast<CSHORT>(sizeof(FUSAPI_PORT_MESSAGE)); if (NT_SUCCESS(NtRequestWaitReplyPort(hPort, &portMessageIn.portMessage, &portMessageOut.portMessage)) && NT_SUCCESS(portMessageOut.apiBAM.apiGeneric.status)) { fCanTerminate = portMessageOut.apiBAM.apiSpecific.apiQueryUserPermission.out.fCanShutdownApplication; pszUser[cchUser - sizeof('\0')] = L'\0'; } else { pszUser[0] = L'\0'; } } return(fCanTerminate);}
// --------------------------------------------------------------------------
// CGracefulTerminateApplication::TerminatedFirstInstance
//
// Arguments: hPort = Port to server.
// pszImageName = Image name to terminate.
//
// Returns: bool
//
// Purpose: Asks the server to terminate the first running instance of the
// BAM type 1 process.
//
// History: 2000-11-03 vtan created
// --------------------------------------------------------------------------
bool CGracefulTerminateApplication::TerminatedFirstInstance (HANDLE hPort, const WCHAR *pszImageName)
{ bool fTerminated;
fTerminated = false; if (hPort != NULL) { FUSAPI_PORT_MESSAGE portMessageIn, portMessageOut;
ZeroMemory(&portMessageIn, sizeof(portMessageIn)); ZeroMemory(&portMessageOut, sizeof(portMessageOut)); portMessageIn.apiBAM.apiGeneric.ulAPINumber = API_BAM_TERMINATERUNNING; portMessageIn.apiBAM.apiSpecific.apiTerminateRunning.in.pszImageName = pszImageName; portMessageIn.apiBAM.apiSpecific.apiTerminateRunning.in.cchImageName = lstrlen(pszImageName) + sizeof('\0'); portMessageIn.portMessage.u1.s1.DataLength = sizeof(API_BAM); portMessageIn.portMessage.u1.s1.TotalLength = static_cast<CSHORT>(sizeof(FUSAPI_PORT_MESSAGE)); if (NT_SUCCESS(NtRequestWaitReplyPort(hPort, &portMessageIn.portMessage, &portMessageOut.portMessage)) && NT_SUCCESS(portMessageOut.apiBAM.apiGeneric.status)) { fTerminated = portMessageOut.apiBAM.apiSpecific.apiTerminateRunning.out.fResult; } } return(fTerminated);}
// --------------------------------------------------------------------------
// CGracefulTerminateApplication::EnumWindowsProc
//
// Arguments: See the platform SDK under EnumWindowsProc.
//
// Returns: See the platform SDK under EnumWindowsProc.
//
// Purpose: Top level window enumerator callback which compares the
// process IDs of the windows and whether they are visible. If
// there is a match on BOTH counts the a WM_CLOSE message is
// posted to the window to allow a graceful termination.
//
// History: 2000-10-27 vtan created
// --------------------------------------------------------------------------
BOOL CALLBACK CGracefulTerminateApplication::EnumWindowsProc (HWND hwnd, LPARAM lParam)
{ DWORD dwThreadID, dwProcessID; CGracefulTerminateApplication *pThis;
pThis = reinterpret_cast<CGracefulTerminateApplication*>(lParam); dwThreadID = GetWindowThreadProcessId(hwnd, &dwProcessID); if ((dwProcessID == pThis->_dwProcessID) && IsWindowVisible(hwnd)) { pThis->_fFoundWindow = true; TBOOL(PostMessage(hwnd, WM_CLOSE, 0, 0)); } return(TRUE);}
#endif /* _X86_ */
|
