1581 lines
37 KiB
C++
1581 lines
37 KiB
C++
/*++
|
|
|
|
Copyright (c) 1998-2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
w32proc.cpp
|
|
|
|
Abstract:
|
|
|
|
Contains the parent of the Win32 IO processing class hierarchy
|
|
for TS Device Redirection, W32ProcObj.
|
|
|
|
Author:
|
|
|
|
madan appiah (madana) 16-Sep-1998
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include <precom.h>
|
|
|
|
#define TRC_FILE "w32proc"
|
|
|
|
#include "rdpdrcom.h"
|
|
#include <winsock.h>
|
|
#include "dbt.h"
|
|
|
|
#include "w32proc.h"
|
|
#include "w32drprn.h"
|
|
#include "w32drman.h"
|
|
#include "w32drlpt.h"
|
|
#include "w32drcom.h"
|
|
#include "w32drive.h"
|
|
#include "drconfig.h"
|
|
#include "drdbg.h"
|
|
#include "thrpool.h"
|
|
|
|
|
|
W32ProcObj::W32ProcObj( VCManager *pVCM ) : ProcObj(pVCM)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Constructor
|
|
|
|
Arguments:
|
|
|
|
pVCM - Virtual Channel IO Manager
|
|
|
|
Return Value:
|
|
|
|
NA
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("W32ProcObj::W32ProcObj");
|
|
|
|
//
|
|
// Initialize the member variables.
|
|
//
|
|
_pWorkerThread = NULL;
|
|
_bWin9xFlag = FALSE;
|
|
_hRdpDrModuleHandle = NULL;
|
|
_bLocalDevicesScanned = FALSE;
|
|
_isShuttingDown = FALSE;
|
|
|
|
//
|
|
// Unit-Test Functions that Tests Thread Pools in the Background
|
|
//
|
|
#if DBG
|
|
//ThreadPoolTestInit();
|
|
#endif
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
|
|
W32ProcObj::~W32ProcObj(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Destructor for the W32ProcObj object.
|
|
|
|
Arguments:
|
|
|
|
none.
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("W32ProcObj::~W32ProcObj");
|
|
|
|
//
|
|
// Shutdown the worker thread and cleanup if we are not already shut down.
|
|
//
|
|
if ((_pWorkerThread != NULL) && (_pWorkerThread->shutDownFlag == FALSE)) {
|
|
Shutdown();
|
|
}
|
|
|
|
DC_END_FN();
|
|
return;
|
|
}
|
|
|
|
ULONG
|
|
W32ProcObj::GetDWordParameter(
|
|
LPTSTR pszValueName,
|
|
PULONG pulValue
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Reads a parameter ULONG value from the registry.
|
|
|
|
Arguments:
|
|
|
|
pszValueName - pointer to the value name string.
|
|
|
|
pulValue - pointer to an ULONG parameter location.
|
|
|
|
Return Value:
|
|
|
|
Windows Error Code.
|
|
|
|
--*/
|
|
{
|
|
ULONG ulError;
|
|
HKEY hRootKey = HKEY_CURRENT_USER;
|
|
HKEY hKey = NULL;
|
|
ULONG ulType;
|
|
ULONG ulValueDataSize;
|
|
|
|
DC_BEGIN_FN("W32ProcObj::GetDWordParameter");
|
|
|
|
TryAgain:
|
|
|
|
ulError =
|
|
RegOpenKeyEx(
|
|
hRootKey,
|
|
REG_RDPDR_PARAMETER_PATH,
|
|
0L,
|
|
KEY_READ,
|
|
&hKey);
|
|
|
|
if (ulError != ERROR_SUCCESS) {
|
|
|
|
TRC_ALT((TB, _T("RegOpenKeyEx() failed, %ld."), ulError));
|
|
|
|
if( hRootKey == HKEY_CURRENT_USER ) {
|
|
|
|
//
|
|
// try with HKEY_LOCAL_MACHINE.
|
|
//
|
|
|
|
hRootKey = HKEY_LOCAL_MACHINE;
|
|
goto TryAgain;
|
|
}
|
|
|
|
goto Cleanup;
|
|
}
|
|
|
|
ulValueDataSize = sizeof(ULONG);
|
|
ulError =
|
|
RegQueryValueEx(
|
|
hKey,
|
|
pszValueName,
|
|
NULL,
|
|
&ulType,
|
|
(PBYTE)pulValue,
|
|
&ulValueDataSize);
|
|
|
|
if (ulError != ERROR_SUCCESS) {
|
|
|
|
TRC_ALT((TB, _T("RegQueryValueEx() failed, %ld."), ulError));
|
|
|
|
if( hRootKey == HKEY_CURRENT_USER ) {
|
|
|
|
//
|
|
// try with HKEY_LOCAL_MACHINE.
|
|
//
|
|
|
|
hRootKey = HKEY_LOCAL_MACHINE;
|
|
RegCloseKey( hKey );
|
|
hKey = NULL;
|
|
|
|
goto TryAgain;
|
|
}
|
|
|
|
goto Cleanup;
|
|
}
|
|
|
|
ASSERT(ulType == REG_DWORD);
|
|
ASSERT(ulValueDataSize == sizeof(ULONG));
|
|
|
|
TRC_NRM((TB, _T("Parameter Value, %lx."), *pulValue));
|
|
|
|
//
|
|
// successfully done.
|
|
//
|
|
|
|
Cleanup:
|
|
|
|
if( hKey != NULL ) {
|
|
RegCloseKey( hKey );
|
|
}
|
|
|
|
DC_END_FN();
|
|
return( ulError );
|
|
}
|
|
|
|
ULONG W32ProcObj::GetStringParameter(
|
|
IN LPTSTR valueName,
|
|
OUT DRSTRING value,
|
|
IN ULONG maxSize
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Return Configurable string parameter.
|
|
|
|
Arguments:
|
|
|
|
valueName - Name of value to retrieve.
|
|
value - Storage location for retrieved value.
|
|
maxSize - Number of bytes available in the "value" data
|
|
area.
|
|
|
|
Return Value:
|
|
|
|
Windows Error Code.
|
|
|
|
--*/
|
|
{
|
|
ULONG ulError;
|
|
HKEY hRootKey;
|
|
HKEY hKey = NULL;
|
|
ULONG ulType;
|
|
|
|
DC_BEGIN_FN("W32ProcObj::GetStringParameter");
|
|
|
|
//
|
|
// Start with HKCU.
|
|
//
|
|
hRootKey = HKEY_CURRENT_USER;
|
|
|
|
TryAgain:
|
|
|
|
//
|
|
// Open the reg key.
|
|
//
|
|
ulError =
|
|
RegOpenKeyEx(
|
|
hRootKey,
|
|
REG_RDPDR_PARAMETER_PATH,
|
|
0L,
|
|
KEY_READ,
|
|
&hKey);
|
|
|
|
if (ulError != ERROR_SUCCESS) {
|
|
|
|
TRC_ERR((TB, _T("RegOpenKeyEx %ld."), ulError));
|
|
|
|
//
|
|
// Try with HKEY_LOCAL_MACHINE.
|
|
//
|
|
if( hRootKey == HKEY_CURRENT_USER ) {
|
|
hRootKey = HKEY_LOCAL_MACHINE;
|
|
goto TryAgain;
|
|
}
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Query the value.
|
|
//
|
|
ulError =
|
|
RegQueryValueEx(
|
|
hKey,
|
|
valueName,
|
|
NULL,
|
|
&ulType,
|
|
(PBYTE)value,
|
|
&maxSize);
|
|
|
|
if (ulError != ERROR_SUCCESS) {
|
|
|
|
TRC_ERR((TB, _T("RegQueryValueEx %ld."), ulError));
|
|
|
|
//
|
|
// Try with HKEY_LOCAL_MACHINE.
|
|
//
|
|
if( hRootKey == HKEY_CURRENT_USER ) {
|
|
hRootKey = HKEY_LOCAL_MACHINE;
|
|
RegCloseKey( hKey );
|
|
hKey = NULL;
|
|
goto TryAgain;
|
|
}
|
|
goto Cleanup;
|
|
}
|
|
|
|
ASSERT(ulType == REG_SZ);
|
|
|
|
TRC_NRM((TB, _T("Returning %s"), value));
|
|
|
|
//
|
|
// Successfully done.
|
|
//
|
|
Cleanup:
|
|
|
|
if( hKey != NULL ) {
|
|
RegCloseKey( hKey );
|
|
}
|
|
|
|
DC_END_FN();
|
|
return ulError;
|
|
}
|
|
|
|
ULONG W32ProcObj::Initialize()
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Initialize an instance of this class.
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
ERROR_SUCCESS on success. Windows error status, otherwise.
|
|
|
|
--*/
|
|
{
|
|
ULONG status = ERROR_SUCCESS;
|
|
|
|
DC_BEGIN_FN("W32ProcObj::Initialize");
|
|
|
|
//
|
|
// We are not shutting down.
|
|
//
|
|
_isShuttingDown = FALSE;
|
|
|
|
//
|
|
// Find out which version of the OS is being run.
|
|
//
|
|
OSVERSIONINFO osVersion;;
|
|
osVersion.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
|
|
if (!GetVersionEx(&osVersion)) {
|
|
status = GetLastError();
|
|
TRC_ERR((TB, _T("GetVersionEx: %08X"), status));
|
|
SetValid(FALSE);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Are we a 9x OS?
|
|
//
|
|
if (osVersion.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) {
|
|
_bWin9xFlag = TRUE;
|
|
}
|
|
|
|
//
|
|
// Get the background thread timeout value from the registry,
|
|
// if it is defined.
|
|
//
|
|
if (GetDWordParameter(
|
|
REGISTRY_BACKGROUNDTHREAD_TIMEOUT_NAME,
|
|
&_threadTimeout
|
|
) != ERROR_SUCCESS) {
|
|
_threadTimeout = REGISTRY_BACKGROUNDTHREAD_TIMEOUT_DEFAULT;
|
|
}
|
|
TRC_NRM((TB, _T("Thread timeout is %08X"), _threadTimeout));
|
|
|
|
//
|
|
// Instantiate the thread pool.
|
|
//
|
|
_threadPool = new ThreadPool(THRPOOL_DEFAULTMINTHREADS,
|
|
THRPOOL_DEFAULTMAXTHREADS, _threadTimeout);
|
|
if (_threadPool == NULL) {
|
|
status = ERROR_NOT_ENOUGH_MEMORY;
|
|
TRC_ERR((TB, L"Error allocating thread pool."));
|
|
SetValid(FALSE);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
status = _threadPool->Initialize();
|
|
if (status != ERROR_SUCCESS) {
|
|
delete _threadPool;
|
|
_threadPool = NULL;
|
|
SetValid(FALSE);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Create and resume the worker thread.
|
|
//
|
|
status = CreateWorkerThreadEntry(&_pWorkerThread);
|
|
if (status != ERROR_SUCCESS) {
|
|
SetValid(FALSE);
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
if (ResumeThread(_pWorkerThread->hWorkerThread) == 0xFFFFFFFF ) {
|
|
SetValid(FALSE);
|
|
status = GetLastError();
|
|
TRC_ERR((TB, _T("ResumeThread: %08X"), status));
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
//
|
|
// Call the parent's init function.
|
|
//
|
|
status = ProcObj::Initialize();
|
|
if (status != ERROR_SUCCESS) {
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
DC_END_FN();
|
|
|
|
return status;
|
|
}
|
|
|
|
VOID
|
|
W32ProcObj::Shutdown()
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Triggers the _hShutdownEvent event to terminate the worker thread and
|
|
cleans up all resources.
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG i;
|
|
DWORD waitResult;
|
|
|
|
DC_BEGIN_FN("W32ProcObj::Shutdown");
|
|
|
|
#if DBG
|
|
//ThreadPoolTestShutdown();
|
|
#endif
|
|
|
|
//
|
|
// Indicate that the object is in a shutdown state.
|
|
//
|
|
_isShuttingDown = TRUE;
|
|
|
|
//
|
|
// Wait for the worker thread to shut down.
|
|
//
|
|
if (_pWorkerThread != NULL) {
|
|
|
|
//
|
|
// Trigger worker thread shutdown and record that we are shutting down.
|
|
//
|
|
_pWorkerThread->shutDownFlag = TRUE;
|
|
SetEvent(_pWorkerThread->controlEvent);
|
|
|
|
//
|
|
// Wait for it to shut down. DebugBreak if we hit the timeout, even in
|
|
// free builds. By default, the timeout is infinite.
|
|
//
|
|
if (_pWorkerThread->hWorkerThread != NULL) {
|
|
|
|
TRC_NRM((TB, _T("Waiting for worker thread to shut down.")));
|
|
waitResult = WaitForSingleObject(
|
|
_pWorkerThread->hWorkerThread,
|
|
_threadTimeout
|
|
);
|
|
if (waitResult == WAIT_TIMEOUT) {
|
|
TRC_ERR((TB, _T("Thread timeout")));
|
|
DebugBreak();
|
|
}
|
|
else if (waitResult != WAIT_OBJECT_0) {
|
|
TRC_ERR((TB, _T("WaitForSingleObject: %08X"), waitResult));
|
|
ASSERT(FALSE);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Remove all the threads in the thread pool.
|
|
//
|
|
if (_threadPool != NULL) {
|
|
_threadPool->RemoveAllThreads();
|
|
}
|
|
|
|
//
|
|
// Finish all outstanding IO requests and clean up respective
|
|
// request contexts. First object is the control event. Second
|
|
// object is the operation dispatch queue data ready event.
|
|
//
|
|
for (i=2; i<_pWorkerThread->waitableObjectCount; i++) {
|
|
|
|
PASYNCIOREQCONTEXT reqContext = _pWorkerThread->waitingReqs[i];
|
|
ASSERT(reqContext != NULL);
|
|
if (reqContext->ioCompleteFunc != NULL) {
|
|
reqContext->ioCompleteFunc(reqContext->clientContext,
|
|
ERROR_CANCELLED);
|
|
}
|
|
delete reqContext;
|
|
}
|
|
|
|
//
|
|
// Finish any pending operations in the worker thread's opearation
|
|
// dispatch queue.
|
|
//
|
|
|
|
//
|
|
// Clean up the control event and release the worker thread info. struct.
|
|
//
|
|
ASSERT(_pWorkerThread->controlEvent != NULL);
|
|
CloseHandle(_pWorkerThread->controlEvent);
|
|
if (_pWorkerThread->dispatchQueue != NULL) {
|
|
delete _pWorkerThread->dispatchQueue;
|
|
}
|
|
delete _pWorkerThread;
|
|
_pWorkerThread = NULL;
|
|
}
|
|
|
|
//
|
|
// Let go of the thread pool.
|
|
//
|
|
if (_threadPool != NULL) {
|
|
delete _threadPool;
|
|
_threadPool = NULL;
|
|
}
|
|
|
|
//
|
|
// Release attached DLL's
|
|
//
|
|
if (_hRdpDrModuleHandle != NULL) {
|
|
FreeLibrary( _hRdpDrModuleHandle );
|
|
_hRdpDrModuleHandle = NULL;
|
|
}
|
|
|
|
DC_END_FN();
|
|
return;
|
|
}
|
|
|
|
VOID
|
|
W32ProcObj::AnnounceDevicesToServer()
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Enumerate devices and announce them to the server.
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("W32ProcObj::AnnounceDevicesToServer");
|
|
|
|
DispatchAsyncIORequest(
|
|
(RDPAsyncFunc_StartIO)W32ProcObj::_AnnounceDevicesToServerFunc,
|
|
NULL,
|
|
NULL,
|
|
this
|
|
);
|
|
}
|
|
|
|
HANDLE W32ProcObj::_AnnounceDevicesToServerFunc(
|
|
W32ProcObj *obj,
|
|
DWORD *status
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Enumerate devices and announce them to the server from the
|
|
worker thread.
|
|
|
|
Arguments:
|
|
|
|
obj - Relevant W32ProcObj instance.
|
|
status - Return status.
|
|
|
|
Return Value:
|
|
|
|
NULL
|
|
|
|
--*/
|
|
{
|
|
obj->AnnounceDevicesToServerFunc(status);
|
|
return NULL;
|
|
}
|
|
VOID W32ProcObj::AnnounceDevicesToServerFunc(
|
|
DWORD *status
|
|
)
|
|
{
|
|
DC_BEGIN_FN("W32ProcObj::AnnounceDevicesToServerFunc");
|
|
|
|
ULONG count, i;
|
|
PRDPDR_HEADER pPacketHeader = NULL;
|
|
INT sz;
|
|
|
|
ASSERT(_initialized);
|
|
|
|
*status = ERROR_SUCCESS;
|
|
|
|
//
|
|
// If we haven't already scanned for local devices.
|
|
//
|
|
if (!_bLocalDevicesScanned) {
|
|
_bLocalDevicesScanned = TRUE;
|
|
|
|
//
|
|
// Invoke the enum functions.
|
|
//
|
|
count = DeviceEnumFunctionsCount();
|
|
for (i=0; i<count; i++) {
|
|
|
|
// Bail out if the shutdown flag is set.
|
|
if (_pWorkerThread->shutDownFlag == TRUE) {
|
|
TRC_NRM((TB, _T("Bailing out because shutdown flag is set.")));
|
|
*status = WAIT_TIMEOUT;
|
|
goto CLEANUPANDEXIT;
|
|
}
|
|
|
|
ASSERT(_DeviceEnumFunctions[i] != NULL);
|
|
_DeviceEnumFunctions[i](this, _deviceMgr);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Send the announce packet to the server. _pVCMgr cleans
|
|
// up the packet on failure and on success.
|
|
//
|
|
pPacketHeader = GenerateAnnouncePacket(&sz, FALSE);
|
|
if (pPacketHeader) {
|
|
pPacketHeader->Component = RDPDR_CTYP_CORE;
|
|
pPacketHeader->PacketId = DR_CORE_DEVICELIST_ANNOUNCE;
|
|
_pVCMgr->ChannelWriteEx(pPacketHeader, sz);
|
|
}
|
|
|
|
CLEANUPANDEXIT:
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
DWORD W32ProcObj::DispatchAsyncIORequest(
|
|
IN RDPAsyncFunc_StartIO ioStartFunc,
|
|
IN OPTIONAL RDPAsyncFunc_IOComplete ioCompleteFunc,
|
|
IN OPTIONAL RDPAsyncFunc_IOCancel ioCancelFunc,
|
|
IN OPTIONAL PVOID clientContext
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Dispatch an asynchronous IO function.
|
|
|
|
Arguments:
|
|
|
|
startFunc - Points to the function that will be called to initiate the IO.
|
|
finishFunc - Optionally, points to the function that will be called once
|
|
the IO has completed.
|
|
clientContext - Optional client information to be associated with the
|
|
IO request.
|
|
Return Value:
|
|
|
|
ERROR_SUCCESS or Windows error code.
|
|
|
|
--*/
|
|
{
|
|
PASYNCIOREQCONTEXT reqContext;
|
|
DWORD result;
|
|
|
|
DC_BEGIN_FN("W32ProcObj::DispatchAsyncIORequest");
|
|
|
|
//
|
|
// Assert that we are valid.
|
|
//
|
|
ASSERT(IsValid());
|
|
if (!IsValid()) {
|
|
DC_END_FN();
|
|
return ERROR_INVALID_FUNCTION;
|
|
}
|
|
|
|
//
|
|
// Instantiate the IO request context.
|
|
//
|
|
result = ERROR_SUCCESS;
|
|
reqContext = new ASYNCIOREQCONTEXT();
|
|
if (reqContext == NULL) {
|
|
TRC_ERR((TB, _T("Alloc failed.")));
|
|
result = ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
//
|
|
// Fill it in.
|
|
//
|
|
if (result == ERROR_SUCCESS) {
|
|
reqContext->ioStartFunc = ioStartFunc;
|
|
reqContext->ioCompleteFunc = ioCompleteFunc;
|
|
reqContext->ioCancelFunc = ioCancelFunc;
|
|
reqContext->clientContext = clientContext;
|
|
reqContext->instance = this;
|
|
}
|
|
|
|
//
|
|
// Shove it into the worker thread's operation dispatch queue.
|
|
//
|
|
if (result == ERROR_SUCCESS) {
|
|
if (!_pWorkerThread->dispatchQueue->Enqueue(
|
|
(W32DispatchQueueFunc)_DispatchAsyncIORequest_Private,
|
|
reqContext
|
|
)) {
|
|
result = GetLastError();
|
|
delete reqContext;
|
|
}
|
|
}
|
|
|
|
DC_END_FN();
|
|
return result;
|
|
}
|
|
|
|
VOID W32ProcObj::DispatchAsyncIORequest_Private(
|
|
IN PASYNCIOREQCONTEXT reqContext,
|
|
IN BOOL cancelled
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Handler for asynchronous IO request dispatching.
|
|
|
|
Arguments:
|
|
|
|
reqContext - Request context for this function.
|
|
cancelled - True if the queued request was cancelled and we need
|
|
to clean up.
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
HANDLE waitableObject;
|
|
DWORD result;
|
|
|
|
DC_BEGIN_FN("W32ProcObj::DispatchAsyncIORequest_Private");
|
|
|
|
//
|
|
// If we are being cancelled, call the cancel function. Otherwise, start the
|
|
// IO transaction.
|
|
//
|
|
if (!cancelled) {
|
|
waitableObject = reqContext->ioStartFunc(reqContext->clientContext, &result);
|
|
}
|
|
else {
|
|
TRC_NRM((TB, _T("Cancelling.")));
|
|
if (reqContext->ioCancelFunc != NULL) {
|
|
reqContext->ioCancelFunc(reqContext->clientContext);
|
|
}
|
|
waitableObject = NULL;
|
|
result = ERROR_CANCELLED;
|
|
}
|
|
|
|
//
|
|
// If we have a waitable object then add it to our list.
|
|
//
|
|
if (waitableObject != NULL) {
|
|
result = AddWaitableObjectToWorkerThread(
|
|
_pWorkerThread,
|
|
waitableObject,
|
|
reqContext
|
|
);
|
|
|
|
//
|
|
// If we couldn't add the waitable object because we have
|
|
// exceeded our max, then requeue the request, but do not
|
|
// signal new data in the queue. We will check for new
|
|
// data as soon as the waitable object count goes below the
|
|
// max.
|
|
//
|
|
if (result == ERROR_INVALID_INDEX) {
|
|
if (!_pWorkerThread->dispatchQueue->Requeue(
|
|
(W32DispatchQueueFunc)_DispatchAsyncIORequest_Private,
|
|
reqContext, FALSE)) {
|
|
|
|
result = GetLastError();
|
|
|
|
}
|
|
else {
|
|
result = ERROR_SUCCESS;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Complete if IO is not pending and clean up the request context.
|
|
//
|
|
if (waitableObject == NULL) {
|
|
if (!cancelled) {
|
|
if (reqContext->ioCompleteFunc != NULL) {
|
|
reqContext->ioCompleteFunc(reqContext->clientContext, result);
|
|
}
|
|
}
|
|
delete reqContext;
|
|
}
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
ULONG
|
|
W32ProcObj::CreateWorkerThreadEntry(
|
|
PTHREAD_INFO *ppThreadInfo
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Create a worker thread entry and start the worker thread.
|
|
|
|
Arguments:
|
|
|
|
ppThreadInfo - pointer a location where the newly created thread info is
|
|
returned.
|
|
|
|
Return Value:
|
|
|
|
Windows Status Code.
|
|
|
|
--*/
|
|
{
|
|
ULONG ulRetCode;
|
|
PTHREAD_INFO pThreadInfo = NULL;
|
|
|
|
DC_BEGIN_FN("W32ProcObj::CreateWorkerThreadEntry");
|
|
|
|
//
|
|
// Initialize return value.
|
|
//
|
|
*ppThreadInfo = NULL;
|
|
|
|
//
|
|
// Create the associated thread data structure.
|
|
//
|
|
pThreadInfo = new THREAD_INFO();
|
|
if (pThreadInfo == NULL) {
|
|
TRC_ERR((TB, _T("Failed to alloc thread chain info structure.")));
|
|
ulRetCode = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Instantiate the dispatch queue.
|
|
//
|
|
pThreadInfo->dispatchQueue = new W32DispatchQueue();
|
|
if (pThreadInfo->dispatchQueue == NULL) {
|
|
TRC_ERR((TB, _T("Failed to alloc thread chain info structure.")));
|
|
ulRetCode = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto Cleanup;
|
|
}
|
|
ulRetCode = pThreadInfo->dispatchQueue->Initialize();
|
|
if (ulRetCode != ERROR_SUCCESS) {
|
|
delete pThreadInfo->dispatchQueue;
|
|
delete pThreadInfo;
|
|
pThreadInfo = NULL;
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Create the control event and zero out the shutdown flag.
|
|
//
|
|
pThreadInfo->shutDownFlag = FALSE;
|
|
pThreadInfo->controlEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
|
|
if (pThreadInfo->controlEvent == NULL) {
|
|
TRC_ERR((TB, _T("CreateEvent %ld."), GetLastError()));
|
|
delete pThreadInfo->dispatchQueue;
|
|
delete pThreadInfo;
|
|
pThreadInfo = NULL;
|
|
ulRetCode = GetLastError();
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Init waiting object info array.
|
|
//
|
|
memset(pThreadInfo->waitableObjects, 0, sizeof(pThreadInfo->waitableObjects));
|
|
memset(pThreadInfo->waitingReqs, 0, sizeof(pThreadInfo->waitingReqs));
|
|
|
|
//
|
|
// Set the first waitable object as the controller event object for
|
|
// worker thread shutdown.
|
|
//
|
|
pThreadInfo->waitableObjects[0] = pThreadInfo->controlEvent;
|
|
pThreadInfo->waitableObjectCount = 1;
|
|
|
|
//
|
|
// Set the second waitable object as the waitable event for the operation
|
|
// dispatch queue.
|
|
//
|
|
pThreadInfo->waitableObjects[1] = pThreadInfo->dispatchQueue->GetWaitableObject();
|
|
pThreadInfo->waitableObjectCount++;
|
|
|
|
//
|
|
// Create the worker thread.
|
|
//
|
|
pThreadInfo->hWorkerThread = CreateThread(
|
|
NULL, 0, _ObjectWorkerThread,
|
|
this, CREATE_SUSPENDED,
|
|
&pThreadInfo->ulThreadId
|
|
);
|
|
|
|
//
|
|
// If failure.
|
|
//
|
|
if (pThreadInfo->hWorkerThread == NULL) {
|
|
ulRetCode = GetLastError();
|
|
TRC_ERR((TB, _T("CreateThread failed, %d."), ulRetCode));
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Success!
|
|
//
|
|
ulRetCode = ERROR_SUCCESS;
|
|
|
|
//
|
|
// Set the return value.
|
|
//
|
|
*ppThreadInfo = pThreadInfo;
|
|
|
|
//
|
|
// Set the thread pointer to NULL so we don't clean up.
|
|
//
|
|
pThreadInfo = NULL;
|
|
|
|
Cleanup:
|
|
|
|
//
|
|
// Clean up on error.
|
|
//
|
|
if (pThreadInfo != NULL) {
|
|
if (pThreadInfo->dispatchQueue != NULL) {
|
|
delete pThreadInfo->dispatchQueue;
|
|
}
|
|
ASSERT(ulRetCode != ERROR_SUCCESS);
|
|
ASSERT(pThreadInfo->controlEvent != NULL);
|
|
CloseHandle(pThreadInfo->controlEvent);
|
|
delete pThreadInfo;
|
|
}
|
|
|
|
DC_END_FN();
|
|
|
|
return ulRetCode;
|
|
}
|
|
|
|
VOID
|
|
W32ProcObj::ProcessWorkerThreadObject(
|
|
PTHREAD_INFO pThreadInfo,
|
|
ULONG offset
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Process a signalled worker thread waitable object.
|
|
|
|
Arguments:
|
|
|
|
pThreadInfo - pointer to the thread info structure that triggered this even.
|
|
|
|
offset - offset of object that is signaled.
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
HANDLE hWaitableObject;
|
|
PASYNCIOREQCONTEXT reqContext;
|
|
|
|
DC_BEGIN_FN("W32ProcObj::ProcessWorkerThreadObject");
|
|
|
|
//
|
|
// Check the validity of the waitable object.
|
|
//
|
|
if (offset >= pThreadInfo->waitableObjectCount) {
|
|
ASSERT(FALSE);
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Get the parms for this waitable object.
|
|
//
|
|
hWaitableObject = pThreadInfo->waitableObjects[offset];
|
|
reqContext = pThreadInfo->waitingReqs[offset];
|
|
|
|
//
|
|
// Invoke the completion function and clean up the request context.
|
|
//
|
|
if (reqContext->ioCompleteFunc != NULL) {
|
|
reqContext->ioCompleteFunc(reqContext->clientContext, ERROR_SUCCESS);
|
|
}
|
|
delete reqContext;
|
|
|
|
//
|
|
// Move the last items to the now vacant spot and decrement the count.
|
|
//
|
|
pThreadInfo->waitableObjects[offset] =
|
|
pThreadInfo->waitableObjects[pThreadInfo->waitableObjectCount - 1];
|
|
pThreadInfo->waitingReqs[offset] =
|
|
pThreadInfo->waitingReqs[pThreadInfo->waitableObjectCount - 1];
|
|
|
|
//
|
|
// Clear the unused spot.
|
|
//
|
|
memset(&pThreadInfo->waitingReqs[pThreadInfo->waitableObjectCount - 1],
|
|
0,sizeof(pThreadInfo->waitingReqs[pThreadInfo->waitableObjectCount - 1]));
|
|
memset(&pThreadInfo->waitableObjects[pThreadInfo->waitableObjectCount - 1],
|
|
0,sizeof(pThreadInfo->waitableObjects[pThreadInfo->waitableObjectCount - 1]));
|
|
pThreadInfo->waitableObjectCount--;
|
|
|
|
//
|
|
// Check to see if there are any operations in the queue that are pending
|
|
// dispatch. This can happen if an operation was requeued because we
|
|
// exceeded the maximum number of waitable objects.
|
|
//
|
|
CheckForQueuedOperations(pThreadInfo);
|
|
|
|
Cleanup:
|
|
|
|
DC_END_FN();
|
|
return;
|
|
}
|
|
|
|
ULONG
|
|
W32ProcObj::ObjectWorkerThread(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Worker Thread that manages waitable objects and their associated
|
|
callbacks. This function allows us to do the bulk of the work for
|
|
this module in the background so our impact on the client is minimal.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG waitResult;
|
|
ULONG objectOffset;
|
|
W32DispatchQueueFunc func;
|
|
PVOID clientData;
|
|
|
|
DC_BEGIN_FN("W32ProcObj::ObjectWorkerThread");
|
|
|
|
//
|
|
// Loop Forever.
|
|
//
|
|
for (;;) {
|
|
|
|
TRC_NRM((TB, _T("Entering wait with %d objects."),
|
|
_pWorkerThread->waitableObjectCount));
|
|
|
|
//
|
|
// Wait for all the waitable objects.
|
|
//
|
|
#ifndef OS_WINCE
|
|
waitResult = WaitForMultipleObjectsEx(
|
|
_pWorkerThread->waitableObjectCount,
|
|
_pWorkerThread->waitableObjects,
|
|
FALSE,
|
|
INFINITE,
|
|
FALSE
|
|
);
|
|
#else
|
|
waitResult = WaitForMultipleObjects(
|
|
_pWorkerThread->waitableObjectCount,
|
|
_pWorkerThread->waitableObjects,
|
|
FALSE,
|
|
INFINITE
|
|
);
|
|
#endif
|
|
|
|
//
|
|
// If the signalled object is the control object or the queue dispatch queue
|
|
// data ready object then we need to check for shutdown and for data in the
|
|
// dispatch queue.
|
|
//
|
|
objectOffset = waitResult - WAIT_OBJECT_0;
|
|
if ((waitResult == WAIT_FAILED) ||
|
|
(objectOffset == 0) ||
|
|
(objectOffset == 1)) {
|
|
if (_pWorkerThread->shutDownFlag) {
|
|
TRC_NRM((TB, _T("Shutting down.")));
|
|
break;
|
|
}
|
|
else {
|
|
CheckForQueuedOperations(_pWorkerThread);
|
|
}
|
|
}
|
|
else {
|
|
if (objectOffset < _pWorkerThread->waitableObjectCount) {
|
|
ProcessWorkerThreadObject(_pWorkerThread, objectOffset);
|
|
}
|
|
else {
|
|
ASSERT(FALSE);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Cancel any outstanding IO requests.
|
|
//
|
|
TRC_NRM((TB, _T("Canceling outstanding IO.")));
|
|
while (_pWorkerThread->dispatchQueue->Dequeue(&func, &clientData)) {
|
|
func(clientData, TRUE);
|
|
}
|
|
|
|
DC_END_FN();
|
|
return 0;
|
|
}
|
|
DWORD WINAPI
|
|
W32ProcObj::_ObjectWorkerThread(
|
|
LPVOID lpParam
|
|
)
|
|
{
|
|
return ((W32ProcObj *)lpParam)->ObjectWorkerThread();
|
|
}
|
|
|
|
VOID W32ProcObj::_DispatchAsyncIORequest_Private(
|
|
IN PASYNCIOREQCONTEXT reqContext,
|
|
IN BOOL cancelled
|
|
)
|
|
{
|
|
reqContext->instance->DispatchAsyncIORequest_Private(
|
|
reqContext,
|
|
cancelled);
|
|
}
|
|
|
|
DWORD W32ProcObj::AddWaitableObjectToWorkerThread(
|
|
IN PTHREAD_INFO threadInfo,
|
|
IN HANDLE waitableObject,
|
|
IN PASYNCIOREQCONTEXT reqContext
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Add a waitable object to a worker thread.
|
|
|
|
Arguments:
|
|
|
|
threadInfo - Worker thread context.
|
|
waitableObject - Waitable object.
|
|
reqContext - Context for the IO request.
|
|
|
|
Return Value:
|
|
|
|
Returns ERROR_SUCCESS on success. Returns ERROR_INVALID_INDEX if there
|
|
isn't currently room for another waitable object in the specified
|
|
thread. Otherwise, windows error code is returned.
|
|
|
|
--*/
|
|
{
|
|
ULONG waitableObjectCount = threadInfo->waitableObjectCount;
|
|
|
|
DC_BEGIN_FN("W32ProcObj::AddWaitableObjectToWorkerThread");
|
|
|
|
//
|
|
// Make sure we don't run out of waitable objects.
|
|
//
|
|
if (waitableObjectCount < MAXIMUM_WAIT_OBJECTS) {
|
|
ASSERT(threadInfo->waitableObjects[waitableObjectCount] == NULL);
|
|
threadInfo->waitableObjects[waitableObjectCount] = waitableObject;
|
|
threadInfo->waitingReqs[waitableObjectCount] = reqContext;
|
|
threadInfo->waitableObjectCount++;
|
|
DC_END_FN();
|
|
return ERROR_SUCCESS;
|
|
}
|
|
else {
|
|
DC_END_FN();
|
|
return ERROR_INVALID_INDEX;
|
|
}
|
|
}
|
|
|
|
VOID
|
|
W32ProcObj::GetClientComputerName(
|
|
PBYTE pbBuffer,
|
|
PULONG pulBufferLen,
|
|
PBOOL pbUnicodeFlag,
|
|
PULONG pulCodePage
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Get Client Computer Name.
|
|
|
|
Arguments:
|
|
|
|
pbBuffer - pointer to a buffer where the computer name is returned.
|
|
|
|
pulBufferLen - length of the above buffer.
|
|
|
|
pbUnicodeFlag - pointer a BOOL location which is SET if the unicode returned
|
|
computer name is returned.
|
|
|
|
pulCodePage - pointer to a ULONG where the codepage value is returned if
|
|
ansi computer.
|
|
|
|
Return Value:
|
|
|
|
Window Error Code.
|
|
|
|
--*/
|
|
{
|
|
ULONG ulLen;
|
|
|
|
DC_BEGIN_FN("W32ProcObj::GetClientComputerName");
|
|
|
|
//
|
|
// check to see we have sufficient buffer.
|
|
//
|
|
|
|
ASSERT(*pulBufferLen >= ((MAX_COMPUTERNAME_LENGTH + 1) * sizeof(WCHAR)));
|
|
|
|
#ifndef OS_WINCE
|
|
if( _bWin9xFlag == TRUE ) {
|
|
|
|
//
|
|
// get ansi computer name.
|
|
//
|
|
|
|
CHAR achAnsiComputerName[MAX_COMPUTERNAME_LENGTH + 1];
|
|
|
|
ulLen = sizeof(achAnsiComputerName);
|
|
ulLen = GetComputerNameA( (LPSTR)achAnsiComputerName, &ulLen);
|
|
|
|
if( ulLen != 0 ) {
|
|
//
|
|
// Convert the string to unicode.
|
|
//
|
|
RDPConvertToUnicode(
|
|
(LPSTR)achAnsiComputerName,
|
|
(LPWSTR)pbBuffer,
|
|
*pulBufferLen );
|
|
}
|
|
}
|
|
else {
|
|
|
|
//
|
|
// get unicode computer name.
|
|
//
|
|
ULONG numChars = *pulBufferLen / sizeof(TCHAR);
|
|
ulLen = GetComputerNameW( (LPWSTR)pbBuffer, &numChars );
|
|
*pulBufferLen = numChars * sizeof(TCHAR);
|
|
}
|
|
#else
|
|
|
|
//
|
|
// get ansi computer name.
|
|
//
|
|
|
|
CHAR achAnsiComputerName[MAX_COMPUTERNAME_LENGTH + 1];
|
|
|
|
if (gethostname(achAnsiComputerName, sizeof(achAnsiComputerName)) == 0)
|
|
{
|
|
ulLen = strlen(achAnsiComputerName);
|
|
}
|
|
else {
|
|
ulLen = 0;
|
|
}
|
|
|
|
|
|
if( ulLen != 0 ) {
|
|
//
|
|
// Convert the string to unicode.
|
|
//
|
|
RDPConvertToUnicode(
|
|
(LPSTR)achAnsiComputerName,
|
|
(LPWSTR)pbBuffer,
|
|
*pulBufferLen );
|
|
}
|
|
|
|
#endif
|
|
if( ulLen == 0 ) {
|
|
|
|
ULONG ulError;
|
|
ulError = GetLastError();
|
|
|
|
ASSERT(ulError != ERROR_BUFFER_OVERFLOW);
|
|
|
|
TRC_ERR((TB, _T("GetComputerNameA() failed, %ld."), ulError));
|
|
*(LPWSTR)pbBuffer = L'\0';
|
|
}
|
|
|
|
//
|
|
// set return parameters.
|
|
//
|
|
|
|
*pbUnicodeFlag = TRUE;
|
|
*pulCodePage = 0;
|
|
|
|
*pulBufferLen = ((wcslen((LPWSTR)pbBuffer) + 1) * sizeof(WCHAR));
|
|
|
|
Cleanup:
|
|
|
|
DC_END_FN();
|
|
return;
|
|
}
|
|
|
|
VOID
|
|
W32ProcObj::CheckForQueuedOperations(
|
|
IN PTHREAD_INFO thread
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Check the operation dispatch queue for queued operations.
|
|
|
|
Arguments:
|
|
|
|
thread - Is the thread form which to dequeue the next operation.
|
|
|
|
Return Value:
|
|
|
|
ERROR_SUCCESS on success. Otherwise, Windows error code is returned.
|
|
|
|
--*/
|
|
{
|
|
W32DispatchQueueFunc func;
|
|
PVOID clientData;
|
|
|
|
DC_BEGIN_FN("W32ProcObj::CheckForQueuedOperations");
|
|
|
|
while (thread->dispatchQueue->Dequeue(&func, &clientData)) {
|
|
func(clientData, FALSE);
|
|
}
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
|
|
|
|
void
|
|
W32ProcObj::OnDeviceChange(
|
|
IN WPARAM wParam,
|
|
IN LPARAM lParam)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
On Device Change notification
|
|
|
|
Arguments:
|
|
|
|
wParam device change notification type
|
|
lParam device change info
|
|
|
|
Return Value:
|
|
|
|
N/A
|
|
|
|
--*/
|
|
|
|
{
|
|
W32DeviceChangeParam *param = NULL;
|
|
BYTE *devBuffer = NULL;
|
|
DEV_BROADCAST_HDR *pDBHdr;
|
|
DWORD status = ERROR_OUTOFMEMORY;
|
|
|
|
DC_BEGIN_FN("W32ProcObj::OnDeviceChange");
|
|
|
|
//
|
|
// We only care about device arrival and removal.
|
|
//
|
|
if (wParam == DBT_DEVICEARRIVAL || wParam == DBT_DEVICEREMOVECOMPLETE) {
|
|
pDBHdr = (DEV_BROADCAST_HDR *)lParam;
|
|
|
|
if (pDBHdr != NULL && pDBHdr->dbch_devicetype == DBT_DEVTYP_VOLUME) {
|
|
DEV_BROADCAST_VOLUME * pDBVol = (DEV_BROADCAST_VOLUME *)lParam;
|
|
|
|
if (!(pDBVol->dbcv_flags & DBTF_MEDIA)) {
|
|
|
|
devBuffer = new BYTE[pDBHdr->dbch_size];
|
|
|
|
|
|
if (devBuffer != NULL) {
|
|
memcpy(devBuffer, (void*)lParam, pDBHdr->dbch_size);
|
|
param = new W32DeviceChangeParam(this, wParam, (LPARAM)devBuffer);
|
|
|
|
|
|
if (param != NULL) {
|
|
|
|
status = DispatchAsyncIORequest(
|
|
(RDPAsyncFunc_StartIO)W32ProcObj::_OnDeviceChangeFunc,
|
|
NULL,
|
|
NULL,
|
|
param
|
|
);
|
|
}
|
|
else {
|
|
status = GetLastError();
|
|
}
|
|
}
|
|
|
|
//
|
|
// Clean up
|
|
//
|
|
if (status != ERROR_SUCCESS) {
|
|
if (param != NULL) {
|
|
delete param;
|
|
}
|
|
if (devBuffer != NULL) {
|
|
delete devBuffer;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
HANDLE W32ProcObj::_OnDeviceChangeFunc(
|
|
W32DeviceChangeParam *param,
|
|
DWORD *status
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Handle device change notification from the worker thread.
|
|
|
|
Arguments:
|
|
|
|
param - Relevant W32DeviceChangeParam
|
|
status - Return status.
|
|
|
|
Return Value:
|
|
|
|
NULL
|
|
|
|
--*/
|
|
{
|
|
DC_BEGIN_FN("_OnDeviceChangeFunc");
|
|
|
|
ASSERT(param != NULL);
|
|
param->_instance->OnDeviceChangeFunc(status, param->_wParam, param->_lParam);
|
|
|
|
DC_END_FN();
|
|
|
|
delete ((void *)(param->_lParam));
|
|
delete param;
|
|
return NULL;
|
|
}
|
|
|
|
void
|
|
W32ProcObj::OnDeviceChangeFunc(
|
|
DWORD *status,
|
|
IN WPARAM wParam,
|
|
IN LPARAM lParam)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
On Device Change notification
|
|
|
|
Arguments:
|
|
|
|
status return status
|
|
wParam device change notification type
|
|
lParam device change info
|
|
|
|
Return Value:
|
|
|
|
N/A
|
|
|
|
--*/
|
|
|
|
{
|
|
DEV_BROADCAST_HDR *pDBHdr;
|
|
PRDPDR_HEADER pPacketHeader = NULL;
|
|
|
|
INT sz;
|
|
|
|
DC_BEGIN_FN("OnDeviceChangeFunc");
|
|
|
|
ASSERT(_initialized);
|
|
|
|
*status = ERROR_SUCCESS;
|
|
|
|
pDBHdr = (DEV_BROADCAST_HDR *)lParam;
|
|
switch (wParam) {
|
|
//
|
|
// Device arrival
|
|
//
|
|
case DBT_DEVICEARRIVAL:
|
|
|
|
//
|
|
// This is a volume device arrival message
|
|
//
|
|
if (pDBHdr->dbch_devicetype == DBT_DEVTYP_VOLUME) {
|
|
DEV_BROADCAST_VOLUME * pDBVol = (DEV_BROADCAST_VOLUME *)lParam;
|
|
|
|
if (!(pDBVol->dbcv_flags & DBTF_MEDIA)) {
|
|
|
|
DWORD unitMask = pDBVol->dbcv_unitmask;
|
|
|
|
W32Drive::EnumerateDrives(this, _deviceMgr, unitMask);
|
|
|
|
pPacketHeader = GenerateAnnouncePacket(&sz, TRUE);
|
|
if (pPacketHeader) {
|
|
pPacketHeader->Component = RDPDR_CTYP_CORE;
|
|
pPacketHeader->PacketId = DR_CORE_DEVICELIST_ANNOUNCE;
|
|
_pVCMgr->ChannelWrite(pPacketHeader, sz);
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
//
|
|
// Device removal
|
|
//
|
|
case DBT_DEVICEREMOVECOMPLETE:
|
|
|
|
//
|
|
// This is a volume device removal message
|
|
//
|
|
if (pDBHdr->dbch_devicetype == DBT_DEVTYP_VOLUME) {
|
|
|
|
DEV_BROADCAST_VOLUME * pDBVol = (DEV_BROADCAST_VOLUME *)lParam;
|
|
|
|
if (!(pDBVol->dbcv_flags & DBTF_MEDIA)) {
|
|
DWORD unitMask = pDBVol->dbcv_unitmask;
|
|
|
|
W32Drive::RemoveDrives(this, _deviceMgr, unitMask);
|
|
|
|
pPacketHeader = GenerateDeviceRemovePacket(&sz);
|
|
if (pPacketHeader) {
|
|
pPacketHeader->Component = RDPDR_CTYP_CORE;
|
|
pPacketHeader->PacketId = DR_CORE_DEVICELIST_REMOVE;
|
|
_pVCMgr->ChannelWrite(pPacketHeader, sz);
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
return;
|
|
}
|
|
|
|
DC_END_FN();
|
|
}
|
|
|