765 lines
18 KiB
C++
765 lines
18 KiB
C++
//+-------------------------------------------------------------
|
||
//
|
||
// File: perfcli.cxx
|
||
//
|
||
// Contents: First attempt at getting perfcliing to work
|
||
//
|
||
// This is the client side
|
||
//
|
||
//
|
||
//---------------------------------------------------------------
|
||
|
||
#include <windows.h>
|
||
#include <stdio.h>
|
||
#include <sys/types.h>
|
||
#include <sys/stat.h>
|
||
#include <errno.h>
|
||
#include <io.h>
|
||
|
||
#include <ole2.h>
|
||
#include <com.hxx>
|
||
#include "app.hxx"
|
||
#include <memalloc.h>
|
||
#include <objerror.h>
|
||
|
||
#pragma hdrstop
|
||
|
||
//+--------------------------------------------------------------
|
||
/* Definitions. */
|
||
|
||
#define MAX_CALLS 1000
|
||
#define MAX_THREADS 10
|
||
|
||
typedef enum what_next_en
|
||
{
|
||
wait_wn,
|
||
interrupt_wn,
|
||
quit_wn
|
||
} what_next_en;
|
||
|
||
//+--------------------------------------------------------------
|
||
/* Prototypes. */
|
||
void interrupt ( void );
|
||
void check_for_request ( void );
|
||
BOOL server_loop ( void );
|
||
DWORD _stdcall ThreadHelper ( void * );
|
||
void wait_for_message ( void );
|
||
void wake_up_and_smell_the_roses( void );
|
||
|
||
|
||
//+--------------------------------------------------------------
|
||
/* Globals. */
|
||
DWORD thread_mode = COINIT_MULTITHREADED;
|
||
HANDLE Done;
|
||
BOOL server;
|
||
BOOL Multicall_Test;
|
||
BOOL InterruptTestResults;
|
||
BOOL InterruptTestDone;
|
||
DWORD MainThread;
|
||
DWORD NestedCallCount = 0;
|
||
what_next_en WhatNext;
|
||
ITest *global_test = NULL;
|
||
BOOL global_interrupt_test;
|
||
|
||
|
||
/***************************************************************************/
|
||
STDMETHODIMP_(ULONG) CTest::AddRef( THIS )
|
||
{
|
||
InterlockedIncrement( (long *) &ref_count );
|
||
return ref_count;
|
||
}
|
||
|
||
/***************************************************************************/
|
||
CTest::CTest()
|
||
{
|
||
ref_count = 1;
|
||
custom = NULL;
|
||
}
|
||
|
||
/***************************************************************************/
|
||
CTest::~CTest()
|
||
{
|
||
if (custom != NULL)
|
||
{
|
||
custom->Release();
|
||
custom = NULL;
|
||
}
|
||
}
|
||
|
||
/***************************************************************************/
|
||
STDMETHODIMP CTest::sick( ULONG val )
|
||
{
|
||
TRY
|
||
{
|
||
THROW( CException(val) );
|
||
}
|
||
CATCH( CException, exp )
|
||
{
|
||
}
|
||
END_CATCH;
|
||
return S_OK;
|
||
}
|
||
|
||
/***************************************************************************/
|
||
STDMETHODIMP CTest::die_cpp( ULONG val )
|
||
{
|
||
THROW( CException(val) );
|
||
return S_OK;
|
||
}
|
||
|
||
/***************************************************************************/
|
||
STDMETHODIMP CTest::die_nt( ULONG val )
|
||
{
|
||
RaiseException( val, 0, 0, NULL );
|
||
return S_OK;
|
||
}
|
||
|
||
/***************************************************************************/
|
||
STDMETHODIMP_(DWORD) CTest::die( ITest *callback, ULONG catch_depth,
|
||
ULONG throw_depth, ULONG throw_val )
|
||
{
|
||
if (catch_depth == 0)
|
||
{
|
||
TRY
|
||
{
|
||
return callback->die( this, catch_depth - 1, throw_depth - 1, throw_val );
|
||
}
|
||
CATCH( CException, exp )
|
||
{
|
||
#if DBG==1
|
||
if (DebugCoGetRpcFault() != throw_val)
|
||
{
|
||
printf( "Propogated server fault was returned as 0x%x not 0x%x\n",
|
||
DebugCoGetRpcFault(), throw_val );
|
||
// return FALSE;
|
||
}
|
||
#endif
|
||
return TRUE;
|
||
}
|
||
END_CATCH
|
||
}
|
||
else if (throw_depth == 0)
|
||
{
|
||
THROW( CException(throw_val) );
|
||
}
|
||
else
|
||
return callback->die( this, catch_depth - 1, throw_depth - 1, throw_val );
|
||
return FALSE;
|
||
}
|
||
|
||
/***************************************************************************/
|
||
STDMETHODIMP CTest::interrupt( ITest *param, BOOL go )
|
||
{
|
||
global_interrupt_test = go;
|
||
if (go)
|
||
{
|
||
global_test = param;
|
||
global_test->AddRef();
|
||
WhatNext = interrupt_wn;
|
||
wake_up_and_smell_the_roses();
|
||
}
|
||
else
|
||
WhatNext = wait_wn;
|
||
return S_OK;
|
||
}
|
||
|
||
/***************************************************************************/
|
||
STDMETHODIMP_(BOOL) CTest::hello()
|
||
{
|
||
if (GetCurrentThreadId() == MainThread)
|
||
printf( "Hello on the main thread.\n" );
|
||
else
|
||
printf( "Hello on thread %d.\n", GetCurrentThreadId );
|
||
return !InterruptTestDone;
|
||
}
|
||
|
||
/***************************************************************************/
|
||
STDMETHODIMP CTest::recurse( ITest *callback, ULONG depth )
|
||
{
|
||
if (depth == 0)
|
||
return S_OK;
|
||
else
|
||
return callback->recurse( this, depth-1 );
|
||
}
|
||
|
||
/***************************************************************************/
|
||
STDMETHODIMP CTest::recurse_interrupt( ITest *callback, ULONG depth )
|
||
{
|
||
MSG msg;
|
||
|
||
if (PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ))
|
||
{
|
||
TranslateMessage (&msg);
|
||
DispatchMessage (&msg);
|
||
}
|
||
|
||
if (depth == 0)
|
||
return S_OK;
|
||
else
|
||
return callback->recurse( this, depth-1 );
|
||
}
|
||
|
||
/***************************************************************************/
|
||
STDMETHODIMP CTest::sleep( ULONG time )
|
||
{
|
||
|
||
// For single threaded mode, verify that this is the only call on the
|
||
// main thread.
|
||
NestedCallCount += 1;
|
||
printf( "Sleeping on thread %d for the %d time concurrently.\n",
|
||
GetCurrentThreadId(), NestedCallCount );
|
||
if (thread_mode == COINIT_SINGLETHREADED)
|
||
{
|
||
if (GetCurrentThreadId() != MainThread)
|
||
{
|
||
printf( "Sleep called on the wrong thread in single threaded mode.\n" );
|
||
NestedCallCount -= 1;
|
||
return FALSE;
|
||
}
|
||
else if (NestedCallCount != 1)
|
||
{
|
||
printf( "Sleep nested call count is %d instead of not 1 in single threaded mode.\n",
|
||
NestedCallCount );
|
||
NestedCallCount -= 1;
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
// For multithreaded mode, verify that this is not the main thread.
|
||
else if (GetCurrentThreadId() == MainThread)
|
||
{
|
||
printf( "Sleep called on the main thread in multi threaded mode.\n" );
|
||
NestedCallCount -= 1;
|
||
return FALSE;
|
||
}
|
||
|
||
Sleep( time );
|
||
NestedCallCount -= 1;
|
||
return S_OK;
|
||
}
|
||
|
||
/***************************************************************************/
|
||
STDMETHODIMP_(DWORD) CTest::DoTest( ITest *test, ITest *another )
|
||
{
|
||
HRESULT result;
|
||
int i;
|
||
BOOL success;
|
||
HANDLE helper[MAX_THREADS];
|
||
DWORD thread_id;
|
||
DWORD status;
|
||
|
||
// Let the server throw and exception and catch it before returning.
|
||
result = test->sick( 95 );
|
||
if (result != S_OK)
|
||
{
|
||
printf( "Internal server fault was not dealt with correctly.\n" );
|
||
return FALSE;
|
||
}
|
||
|
||
// Let the server throw a C++ exception here.
|
||
result = test->die_cpp( 0xdeaff00d );
|
||
if (result != RPC_E_FAULT)
|
||
{
|
||
printf( "C++ server fault was not dealt with correctly.\n" );
|
||
return FALSE;
|
||
}
|
||
#if DBG==1
|
||
if (DebugCoGetRpcFault() != 0xdeaff00d)
|
||
{
|
||
printf( "C++ server fault was returned as 0x%x not 0x%x\n",
|
||
DebugCoGetRpcFault(), 0xdeaff00d );
|
||
// return FALSE;
|
||
}
|
||
#endif
|
||
|
||
// Let the server throw a NT exception here.
|
||
result = test->die_nt( 0xaaaabdbd );
|
||
if (result != RPC_E_FAULT)
|
||
{
|
||
printf( "NT server fault was not dealt with correctly.\n" );
|
||
return FALSE;
|
||
}
|
||
#if DBG==1
|
||
if (DebugCoGetRpcFault() != 0xaaaabdbd)
|
||
{
|
||
printf( "C++ server fault was returned as 0x%x not 0x%x\n",
|
||
DebugCoGetRpcFault(), 0xaaaabdbd );
|
||
return FALSE;
|
||
}
|
||
#endif
|
||
|
||
// Test a recursive call.
|
||
result = test->recurse( this, 10 );
|
||
if (result != S_OK)
|
||
{
|
||
printf( "Recursive call failed: 0x%x\n", result );
|
||
return FALSE;
|
||
}
|
||
|
||
// Test throwing and immediately catching an exception.
|
||
//success = test->die( this, 2, 3, 0x12345678 );
|
||
//if (!success)
|
||
//{
|
||
// printf( "Could not catch server exception.\n" );
|
||
// return FALSE;
|
||
//}
|
||
|
||
// Test throwing, propogating, and then catching an exception.
|
||
// success = test->die( this, 1, 3, 0x87654321 );
|
||
//if (!success)
|
||
//{
|
||
// printf( "Could not catch propogated server exception.\n" );
|
||
// return FALSE;
|
||
//}
|
||
|
||
// Test multiple threads.
|
||
Multicall_Test = TRUE;
|
||
for (i = 0; i < MAX_THREADS; i++)
|
||
{
|
||
helper[i] = CreateThread( NULL, 0, ThreadHelper, test, 0, &thread_id );
|
||
if (helper == NULL)
|
||
{
|
||
printf( "Could not create helper thread number %d.\n", i );
|
||
return FALSE;
|
||
}
|
||
}
|
||
result = test->sleep(4000);
|
||
if (result != S_OK)
|
||
{
|
||
printf( "Multiple call failed on main thread: 0x%x\n", result );
|
||
return FALSE;
|
||
}
|
||
status = WaitForMultipleObjects( MAX_THREADS, helper, TRUE, INFINITE );
|
||
if (status == WAIT_FAILED)
|
||
{
|
||
printf( "Could not wait for helper threads to die: 0x%x\n", status );
|
||
return FALSE;
|
||
}
|
||
if (!Multicall_Test)
|
||
{
|
||
printf( "Multiple call failed on helper thread.\n" );
|
||
return FALSE;
|
||
}
|
||
|
||
// See if methods can correctly call GetMessage.
|
||
another->interrupt( test, TRUE );
|
||
result = test->recurse_interrupt( this, 10 );
|
||
if (result != S_OK)
|
||
{
|
||
printf( "Recursive call with interrupts failed: 0x%x\n", result );
|
||
return FALSE;
|
||
}
|
||
another->interrupt( test, FALSE );
|
||
|
||
// Finally, its all over.
|
||
return TRUE;
|
||
}
|
||
|
||
/***************************************************************************/
|
||
STDMETHODIMP CTest::QueryInterface( THIS_ REFIID riid, LPVOID FAR* ppvObj)
|
||
{
|
||
if (IsEqualIID(riid, IID_IUnknown) ||
|
||
IsEqualIID(riid, IID_ITest))
|
||
{
|
||
*ppvObj = (IUnknown *) this;
|
||
AddRef();
|
||
return S_OK;
|
||
}
|
||
else if (IsEqualIID( riid, IID_IMarshal))
|
||
{
|
||
if (custom == NULL)
|
||
{
|
||
custom = new CCMarshal;
|
||
if (custom == NULL)
|
||
return E_FAIL;
|
||
}
|
||
*ppvObj = (IMarshal *) custom;
|
||
custom->AddRef();
|
||
return S_OK;
|
||
}
|
||
else
|
||
{
|
||
*ppvObj = NULL;
|
||
return E_NOINTERFACE;
|
||
}
|
||
}
|
||
|
||
/***************************************************************************/
|
||
STDMETHODIMP_(ULONG) CTest::Release( THIS )
|
||
{
|
||
if (InterlockedDecrement( (long*) &ref_count ) == 0)
|
||
{
|
||
WhatNext = quit_wn;
|
||
wake_up_and_smell_the_roses();
|
||
delete this;
|
||
return 0;
|
||
}
|
||
else
|
||
return ref_count;
|
||
}
|
||
|
||
/***************************************************************************/
|
||
STDMETHODIMP_(ULONG) CTestCF::AddRef( THIS )
|
||
{
|
||
InterlockedIncrement( (long *) &ref_count );
|
||
return ref_count;
|
||
}
|
||
|
||
/***************************************************************************/
|
||
CTestCF::CTestCF()
|
||
{
|
||
ref_count = 1;
|
||
}
|
||
|
||
/***************************************************************************/
|
||
CTestCF::~CTestCF()
|
||
{
|
||
}
|
||
|
||
/***************************************************************************/
|
||
STDMETHODIMP CTestCF::CreateInstance(
|
||
IUnknown FAR* pUnkOuter,
|
||
REFIID iidInterface,
|
||
void FAR* FAR* ppv)
|
||
{
|
||
*ppv = NULL;
|
||
if (pUnkOuter != NULL)
|
||
{
|
||
return E_FAIL;
|
||
}
|
||
|
||
if (!IsEqualIID( iidInterface, IID_ITest ))
|
||
return E_NOINTERFACE;
|
||
|
||
CTest *Test = new FAR CTest();
|
||
|
||
if (Test == NULL)
|
||
{
|
||
return E_OUTOFMEMORY;
|
||
}
|
||
|
||
*ppv = Test;
|
||
return S_OK;
|
||
}
|
||
|
||
/***************************************************************************/
|
||
STDMETHODIMP CTestCF::LockServer(BOOL fLock)
|
||
{
|
||
return E_FAIL;
|
||
}
|
||
|
||
|
||
/***************************************************************************/
|
||
STDMETHODIMP CTestCF::QueryInterface( THIS_ REFIID riid, LPVOID FAR* ppvObj)
|
||
{
|
||
if (IsEqualIID(riid, IID_IUnknown) ||
|
||
IsEqualIID(riid, IID_IClassFactory))
|
||
{
|
||
*ppvObj = (IUnknown *) this;
|
||
AddRef();
|
||
return S_OK;
|
||
}
|
||
|
||
*ppvObj = NULL;
|
||
return E_NOINTERFACE;
|
||
}
|
||
|
||
/***************************************************************************/
|
||
STDMETHODIMP_(ULONG) CTestCF::Release( THIS )
|
||
{
|
||
if (InterlockedDecrement( (long*) &ref_count ) == 0)
|
||
{
|
||
delete this;
|
||
return 0;
|
||
}
|
||
else
|
||
return ref_count;
|
||
}
|
||
|
||
/***************************************************************************/
|
||
void interrupt()
|
||
{
|
||
while (global_interrupt_test)
|
||
{
|
||
global_test->hello();
|
||
check_for_request();
|
||
}
|
||
global_test->Release();
|
||
}
|
||
|
||
//+--------------------------------------------------------------
|
||
// Function: Main
|
||
//
|
||
// Synopsis: Executes the BasicBnd test
|
||
//
|
||
// Effects: None
|
||
//
|
||
//
|
||
// Returns: Exits with exit code 0 if success, 1 otherwise
|
||
//
|
||
// History: 05-Mar-92 Sarahj Created
|
||
//
|
||
//---------------------------------------------------------------
|
||
|
||
int _cdecl main(int argc, char *argv[])
|
||
{
|
||
HRESULT result;
|
||
DWORD wrong;
|
||
BOOL success = TRUE;
|
||
ITest *another = NULL;
|
||
ITest *test = NULL;
|
||
CTest *tester = new CTest;
|
||
|
||
// Initialize Globals.
|
||
MainThread = GetCurrentThreadId();
|
||
|
||
// Create an event for termination notification.
|
||
Done = CreateEvent( NULL, FALSE, FALSE, NULL );
|
||
if (Done == NULL)
|
||
{
|
||
printf( "Could not create event.\n" );
|
||
success = FALSE;
|
||
goto exit_main;
|
||
}
|
||
|
||
int len;
|
||
TCHAR buffer[80];
|
||
|
||
// Look up the thread mode from the win.ini file.
|
||
len = GetProfileString( L"My Section", L"ThreadMode", L"MultiThreaded", buffer,
|
||
sizeof(buffer) );
|
||
if (lstrcmp(buffer, L"SingleThreaded") == 0)
|
||
{
|
||
thread_mode = COINIT_SINGLETHREADED;
|
||
wrong = COINIT_MULTITHREADED;
|
||
printf( "Testing channel in single threaded mode.\n" );
|
||
}
|
||
else if (lstrcmp(buffer, L"MultiThreaded") == 0)
|
||
{
|
||
thread_mode = COINIT_MULTITHREADED;
|
||
wrong = COINIT_SINGLETHREADED;
|
||
printf( "Testing channel in multithreaded mode.\n" );
|
||
}
|
||
|
||
// Initialize OLE.
|
||
result = OleInitializeEx(NULL, thread_mode);
|
||
if (!SUCCEEDED(result))
|
||
{
|
||
success = FALSE;
|
||
printf( "OleInitializeEx failed: %x\n", result );
|
||
goto exit_main;
|
||
}
|
||
result = CoInitializeEx(NULL, thread_mode);
|
||
if (!SUCCEEDED(result))
|
||
{
|
||
success = FALSE;
|
||
printf( "Recalling CoInitializeEx failed: %x\n", result );
|
||
goto exit_main;
|
||
}
|
||
result = CoInitializeEx(NULL, wrong);
|
||
if (result == S_OK)
|
||
{
|
||
success = FALSE;
|
||
printf( "Recalling CoInitializeEx with wrong thread mode succeeded: %x\n", result );
|
||
goto exit_main;
|
||
}
|
||
CoUninitialize();
|
||
CoUninitialize();
|
||
|
||
// If this is a server app, register and wait for a quit message.
|
||
if (argv[1] == NULL)
|
||
server = FALSE;
|
||
else
|
||
server = strcmp( argv[1], "-Embedding" ) == 0;
|
||
if (server)
|
||
{
|
||
success = server_loop( );
|
||
}
|
||
|
||
// Initialize and run the tests.
|
||
else
|
||
{
|
||
// Get a test object.
|
||
result = CoCreateInstance( CLSID_ITest, NULL, CLSCTX_LOCAL_SERVER,
|
||
IID_ITest, (void **) &test );
|
||
if (!SUCCEEDED(result))
|
||
{
|
||
printf( "Could not create instance of test server: %x\n", result );
|
||
success = FALSE;
|
||
goto exit_main;
|
||
}
|
||
|
||
// Get another test object.
|
||
result = CoCreateInstance( CLSID_ITest, NULL, CLSCTX_LOCAL_SERVER,
|
||
IID_ITest, (void **) &another );
|
||
if (!SUCCEEDED(result))
|
||
{
|
||
printf( "Could not create another instance of test server: %x\n", result );
|
||
success = FALSE;
|
||
goto exit_main;
|
||
}
|
||
|
||
success = tester->DoTest( test, another );
|
||
}
|
||
|
||
exit_main:
|
||
|
||
// Release the external test objects used.
|
||
if (test != NULL)
|
||
test->Release();
|
||
if (another != NULL)
|
||
another->Release();
|
||
|
||
// Release the internal test object.
|
||
tester->Release();
|
||
//wait_for_message();
|
||
|
||
OleUninitialize();
|
||
|
||
if (!server)
|
||
if (success)
|
||
printf("\nChannel Unit Test: PASSED\n");
|
||
else
|
||
printf("\nChannel Unit Test: FAILED\n");
|
||
|
||
return !success;
|
||
}
|
||
|
||
//+--------------------------------------------------------------
|
||
void check_for_request()
|
||
{
|
||
MSG msg;
|
||
|
||
if (thread_mode == COINIT_SINGLETHREADED)
|
||
{
|
||
if (PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ))
|
||
{
|
||
TranslateMessage (&msg);
|
||
DispatchMessage (&msg);
|
||
}
|
||
}
|
||
}
|
||
|
||
//+--------------------------------------------------------------
|
||
BOOL server_loop( )
|
||
{
|
||
HRESULT result;
|
||
DWORD dwRegistration;
|
||
|
||
// Create our class factory
|
||
WhatNext = wait_wn;
|
||
CTestCF *test_cf = new CTestCF();
|
||
|
||
// Register our class with OLE
|
||
result = CoRegisterClassObject(CLSID_ITest, test_cf, CLSCTX_LOCAL_SERVER,
|
||
REGCLS_SINGLEUSE, &dwRegistration);
|
||
if (!SUCCEEDED(result))
|
||
{
|
||
printf( "CoRegisterClassObject failed: %x\n", result );
|
||
return FALSE;
|
||
}
|
||
|
||
// CoRegister bumps reference count so we don't have to!
|
||
test_cf->Release();
|
||
|
||
// Do whatever we have to do till it is time to pay our taxes and die.
|
||
while (WhatNext != quit_wn)
|
||
switch (WhatNext)
|
||
{
|
||
|
||
// Wait till a quit arrives.
|
||
case wait_wn:
|
||
wait_for_message();
|
||
break;
|
||
|
||
case interrupt_wn:
|
||
interrupt();
|
||
break;
|
||
}
|
||
|
||
// Deregister out class - should release object as well
|
||
result = CoRevokeClassObject(dwRegistration);
|
||
if (!SUCCEEDED(result))
|
||
{
|
||
printf( "CoRevokeClassObject failed: %x\n", result );
|
||
return FALSE;
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
/***************************************************************************/
|
||
DWORD _stdcall ThreadHelper( void *param )
|
||
{
|
||
ITest *test = (ITest *) param;
|
||
HRESULT result;
|
||
|
||
// Call the server.
|
||
result = test->sleep( 2000 );
|
||
|
||
// Check the result for single threaded mode.
|
||
if (thread_mode == COINIT_SINGLETHREADED)
|
||
{
|
||
if (SUCCEEDED(result))
|
||
{
|
||
Multicall_Test = FALSE;
|
||
printf( "Call succeeded on wrong thread in single threaded mode: 0x%x.\n",
|
||
result );
|
||
}
|
||
#if DBG==1
|
||
else if (DebugCoGetRpcFault() != RPC_E_ATTEMPTED_MULTITHREAD)
|
||
{
|
||
printf( "Multithread failure code was 0x%x not 0x%x\n",
|
||
DebugCoGetRpcFault(), RPC_E_ATTEMPTED_MULTITHREAD );
|
||
Multicall_Test = FALSE;
|
||
}
|
||
#endif
|
||
}
|
||
|
||
// Check the result for multithreaded mode.
|
||
else if (result != S_OK)
|
||
{
|
||
printf( "Could not make multiple calls in multithreaded mode: 0x%x\n",
|
||
result );
|
||
Multicall_Test = FALSE;
|
||
}
|
||
|
||
#define DO_DA 42
|
||
return DO_DA;
|
||
}
|
||
|
||
/***************************************************************************/
|
||
void wait_for_message()
|
||
{
|
||
MSG msg;
|
||
DWORD status;
|
||
|
||
if (thread_mode == COINIT_MULTITHREADED)
|
||
{
|
||
status = WaitForSingleObject( Done, INFINITE );
|
||
if (status != WAIT_OBJECT_0 )
|
||
{
|
||
printf( "Could not wait for event.\n" );
|
||
}
|
||
}
|
||
else
|
||
{
|
||
while (GetMessage( &msg, NULL, 0, 0 ) && msg.message != WM_USER)
|
||
{
|
||
TranslateMessage (&msg);
|
||
DispatchMessage (&msg);
|
||
}
|
||
}
|
||
}
|
||
|
||
/***************************************************************************/
|
||
void wake_up_and_smell_the_roses()
|
||
{
|
||
if (thread_mode == COINIT_MULTITHREADED)
|
||
SetEvent( Done );
|
||
else
|
||
PostThreadMessage(MainThread, WM_USER, 0, 0);
|
||
}
|
||
|