summaryrefslogtreecommitdiffstats
path: root/private/oleutest/channel
diff options
context:
space:
mode:
Diffstat (limited to 'private/oleutest/channel')
-rw-r--r--private/oleutest/channel/app/app.cxx9685
-rw-r--r--private/oleutest/channel/app/app_i.c28
-rw-r--r--private/oleutest/channel/app/makefile20
-rw-r--r--private/oleutest/channel/app/prxydll.def7
-rw-r--r--private/oleutest/channel/app/sources70
-rw-r--r--private/oleutest/channel/dirs38
-rw-r--r--private/oleutest/channel/idl/dog.acf9
-rw-r--r--private/oleutest/channel/idl/dog.idl45
-rw-r--r--private/oleutest/channel/idl/itest.acf4
-rw-r--r--private/oleutest/channel/idl/itest.idl192
-rw-r--r--private/oleutest/channel/idl/makefile9
-rw-r--r--private/oleutest/channel/idl/makefile.inc37
-rw-r--r--private/oleutest/channel/idl/pch.cxx18
-rw-r--r--private/oleutest/channel/idl/prxydll.def47
-rw-r--r--private/oleutest/channel/idl/sources66
-rw-r--r--private/oleutest/channel/idl/test.reg24
-rw-r--r--private/oleutest/channel/idl/test2.reg16
-rw-r--r--private/oleutest/channel/rel.cmd3
18 files changed, 10318 insertions, 0 deletions
diff --git a/private/oleutest/channel/app/app.cxx b/private/oleutest/channel/app/app.cxx
new file mode 100644
index 000000000..e7c565a4f
--- /dev/null
+++ b/private/oleutest/channel/app/app.cxx
@@ -0,0 +1,9685 @@
+//--------------------------------------------------------------
+//
+// 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 <malloc.h>
+
+#include <ole2.h>
+#include "..\idl\itest.h"
+#include <objerror.h>
+#include <dog.h>
+#include <winnt.h> // Security definitions
+
+ /***************************************************************************/
+/* Macros. */
+#define ASSERT( result, message ) \
+if ((result) != 0) \
+{ \
+ printf( "%s: 0x%x\n", (message), result ); \
+ goto cleanup; \
+}
+
+#define ASSERT_EXPR( expr, message ) \
+if (!(expr)) \
+{ \
+ printf( "%s\n", (message) ); \
+ goto cleanup; \
+}
+
+#define ASSERT_THREAD() \
+ if ((ThreadMode == COINIT_SINGLETHREADED || \
+ ThreadMode == COINIT_APARTMENTTHREADED) && \
+ (my_id.process != GetCurrentProcessId() || \
+ my_id.thread != GetCurrentThreadId())) \
+ return RPC_E_WRONG_THREAD;
+
+
+#define MAKE_WIN32( status ) \
+ MAKE_SCODE( SEVERITY_ERROR, FACILITY_WIN32, (status) )
+
+#define MCoCopyProxy (*GCoCopyProxy)
+#define MCoGetCallContext (*GCoGetCallContext)
+#define MCoImpersonateClient (*GCoImpersonateClient)
+#define MCoInitializeSecurity (*GCoInitializeSecurity)
+#define MCoQueryAuthenticationServices (*GCoQueryAuthenticationServices)
+#define MCoQueryClientBlanket (*GCoQueryClientBlanket)
+#define MCoQueryProxyBlanket (*GCoQueryProxyBlanket)
+#define MCoRevertToSelf (*GCoRevertToSelf)
+#define MCoSetProxyBlanket (*GCoSetProxyBlanket)
+#define MCoSwitchCallContext (*GCoSwitchCallContext)
+
+
+ /***************************************************************************/
+/* Definitions. */
+
+#define MAX_CALLS 1000
+#define MAX_THREADS 10
+#define NUM_MARSHAL_LOOP 10
+#define REGISTRY_ENTRY_LEN 256
+#define STATUS_DELAY 2000
+
+const int MAX_NAME = 80;
+const int NUM_CLASS_IDS = 10;
+const int NUM_INTERFACE_IDS = 7;
+
+const char REG_INTERFACE_CLASS[] = "{60000200-76d7-11cf-9af1-0020af6e72f4}";
+const char REG_PROXY_NAME[] = "ITest proxy";
+const char REG_PROXY_DLL[] = "app.exe";
+const char REG_APPID_NAME[] = "Application";
+const char REG_APP_EXE[] = "app.exe";
+const char REG_LOGGED_ON[] = "Interactive User";
+const char REG_CLASS_ID[] = "CLSID\\{60000000-AB0F-101A-B4AE-08002B30612C}";
+const char REG_CLASS_EXE[] = "CLSID\\{60000000-AB0F-101A-B4AE-08002B30612C}\\LocalServer32";
+const char *REG_INTERFACE_NAME[NUM_INTERFACE_IDS] =
+{
+ "ITest",
+ "ITestNoneImp",
+ "ITestConnectImp",
+ "ITestEncryptImp",
+ "ITestNoneId",
+ "ITestConnectId",
+ "ITestEncryptId"
+};
+const char *REG_APP_NAME[NUM_CLASS_IDS] =
+{
+ "Apartment Application with automatic security set to none",
+ "Apartment Application with automatic security set to connect",
+ "Apartment Application with automatic security set to integrity",
+ "Apartment Application with basic security",
+ "Apartment Application with legacy security",
+ "FreeThreaded Application with automatic security set to none",
+ "FreeThreaded Application with automatic security set to connect",
+ "FreeThreaded Application with automatic security set to integrity",
+ "FreeThreaded Application with basic security",
+ "FreeThreaded Application with legacy security",
+};
+const char *REG_APP_OPTIONS[NUM_CLASS_IDS] =
+{
+ " Apartment -auto 1",
+ " Apartment -auto 2",
+ " Apartment -auto 5",
+ " Apartment -basic",
+ " Apartment -legacy",
+ " Multi -auto 1",
+ " Multi -auto 2",
+ " Multi -auto 5",
+ " Multi -basic",
+ " Multi -legacy",
+};
+
+// Private symbols needed for the apartment model.
+#define COINIT_MULTITHREADED 0
+#define COINIT_SINGLETHREADED 1
+#define COINIT_APARTMENTTHREADED 2
+
+typedef enum
+{
+ dirty_s,
+ late_dispatch_s
+} state_en;
+
+typedef enum what_next_en
+{
+ callback_wn,
+ catch_wn,
+ crippled_wn,
+ interrupt_wn,
+ interrupt_marshal_wn,
+ quit_wn,
+ reinitialize_wn,
+ rest_and_die_wn,
+ setup_wn,
+ wait_wn
+} what_next_en;
+
+typedef enum
+{
+ cancel_wt,
+ crash_wt,
+ cstress_wt,
+ hook_wt,
+ load_client_wt,
+ load_server_wt,
+ lots_wt,
+ mmarshal_wt,
+ none_wt,
+ null_wt,
+ one_wt,
+ perf_wt,
+ perfremote_wt,
+ perfrpc_wt,
+ perfsec_wt,
+ post_wt,
+ reject_wt,
+ remote_client_wt,
+ remote_server_wt,
+ ring_wt,
+ rpc_wt,
+ rundown_wt,
+ securerefs_wt,
+ security_wt,
+ send_wt,
+ server_wt,
+ sid_wt,
+ simple_rundown_wt,
+ thread_wt,
+ three_wt,
+ two_wt,
+ uninit_wt,
+ unknown_wt
+} what_test_en;
+
+typedef enum
+{
+ apt_auto_none,
+ apt_auto_connect,
+ apt_auto_integrity,
+ apt_basic,
+ apt_legacy,
+ free_auto_none,
+ free_auto_connect,
+ free_auto_integrity,
+ free_basic,
+ free_legacy
+} class_id_types;
+
+typedef enum
+{
+ auto_sm,
+ basic_sm,
+ legacy_sm
+} security_model;
+
+typedef struct
+{
+ IStream *stream;
+ HANDLE ready;
+} new_apt_params;
+
+typedef struct
+{
+ LONG object_count;
+ what_next_en what_next;
+ BOOL exit_dirty;
+ DWORD sequence;
+} SAptData;
+
+typedef struct
+{
+ unsigned char **buffer;
+ long *buf_size;
+ RPC_STATUS status;
+ ULONG thread;
+} SGetInterface;
+
+typedef HRESULT (*INIT_FN)( void *, ULONG );
+
+typedef void (*SIMPLE_FN)( void * );
+
+typedef HRESULT (*CoInitializeSecurityFn)(
+ SECURITY_DESCRIPTOR *pSecDesc,
+ DWORD cbAuthSvc,
+ SOLE_AUTHENTICATION_SERVICE *asAuthSvc,
+ WCHAR *pPrincName,
+ DWORD dwAuthnLevel,
+ DWORD dwImpLevel,
+ RPC_AUTH_IDENTITY_HANDLE pAuthInfo,
+ DWORD dwCapabilities,
+ void *pReserved );
+typedef HRESULT (*CoQueryAuthenticationServicesFn)( DWORD *pcbAuthSvc,
+ SOLE_AUTHENTICATION_SERVICE **asAuthSvc );
+typedef HRESULT (*CoGetCallContextFn)( REFIID riid, void **ppInterface );
+typedef HRESULT (*CoSwitchCallContextFn)( IUnknown *pNewObject, IUnknown **ppOldObject );
+typedef HRESULT (*CoQueryProxyBlanketFn)(
+ IUnknown *pProxy,
+ DWORD *pwAuthnSvc,
+ DWORD *pAuthzSvc,
+ OLECHAR **pServerPrincName,
+ DWORD *pAuthnLevel,
+ DWORD *pImpLevel,
+ RPC_AUTH_IDENTITY_HANDLE *pAuthInfo,
+ DWORD *pCapabilites );
+typedef HRESULT (*CoSetProxyBlanketFn)(
+ IUnknown *pProxy,
+ DWORD dwAuthnSvc,
+ DWORD dwAuthzSvc,
+ OLECHAR *pServerPrincName,
+ DWORD dwAuthnLevel,
+ DWORD dwImpLevel,
+ RPC_AUTH_IDENTITY_HANDLE *pAuthInfo,
+ DWORD dwCapabilities );
+typedef HRESULT (*CoCopyProxyFn)(
+ IUnknown *pProxy,
+ IUnknown **ppCopy );
+typedef HRESULT (*CoQueryClientBlanketFn)(
+ DWORD *pAuthnSvc,
+ DWORD *pAuthzSvc,
+ OLECHAR **pServerPrincName,
+ DWORD *pAuthnLevel,
+ DWORD *pImpLevel,
+ RPC_AUTHZ_HANDLE *pPrivs,
+ DWORD *pCapabilities );
+typedef HRESULT (*CoImpersonateClientFn)();
+typedef HRESULT (*CoRevertToSelfFn)();
+
+ /***************************************************************************/
+/* Classes */
+
+//+-------------------------------------------------------------------
+//
+// Class: CTestCF
+//
+// Synopsis: Class Factory for CTest
+//
+// Methods: IUnknown - QueryInterface, AddRef, Release
+// IClassFactory - CreateInstance
+//
+//--------------------------------------------------------------------
+
+
+class FAR CTestCF: public IClassFactory
+{
+public:
+
+ // Constructor/Destructor
+ CTestCF();
+ ~CTestCF();
+
+ // IUnknown
+ STDMETHOD (QueryInterface) (REFIID iid, void FAR * FAR * ppv);
+ STDMETHOD_(ULONG,AddRef) ( void );
+ STDMETHOD_(ULONG,Release) ( void );
+
+ // IClassFactory
+ STDMETHODIMP CreateInstance(
+ IUnknown FAR* pUnkOuter,
+ REFIID iidInterface,
+ void FAR* FAR* ppv);
+
+ STDMETHODIMP LockServer(BOOL fLock);
+
+private:
+
+ ULONG ref_count;
+};
+
+//+-------------------------------------------------------------------
+//
+// Class: CAdvise
+//
+// Synopsis: Asynchronous test class
+//
+//--------------------------------------------------------------------
+class CAdvise : public IAdviseSink
+{
+ public:
+ CAdvise();
+ ~CAdvise();
+
+ // IUnknown
+ STDMETHOD (QueryInterface) (REFIID iid, void FAR * FAR * ppv);
+ STDMETHOD_(ULONG,AddRef) ( void );
+ STDMETHOD_(ULONG,Release) ( void );
+
+ // IAdviseSink
+ STDMETHODIMP_(void) OnDataChange( FORMATETC *, STGMEDIUM * );
+ STDMETHODIMP_(void) OnViewChange( DWORD, LONG );
+ STDMETHODIMP_(void) OnRename ( IMoniker * );
+ STDMETHODIMP_(void) OnSave ( void );
+ STDMETHODIMP_(void) OnClose ( void );
+
+ private:
+ ULONG ref_count;
+};
+
+//+----------------------------------------------------------------
+//
+// Class: CHook
+//
+// Purpose: Test channel hooks
+//
+//-----------------------------------------------------------------
+
+class CHook : public IChannelHook
+{
+ public:
+ CHook( REFGUID, DWORD seq );
+
+ STDMETHOD (QueryInterface) ( REFIID riid, LPVOID FAR* ppvObj);
+ STDMETHOD_(ULONG,AddRef) ( void );
+ STDMETHOD_(ULONG,Release) ( void );
+
+ STDMETHOD_(void,ClientGetSize) ( REFGUID, REFIID, ULONG *DataSize );
+ STDMETHOD_(void,ClientFillBuffer)( REFGUID, REFIID, ULONG *DataSize, void *DataBuffer );
+ STDMETHOD_(void,ClientNotify) ( REFGUID, REFIID, ULONG DataSize, void *DataBuffer,
+ DWORD DataRep, HRESULT );
+ STDMETHOD_(void,ServerNotify) ( REFGUID, REFIID, ULONG DataSize, void *DataBuffer,
+ DWORD DataRep );
+ STDMETHOD_(void,ServerGetSize) ( REFGUID, REFIID, HRESULT, ULONG *DataSize );
+ STDMETHOD_(void,ServerFillBuffer)( REFGUID, REFIID, ULONG *DataSize, void *DataBuffer, HRESULT );
+
+ HRESULT check ( DWORD, DWORD, DWORD, DWORD );
+ void check_buf( DWORD size, unsigned char *buf );
+ void fill_buf ( DWORD count, unsigned char *buf );
+ DWORD get_size ( DWORD count );
+
+ private:
+ ULONG ref_count;
+ GUID extent;
+ DWORD sequence;
+ DWORD client_get;
+ DWORD client_fill;
+ DWORD client_notify;
+ DWORD server_get;
+ DWORD server_fill;
+ DWORD server_notify;
+ HRESULT result;
+};
+
+
+//+-------------------------------------------------------------------
+//
+// Class: CTest
+//
+// Synopsis: Test class
+//
+//--------------------------------------------------------------------
+class CTest: public ITest, public IMessageFilter
+{
+public:
+ CTest();
+ ~CTest();
+
+ // IUnknown
+ STDMETHOD (QueryInterface) (REFIID iid, void FAR * FAR * ppv);
+ STDMETHOD_(ULONG,AddRef) ( void );
+ STDMETHOD_(ULONG,Release) ( void );
+
+ // ITest
+ STDMETHOD (align) ( unsigned char x[17] );
+ STDMETHOD (call_canceled) ( long, long, ITest * );
+ STDMETHOD (call_dead) ( void );
+ STDMETHOD (call_me_back) ( ITest *obj );
+ STDMETHOD (call_next) ( void );
+ STDMETHOD (callback) ( void );
+ STDMETHOD (cancel) ( void );
+ STDMETHOD (cancel_now) ( void );
+ STDMETHOD (cancel_pending_call) ( DWORD * );
+ STDMETHOD (cancel_stress) ( ITest *obj );
+ STDMETHOD (catch_at_top) ( BOOL, ITest *, STRING );
+ STDMETHOD (check) ( SAptId );
+ STDMETHOD (check_hook) ( DWORD, DWORD, DWORD, DWORD,
+ DWORD, DWORD, DWORD, DWORD );
+ STDMETHOD (count) ( void );
+ STDMETHOD (crash_out) ( transmit_crash * );
+ STDMETHOD (delegate) ( ITest *, SAptId, HACKSID * );
+ STDMETHOD (exit) ( void );
+ STDMETHOD (forget) ( void );
+ STDMETHOD (get_advise) ( IAdviseSink ** );
+ STDMETHOD (get_data) ( DWORD, unsigned char *, DWORD,
+ unsigned char ** );
+ STDMETHOD (get_id) ( SAptId * );
+ STDMETHOD (get_next) ( ITest **, SAptId * );
+ STDMETHOD (get_next_slowly) ( ITest **, SAptId * );
+ STDMETHOD (get_obj_from_new_apt) ( ITest **, SAptId * );
+ STDMETHOD (get_obj_from_this_apt) ( ITest **, SAptId * );
+ STDMETHOD (get_sid) ( HACKSID ** );
+ STDMETHOD (interface_in) ( ITest * );
+ STDMETHOD (interrupt) ( ITest *, SAptId, BOOL );
+ STDMETHOD (interrupt_marshal) ( ITest *, ITest * );
+ STDMETHOD (make_acl) ( HACKSID * );
+ STDMETHOD (null) ( void );
+ STDMETHOD (out) ( ITest ** );
+ STDMETHOD (pointer) ( DWORD * );
+ STDMETHOD (recurse) ( ITest *, ULONG );
+ STDMETHOD (recurse_disconnect) ( ITest *, ULONG );
+ STDMETHOD (recurse_excp) ( ITest *, ULONG );
+ STDMETHOD (recurse_fatal) ( ITest *, ULONG, ULONG, BOOL );
+ STDMETHOD (recurse_fatal_helper) ( ITest *, ULONG, ULONG, BOOL );
+ STDMETHOD (recurse_interrupt) ( ITest *, ULONG );
+ STDMETHOD (recurse_secure) ( ITest *, ULONG, ULONG, HACKSID * );
+ STDMETHOD (register_hook) ( GUID, DWORD );
+ STDMETHOD (register_message_filter)( BOOL );
+ STDMETHOD (register_rpc) ( WCHAR *, WCHAR ** );
+ STDMETHOD (reinitialize) ( void );
+ STDMETHOD (reject_next) ( void );
+ STDMETHOD (remember) ( ITest *, SAptId );
+ STDMETHOD (rest_and_die) ( void );
+ STDMETHOD (retry_next) ( void );
+ STDMETHOD (ring) ( DWORD );
+ STDMETHOD (secure) ( SAptId, DWORD, DWORD, DWORD, DWORD,
+ STRING, HACKSID *, DWORD * );
+ STDMETHOD (security_performance) ( DWORD *, DWORD *, DWORD *, DWORD * );
+ STDMETHOD (set_state) ( DWORD, DWORD );
+ STDMETHOD (sick) ( ULONG );
+ STDMETHOD (sleep) ( ULONG );
+ STDMETHOD (test) ( ULONG );
+
+ // IMessageFilter
+ STDMETHOD_(DWORD,HandleInComingCall)( DWORD, HTASK, DWORD, LPINTERFACEINFO );
+ STDMETHOD_(DWORD,MessagePending) ( HTASK, DWORD, DWORD );
+ STDMETHOD_(DWORD,RetryRejectedCall) ( HTASK, DWORD, DWORD );
+
+ // Other
+ void assert_unknown();
+
+
+private:
+
+ ULONG ref_count;
+ SAptId my_id;
+ SAptId next_id;
+ ITest *next;
+ BOOL fcancel_next;
+ BOOL freject_next;
+ BOOL fretry_next;
+ BOOL flate_dispatch;
+};
+
+ /***************************************************************************/
+/* Prototypes. */
+DWORD _stdcall apartment_base ( void * );
+void check_for_request ( void );
+HRESULT create_instance ( REFCLSID, ITest **, SAptId * );
+void crippled ( void );
+void decrement_object_count ( void );
+BOOL dirty_thread ( void );
+void do_cancel ( void );
+BOOL do_cancel_helper ( ITest *, SAptId, ITest *, SAptId );
+void do_crash ( void );
+BOOL do_crash_helper ( ITest *, SAptId, ITest *, SAptId );
+void do_cstress ( void );
+void do_hook ( void );
+BOOL do_hook_helper ( BOOL, ITest *, SAptId, ITest * );
+void do_load_client ( void );
+void do_load_server ( void );
+void do_mmarshal ( void );
+void do_null ( void );
+void do_one ( void );
+void do_perf ( void );
+void do_perfremote ( void );
+void do_perfrpc ( void );
+void do_perfsec ( void );
+void do_post ( void );
+void do_reject ( void );
+void do_remote_client ( void );
+void do_remote_server ( void );
+void do_ring ( void );
+void do_rpc ( void );
+void do_rundown ( void );
+BOOL do_rundown1 ( ITest **, SAptId *, DWORD );
+BOOL do_rundown2 ( ITest **, SAptId *, DWORD );
+void do_securerefs ( void );
+BOOL do_securerefs_helper ( ITest ** );
+void do_security ( void );
+BOOL do_security_auto ( void );
+BOOL do_security_call ( ITest *, SAptId, DWORD, DWORD,
+ DWORD, DWORD, SID * );
+BOOL do_security_copy ( ITest *, SAptId );
+BOOL do_security_delegate ( ITest *, SAptId, ITest *, SAptId );
+BOOL do_security_handle ( ITest *, SAptId );
+BOOL do_security_lazy_call ( ITest *, SAptId, DWORD, DWORD,
+ DWORD, DWORD, SID * );
+BOOL do_security_nested ( ITest *, SAptId );
+void do_send ( void );
+void do_sid ( void );
+void do_simple_rundown ( void );
+void do_thread ( void );
+void do_three ( void );
+void do_two ( void );
+void do_uninit ( void );
+DWORD _stdcall do_uninit_helper ( void *param );
+void do_unknown ( void );
+BOOL do_unknown_call ( IUnknown *, DWORD, DWORD, REFIID );
+BOOL do_unknown_helper ( IUnknown *server );
+void *Fixup ( char * );
+WINOLEAPI FixupCoCopyProxy ( IUnknown *, IUnknown ** );
+WINOLEAPI FixupCoGetCallContext ( REFIID, void ** );
+WINOLEAPI FixupCoImpersonateClient ();
+WINOLEAPI FixupCoInitializeSecurity ( SECURITY_DESCRIPTOR *, DWORD, SOLE_AUTHENTICATION_SERVICE *, WCHAR *, DWORD, DWORD, RPC_AUTH_IDENTITY_HANDLE, DWORD, void * );
+WINOLEAPI FixupCoQueryAuthenticationServices ( DWORD *, SOLE_AUTHENTICATION_SERVICE ** );
+WINOLEAPI FixupCoQueryClientBlanket ( DWORD *, DWORD *, OLECHAR **, DWORD *, DWORD *, RPC_AUTHZ_HANDLE *, DWORD * );
+WINOLEAPI FixupCoQueryProxyBlanket ( IUnknown *, DWORD *, DWORD *, OLECHAR **, DWORD *, DWORD *, RPC_AUTH_IDENTITY_HANDLE *, DWORD * );
+WINOLEAPI FixupCoRevertToSelf ();
+WINOLEAPI FixupCoSetProxyBlanket ( IUnknown *, DWORD, DWORD, OLECHAR *, DWORD, DWORD, RPC_AUTH_IDENTITY_HANDLE *, DWORD );
+WINOLEAPI FixupCoSwitchCallContext ( IUnknown *, IUnknown ** );
+DWORD get_sequence ( void );
+void hello ( char * );
+void increment_object_count ( void );
+HRESULT initialize ( void *, ULONG );
+HRESULT initialize_security ( void );
+void interrupt ( void );
+HRESULT new_apartment_test ( ITest **, SAptId *, HANDLE * );
+BOOL parse ( int argc, char *argv[] );
+BOOL registry_setup ( char * );
+void reinitialize ( void );
+void server_loop ( void );
+DWORD _stdcall status_helper ( void * );
+HRESULT switch_thread ( SIMPLE_FN, void * );
+void switch_test ( void );
+void thread_get_interface_buffer( handle_t binding, long *buf_size,
+ unsigned char **buffer, SAptId *id,
+ error_status_t *status );
+DWORD _stdcall thread_helper ( void * );
+void wait_for_message ( void );
+void wake_up_and_smell_the_roses( void );
+void what_next ( what_next_en );
+
+
+ /***************************************************************************/
+/* Externals. */
+const IID ClassIds[NUM_CLASS_IDS] =
+{
+ {0x60000000, 0xAB0F, 0x101A, {0xB4, 0xAE, 0x08, 0x00, 0x2B, 0x30, 0x61, 0x2C}},
+ {0x60000001, 0xAB0F, 0x101A, {0xB4, 0xAE, 0x08, 0x00, 0x2B, 0x30, 0x61, 0x2C}},
+ {0x60000002, 0xAB0F, 0x101A, {0xB4, 0xAE, 0x08, 0x00, 0x2B, 0x30, 0x61, 0x2C}},
+ {0x60000003, 0xAB0F, 0x101A, {0xB4, 0xAE, 0x08, 0x00, 0x2B, 0x30, 0x61, 0x2C}},
+ {0x60000004, 0xAB0F, 0x101A, {0xB4, 0xAE, 0x08, 0x00, 0x2B, 0x30, 0x61, 0x2C}},
+ {0x60000005, 0xAB0F, 0x101A, {0xB4, 0xAE, 0x08, 0x00, 0x2B, 0x30, 0x61, 0x2C}},
+ {0x60000006, 0xAB0F, 0x101A, {0xB4, 0xAE, 0x08, 0x00, 0x2B, 0x30, 0x61, 0x2C}},
+ {0x60000007, 0xAB0F, 0x101A, {0xB4, 0xAE, 0x08, 0x00, 0x2B, 0x30, 0x61, 0x2C}},
+ {0x60000008, 0xAB0F, 0x101A, {0xB4, 0xAE, 0x08, 0x00, 0x2B, 0x30, 0x61, 0x2C}},
+ {0x60000009, 0xAB0F, 0x101A, {0xB4, 0xAE, 0x08, 0x00, 0x2B, 0x30, 0x61, 0x2C}},
+};
+
+/* Globals. */
+BOOL Change = FALSE;
+CTestCF *ClassFactory;
+char Debugger[MAX_PATH+MAX_PATH] = "";
+HANDLE Done;
+CoCopyProxyFn GCoCopyProxy = FixupCoCopyProxy;
+CoGetCallContextFn GCoGetCallContext = FixupCoGetCallContext;
+CoImpersonateClientFn GCoImpersonateClient = FixupCoImpersonateClient;
+CoInitializeSecurityFn GCoInitializeSecurity = FixupCoInitializeSecurity;
+CoQueryAuthenticationServicesFn GCoQueryAuthenticationServices = FixupCoQueryAuthenticationServices;
+CoQueryClientBlanketFn GCoQueryClientBlanket = FixupCoQueryClientBlanket;
+CoQueryProxyBlanketFn GCoQueryProxyBlanket = FixupCoQueryProxyBlanket;
+CoRevertToSelfFn GCoRevertToSelf = FixupCoRevertToSelf;
+CoSetProxyBlanketFn GCoSetProxyBlanket = FixupCoSetProxyBlanket;
+CoSwitchCallContextFn GCoSwitchCallContext = FixupCoSwitchCallContext;
+DWORD GlobalAuthnLevel = RPC_C_AUTHN_LEVEL_NONE;
+SAptId GlobalApt;
+WCHAR *GlobalBinding;
+BOOL GlobalBool;
+long GlobalCalls = 0;
+long GlobalClients = 0;
+LONG GlobalFirst = TRUE;
+CHook *GlobalHook1 = NULL;
+CHook *GlobalHook2 = NULL;
+BOOL GlobalInterruptTest;
+SECURITY_DESCRIPTOR *GlobalSecurityDescriptor = NULL;
+security_model GlobalSecurityModel = auto_sm;
+ITest *GlobalTest = NULL;
+ITest *GlobalTest2 = NULL;
+ULONG GlobalThreadId = 0;
+long GlobalTotal = 0;
+BOOL GlobalWaiting = FALSE;
+DWORD MainThread;
+BOOL Multicall_Test;
+WCHAR Name[MAX_NAME] = L"";
+DWORD NestedCallCount = 0;
+int NumIterations = 1000;
+int NumObjects = 2;
+int NumProcesses = 2;
+int NumRecursion = 2;
+int NumThreads = 2;
+BOOL Popup = FALSE;
+SAptData ProcessAptData;
+SID *ProcessSid;
+HANDLE RawEvent = NULL;
+HRESULT RawResult;
+DWORD Registration;
+const IID *ServerClsid = &ClassIds[apt_auto_none];
+WCHAR TestProtseq[MAX_NAME] = L"ncadg_ip_udp";
+DWORD ThreadMode = COINIT_APARTMENTTHREADED;
+DWORD TlsIndex;
+what_test_en WhatTest;
+BOOL WriteClass = FALSE;
+
+
+ /***************************************************************************/
+STDMETHODIMP_(ULONG) CAdvise::AddRef( THIS )
+{
+ InterlockedIncrement( (long *) &ref_count );
+ return ref_count;
+}
+
+ /***************************************************************************/
+CAdvise::CAdvise()
+{
+ ref_count = 1;
+ increment_object_count();
+}
+
+ /***************************************************************************/
+CAdvise::~CAdvise()
+{
+}
+
+ /***************************************************************************/
+STDMETHODIMP_(void) CAdvise::OnClose( void )
+{
+}
+
+ /***************************************************************************/
+STDMETHODIMP_(void) CAdvise::OnDataChange( FORMATETC *format, STGMEDIUM *stg )
+{
+}
+
+ /***************************************************************************/
+STDMETHODIMP_(void) CAdvise::OnRename( IMoniker *moniker )
+{
+}
+
+ /***************************************************************************/
+STDMETHODIMP_(void) CAdvise::OnSave( void )
+{
+}
+
+ /***************************************************************************/
+STDMETHODIMP_(void) CAdvise::OnViewChange( DWORD aspect, LONG index )
+{
+}
+
+ /***************************************************************************/
+STDMETHODIMP CAdvise::QueryInterface( THIS_ REFIID riid, LPVOID FAR* ppvObj)
+{
+ if (IsEqualIID(riid, IID_IUnknown) ||
+ IsEqualIID(riid, IID_IAdviseSink))
+ {
+ *ppvObj = (IUnknown *) (IAdviseSink *) this;
+ AddRef();
+ return S_OK;
+ }
+ else
+ {
+ *ppvObj = NULL;
+ return E_NOINTERFACE;
+ }
+}
+
+ /***************************************************************************/
+STDMETHODIMP_(ULONG) CAdvise::Release( THIS )
+{
+ if (InterlockedDecrement( (long*) &ref_count ) == 0)
+ {
+ decrement_object_count();
+ delete this;
+ return 0;
+ }
+ else
+ return ref_count;
+}
+
+ /***************************************************************************/
+STDMETHODIMP_(ULONG) CHook::AddRef( THIS )
+{
+ InterlockedIncrement( (long *) &ref_count );
+ return ref_count;
+}
+
+ /***************************************************************************/
+HRESULT CHook::check( DWORD cget, DWORD cnot, DWORD sget, DWORD snot )
+{
+ if (result != S_OK)
+ return result;
+ if (cget != client_get || cnot != client_notify ||
+ sget != server_get || snot != server_notify)
+ return E_INVALIDARG;
+ return S_OK;
+}
+
+ /***************************************************************************/
+void CHook::check_buf( DWORD size, unsigned char *buf )
+{
+ DWORD i;
+
+ if (sequence == 1)
+ {
+ if (size == 1)
+ {
+ if (*buf != 1)
+ goto error;
+ }
+ else if (size == 1000)
+ {
+ for (i = 0; i < size; i++)
+ if (buf[i] != 255)
+ goto error;
+ }
+ else if (size != 0)
+ goto error;
+ }
+ else if (sequence == 2)
+ {
+ for (i = 0; i < size; i++)
+ if (buf[i] != (unsigned char) i)
+ goto error;
+ }
+ else
+ {
+ if (size != 42)
+ goto error;
+ i = 0;
+ while (i < 42)
+ if (buf[i++] != '4' || buf[i++] != '2')
+ goto error;
+ }
+
+ return;
+error:
+ printf( "Hook got bad data.\n" );
+ result = E_UNEXPECTED;
+}
+
+ /***************************************************************************/
+CHook::CHook( REFGUID ext, DWORD seq )
+{
+ extent = ext;
+ sequence = seq;
+ ref_count = 1;
+ client_get = 0;
+ client_fill = 0;
+ client_notify = 0;
+ server_get = 0;
+ server_fill = 0;
+ server_notify = 0;
+ result = S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP_(void) CHook::ClientGetSize( REFGUID ext, REFIID riid,
+ ULONG *size )
+{
+ // Check the parameters.
+ if (extent != ext)
+ {
+ printf( "Hook received the wrong extent.\n" );
+ result = E_FAIL;
+ }
+
+ // Return the correct size for each sequence.
+ client_get += 1;
+ *size = get_size( client_get );
+}
+
+ /***************************************************************************/
+STDMETHODIMP_(void) CHook::ClientFillBuffer( REFGUID ext, REFIID riid,
+ ULONG *max, void *buffer )
+{
+ DWORD size = get_size( client_get );
+
+ // Check the parameters.
+ if (extent != ext)
+ {
+ printf( "Hook received the wrong extent.\n" );
+ result = E_FAIL;
+ }
+ else if (*max < size)
+ {
+ printf( "Hook lost space.\n" );
+ result = E_OUTOFMEMORY;
+ }
+
+ // Fill the buffer.
+ *max = size;
+ client_fill += 1;
+ fill_buf( client_get, (unsigned char *) buffer );
+}
+
+ /***************************************************************************/
+STDMETHODIMP_(void) CHook::ClientNotify( REFGUID ext, REFIID riid,
+ ULONG size, void *buffer,
+ DWORD data_rep, HRESULT result )
+{
+ // Verify the parameters.
+ if (extent != ext)
+ {
+ printf( "Hook received the wrong extent.\n" );
+ result = E_FAIL;
+ }
+
+ // Verify the data.
+ client_notify += 1;
+ if (result == S_OK && buffer != NULL)
+ check_buf( size, (unsigned char *) buffer );
+}
+
+ /***************************************************************************/
+void CHook::fill_buf( DWORD count, unsigned char *buffer )
+{
+ DWORD size = get_size( count );
+ DWORD i;
+
+ if (sequence == 1)
+ {
+ if (size == 1)
+ *buffer = 1;
+ else
+ for (i = 0; i < size; i++)
+ buffer[i] = 255;
+ }
+ else if (sequence == 2)
+ {
+ for (i = 0; i < size; i++)
+ buffer[i] = i;
+ }
+ else
+ {
+ i = 0;
+ while (i < 42)
+ {
+ buffer[i++] = '4';
+ buffer[i++] = '2';
+ }
+ }
+}
+
+ /***************************************************************************/
+DWORD CHook::get_size( DWORD count )
+{
+ DWORD size;
+
+ if (sequence == 1)
+ {
+ size = count % 3;
+ if (size == 2)
+ size = 1000;
+ return size;
+ }
+ else if (sequence == 2)
+ return count;
+ else
+ return 42;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CHook::QueryInterface( THIS_ REFIID riid, LPVOID FAR* ppvObj)
+{
+ if (IsEqualIID(riid, IID_IUnknown) ||
+ IsEqualIID(riid, IID_IChannelHook))
+ {
+ *ppvObj = (IUnknown *) this;
+ AddRef();
+ return S_OK;
+ }
+ else
+ {
+ *ppvObj = NULL;
+ return E_NOINTERFACE;
+ }
+}
+
+ /***************************************************************************/
+STDMETHODIMP_(ULONG) CHook::Release( THIS )
+{
+ if (InterlockedDecrement( (long*) &ref_count ) == 0)
+ {
+ delete this;
+ return 0;
+ }
+ else
+ return ref_count;
+}
+
+ /***************************************************************************/
+STDMETHODIMP_(void) CHook::ServerNotify( REFGUID ext, REFIID riid,
+ ULONG size, void *buffer,
+ DWORD data_rep )
+{
+ // Verify the parameters.
+ if (extent != ext)
+ {
+ printf( "Hook received the wrong extent.\n" );
+ result = E_FAIL;
+ }
+
+ // Verify the data.
+ server_notify += 1;
+ if (result == S_OK && buffer != NULL)
+ check_buf( size, (unsigned char *) buffer );
+}
+
+ /***************************************************************************/
+STDMETHODIMP_(void) CHook::ServerGetSize( REFGUID ext, REFIID riid, HRESULT hr,
+ ULONG *size )
+{
+ // Check the parameters.
+ if (extent != ext)
+ {
+ printf( "Hook received the wrong extent.\n" );
+ result = E_FAIL;
+ }
+
+ // Return the correct size for each sequence.
+ server_get += 1;
+ *size = get_size( server_get );
+}
+
+ /***************************************************************************/
+STDMETHODIMP_(void) CHook::ServerFillBuffer( REFGUID ext, REFIID riid,
+ ULONG *max, void *buffer, HRESULT hr )
+{
+ DWORD size = get_size( server_get );
+
+ // Check the parameters.
+ if (extent != ext)
+ {
+ printf( "Hook received the wrong extent.\n" );
+ result = E_FAIL;
+ }
+ else if (*max < size)
+ {
+ printf( "Hook lost space.\n" );
+ result = E_OUTOFMEMORY;
+ }
+
+ // Fill the buffer.
+ *max = size;
+ server_fill += 1;
+ fill_buf( server_get, (unsigned char *) buffer );
+}
+
+ /***************************************************************************/
+STDMETHODIMP_(ULONG) CTest::AddRef( THIS )
+{
+ assert_unknown();
+ InterlockedIncrement( (long *) &ref_count );
+ return ref_count;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::align( unsigned char x[17] )
+{
+ ASSERT_THREAD();
+ return S_OK;
+}
+
+ /***************************************************************************/
+void CTest::assert_unknown()
+{
+ if ((ThreadMode == COINIT_SINGLETHREADED ||
+ ThreadMode == COINIT_APARTMENTTHREADED) &&
+ (my_id.process != GetCurrentProcessId() ||
+ my_id.thread != GetCurrentThreadId()))
+ {
+ printf( "**************************************************************\n" );
+ printf( "**************************************************************\n" );
+ printf( "* Unknown called on wrong thread. *\n" );
+ printf( "**************************************************************\n" );
+ printf( "**************************************************************\n" );
+ }
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::call_canceled( long recurse, long cancel,
+ ITest *callback )
+{
+ HRESULT result = S_OK;
+ DWORD wakeup;
+ DWORD sleep;
+ DWORD reason;
+ MSG msg;
+ ASSERT_THREAD();
+
+ // If the recursion count isn't zero, call back.
+ if (recurse > 0)
+ {
+ result = callback->call_canceled( recurse-1, cancel, this );
+ if (recurse <= cancel)
+ {
+ if (result != RPC_E_CALL_CANCELED &&
+ result != MAKE_WIN32( RPC_S_CALL_CANCELLED ))
+ if (result == S_OK)
+ return E_FAIL;
+ else
+ return result;
+ result = S_OK;
+ }
+ else if (result != S_OK)
+ return result;
+ }
+
+ // If the cancel count is greater then the recursion count, cancel the
+ // object that called me.
+ if (cancel > recurse)
+ {
+ // Give the other object a chance to finish canceling me before I cancel
+ // him.
+ printf( "Waiting 10 seconds before canceling.\n" );
+ Sleep(10000);
+ result = next->cancel();
+
+ // Give the cancel a chance to complete before returning.
+ printf( "Waiting 5 seconds for cancel to complete.\n" );
+ wakeup = GetCurrentTime() + 5000;
+ sleep = 5000;
+ do
+ {
+ reason = MsgWaitForMultipleObjects( 0, NULL, FALSE, sleep, QS_ALLINPUT );
+ sleep = wakeup - GetCurrentTime();
+ if (sleep > 5000)
+ sleep = 0;
+ if (reason != WAIT_TIMEOUT)
+ if (GetMessageA( &msg, NULL, 0, 0 ))
+ {
+ TranslateMessage (&msg);
+ DispatchMessageA (&msg);
+ }
+ } while (sleep != 0);
+ }
+ return result;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::call_dead( void )
+{
+ HRESULT result;
+ ASSERT_THREAD();
+
+ // Call the server, who is dead by now.
+ result = next->check( next_id );
+ next->Release();
+ next = NULL;
+ if (SUCCEEDED(result))
+ return E_FAIL;
+ else
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::call_me_back( ITest *test )
+{
+ ASSERT_THREAD();
+
+ // Save the global object and tell the driver loop what to do next.
+ test->AddRef();
+ GlobalTest = test;
+ what_next( callback_wn );
+ wake_up_and_smell_the_roses();
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::call_next( void )
+{
+ HRESULT result;
+ ASSERT_THREAD();
+
+ // Call the neighbor.
+ return next->check( next_id );
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::callback( void )
+{
+ ASSERT_THREAD();
+ GlobalWaiting = FALSE;
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::cancel()
+{
+ HRESULT result;
+ DWORD thread;
+ ASSERT_THREAD();
+
+ // Tell my neighbor to cancel the current call next time he receives a
+ // message on his message queue.
+ result = next->cancel_pending_call( &thread );
+
+ // Put a message on my neighbor's message queue.
+ if (result == S_OK)
+ {
+ if (!PostThreadMessageA( thread, WM_USER, 0, 0 ))
+ return E_FAIL;
+ }
+ return result;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::cancel_now()
+{
+ HRESULT result;
+
+ return next->cancel();
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::cancel_pending_call( DWORD *thread )
+{
+ ASSERT_THREAD();
+ fcancel_next = TRUE;
+ *thread = GetCurrentThreadId();
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::cancel_stress( ITest *obj )
+{
+ HRESULT result;
+
+ ASSERT_THREAD();
+
+ // If there is an object, ask it to cancel the call to it.
+ if (obj != NULL)
+ result = obj->cancel_now();
+
+ // Otherwise ask my neighbor to cancel the call to him.
+ else
+ // This only works locally.
+ result = next->cancel();
+
+ // Although the call should have been canceled, sometimes it completes
+ // before the cancel does.
+ if (result == S_OK || result == RPC_E_CALL_CANCELED ||
+ result == MAKE_WIN32( RPC_S_CALL_CANCELLED ))
+ return S_OK;
+ else
+ return result;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::catch_at_top( BOOL catchme, ITest *callback, STRING binding )
+{
+ // Save the callback object and the binding.
+ callback->AddRef();
+ GlobalTest = callback;
+ GlobalBinding = binding;
+
+ // If the catch flag is true, tell the top level message loop to catch
+ // exceptions.
+ what_next( catch_wn );
+ wake_up_and_smell_the_roses();
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::check( SAptId id )
+{
+ ASSERT_THREAD();
+ if (my_id.process == id.process && my_id.thread == id.thread &&
+ my_id.sequence == id.sequence)
+ return S_OK;
+ else
+ return E_FAIL;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::check_hook( DWORD cg1, DWORD cn1, DWORD sg1, DWORD sn1,
+ DWORD cg2, DWORD cn2, DWORD sg2, DWORD sn2 )
+{
+ HRESULT result;
+ ASSERT_THREAD();
+ result = GlobalHook1->check( cg1, cn1, sg1, sn1 );
+ if (result == S_OK && GlobalHook2 != NULL)
+ result = GlobalHook2->check( cg2, cn2, sg2, sn2 );
+ return result;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::count()
+{
+ InterlockedIncrement( &GlobalCalls );
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::crash_out( transmit_crash *x )
+{
+ *x = 0;
+ return S_OK;
+}
+
+ /***************************************************************************/
+CTest::CTest()
+{
+ ref_count = 1;
+ next = NULL;
+ fcancel_next = FALSE;
+ freject_next = FALSE;
+ fretry_next = FALSE;
+ flate_dispatch = FALSE;
+ my_id.sequence = get_sequence();
+ my_id.thread = GetCurrentThreadId();
+ my_id.process = GetCurrentProcessId();
+ increment_object_count();
+}
+
+ /***************************************************************************/
+CTest::~CTest()
+{
+ if (next != NULL)
+ if (!dirty_thread())
+ next->Release();
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::delegate( ITest *obj, SAptId id, HACKSID *sid )
+{
+ HRESULT result = S_OK;
+ DWORD ignore;
+
+ ASSERT_THREAD();
+
+ // Impersonate.
+ result = MCoImpersonateClient();
+ ASSERT( result, "Could not impersonate" );
+
+ // Set the security for the next call.
+ result = MCoSetProxyBlanket( obj, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
+ NULL, RPC_C_AUTHN_LEVEL_CONNECT,
+ RPC_C_IMP_LEVEL_IMPERSONATE, NULL,
+ EOAC_NONE );
+ ASSERT( result, "Could not set blanket" );
+
+ // Call the final server.
+ result = obj->secure( id, RPC_C_AUTHN_LEVEL_CONNECT,
+ RPC_C_IMP_LEVEL_IMPERSONATE, RPC_C_AUTHN_WINNT,
+ RPC_C_AUTHZ_NONE, NULL, sid, &ignore );
+ ASSERT( result, "Could not make delegate call" );
+
+cleanup:
+ return result;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::exit( void )
+{
+ what_next( quit_wn );
+ wake_up_and_smell_the_roses();
+ ASSERT_THREAD();
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::forget( void )
+{
+ ASSERT_THREAD();
+ if (next != NULL)
+ {
+ next->Release();
+ next = NULL;
+ }
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::get_advise( IAdviseSink **obj )
+{
+ *obj = NULL;
+ ASSERT_THREAD();
+ *obj = new CAdvise;
+ if (*obj!= NULL)
+ return S_OK;
+ else
+ return E_FAIL;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::get_data( DWORD isize, unsigned char *idata, DWORD osize,
+ unsigned char **odata )
+{
+ *odata = (unsigned char *) CoTaskMemAlloc( 1 );
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::get_id( SAptId *id )
+{
+ ASSERT_THREAD();
+ *id = my_id;
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::get_next( ITest **obj, SAptId *id )
+{
+ *obj = NULL;
+ ASSERT_THREAD();
+ *id = next_id;
+ *obj = next;
+ if (next != NULL)
+ next->AddRef();
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::get_next_slowly( ITest **obj, SAptId *id )
+{
+ *obj = NULL;
+ ASSERT_THREAD();
+ *id = next_id;
+ *obj = next;
+ if (next != NULL)
+ next->AddRef();
+
+ // Start shutting down.
+ exit();
+
+ // Wait a while.
+ SetEvent( RawEvent );
+ Sleep( 5000 );
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::get_obj_from_new_apt( ITest **obj, SAptId *id )
+{
+ *obj = NULL;
+ ASSERT_THREAD();
+ return new_apartment_test( obj, id, NULL );
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::get_obj_from_this_apt( ITest **obj, SAptId *id )
+{
+ *obj = NULL;
+ ASSERT_THREAD();
+ *obj = new CTest;
+ if (*obj!= NULL)
+ return (*obj)->get_id( id );
+ else
+ return E_FAIL;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::get_sid( HACKSID **sid )
+{
+ // Allocate memory to return the sid.
+ *sid = (HACKSID *) CoTaskMemAlloc( GetLengthSid( ProcessSid ) );
+ if (*sid == NULL)
+ return E_OUTOFMEMORY;
+
+ // Copy it.
+ memcpy( *sid, ProcessSid, GetLengthSid( ProcessSid ) );
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP_(DWORD) CTest::HandleInComingCall( DWORD type, HTASK task,
+ DWORD tick,
+ LPINTERFACEINFO info )
+{
+ if (freject_next)
+ {
+ freject_next = FALSE;
+ return SERVERCALL_REJECTED;
+ }
+
+ // Accept everything.
+ else
+ return SERVERCALL_ISHANDLED;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::interface_in( ITest *test )
+{
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::interrupt( ITest *param, SAptId id, BOOL go )
+{
+ ASSERT_THREAD();
+ GlobalInterruptTest = go;
+ if (go)
+ {
+ GlobalTest = param;
+ GlobalApt = id;
+ GlobalTest->AddRef();
+ what_next( interrupt_wn );
+ wake_up_and_smell_the_roses();
+ }
+ else
+ what_next( wait_wn );
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::interrupt_marshal( ITest *obj1, ITest *obj2 )
+{
+ ASSERT_THREAD();
+ GlobalTest = obj1;
+ GlobalTest2 = obj2;
+ GlobalTest->AddRef();
+ GlobalTest2->AddRef();
+ what_next( interrupt_marshal_wn );
+ wake_up_and_smell_the_roses();
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::make_acl( HACKSID *allow )
+{
+ BOOL success = FALSE;
+ BOOL call_success = FALSE;
+ PACL pACLNew = NULL;
+ DWORD cbACL = 1024;
+ PRIVILEGE_SET set;
+ DWORD granted_access;
+ BOOL access;
+ DWORD privilege_size;
+ HANDLE token = NULL;
+ HRESULT result = E_FAIL;
+ LUID audit;
+ TOKEN_PRIVILEGES privilege;
+ SID *copy = NULL;
+ DWORD length;
+
+ // Open the process's token.
+ call_success = OpenProcessToken( GetCurrentProcess(),
+ TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
+ &token );
+ result = GetLastError();
+ ASSERT( result, "Could not OpenProcessToken" );
+ ASSERT_EXPR( call_success, "Could not OpenProcessToken." );
+
+ // Lookup the audit privilege.
+ call_success = LookupPrivilegeValue( NULL, SE_AUDIT_NAME, &audit );
+ result = GetLastError();
+ ASSERT( result, "Could not LookupPrivilegeValue" );
+
+ // Enable it.
+ privilege.PrivilegeCount = 1;
+ privilege.Privileges[0].Luid = audit;
+ privilege.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
+ AdjustTokenPrivileges( token, FALSE, &privilege, sizeof(privilege), NULL,
+ NULL );
+ result = GetLastError();
+ ASSERT( result, "Could not AdjustTokenPrivileges" );
+
+ // Copy the SID.
+ length = GetLengthSid( (SID *) allow );
+ copy = (SID *) malloc( length );
+ ASSERT_EXPR( copy != NULL, "Could not allocate memory." );
+ memcpy( copy, allow, length );
+
+ // Initialize a new security descriptor.
+ GlobalSecurityDescriptor = (SECURITY_DESCRIPTOR *) LocalAlloc(LPTR,
+ SECURITY_DESCRIPTOR_MIN_LENGTH);
+ ASSERT_EXPR( GlobalSecurityDescriptor != NULL, "Could not allocate memory for the security descriptor." );
+ call_success = InitializeSecurityDescriptor(GlobalSecurityDescriptor,
+ SECURITY_DESCRIPTOR_REVISION);
+ ASSERT_EXPR( call_success, "InitializeSecurityDescriptor" );
+
+ // Initialize a new ACL.
+ pACLNew = (PACL) LocalAlloc(LPTR, cbACL);
+ ASSERT_EXPR( pACLNew != NULL, "LocalAlloc" );
+ call_success = InitializeAcl(pACLNew, cbACL, ACL_REVISION2);
+ ASSERT_EXPR( call_success, "InitializeAcl" );
+
+ // Allow read but not write access to the file.
+ call_success = AddAccessAllowedAce( pACLNew, ACL_REVISION2, READ_CONTROL,
+ copy );
+ ASSERT_EXPR( call_success, "AddAccessAllowedAce failed." );
+
+ // Add a new ACL to the security descriptor.
+ call_success = SetSecurityDescriptorDacl(GlobalSecurityDescriptor,
+ TRUE, /* fDaclPresent flag */
+ pACLNew,
+ FALSE);
+ result = GetLastError();
+ ASSERT( result, "SetSecurityDescriptorDacl failed" );
+ ASSERT_EXPR( call_success, "SetSecurityDescriptorDacl failed." );
+
+ // Set the group.
+ call_success = SetSecurityDescriptorGroup( GlobalSecurityDescriptor,
+ copy, FALSE );
+ ASSERT_EXPR( call_success, "SetSecurityDescriptorGroup failed." );
+
+ // Set the owner.
+ call_success = SetSecurityDescriptorOwner( GlobalSecurityDescriptor,
+ copy, FALSE );
+ ASSERT_EXPR( call_success, "SetSecurityDescriptorOwner failed." );
+
+ // Check the security descriptor.
+ call_success = IsValidSecurityDescriptor( GlobalSecurityDescriptor );
+ ASSERT_EXPR( call_success, "IsValidSecurityDescriptor failed." );
+
+ success = TRUE;
+cleanup:
+ if (!success)
+ {
+ if(GlobalSecurityDescriptor != NULL)
+ LocalFree((HLOCAL) GlobalSecurityDescriptor);
+ if(pACLNew != NULL)
+ LocalFree((HLOCAL) pACLNew);
+ if (copy != NULL)
+ free( copy );
+ }
+
+ if (token != NULL)
+ CloseHandle( token );
+
+ if (success)
+ return S_OK;
+ else if (result != S_OK)
+ return result;
+ else
+ return E_FAIL;
+}
+
+ /***************************************************************************/
+STDMETHODIMP_(DWORD) CTest::MessagePending( HTASK callee, DWORD tick,
+ DWORD type )
+{
+ if (fcancel_next)
+ {
+ fcancel_next = FALSE;
+ return PENDINGMSG_CANCELCALL;
+ }
+ else
+ return PENDINGMSG_WAITDEFPROCESS;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::QueryInterface( THIS_ REFIID riid, LPVOID FAR* ppvObj)
+{
+ HRESULT result = S_OK;
+ DWORD query_authn_level;
+ BOOL success;
+ char value[REGISTRY_ENTRY_LEN];
+ LONG value_size = sizeof(value);
+ HANDLE token;
+
+ ASSERT_THREAD();
+ *ppvObj = NULL;
+
+ // Return the normal interfaces.
+ if (IsEqualIID(riid, IID_IUnknown) ||
+ IsEqualIID(riid, IID_ITest))
+ {
+ *ppvObj = (IUnknown *) (ITest *) this;
+ AddRef();
+ return S_OK;
+ }
+
+ // Return the message filter.
+ else if (IsEqualIID(riid, IID_IMessageFilter))
+ {
+ *ppvObj = (IUnknown *) (IMessageFilter *) this;
+ AddRef();
+ return S_OK;
+ }
+
+ // Check security and return ITest.
+ else if (IsEqualIID( riid, IID_ITestNoneImp ) ||
+ IsEqualIID( riid, IID_ITestConnectImp ) ||
+ IsEqualIID( riid, IID_ITestEncryptImp ) ||
+ IsEqualIID( riid, IID_ITestNoneId ) ||
+ IsEqualIID( riid, IID_ITestConnectId ) ||
+ IsEqualIID( riid, IID_ITestEncryptId ))
+ {
+ // Get the authentication information.
+ result = MCoQueryClientBlanket( NULL, NULL, NULL, &query_authn_level,
+ NULL, NULL, NULL );
+ // Impersonate.
+ if (SUCCEEDED(result))
+ {
+ result = MCoImpersonateClient();
+ if (query_authn_level != RPC_C_AUTHN_LEVEL_NONE && FAILED(result))
+ return result;
+ }
+
+ // Look at the IID to determine the proper results.
+ if (IsEqualIID( riid, IID_ITestNoneImp ))
+ {
+ // If there is a token, should not be able to read the registry.
+ success = OpenThreadToken( GetCurrentThread(), TOKEN_QUERY, TRUE, &token );
+ if (success)
+ {
+ result = RegQueryValueA( HKEY_CLASSES_ROOT, REG_CLASS_EXE, value, &value_size );
+ if (result != ERROR_SUCCESS)
+ goto exit;
+ }
+ *ppvObj = (ITest *) this;
+ AddRef();
+ result = S_OK;
+ goto exit;
+ }
+ if (IsEqualIID( riid, IID_ITestConnectImp ))
+ {
+ // The query and impersonate should have succeeded.
+ if (FAILED(result)) return result;
+
+ // Should be able to read the registry.
+ if (query_authn_level < RPC_C_AUTHN_LEVEL_CONNECT)
+ {
+ result = E_FAIL;
+ goto exit;
+ }
+ result = RegQueryValueA( HKEY_CLASSES_ROOT, REG_CLASS_EXE, value, &value_size );
+ if (result != ERROR_SUCCESS)
+ goto exit;
+ *ppvObj = (ITest *) this;
+ AddRef();
+ result = S_OK;
+ goto exit;
+ }
+ if (IsEqualIID( riid, IID_ITestEncryptImp ))
+ {
+ // The query and impersonate should have succeeded.
+ if (FAILED(result)) return result;
+
+ // Should be able to read the registry.
+ if (query_authn_level < RPC_C_AUTHN_LEVEL_PKT_PRIVACY)
+ {
+ result = E_FAIL;
+ goto exit;
+ }
+ result = RegQueryValueA( HKEY_CLASSES_ROOT, REG_CLASS_EXE, value, &value_size );
+ if (result != ERROR_SUCCESS)
+ goto exit;
+ *ppvObj = (ITest *) this;
+ AddRef();
+ result = S_OK;
+ goto exit;
+ }
+ if (IsEqualIID( riid, IID_ITestNoneId ))
+ {
+ // If there is a token, should not be able to read the registry.
+ success = OpenThreadToken( GetCurrentThread(), TOKEN_QUERY, TRUE, &token );
+ if (success)
+ {
+ result = RegQueryValueA( HKEY_CLASSES_ROOT, REG_CLASS_EXE, value, &value_size );
+ if (result != ERROR_BAD_IMPERSONATION_LEVEL)
+ {
+ result = E_FAIL;
+ goto exit;
+ }
+ }
+ *ppvObj = (ITest *) this;
+ AddRef();
+ result = S_OK;
+ goto exit;
+ }
+ if (IsEqualIID( riid, IID_ITestConnectId ))
+ {
+ // The query and impersonate should have succeeded.
+ if (FAILED(result)) return result;
+
+ // Should not be able to read the registry.
+ if (query_authn_level < RPC_C_AUTHN_LEVEL_CONNECT)
+ {
+ result = E_FAIL;
+ goto exit;
+ }
+ result = RegQueryValueA( HKEY_CLASSES_ROOT, REG_CLASS_EXE, value, &value_size );
+ if (result != ERROR_BAD_IMPERSONATION_LEVEL)
+ {
+ result = E_FAIL;
+ goto exit;
+ }
+ *ppvObj = (ITest *) this;
+ AddRef();
+ result = S_OK;
+ goto exit;
+ }
+ if (IsEqualIID( riid, IID_ITestEncryptId ))
+ {
+ // The query and impersonate should have succeeded.
+ if (FAILED(result)) return result;
+
+ // Should be able to read the registry.
+ if (query_authn_level < RPC_C_AUTHN_LEVEL_PKT_PRIVACY)
+ {
+ result = E_FAIL;
+ goto exit;
+ }
+ result = RegQueryValueA( HKEY_CLASSES_ROOT, REG_CLASS_EXE, value, &value_size );
+ if (result != ERROR_BAD_IMPERSONATION_LEVEL)
+ {
+ result = E_FAIL;
+ goto exit;
+ }
+ *ppvObj = (ITest *) this;
+ AddRef();
+ result = S_OK;
+ goto exit;
+ }
+exit:
+ CoRevertToSelf();
+ return result;
+ }
+ return E_NOINTERFACE;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::null()
+{
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::out( ITest **obj )
+{
+ *obj = this;
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::pointer( DWORD *p )
+{
+ ASSERT_THREAD();
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::recurse( ITest *callback, ULONG depth )
+{
+ ASSERT_THREAD();
+ if (depth == 0)
+ return S_OK;
+ else
+ return callback->recurse( this, depth-1 );
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::recurse_disconnect( ITest *callback, ULONG depth )
+{
+ ASSERT_THREAD();
+
+ HRESULT result;
+
+ if (depth == 0)
+ {
+ result = CoDisconnectObject( (ITest *) this, 0 );
+ return result;
+ }
+ else
+ {
+ result = callback->recurse_disconnect( this, depth-1 );
+ return result;
+ }
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::recurse_excp( ITest *callback, ULONG depth )
+{
+ ASSERT_THREAD();
+ if (depth == 0)
+ {
+ RaiseException( E_FAIL, 0, 0, NULL );
+ return E_FAIL;
+ }
+ else
+ return callback->recurse_excp( this, depth-1 );
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::recurse_fatal( ITest *callback, ULONG catch_depth,
+ ULONG throw_depth, BOOL cancel )
+{
+ ASSERT_THREAD();
+ if (catch_depth == 0)
+ {
+ __try
+ {
+ return recurse_fatal_helper( callback, catch_depth, throw_depth, cancel );
+ }
+ __except(EXCEPTION_EXECUTE_HANDLER)
+ {
+ printf( "Exception on thread 0x%x\n", GetCurrentThreadId() );
+ what_next( crippled_wn );
+ wake_up_and_smell_the_roses();
+ return S_OK;
+ }
+ }
+ else
+ return recurse_fatal_helper( callback, catch_depth, throw_depth, cancel );
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::recurse_fatal_helper( ITest *callback, ULONG catch_depth,
+ ULONG throw_depth, BOOL cancel )
+{
+ volatile void **p = (volatile void **) 0xffffffff;
+
+ if (throw_depth == 0)
+ {
+ // If the cancel flag is set, tell the helper to tell the caller to cancel
+ // the call to this object.
+ if (cancel)
+ next->cancel();
+
+ // Die a horrible death.
+ return (HRESULT) *p;
+ }
+ else
+ return callback->recurse_fatal( this, catch_depth-1, throw_depth-1, cancel );
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::recurse_interrupt( ITest *callback, ULONG depth )
+{
+ MSG msg;
+
+ ASSERT_THREAD();
+ if (PeekMessageA( &msg, NULL, 0, 0, PM_REMOVE ))
+ {
+ TranslateMessage (&msg);
+ DispatchMessageA (&msg);
+ }
+
+ if (depth == 0)
+ return S_OK;
+ else
+ return callback->recurse( this, depth-1 );
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::recurse_secure( ITest *callback, ULONG depth,
+ ULONG imp_depth, HACKSID *sid )
+{
+ HRESULT result;
+ TOKEN_USER *token_info = NULL;
+ DWORD info_size = 1024;
+ HANDLE token = NULL;
+ PSID me = NULL;
+ ASSERT_THREAD();
+
+ if (depth != 0)
+ {
+ // Set the authentication level to connect.
+ result = MCoSetProxyBlanket( callback, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
+ NULL, RPC_C_AUTHN_LEVEL_CONNECT,
+ RPC_C_IMP_LEVEL_IMPERSONATE, NULL,
+ EOAC_NONE );
+ ASSERT( result, "Could not set blanket" );
+ }
+
+ // Impersonate if necessary.
+ if (imp_depth == 0)
+ {
+ result = MCoImpersonateClient();
+ ASSERT( result, "Could not impersonate" );
+ }
+
+ // If not deep enough, continue to recurse.
+ if (depth != 0)
+ {
+ result = callback->recurse_secure( this, depth-1, imp_depth-1,
+ (HACKSID *) ProcessSid );
+ ASSERT( result, "Could not recurse" );
+ }
+
+ // Open the thread's token.
+ if (OpenThreadToken( GetCurrentThread(), TOKEN_QUERY, TRUE, &token ))
+ result = S_OK;
+ else
+ result = GetLastError();
+ if (imp_depth == 0)
+ {
+ ASSERT( result, "Could not open thread token while impersonating" );
+ }
+ else
+ {
+ ASSERT_EXPR( result == NOERROR || result == ERROR_NO_TOKEN, "Could not OpenThreadToken" );
+ }
+
+ // Lookup SID of thread token.
+ token_info = (TOKEN_USER *) malloc( info_size );
+ if (token_info == NULL)
+ {
+ result = E_OUTOFMEMORY;
+ goto cleanup;
+ }
+ if (result == NOERROR)
+ {
+ if (GetTokenInformation( token, TokenUser, token_info, info_size, &info_size ))
+ result = S_OK;
+ else
+ result = GetLastError();
+ ASSERT( result, "Could not GetTokenInformation" );
+ me = token_info->User.Sid;
+ CloseHandle( token );
+ token = NULL;
+
+ // Check the SID in the thread token.
+ if (imp_depth == 0)
+ {
+ if (!EqualSid( me, sid ))
+ {
+ result = E_FAIL;
+ goto cleanup;
+ }
+ }
+ else
+ {
+ if (!EqualSid( me, ProcessSid ))
+ {
+ result = E_FAIL;
+ goto cleanup;
+ }
+ }
+ }
+
+ // Revert.
+ if (imp_depth != 0)
+ {
+ result = MCoRevertToSelf();
+ ASSERT( result, "Could not revert" );
+ }
+
+ // Open the thread's token.
+ if (OpenThreadToken( GetCurrentThread(), TOKEN_QUERY, TRUE, &token ))
+ result = S_OK;
+ else
+ result = GetLastError();
+ if (imp_depth == 0)
+ {
+ ASSERT( result, "Could not open thread token while impersonating" );
+ }
+ else
+ {
+ ASSERT_EXPR( result == NOERROR || result == ERROR_NO_TOKEN, "Could not OpenThreadToken" );
+ }
+
+ // Lookup SID of thread token.
+ if (result == NOERROR)
+ {
+ if (GetTokenInformation( token, TokenUser, token_info, info_size, &info_size ))
+ result = S_OK;
+ else
+ result = GetLastError();
+ ASSERT( result, "Could not GetTokenInformation" );
+ me = token_info->User.Sid;
+ CloseHandle( token );
+ token = NULL;
+
+ // Check the SID in the thread token.
+ if (imp_depth == 0)
+ {
+ if (!EqualSid( me, sid ))
+ {
+ result = E_FAIL;
+ goto cleanup;
+ }
+ }
+ else
+ {
+ if (!EqualSid( me, ProcessSid ))
+ {
+ result = E_FAIL;
+ goto cleanup;
+ }
+ }
+ }
+
+ result = S_OK;
+cleanup:
+ if (token_info != NULL)
+ free(token_info);
+ if (token != NULL)
+ CloseHandle( token );
+ return result;
+}
+
+ /***************************************************************************/
+STDMETHODIMP_(ULONG) CTest::Release( THIS )
+{
+ DWORD status;
+
+ assert_unknown();
+ if (InterlockedDecrement( (long*) &ref_count ) == 0)
+ {
+ decrement_object_count();
+ if (flate_dispatch)
+ {
+ status = WaitForSingleObject( RawEvent, INFINITE );
+ if (status != WAIT_OBJECT_0)
+ printf( "WaitForSingleObject failed.\n" );
+ }
+ delete this;
+ return 0;
+ }
+ else
+ return ref_count;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::register_hook( GUID ext, DWORD seq )
+{
+ CHook *hook;
+ ASSERT_THREAD();
+
+ // Create a new hook.
+ hook = new CHook( ext, seq );
+ if (hook == NULL)
+ return E_OUTOFMEMORY;
+ if (GlobalHook1 == NULL)
+ GlobalHook1 = hook;
+ else
+ GlobalHook2 = hook;
+
+ // Register it.
+ return CoRegisterChannelHook( ext, hook );
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::register_message_filter( BOOL reg )
+{
+ ASSERT_THREAD();
+
+ if (reg)
+ return CoRegisterMessageFilter( this, NULL );
+ else
+ return CoRegisterMessageFilter( NULL, NULL );
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::register_rpc( WCHAR *protseq, WCHAR **binding )
+{
+ ASSERT_THREAD();
+
+ RPC_STATUS status;
+ RPC_BINDING_VECTOR *bindings;
+ WCHAR *string;
+ DWORD i;
+ WCHAR *binding_protseq;
+ BOOL found;
+
+ *binding = NULL;
+ status = RpcServerUseProtseqEp( protseq, 20, NULL, NULL );
+ if (status != RPC_S_OK)
+ return MAKE_WIN32( status );
+
+ status = RpcServerRegisterIf(xIDog_v0_1_s_ifspec,
+ NULL, // MgrTypeUuid
+ NULL); // MgrEpv; null means use default
+ if (status != RPC_S_OK)
+ return MAKE_WIN32( status );
+
+ status = RpcServerRegisterAuthInfo( L"none", RPC_C_AUTHN_WINNT, 0, 0 );
+ if (status != RPC_S_OK)
+ return MAKE_WIN32( status );
+
+ status = RpcServerListen( 1, 1235, TRUE );
+ if (status != RPC_S_OK && status != RPC_S_ALREADY_LISTENING)
+ return MAKE_WIN32( status );
+
+ // Inquire the string bindings.
+ status = RpcServerInqBindings( &bindings );
+ if (status != RPC_S_OK)
+ return MAKE_WIN32( status );
+ if (bindings->Count == 0)
+ {
+ RpcBindingVectorFree( &bindings );
+ return E_FAIL;
+ }
+
+ // Look for ncalrpc.
+ for (i = 0; i < bindings->Count; i++)
+ {
+
+ // Convert the binding handle to a string binding, copy it, and free it.
+ status = RpcBindingToStringBinding( bindings->BindingH[i], &string );
+ if (status == RPC_S_OK)
+ {
+ // Look up the protseq.
+ status = RpcStringBindingParse( string, NULL, &binding_protseq,
+ NULL, NULL, NULL );
+ if (status == RPC_S_OK)
+ {
+ found = wcscmp( binding_protseq, protseq ) == 0;
+ RpcStringFree( &binding_protseq );
+ if (found)
+ {
+ *binding = (WCHAR *) CoTaskMemAlloc( (wcslen(string)+1) * sizeof(WCHAR) );
+ if (*binding != NULL)
+ wcscpy( *binding, string );
+ else
+ status = RPC_S_OUT_OF_RESOURCES;
+ RpcStringFree( &string );
+ break;
+ }
+ }
+ RpcStringFree( &string );
+ }
+ }
+ if (*binding == NULL)
+ status = E_FAIL;
+
+ // Free the binding vector.
+ RpcBindingVectorFree( &bindings );
+ return status;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::reject_next()
+{
+ freject_next = TRUE;
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::reinitialize()
+{
+ ASSERT_THREAD();
+ what_next( reinitialize_wn );
+ wake_up_and_smell_the_roses();
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::remember( ITest *neighbor, SAptId id )
+{
+ ASSERT_THREAD();
+
+ // Save this interface pointer.
+ if (next != NULL)
+ next->Release();
+ next_id = id;
+ next = neighbor;
+ next->AddRef();
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::rest_and_die()
+{
+ ASSERT_THREAD();
+ what_next( rest_and_die_wn );
+ wake_up_and_smell_the_roses();
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::retry_next()
+{
+ fretry_next = TRUE;
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP_(DWORD) CTest::RetryRejectedCall( HTASK callee, DWORD tick,
+ DWORD reject )
+{
+ if (fretry_next)
+ {
+ fretry_next = FALSE;
+ return 0;
+ }
+
+ // Never retry.
+ else
+ return 0xffffffff;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::ring( DWORD length )
+{
+ DWORD i = 0;
+ ITest *ring;
+ ITest *ring_next;
+ SAptId ring_id;
+ HRESULT result;
+
+ ASSERT_THREAD();
+
+ // Call all the neighbors in the ring.
+ ring = next;
+ ring_id = next_id;
+ next->AddRef();
+ while (ring != this)
+ {
+ result = ring->check( ring_id );
+ if (FAILED(result))
+ {
+ ring->Release();
+ return result;
+ }
+ result = ring->get_next( &ring_next, &ring_id );
+ if (FAILED(result))
+ {
+ ring->Release();
+ return result;
+ }
+ ring->Release();
+ ring = ring_next;
+ i++;
+ }
+
+ // Check to make sure the ring is correct.
+ ring->Release();
+ if (i+1 != length || ring_id.process != my_id.process ||
+ ring_id.thread != my_id.thread || ring_id.sequence != my_id.sequence)
+ return E_FAIL;
+ else
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::secure( SAptId id, DWORD authn_level, DWORD imp_level,
+ DWORD authn_svc, DWORD authz_svc,
+ STRING princ_name, HACKSID *caller,
+ DWORD *authn_level_out )
+{
+ HRESULT result = S_OK;
+ DWORD query_authn_level;
+ DWORD query_imp_level;
+ DWORD query_authn_svc;
+ DWORD query_authz_svc;
+ STRING query_princ_name = NULL;
+ TOKEN_USER *token_info = NULL;
+ DWORD info_size = 1024;
+ HANDLE token = NULL;
+ PSID me = NULL;
+
+ *authn_level_out = RPC_C_AUTHN_LEVEL_NONE;
+
+ ASSERT_THREAD();
+ if (my_id.process != id.process || my_id.thread != id.thread ||
+ my_id.sequence != id.sequence)
+ return E_FAIL;
+
+ // Query for the authentication information.
+ result = MCoQueryClientBlanket( &query_authn_svc, &query_authz_svc,
+ &query_princ_name, &query_authn_level,
+ &query_imp_level, NULL, NULL );
+ *authn_level_out = query_authn_level;
+
+ // For unsecure calls, all the other fields should be clear.
+ if (authn_level == RPC_C_AUTHN_LEVEL_NONE)
+ {
+ if (result == S_OK)
+ {
+ if (query_authn_level < authn_level)
+ {
+ result = E_INVALIDARG;
+ goto cleanup;
+ }
+ // The impersonation level can't be determined on the server.
+ // if (query_imp_level != RPC_C_IMP_LEVEL_IMPERSONATE)
+ if (query_imp_level != RPC_C_IMP_LEVEL_ANONYMOUS)
+ {
+ result = E_INVALIDARG;
+ goto cleanup;
+ }
+ if (query_authn_svc != RPC_C_AUTHN_NONE &&
+ query_authn_svc != RPC_C_AUTHN_WINNT)
+ {
+ result = E_INVALIDARG;
+ goto cleanup;
+ }
+ if (query_authz_svc != RPC_C_AUTHZ_NONE)
+ {
+ result = E_INVALIDARG;
+ goto cleanup;
+ }
+ /*
+ if ((princ_name == NULL && query_princ_name != NULL) ||
+ (princ_name != NULL && query_princ_name == NULL))
+ {
+ result = E_INVALIDARG;
+ goto cleanup;
+ }
+ if (princ_name != NULL &&
+ wcscmp(princ_name, query_princ_name) != 0)
+ {
+ result = E_INVALIDARG;
+ goto cleanup;
+ }
+ */
+ }
+ }
+
+ // For secure calls, verify all the authnetication info.
+ else
+ {
+ ASSERT( result, "Could not query client blanket" );
+ if (query_authn_level < authn_level)
+ {
+ result = E_INVALIDARG;
+ goto cleanup;
+ }
+ // The impersonation level can't be determined on the server.
+ //if (query_imp_level != imp_level)
+ if (query_imp_level != RPC_C_IMP_LEVEL_ANONYMOUS)
+ {
+ result = E_INVALIDARG;
+ goto cleanup;
+ }
+ // Sometimes ncalrpc doesn't set the authentication service.
+ if (query_authn_svc != RPC_C_AUTHN_NONE &&
+ query_authn_svc != authn_svc)
+ {
+ result = E_INVALIDARG;
+ goto cleanup;
+ }
+ if (query_authz_svc != authz_svc)
+ {
+ result = E_INVALIDARG;
+ goto cleanup;
+ }
+ /*
+ if ((princ_name == NULL && query_princ_name != NULL) ||
+ (princ_name != NULL && query_princ_name == NULL))
+ {
+ result = E_INVALIDARG;
+ goto cleanup;
+ }
+ if (princ_name != NULL &&
+ wcscmp(princ_name, query_princ_name) != 0)
+ {
+ result = E_INVALIDARG;
+ goto cleanup;
+ }
+ */
+ }
+
+ // Open the thread's token.
+ if (OpenThreadToken( GetCurrentThread(), TOKEN_QUERY, TRUE, &token ))
+ result = S_OK;
+ else
+ result = GetLastError();
+ ASSERT_EXPR( result == NOERROR || result == ERROR_NO_TOKEN, "Could not OpenThreadToken" );
+
+ // Lookup SID of thread token.
+ token_info = (TOKEN_USER *) malloc( info_size );
+ if (token_info == NULL)
+ {
+ result = E_OUTOFMEMORY;
+ goto cleanup;
+ }
+ if (result == NOERROR)
+ {
+ if (GetTokenInformation( token, TokenUser, token_info, info_size, &info_size ))
+ result = S_OK;
+ else
+ result = GetLastError();
+ ASSERT( result, "Could not GetTokenInformation" );
+ me = token_info->User.Sid;
+ CloseHandle( token );
+ token = NULL;
+
+ // The SID on the thread token should equal the process token.
+ if (!EqualSid( me, ProcessSid ))
+ {
+ result = E_FAIL;
+ goto cleanup;
+ }
+ }
+
+ // Impersonate.
+ result = MCoImpersonateClient();
+
+ // For unsecure calls the impersonate should fail.
+ if (authn_level == RPC_C_AUTHN_LEVEL_NONE)
+ {
+ // Currently the impersonate succeeds without setting the thread token.
+/*
+ if (result == S_OK)
+ {
+ result = E_FAIL;
+ goto cleanup;
+ }
+*/
+ result = S_OK;
+ }
+
+ // For secure calls, compare the new thread token sid to the passed
+ // in sid.
+ else
+ {
+ ASSERT( result, "Could not impersonate" );
+
+ // Open the thread's token.
+ if (OpenThreadToken( GetCurrentThread(), TOKEN_QUERY, TRUE, &token ))
+ result = S_OK;
+ else
+ result = GetLastError();
+ ASSERT( result, "Could not OpenThreadToken" );
+
+ // Lookup SID of thread token.
+ if (GetTokenInformation( token, TokenUser, token_info, info_size, &info_size ))
+ result = S_OK;
+ else
+ result = GetLastError();
+ ASSERT( result, "Could not GetTokenInformation" );
+ me = token_info->User.Sid;
+ CloseHandle( token );
+ token = NULL;
+
+ // Compare the impersonate sid to the passed in sid.
+ if (!EqualSid( me, caller ))
+ {
+ result = E_FAIL;
+ goto cleanup;
+ }
+ }
+
+ // Revert.
+ result = MCoRevertToSelf();
+ ASSERT( result, "Could not revert" );
+
+ // Open the thread's token.
+ if (OpenThreadToken( GetCurrentThread(), TOKEN_QUERY, TRUE, &token ))
+ result = S_OK;
+ else
+ result = GetLastError();
+ ASSERT_EXPR( result == NOERROR || result == ERROR_NO_TOKEN, "Could not OpenThreadToken" );
+
+ // Lookup SID of thread token.
+ if (result == NOERROR)
+ {
+ if (GetTokenInformation( token, TokenUser, token_info, info_size, &info_size ))
+ result = S_OK;
+ else
+ result = GetLastError();
+ ASSERT( result, "Could not GetTokenInformation" );
+ me = token_info->User.Sid;
+ CloseHandle( token );
+ token = NULL;
+
+ // The SID on the thread token should equal the process token.
+ if (!EqualSid( me, ProcessSid ))
+ {
+ result = E_FAIL;
+ goto cleanup;
+ }
+ }
+ else
+ result = S_OK;
+
+cleanup:
+ if (token_info != NULL)
+ free(token_info);
+ if (token != NULL)
+ CloseHandle( token );
+ CoTaskMemFree( query_princ_name );
+ return result;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::security_performance( DWORD *get_call, DWORD *query_client,
+ DWORD *impersonate, DWORD *revert )
+{
+ LARGE_INTEGER start;
+ LARGE_INTEGER qget_call;
+ LARGE_INTEGER qquery_client;
+ LARGE_INTEGER qimpersonate;
+ LARGE_INTEGER qrevert;
+ LARGE_INTEGER freq;
+ IServerSecurity *server_sec = NULL;
+ HRESULT result;
+ DWORD authn_svc;
+ DWORD authz_svc;
+ DWORD authn_level;
+ DWORD imp_level;
+ DWORD capabilities;
+ WCHAR *principal = NULL;
+ void *privs;
+
+ // Import the security APIs.
+ GCoGetCallContext = (CoGetCallContextFn) Fixup( "CoGetCallContext" );
+ GCoImpersonateClient = (CoImpersonateClientFn) Fixup( "CoImpersonateClient" );
+ GCoQueryClientBlanket = (CoQueryClientBlanketFn) Fixup( "CoQueryClientBlanket" );
+ GCoRevertToSelf = (CoRevertToSelfFn) Fixup( "CoRevertToSelf" );
+ if (GCoGetCallContext == NULL ||
+ GCoImpersonateClient == NULL ||
+ GCoQueryClientBlanket == NULL ||
+ GCoRevertToSelf == NULL)
+ return E_NOTIMPL;
+
+ // Measure the performance of get call context.
+ QueryPerformanceFrequency( &freq );
+ QueryPerformanceCounter( &start );
+ result = MCoGetCallContext( IID_IServerSecurity, (void **) &server_sec );
+ QueryPerformanceCounter( &qget_call );
+ qget_call.QuadPart = 1000000 * (qget_call.QuadPart - start.QuadPart) / freq.QuadPart;
+ ASSERT( result, "Could not get call context" );
+ server_sec->Release();
+
+ // Measure the performance of query client.
+ QueryPerformanceCounter( &start );
+ result = MCoQueryClientBlanket( &authn_svc, &authz_svc, &principal,
+ &authn_level, &imp_level, &privs, &capabilities );
+ QueryPerformanceCounter( &qquery_client );
+ qquery_client.QuadPart = 1000000 * (qquery_client.QuadPart - start.QuadPart) / freq.QuadPart;
+ ASSERT( result, "Could not query client blanket" );
+ CoTaskMemFree( principal );
+
+ // Measure the performance of impersonate.
+ QueryPerformanceCounter( &start );
+ result = MCoImpersonateClient();
+ QueryPerformanceCounter( &qimpersonate );
+ qimpersonate.QuadPart = 1000000 * (qimpersonate.QuadPart - start.QuadPart) / freq.QuadPart;
+ ASSERT( result, "Could not impersonate" );
+
+ // Measure the performance of revert.
+ QueryPerformanceCounter( &start );
+ result = MCoRevertToSelf();
+ QueryPerformanceCounter( &qrevert );
+ qrevert.QuadPart = 1000000 * (qrevert.QuadPart - start.QuadPart) / freq.QuadPart;
+ ASSERT( result, "Could not revert" );
+
+ // Return the results.
+ *get_call = qget_call.u.LowPart;
+ *query_client = qquery_client.u.LowPart;
+ *impersonate = qimpersonate.u.LowPart;
+ *revert = qrevert.u.LowPart;
+
+cleanup:
+ return result;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::set_state( DWORD state, DWORD priority )
+{
+ BOOL success;
+ ASSERT_THREAD();
+
+ // Save dirty flag per apartment.
+ if (state & dirty_s)
+ if (ThreadMode == COINIT_MULTITHREADED)
+ ProcessAptData.exit_dirty = TRUE;
+ else
+ {
+ SAptData *tls_data = (SAptData *) TlsGetValue( TlsIndex );
+ tls_data->exit_dirty = TRUE;
+ }
+
+ // Save the late dispatch flag per object.
+ if (state & late_dispatch_s)
+ flate_dispatch = TRUE;
+
+ // Set the priority.
+ success = SetThreadPriority( GetCurrentThread(), priority );
+ if (success)
+ return S_OK;
+ else
+ return E_FAIL;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::sick( ULONG val )
+{
+ ASSERT_THREAD();
+ __try
+ {
+ RaiseException( val, 0, 0, NULL );
+ }
+ __except(EXCEPTION_EXECUTE_HANDLER)
+ {
+ }
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::sleep( ULONG time )
+{
+ ASSERT_THREAD();
+
+ NestedCallCount += 1;
+ printf( "Sleeping on thread %d for the %d time concurrently.\n",
+ GetCurrentThreadId(), NestedCallCount );
+
+ // For multithreaded mode, verify that this is not the main thread.
+ if (ThreadMode == COINIT_MULTITHREADED)
+ {
+ if (GetCurrentThreadId() == MainThread)
+ {
+ printf( "Sleep called on the main thread in multi threaded mode.\n" );
+ NestedCallCount -= 1;
+ return FALSE;
+ }
+ }
+
+ // For single threaded mode, verify that this is the only call on the
+ // main thread.
+ else
+ {
+ 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;
+ }
+ }
+
+ Sleep( time );
+ NestedCallCount -= 1;
+ return S_OK;
+}
+
+ /***************************************************************************/
+STDMETHODIMP CTest::test( ULONG gronk )
+{
+ IStream *stream = (IStream *) gronk;
+ ITest *server = NULL;
+ HRESULT result;
+
+ // Unmarshal from the stream.
+ result = CoGetInterfaceAndReleaseStream( stream, IID_ITest, (void **) &server );
+ if (result != S_OK)
+ return result;
+
+ // Release the server.
+ server->Release();
+ return S_OK;
+}
+
+ /***************************************************************************/
+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)
+ {
+ printf( "Create instance failed, attempted agregation.\n" );
+ return E_FAIL;
+ }
+
+ if (IsEqualIID( iidInterface, IID_ITest ) ||
+ IsEqualIID( iidInterface, IID_IUnknown ))
+ {
+ CTest *Test = new FAR CTest();
+
+ if (Test == NULL)
+ {
+ printf( "Create interface failed, no memory.\n" );
+ return E_OUTOFMEMORY;
+ }
+
+ *ppv = Test;
+ printf( "Created instance.\n" );
+ return S_OK;
+ }
+
+ if (IsEqualIID( iidInterface, IID_IAdviseSink ))
+ {
+ CAdvise *Test = new FAR CAdvise();
+
+ if (Test == NULL)
+ {
+ printf( "Create interface failed, no memory.\n" );
+ return E_OUTOFMEMORY;
+ }
+
+ *ppv = Test;
+ printf( "Created instance.\n" );
+ return S_OK;
+ }
+
+ printf( "Create interface failed, wrong interface.\n" );
+ return E_NOINTERFACE;
+}
+
+ /***************************************************************************/
+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;
+}
+
+ /***************************************************************************/
+DWORD _stdcall apartment_base( void *param )
+{
+ new_apt_params *nap = (new_apt_params *) param;
+ CTestCF *factory;
+ ULONG size;
+ HRESULT result;
+ HANDLE memory;
+ BOOL success;
+ SAptData tls_data;
+
+ // In the single threaded mode, stick a pointer to the object count
+ // in TLS.
+ tls_data.object_count = 0;
+ tls_data.what_next = setup_wn;
+ tls_data.exit_dirty = FALSE;
+ tls_data.sequence = 0;
+ TlsSetValue( TlsIndex, &tls_data );
+
+ // Initialize OLE.
+ printf( "Initializing thread 0x%x\n", GetCurrentThreadId() );
+ result = initialize(NULL,ThreadMode);
+ if (SUCCEEDED(result))
+ {
+
+ // Create a class factory.
+ factory = new CTestCF;
+
+ if (factory != NULL)
+ {
+ // Find out how much memory to allocate.
+ result = CoGetMarshalSizeMax( &size, IID_IClassFactory, factory, 0, NULL,
+ MSHLFLAGS_NORMAL );
+
+ if (SUCCEEDED(result))
+ {
+ // Allocate memory.
+ memory = GlobalAlloc( GMEM_FIXED, size );
+
+ if (memory != NULL)
+ {
+ // Create a stream.
+ result = CreateStreamOnHGlobal( memory, TRUE, &nap->stream );
+ if (FAILED(result))
+ {
+ nap->stream = NULL;
+ GlobalFree( memory );
+ }
+
+ // Marshal the class factory.
+ else
+ {
+ result = CoMarshalInterface( nap->stream, IID_IClassFactory,
+ factory, 0, NULL, MSHLFLAGS_NORMAL );
+
+ // Seek back to the start of the stream.
+ if (SUCCEEDED(result))
+ {
+ LARGE_INTEGER pos;
+ LISet32(pos, 0);
+ result = nap->stream->Seek( pos, STREAM_SEEK_SET, NULL );
+ }
+
+ if (FAILED(result))
+ {
+ nap->stream->Release();
+ nap->stream = NULL;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // Pass it back to the creator.
+ success = nap->stream != NULL;
+ SetEvent( nap->ready );
+
+ // Loop till it is time to go away.
+ if (success)
+ server_loop();
+ if (!dirty_thread())
+ {
+ printf( "Uninitializing thread 0x%x\n", GetCurrentThreadId() );
+ CoUninitialize();
+ }
+ else
+ printf( "Did not uninitialize thread 0x%x\n", GetCurrentThreadId() );
+ TlsSetValue( TlsIndex, NULL );
+ return 0;
+}
+
+ /***************************************************************************/
+void callback()
+{
+ HRESULT result;
+
+ // Call the client back.
+ Sleep(1);
+ result = GlobalTest->callback();
+ if (result != S_OK)
+ printf( "Could not callback client: 0x%x\n", result );
+
+ // Release the client.
+ GlobalTest->Release();
+ GlobalTest = NULL;
+}
+
+ /***************************************************************************/
+void check_for_request()
+{
+ MSG msg;
+
+ if (ThreadMode == COINIT_SINGLETHREADED ||
+ ThreadMode == COINIT_APARTMENTTHREADED)
+ {
+ if (PeekMessageA( &msg, NULL, 0, 0, PM_REMOVE ))
+ {
+ TranslateMessage (&msg);
+ DispatchMessageA (&msg);
+ }
+ }
+}
+
+ /***************************************************************************/
+HRESULT create_instance( REFCLSID class_id, ITest **instance, SAptId *id )
+{
+ COSERVERINFO server_machine;
+ MULTI_QI server_instance;
+ WCHAR this_machine[MAX_NAME];
+ DWORD ignore;
+ HRESULT result;
+
+ // Lookup this machine's name.
+ *instance = NULL;
+ ignore = sizeof(this_machine);
+ GetComputerName( this_machine, &ignore );
+
+ // If the server is this machine, just call CoCreateInstance.
+ if (wcscmp(this_machine, Name) == 0)
+ result = CoCreateInstance( class_id, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) instance );
+
+ // Otherwise call CoCreateInstanceEx.
+ else
+ {
+ server_machine.dwReserved1 = 0;
+ server_machine.pwszName = Name;
+ server_machine.pAuthInfo = 0;
+ server_machine.dwReserved2 = 0;
+ server_instance.pIID = &IID_ITest;
+ server_instance.pItf = NULL;
+ server_instance.hr = S_OK;
+ result = CoCreateInstanceEx( class_id, NULL, CLSCTX_REMOTE_SERVER,
+ &server_machine, 1, &server_instance );
+ *instance = (ITest *) server_instance.pItf;
+ }
+
+ // Get the server's id.
+ if (SUCCEEDED(result) && *instance != NULL)
+ result = (*instance)->get_id( id );
+ return result;
+}
+
+ /***************************************************************************/
+void crippled()
+{
+ HRESULT result;
+ SAptData *mine;
+ SAptId id;
+ RPC_BINDING_HANDLE handle = NULL;
+ RPC_STATUS status;
+ CTest local;
+
+ // Get the apartment specific data.
+ if (ThreadMode == COINIT_MULTITHREADED)
+ mine = &ProcessAptData;
+ else
+ mine = (SAptData *) TlsGetValue( TlsIndex );
+ mine->what_next = quit_wn;
+
+ // Try to make a call out.
+ result = GlobalTest->check( id );
+#if 0
+ if (result != RPC_E_CRIPPLED)
+ {
+ printf( "Expected RPC_E_CRIPPLED making call: 0x%x\n", result );
+ result = E_FAIL;
+ goto cleanup;
+ }
+#endif
+
+ // Try to reinitialize.
+ CoUninitialize();
+ result = initialize(NULL,ThreadMode);
+ if (result != CO_E_INIT_RPC_CHANNEL)
+ {
+ printf( "Expected CO_E_INIT_RPC_CHANNEL reinitializing: 0x%x\n", result );
+ result = E_FAIL;
+ goto cleanup;
+ }
+
+ // Success.
+ result = S_OK;
+cleanup:
+
+ // Make the server loop quit.
+ mine->what_next = quit_wn;
+ mine->object_count = 0;
+
+ // Create a binding handle.
+ status = RpcBindingFromStringBinding( GlobalBinding, &handle );
+ if (status != RPC_S_OK)
+ {
+ printf( "Could not make binding handle form string binding: 0x%x\n" );
+ return;
+ }
+
+ // Make a raw RPC call to report the results.
+ set_status( handle, result, (unsigned long *) &status );
+ if (status != RPC_S_OK)
+ {
+ printf( "Could not make RPC call: 0x%x\n", status );
+ return;
+ }
+ local.set_state( dirty_s, THREAD_PRIORITY_NORMAL );
+}
+
+ /***************************************************************************/
+void decrement_object_count()
+{
+ if (ThreadMode == COINIT_MULTITHREADED)
+ {
+ if (InterlockedDecrement( &ProcessAptData.object_count ) == 0)
+ wake_up_and_smell_the_roses();
+ }
+ else
+ {
+ SAptData *tls_data = (SAptData *) TlsGetValue( TlsIndex );
+ if (tls_data != NULL)
+ tls_data->object_count -= 1;
+ }
+}
+
+ /***************************************************************************/
+BOOL dirty_thread()
+{
+ if (ThreadMode == COINIT_MULTITHREADED)
+ return ProcessAptData.exit_dirty;
+ else
+ {
+ SAptData *tls_data = (SAptData *) TlsGetValue( TlsIndex );
+ return tls_data->exit_dirty;
+ }
+}
+
+ /***************************************************************************/
+void do_cancel()
+{
+ BOOL success = FALSE;
+ ITest *obj1 = NULL;
+ ITest *obj2 = NULL;
+ SAptId id1;
+ SAptId id2;
+ HRESULT result;
+
+ // Initialize OLE.
+ hello( "cancel" );
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+
+ // Create a client.
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &obj1 );
+ ASSERT( result, "Could not create instance of test server" );
+ result = obj1->get_id( &id1 );
+ ASSERT( result, "Could not get client id" );
+
+ // Create a client.
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &obj2 );
+ ASSERT( result, "Could not create instance of test server" );
+ result = obj2->get_id( &id2 );
+ ASSERT( result, "Could not get client id" );
+
+ // Run test between two remote objects.
+ success = do_cancel_helper( obj1, id1, obj2, id2 );
+ obj1 = NULL;
+ obj2 = NULL;
+ if (!success)
+ goto cleanup;
+ success = FALSE;
+
+ // Create a client.
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &obj1 );
+ ASSERT( result, "Could not create instance of test server" );
+ result = obj1->get_id( &id1 );
+ ASSERT( result, "Could not get client id" );
+
+ // Create in process server.
+ result = obj1->get_obj_from_new_apt( &obj2, &id2 );
+ ASSERT( result, "Could not get in process server" );
+
+ // Run test between two local objects.
+ success = do_cancel_helper( obj1, id1, obj2, id2 );
+ obj1 = NULL;
+ obj2 = NULL;
+ if (!success)
+ goto cleanup;
+
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+ if (obj1 != NULL)
+ obj1->Release();
+ if (obj2 != NULL)
+ obj2->Release();
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nCancel Test Passed.\n" );
+ else
+ printf( "\n\nCancel Test Failed.\n" );
+}
+
+ /***************************************************************************/
+BOOL do_cancel_helper( ITest *obj1, SAptId id1, ITest *obj2, SAptId id2 )
+{
+ BOOL success = FALSE;
+ HRESULT result;
+ ITest *helper1 = NULL;
+ ITest *helper2 = NULL;
+ SAptId hid1;
+ SAptId hid2;
+
+ // Create first helper.
+ result = obj1->get_obj_from_new_apt( &helper1, &hid1 );
+ ASSERT( result, "Could not get in process server" );
+
+ // Create second helper.
+ result = obj2->get_obj_from_new_apt( &helper2, &hid2 );
+ ASSERT( result, "Could not get in process server" );
+
+ // Register first message filter.
+ result = obj1->register_message_filter( TRUE );
+ ASSERT( result, "Could not register message filter." );
+
+ // Register second message filter.
+ result = obj2->register_message_filter( TRUE );
+ ASSERT( result, "Could not register message filter." );
+
+ // Tell everybody who their neighbor is.
+ result = obj1->remember( helper2, hid2 );
+ ASSERT( result, "Could not remember object" );
+ result = helper2->remember( obj2, id2 );
+ ASSERT( result, "Could not remember object" );
+ result = obj2->remember( helper1, hid1 );
+ ASSERT( result, "Could not remember object" );
+ result = helper1->remember( obj1, id1 );
+ ASSERT( result, "Could not remember object" );
+
+ // Cancel one call.
+ result = obj1->call_canceled( 1, 1, obj2 );
+ ASSERT( result, "Cancel test failed" );
+
+ // Cancel after recursing.
+ result = obj1->call_canceled( 5, 1, obj2 );
+ ASSERT( result, "Cancel after recusing failed" );
+
+ // Make a recursive call and cancel several times.
+ result = obj1->call_canceled( 5, 3, obj2 );
+ ASSERT( result, "Multiple cancel test failed" );
+
+ // Tell everybody to forget their neighbor.
+ result = obj1->forget();
+ ASSERT( result, "Could not forget neighbor" );
+ result = obj2->forget();
+ ASSERT( result, "Could not forget neighbor" );
+ result = helper1->forget();
+ ASSERT( result, "Could not forget neighbor" );
+ result = helper2->forget();
+ ASSERT( result, "Could not forget neighbor" );
+
+ // Release first message filter.
+ result = obj1->register_message_filter( FALSE );
+ ASSERT( result, "Could not deregister message filter." );
+
+ // Release second message filter.
+ result = obj2->register_message_filter( FALSE );
+ ASSERT( result, "Could not deregister message filter." );
+
+ success = TRUE;
+cleanup:
+ if (helper1 != NULL)
+ helper1->Release();
+ if (helper2 != NULL)
+ helper2->Release();
+ if (obj2 != NULL)
+ obj2->Release();
+ if (obj1 != NULL)
+ obj1->Release();
+ return success;
+}
+
+ /***************************************************************************/
+void do_crash()
+{
+ HRESULT result;
+ int i;
+ BOOL success = FALSE;
+ HANDLE helper[MAX_THREADS];
+ DWORD thread_id;
+ DWORD status;
+ ITest *test = NULL;
+ ITest *another = NULL;
+ ITest *local = NULL;
+ SAptId local_id;
+ SAptId test_id;
+ SAptId another_id;
+ unsigned char c[17];
+ WCHAR *binding = NULL;
+/*
+ printf( "This test doesn't run. It tests functionallity that is not checked in.\n" );
+ return;
+*/
+ // Initialize OLE.
+ hello( "crash" );
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+/*
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Recalling Initialize failed" );
+ result = initialize(NULL,xxx);
+ if (result == S_OK)
+ {
+ printf( "Recalling Initialize with wrong thread mode succeeded: %x\n", result );
+ goto cleanup;
+ }
+ CoUninitialize();
+ CoUninitialize();
+*/
+
+ // Create a local object.
+ local = new CTest;
+ ASSERT_EXPR( local != NULL, "Could not create local instance of test server." );
+
+ // Get a test object.
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &test );
+ ASSERT( result, "Could not create instance of test server" );
+
+ // Get another test object.
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &another );
+ ASSERT( result, "Could not create another instance of test server" );
+ result = another->get_id( &another_id );
+ ASSERT( result, "get_id failed calling second test server" );
+
+ // Let the server throw and exception and catch it before returning.
+ result = test->sick( 95 );
+ ASSERT( result, "Internal server fault was not dealt with correctly." );
+
+ // Throw a non fatal exception on the first call.
+ result = test->recurse_excp( local, 0 );
+ if (result != RPC_E_SERVERFAULT)
+ {
+ printf( "Error with top level exception.\n" );
+ goto cleanup;
+ }
+
+ // Throw a non fatal exception after recursing.
+ result = test->recurse_excp( local, 4 );
+ if (result != RPC_E_SERVERFAULT)
+ {
+ printf( "Error with nested exception.\n" );
+ goto cleanup;
+ }
+
+ // Test alignment of the buffer.
+ result = test->align( c );
+ ASSERT( result, "Alignment call failed" );
+
+ // Test failure marshalling parameters.
+ result = test->pointer( (DWORD *) -1 );
+ if (result != STATUS_ACCESS_VIOLATION)
+ {
+ printf( "Marshalling in parameter failure call failed: 0x%x\n", result );
+ goto cleanup;
+ }
+
+ // Test a recursive call.
+ result = test->recurse( local, 10 );
+ ASSERT( result, "Recursive call failed" );
+
+ // Test multiple threads.
+ Multicall_Test = TRUE;
+ for (i = 0; i < MAX_THREADS; i++)
+ {
+ helper[i] = CreateThread( NULL, 0, thread_helper, test, 0, &thread_id );
+ if (helper[i] == NULL)
+ {
+ printf( "Could not create helper thread number %d.\n", i );
+ goto cleanup;
+ }
+ }
+ result = test->sleep(4000);
+ ASSERT( result, "Multiple call failed on main thread" );
+ status = WaitForMultipleObjects( MAX_THREADS, helper, TRUE, INFINITE );
+ if (status == WAIT_FAILED)
+ {
+ printf( "Could not wait for helper threads to die: 0x%x\n", status );
+ goto cleanup;
+ }
+ if (!Multicall_Test)
+ {
+ printf( "Multiple call failed on helper thread.\n" );
+ goto cleanup;
+ }
+
+ // See if methods can correctly call GetMessage.
+ another->interrupt( test, another_id, TRUE );
+ result = test->recurse_interrupt( local, 10 );
+ ASSERT( result, "Recursive call with interrupts failed" );
+ another->interrupt( test, another_id, FALSE );
+
+ // Kill the server on the first call.
+ printf( "One of the servers may get a popup now. Hit Ok.\n" );
+ result = test->recurse_fatal( local, 0xffffffff, 0, FALSE );
+ ASSERT_EXPR( result != S_OK, "Server still alive after top level exception." );
+ test->Release();
+ test = NULL;
+
+ // Kill the server after nesting.
+ printf( "One of the servers may get a popup now. Hit Ok.\n" );
+ result = another->recurse_fatal( local, 0xffffffff, 4, FALSE );
+ if (result == S_OK)
+ {
+ printf( "Server still alive after nested exception.\n" );
+ goto cleanup;
+ }
+ another->Release();
+ another = NULL;
+/*
+ // Get a test object.
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &test );
+ ASSERT( result, "Could not create instance of test server" );
+
+ // Register this process to receive raw RPC.
+ result = local->register_rpc( TestProtseq, &binding );
+ ASSERT( result, "Could not register rpc" );
+
+ // Tell the server to catch the exception at the message loop.
+ result = test->catch_at_top( TRUE, local, binding );
+ ASSERT( result, "Could not tell server to catch exception at top" );
+
+ // Kill the server on the first call.
+ result = test->recurse_fatal( local, 0xffffffff, 0, FALSE );
+ if (result == S_OK)
+ {
+ printf( "Server still alive after exception caught at top.\n" );
+ goto cleanup;
+ }
+ test->Release();
+ test = NULL;
+
+ // Check the raw result.
+ status = WaitForSingleObject( RawEvent, INFINITE );
+ if (status != WAIT_OBJECT_0)
+ {
+ printf( "Could not wait on RawEvent: 0x%x\n", status );
+ goto cleanup;
+ }
+ ASSERT( RawResult, "Problem after exception" );
+
+ // Get a test object.
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &test );
+ ASSERT( result, "Could not create instance of test server" );
+
+ // Tell the server to catch the exception at the message loop.
+ result = test->catch_at_top( TRUE, local, binding );
+ ASSERT( result, "Could not tell server to catch exception at top" );
+
+ // Kill the server after nesting.
+ result = test->recurse_fatal( local, 0xffffffff, 6, FALSE );
+ if (result == S_OK)
+ {
+ printf( "Server still alive after exception caught at top.\n" );
+ goto cleanup;
+ }
+ test->Release();
+ test = NULL;
+
+ // Check the raw result.
+ status = WaitForSingleObject( RawEvent, INFINITE );
+ if (status != WAIT_OBJECT_0)
+ {
+ printf( "Could not wait on RawEvent: 0x%x\n", status );
+ goto cleanup;
+ }
+ ASSERT( RawResult, "Problem after exception" );
+
+ // Get a test object.
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &test );
+ ASSERT( result, "Could not create instance of test server" );
+
+ // Tell the server not to catch the exception at the message loop.
+ result = test->catch_at_top( FALSE, local, binding );
+ ASSERT( result, "Could not tell server not to catch exception at top" );
+
+ // Tell the server to catch the exception after nesting, nest some more
+ // and then kill it.
+ result = test->recurse_fatal( local, 2, 8, FALSE );
+ ASSERT( result, "Could not gracefully catch exception" );
+ test->Release();
+ test = NULL;
+
+ // Check the raw result.
+ status = WaitForSingleObject( RawEvent, INFINITE );
+ if (status != WAIT_OBJECT_0)
+ {
+ printf( "Could not wait on RawEvent: 0x%x\n", status );
+ goto cleanup;
+ }
+ ASSERT( RawResult, "Problem after exception" );
+
+ // Get a test object.
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &test );
+ ASSERT( result, "Could not create instance of test server" );
+
+ // Tell the server not to catch the exception at the message loop.
+ result = test->catch_at_top( FALSE, local, binding );
+ ASSERT( result, "Could not tell server not to catch exception at top" );
+
+ // Get the object ids.
+ result = local->get_id( &local_id );
+ ASSERT( result, "Could not get local id" );
+ result = test->get_id( &test_id );
+ ASSERT( result, "Could not get test id" );
+
+ // Cancel the call to kill the server.
+ success = do_crash_helper( local, local_id, test, test_id);
+ local = NULL;
+ test = NULL;
+ if (!success)
+ goto cleanup;
+ success = FALSE;
+*/
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+ if (test != NULL)
+ test->Release();
+ if (another != NULL)
+ another->Release();
+ if (local != NULL)
+ local->Release();
+ if (binding != NULL)
+ CoTaskMemFree( binding );
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nCrash Test Passed.\n" );
+ else
+ printf( "\n\nCrash Test Failed.\n" );
+}
+
+ /***************************************************************************/
+BOOL do_crash_helper( ITest *obj1, SAptId id1, ITest *obj2, SAptId id2 )
+{
+ BOOL success = FALSE;
+ HRESULT result;
+ ITest *helper1 = NULL;
+ SAptId hid1;
+ RPC_STATUS status;
+
+ // Create first helper.
+ result = obj1->get_obj_from_new_apt( &helper1, &hid1 );
+ ASSERT( result, "Could not get in process server" );
+
+ // Register first message filter.
+ result = obj1->register_message_filter( TRUE );
+ ASSERT( result, "Could not register message filter." );
+
+ // Tell everybody who their neighbor is.
+ result = obj2->remember( helper1, hid1 );
+ ASSERT( result, "Could not remember object" );
+ result = helper1->remember( obj1, id1 );
+ ASSERT( result, "Could not remember object" );
+
+ // Tell the server to catch the exception after nesting, nest some more
+ // and then kill it, with cancel.
+ result = obj2->recurse_fatal( obj1, 2, 8, TRUE );
+ if (result == S_OK)
+ ASSERT( result, "Could not gracefully catch exception" );
+ obj2->Release();
+ obj2 = NULL;
+
+ // Check the raw result.
+ status = WaitForSingleObject( RawEvent, INFINITE );
+ if (status != WAIT_OBJECT_0)
+ {
+ printf( "Could not wait on RawEvent: 0x%x\n", status );
+ goto cleanup;
+ }
+ ASSERT( RawResult, "Problem after exception" );
+
+ // Tell everybody to forget their neighbor.
+ result = helper1->forget();
+ ASSERT( result, "Could not forget neighbor" );
+
+ // Release first message filter.
+ result = obj1->register_message_filter( FALSE );
+ ASSERT( result, "Could not deregister message filter." );
+
+ success = TRUE;
+cleanup:
+ if (helper1 != NULL)
+ helper1->Release();
+ if (obj2 != NULL)
+ obj2->Release();
+ if (obj1 != NULL)
+ obj1->Release();
+ return success;
+}
+
+ /***************************************************************************/
+void do_cstress()
+{
+ BOOL success = FALSE;
+ ITest *obj1 = NULL;
+ ITest *obj2 = NULL;
+ ITest *helper = NULL;
+ SAptId id1;
+ SAptId id2;
+ SAptId hid;
+ int i;
+ HRESULT result;
+
+ // Initialize OLE.
+ hello( "cstress" );
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+
+ // Create a client.
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &obj1 );
+ ASSERT( result, "Could not create instance of test server" );
+ result = obj1->get_id( &id1 );
+ ASSERT( result, "Could not get client id" );
+
+ // Create helper.
+ result = obj1->get_obj_from_new_apt( &helper, &hid );
+ ASSERT( result, "Could not get in process server" );
+
+ // Create a client.
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &obj2 );
+ ASSERT( result, "Could not create instance of test server" );
+ result = obj2->get_id( &hid );
+ ASSERT( result, "Could not get client id" );
+
+ // Register the message filter.
+ result = obj1->register_message_filter( TRUE );
+ ASSERT( result, "Could not register message filter." );
+
+ // Tell everyone to remember their neighbor.
+ result = obj1->remember( helper, hid );
+ ASSERT( result, "Could not remember object" );
+ result = obj2->remember( helper, hid );
+ ASSERT( result, "Could not remember object" );
+ result = helper->remember( obj1, id1 );
+ ASSERT( result, "Could not remember object" );
+
+ // Loop and cancel a lot of calls.
+ for (i = 0; i < NumIterations; i++)
+ {
+ // Cancel remote call.
+ result = obj1->cancel_stress( obj2 );
+ ASSERT( result, "Remote cancel failed" );
+
+ // Cancel local call.
+ result = obj1->cancel_stress( NULL );
+ ASSERT( result, "Local cancel failed" );
+ }
+
+ // Tell everybody to forget their neighbor.
+ result = obj1->forget();
+ ASSERT( result, "Could not forget neighbor" );
+ result = obj2->forget();
+ ASSERT( result, "Could not forget neighbor" );
+ result = helper->forget();
+ ASSERT( result, "Could not forget neighbor" );
+
+ // Release the message filter.
+ result = obj1->register_message_filter( FALSE );
+ ASSERT( result, "Could not register message filter." );
+
+ // Create in process server.
+ result = obj1->get_obj_from_new_apt( &helper, &hid );
+ ASSERT( result, "Could not get in process server" );
+
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+ if (helper != NULL)
+ helper->Release();
+ if (obj1 != NULL)
+ obj1->Release();
+ if (obj2 != NULL)
+ obj2->Release();
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nCancel Stress Test Passed.\n" );
+ else
+ printf( "\n\nCancel Stress Test Failed.\n" );
+}
+
+ /***************************************************************************/
+void do_hook()
+{
+ BOOL success = FALSE;
+ ITest *server = NULL;
+ SAptId id;
+ ITest *dead = NULL;
+ ITest *local = NULL;
+ HRESULT result;
+
+ // Initialize OLE.
+ hello( "hook" );
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+
+ // Create a remote server.
+ result = create_instance( *ServerClsid, &dead, &id );
+ ASSERT( result, "Could not create a server" );
+
+ // Tell it to die.
+ result = dead->exit();
+ ASSERT( result, "Could not tell server to die" );
+
+ if (ThreadMode == COINIT_APARTMENTTHREADED)
+ {
+ // Create a local server.
+ result = new_apartment_test( &local, &id, NULL );
+ ASSERT( result, "Could not create local server" );
+
+ // Test hooks in process.
+ success = do_hook_helper( TRUE, local, id, dead );
+ if (!success) goto cleanup;
+ success = FALSE;
+
+ // Release the local server.
+ local->Release();
+ local = NULL;
+ dead->Release();
+ dead = NULL;
+
+ // Uninitialize.
+ CoUninitialize();
+
+ // Reinitialize.
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+
+ // Create a remote server.
+ result = create_instance( *ServerClsid, &dead, &id );
+ ASSERT( result, "Could not create a server" );
+
+ // Tell it to die.
+ result = dead->exit();
+ ASSERT( result, "Could not tell server to die" );
+ }
+
+ // Create a remote server.
+ result = create_instance( *ServerClsid, &server, &id );
+ ASSERT( result, "Could not create a server" );
+
+ // Test remote hooks.
+ success = do_hook_helper( FALSE, server, id, dead );
+ if (!success) goto cleanup;
+ success = FALSE;
+
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+ if (local != NULL)
+ local->Release();
+ if (server != NULL)
+ server->Release();
+ if (dead != NULL)
+ dead->Release();
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nHook Test Passed.\n" );
+ else
+ printf( "\n\nHook Test Failed.\n" );
+}
+
+ /***************************************************************************/
+BOOL do_hook_helper( BOOL local, ITest *test, SAptId id, ITest *dead )
+{
+ CHook *hook1 = NULL;
+ CHook *hook2 = NULL;
+ BOOL success = FALSE;
+ UUID extent1;
+ UUID extent2;
+ UUID extent3;
+ HRESULT result;
+ DWORD i;
+ unsigned char *data = NULL;
+
+ // Call the server.
+ result = test->check( id );
+ ASSERT( result, "Could not check server" );
+
+ // Register a hook.
+ result = UuidCreate( &extent1 );
+ ASSERT_EXPR( result == RPC_S_OK || result == RPC_S_UUID_LOCAL_ONLY,
+ "Could not create uuid." );
+ hook1 = new CHook( extent1, 1 );
+ ASSERT_EXPR( hook1 != NULL, "Could not create new hook." );
+ result = CoRegisterChannelHook( extent1, hook1 );
+ ASSERT( result, "Could not register first hook" );
+
+ // Call the server.
+ result = test->check( id );
+ ASSERT( result, "Could not check server" );
+
+ // Register the hook in the server
+ if (!local)
+ {
+ result = test->register_hook( extent1, 1 );
+ ASSERT( result, "Could not register server hook" );
+ }
+
+ // Call the server.
+ result = test->check( id );
+ ASSERT( result, "Could not check server" );
+
+ // Register another hook in the server.
+ result = UuidCreate( &extent3 );
+ ASSERT_EXPR( result == RPC_S_OK || result == RPC_S_UUID_LOCAL_ONLY,
+ "Could not create uuid." );
+ result = test->register_hook( extent3, 3 );
+ ASSERT( result, "Could not register server hook" );
+
+ // Call the server.
+ result = test->check( id );
+ ASSERT( result, "Could not check server" );
+
+ // Register another hook in the client.
+ result = UuidCreate( &extent2 );
+ ASSERT_EXPR( result == RPC_S_OK || result == RPC_S_UUID_LOCAL_ONLY,
+ "Could not create uuid." );
+ hook2 = new CHook( extent2, 2 );
+ ASSERT_EXPR( hook2 != NULL, "Could not create new hook." );
+ result = CoRegisterChannelHook( extent2, hook2 );
+ ASSERT( result, "Could not register first hook" );
+
+ // Call the server several times.
+ for (i = 0; i < NumIterations; i++)
+ {
+ result = test->check( id );
+ ASSERT( result, "Could not check server" );
+ }
+
+ // Verify the server's hook state.
+ if (local)
+ result = test->check_hook( 2+NumIterations, 2+NumIterations,
+ 2+NumIterations, 2+NumIterations,
+ 0, 0, 0, 0 );
+ else
+ result = test->check_hook( 0, 0, 4+NumIterations, 4+NumIterations,
+ 0, 0, 2+NumIterations, 2+NumIterations );
+ ASSERT( result, "Could not check server hook" );
+
+ // Verify the local hook state.
+ if (local)
+ {
+ result = hook1->check( 5+NumIterations, 5+NumIterations,
+ 5+NumIterations, 5+NumIterations );
+ ASSERT( result, "Bad state for hook 1" );
+ result = hook2->check( 1+NumIterations, 1+NumIterations,
+ 1+NumIterations, 1+NumIterations );
+ ASSERT( result, "Bad state for hook 2" );
+ }
+ else
+ {
+ result = hook1->check( 6+NumIterations, 6+NumIterations, 0, 0 );
+ ASSERT( result, "Bad state for hook 1" );
+ result = hook2->check( 1+NumIterations, 1+NumIterations, 0, 0 );
+ ASSERT( result, "Bad state for hook 2" );
+ }
+
+ // Make a call that fails in get buffer.
+ data = (unsigned char *) CoTaskMemAlloc( 1 );
+ ASSERT_EXPR( data != NULL, "Could not allocate memory." );
+ result = test->get_data( 0x7fffffff, data, 0, &data );
+ ASSERT_EXPR( result != S_OK, "Bad call succeeded." );
+
+ // Make a call that fails in send receive.
+ result = dead->check( id );
+ ASSERT_EXPR( result != S_OK, "Bad call succeeded." );
+
+ // Make a call that faults.
+ result = test->recurse_excp( NULL, 0 );
+ ASSERT_EXPR( result != S_OK, "Bad call succeeded." );
+
+ // Make a call that fails in the server get buffer.
+ result = test->get_data( 0, NULL, 0x7fffffff, &data );
+ ASSERT_EXPR( result != S_OK, "Bad call succeeded." );
+
+ // Make a call that faults in the stub processing out parameters.
+ result = test->crash_out( &i );
+ ASSERT_EXPR( result != S_OK, "Bad call succeeded." );
+
+ // Make a successful call.
+ result = test->check( id );
+ ASSERT( result, "Could not check server" );
+
+ // The test succeeded.
+ success = TRUE;
+cleanup:
+ if (hook1 != NULL)
+ hook1->Release();
+ if (hook2 != NULL)
+ hook2->Release();
+ if (data != NULL)
+ CoTaskMemFree( data );
+ return success;
+}
+
+ /***************************************************************************/
+void do_load_client()
+{
+ BOOL success = FALSE;
+ ITest *server = NULL;
+ HRESULT result;
+ RPC_BINDING_HANDLE handle = NULL;
+ RPC_STATUS status;
+ WCHAR binding[MAX_NAME];
+ void *buffer = NULL;
+ SAptId id;
+ SAptId id2;
+ HANDLE memory = NULL;
+ IStream *stream = NULL;
+ LARGE_INTEGER pos;
+ DWORD time_null;
+ long buf_size;
+ DWORD i;
+
+ // Initialize OLE.
+ hello( "Load_Client" );
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+
+ // Build binding handle for the server.
+ wsprintf( binding, L"%ws:%ws", TestProtseq, Name );
+ status = RpcBindingFromStringBinding( binding, &handle );
+ if (status != RPC_S_OK)
+ {
+ printf( "Could not make binding handle from string binding: 0x%x\n", status );
+ goto cleanup;
+ }
+
+ // Get a marshalled interface from the server over raw RPC.
+ get_interface_buffer( handle, &buf_size, (unsigned char **) &buffer, &id,
+ (error_status_t *) &status );
+ if (status != RPC_S_OK)
+ {
+ printf( "Could not get buffer containing interface: 0x%x\n", status );
+ goto cleanup;
+ }
+
+ // Allocate memory.
+ memory = GlobalAlloc( GMEM_FIXED, buf_size );
+ ASSERT_EXPR( memory != NULL, "Could not GlobalAlloc." );
+
+ // Create a stream.
+ result = CreateStreamOnHGlobal( memory, TRUE, &stream );
+ ASSERT( result, "Could not create stream" );
+
+ // Write the data.
+ result = stream->Write( buffer, buf_size, NULL );
+ ASSERT( result, "Could not write to stream" );
+
+ // Seek back to the start of the stream.
+ pos.QuadPart = 0;
+ result = stream->Seek( pos, STREAM_SEEK_SET, NULL );
+ ASSERT( result, "Could not seek stream to start" );
+
+ // Unmarshal Interface.
+ result = CoUnmarshalInterface( stream, IID_ITest, (void **) &server );
+ ASSERT( result, "Could not unmarshal interface" );
+
+ // Call once to make sure everything is set up.
+ result = server->null();
+ ASSERT( result, "Could not make null call" );
+
+ // Make a lot of null calls.
+ time_null = GetTickCount();
+ for (i = 0; i < NumIterations; i++)
+ {
+ result = server->count();
+ ASSERT( result, "Could not make count call" );
+ }
+ time_null = GetTickCount() - time_null;
+
+ // Notify the server that we are done.
+ release_interface( handle, (error_status_t *) &status );
+ if (status != RPC_S_OK)
+ {
+ printf( "Could not release interface: 0x%x\n", status );
+ goto cleanup;
+ }
+
+ // Print the results.
+ printf( "%d uS / DCOM Null Call\n", time_null*1000/NumIterations );
+
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+ if (server != NULL)
+ server->Release();
+ if (handle != NULL)
+ RpcBindingFree( &handle );
+ if (buffer != NULL)
+ midl_user_free( buffer );
+ if (stream != NULL)
+ stream->Release();
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nLoad_Client Test Passed.\n" );
+ else
+ printf( "\n\nLoad_Client Test Failed.\n" );
+}
+
+ /***************************************************************************/
+void do_load_server()
+{
+ BOOL success = FALSE;
+ SAptId id;
+ HRESULT result;
+ RPC_STATUS status;
+ RPC_BINDING_VECTOR *bindings = NULL;
+ HANDLE thread = NULL;
+ DWORD thread_id;
+
+ // Initialize OLE.
+ hello( "Load_Server" );
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+
+ // Start the status thread.
+ thread = CreateThread( NULL, 0, status_helper, NULL, 0, &thread_id );
+ ASSERT_EXPR( thread != 0, "Could not create thread." );
+
+ // Set up thread switching.
+ GlobalThreadId = GetCurrentThreadId();
+
+ // Create a local server
+ GlobalTest = new CTest;
+ ASSERT( !GlobalTest, "Could not create local server" );
+
+ // Register a protseq.
+ status = RpcServerUseProtseq( TestProtseq, RPC_C_PROTSEQ_MAX_REQS_DEFAULT,
+ NULL );
+ ASSERT( status, "Could not register protseq" );
+
+ // Register the dog interface.
+ status = RpcServerRegisterIf(xIDog_v0_1_s_ifspec,
+ NULL, // MgrTypeUuid
+ NULL); // MgrEpv; null means use default
+ ASSERT( status, "Could not register RPC interface" );
+
+ // Inquire the endpoints.
+ status = RpcServerInqBindings(&bindings);
+ ASSERT( status, "Could not inquire bindings" );
+
+ // Register them in the endpoint mapper.
+ status = RpcEpRegister( xIDog_v0_1_s_ifspec, bindings, NULL, NULL );
+ ASSERT( status, "Could not register with endpoint mapper" );
+
+ // Start RPC listening.
+ status = RpcServerListen( 1, RPC_C_LISTEN_MAX_CALLS_DEFAULT, TRUE );
+ ASSERT( status, "Could not start RPC listening" );
+
+ // Wait until the objects are released.
+ server_loop();
+
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+ if (thread != NULL)
+ CloseHandle( thread );
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nLoad_Server Test Passed.\n" );
+ else
+ printf( "\n\nLoad_Server Test Failed.\n" );
+}
+
+ /***************************************************************************/
+void do_lots()
+{
+ do_cancel();
+ do_crash();
+ do_null();
+ do_ring();
+ do_rundown();
+}
+
+ /***************************************************************************/
+void do_mmarshal()
+{
+ BOOL success = FALSE;
+ ITest *client1 = NULL;
+ ITest *client2 = NULL;
+ ITest *test = NULL;
+ ITest *callee = NULL;
+ HRESULT result;
+
+ // Initialize OLE.
+ hello( "mmarshal" );
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+
+ // Create a client.
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &client1 );
+ ASSERT( result, "Could not create instance of test server" );
+
+ // Create a client.
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &client2 );
+ ASSERT( result, "Could not create instance of test server" );
+
+ // Create a client.
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &test );
+ ASSERT( result, "Could not create instance of test server" );
+
+ // Create a client.
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &callee );
+ ASSERT( result, "Could not create instance of test server" );
+
+ // Tell the first client to start calling the test object.
+ result = client1->interrupt_marshal( test, callee);
+ ASSERT( result, "Could not start client" );
+
+ // Tell the first client to start calling the test object.
+ result = client2->interrupt_marshal( test, callee);
+ ASSERT( result, "Could not start client" );
+
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+ if (client1 != NULL)
+ client1->Release();
+ if (client2 != NULL)
+ client2->Release();
+ if (test != NULL)
+ test->Release();
+ if (callee != NULL)
+ callee->Release();
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nMultiple marshal Test passed if all server processes exit.\n" );
+ else
+ printf( "\n\nMultiple marshal Test Failed.\n" );
+}
+
+ /***************************************************************************/
+void do_null()
+{
+ HRESULT result;
+ BOOL success = FALSE;
+ ITest *test = NULL;
+ SAptId id;
+
+ // Initialize OLE.
+ hello( "null" );
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+
+ // Get a test object on another apartment.
+ result = new_apartment_test( &test, &id, NULL );
+ ASSERT( result, "Could not create apartment instance of test server" );
+
+ // Call the test object.
+ result = test->check( id );
+ ASSERT( result, "Could not call check in another apartment" );
+
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+ if (test != NULL)
+ test->Release();
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nNull Test Passed.\n" );
+ else
+ printf( "\n\nNull Test Failed.\n" );
+}
+
+ /***************************************************************************/
+void do_one()
+{
+ BOOL success = FALSE;
+ ITest *server = NULL;
+ ITest *server2 = NULL;
+ ITest *local = NULL;
+ ITest *local2 = NULL;
+ SAptId id_server;
+ SAptId id_server2;
+ SAptId id_local;
+ SAptId id_local2;
+ HRESULT result;
+ DWORD i;
+
+ // Initialize OLE.
+ hello( "one" );
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+
+ // Create a possibly remote object.
+ result = create_instance( *ServerClsid, &server, &id_server );
+ ASSERT( result, "Could not create server" );
+
+ // Test delegation
+ if (ThreadMode != COINIT_MULTITHREADED)
+ {
+ // Create a local server
+ result = new_apartment_test( &local, &id_local, NULL );
+ ASSERT( result, "Could not create local instance of test server" );
+
+ // Create a local server
+ result = new_apartment_test( &local2, &id_local2, NULL );
+ ASSERT( result, "Could not create local instance of test server" );
+
+ success = do_security_delegate( local, id_local, local2, id_local2 );
+ if (!success)
+ goto cleanup;
+ success = FALSE;
+ }
+
+ // Create a client possibly on a remote machine.
+ result = create_instance( *ServerClsid, &server2, &id_server2 );
+ ASSERT( result, "Could not create instance of test server" );
+ ASSERT_EXPR( server2 != NULL, "Create instance returned NULL." );
+
+ // Test delegation
+ success = do_security_delegate( server, id_server, server2, id_server2 );
+ if (!success)
+ goto cleanup;
+ success = FALSE;
+
+ // Set security.
+ result = MCoSetProxyBlanket( server, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
+ NULL, RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
+ RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE );
+ ASSERT( result, "Could not set blanket" );
+
+ // Verify the authentication information.
+ DWORD authn_svc_out, authz_svc_out, authn_level_out, imp_level_out;
+ WCHAR *princ_name_out;
+ result = MCoQueryProxyBlanket( server, &authn_svc_out, &authz_svc_out,
+ &princ_name_out, &authn_level_out,
+ &imp_level_out, NULL, NULL );
+ if (result == S_OK)
+ {
+ ASSERT_EXPR( princ_name_out == NULL, "Got a principle name." );
+ ASSERT_EXPR( RPC_C_AUTHN_LEVEL_PKT_PRIVACY <= authn_level_out, "Wrong authentication level." );
+ ASSERT_EXPR( RPC_C_IMP_LEVEL_IMPERSONATE == imp_level_out, "Wrong impersonation level." );
+ ASSERT_EXPR( RPC_C_AUTHN_WINNT == authn_svc_out, "Wrong authentication service." );
+ ASSERT_EXPR( RPC_C_AUTHZ_NONE == authz_svc_out, "Wrong authorization service." );
+ }
+
+ // Call it.
+ result = server->check( id_server );
+ ASSERT( result, "Could not check server" );
+
+ // Set security.
+ result = MCoSetProxyBlanket( server, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
+ NULL, RPC_C_AUTHN_LEVEL_NONE,
+ RPC_C_IMP_LEVEL_IDENTIFY, NULL, EOAC_NONE );
+ ASSERT( result, "Could not set blanket" );
+
+ // Call it.
+ result = server->check( id_server );
+ ASSERT( result, "Could not check server" );
+
+ // Test nested impersonation for a remote object.
+ success = do_security_nested( server, id_server );
+ if (!success)
+ goto cleanup;
+ success = FALSE;
+
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+ if (server2 != NULL)
+ server2->Release();
+ if (server != NULL)
+ server->Release();
+ if (local != NULL)
+ local->Release();
+ if (local2 != NULL)
+ local2->Release();
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nOne Test Passed.\n" );
+ else
+ printf( "\n\nOne Test Failed.\n" );
+}
+
+ /***************************************************************************/
+void do_perf()
+{
+ BOOL success = FALSE;
+ ITest *client1 = NULL;
+ ITest *client2 = NULL;
+ ITest *tmp = NULL;
+ CTest *local = NULL;
+ SAptId id;
+ HRESULT result;
+ DWORD time_remote = -1;
+ DWORD time_local = -1;
+ DWORD time_in = -1;
+ DWORD time_out = -1;
+ DWORD time_lin = -1;
+ DWORD time_lout = -1;
+ int i;
+
+ // Initialize OLE.
+ hello( "perf" );
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+
+ // Create a client.
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &client1 );
+ ASSERT( result, "Could not create instance of test server" );
+/**/
+ // Call once to make sure everything is set up.
+ result = client1->null();
+ ASSERT( result, "Could not make null call" );
+
+ // Call a lot of times.
+ time_remote = GetTickCount();
+ for (i = 0; i < NumIterations; i++)
+ {
+ result = client1->null();
+ ASSERT( result, "Could not make null call" );
+ }
+ time_remote = GetTickCount() - time_remote;
+/**/
+ // Create a local client
+ result = new_apartment_test( &client2, &id, NULL );
+ ASSERT( result, "Could not create local client" );
+/**/
+ // Call once to make sure everything is set up.
+ result = client2->null();
+ ASSERT( result, "Could not make null call" );
+
+ // Call a lot of times.
+ time_local = GetTickCount();
+ for (i = 0; i < NumIterations; i++)
+ {
+ result = client2->null();
+ ASSERT( result, "Could not make null call" );
+ }
+ time_local = GetTickCount() - time_local;
+/**/
+ // Create a local object.
+ local = new CTest;
+ ASSERT_EXPR( local != NULL, "Could not create local object" );
+/**/
+ // Pass it to the server once.
+ result = client1->interface_in( local );
+ ASSERT( result, "Could not pass in interface" );
+
+ // Pass it to the server a lot of times.
+ time_in = GetTickCount();
+ for (i = 0; i < NumIterations; i++)
+ {
+ result = client1->interface_in( local );
+ ASSERT( result, "Could not pass in interface" );
+ }
+ time_in = GetTickCount() - time_in;
+
+ // Create another remote object.
+ result = client1->get_obj_from_this_apt( &tmp, &id );
+ ASSERT( result, "Could not get new object." );
+
+ // Have the server remember it.
+ result = client1->remember( tmp, id );
+ ASSERT( result, "Could not remember object" );
+ tmp->Release();
+ tmp = NULL;
+
+ // Get and release the remote object a lot of times.
+ time_out = GetTickCount();
+ for (i = 0; i < NumIterations; i++)
+ {
+ result = client1->get_next( &tmp, &id );
+ ASSERT( result, "Could not pass out interface" );
+ tmp->Release();
+ tmp = NULL;
+ }
+ time_out = GetTickCount() - time_out;
+ client1->forget();
+/**/
+ // Pass the object from this thread to another thread once.
+ result = client2->interface_in( local );
+ ASSERT( result, "Could not pass in interface" );
+
+ // Pass the object from this thread to another thread.
+ time_lin = GetTickCount();
+ for (i = 0; i < NumIterations; i++)
+ {
+ result = client2->interface_in( local );
+ ASSERT( result, "Could not pass in interface" );
+ }
+ time_lin = GetTickCount() - time_lin;
+/**/
+ // Create another remote object.
+ result = client2->get_obj_from_this_apt( &tmp, &id );
+ ASSERT( result, "Could not get new object." );
+
+ // Have the server remember it.
+ result = client2->remember( tmp, id );
+ ASSERT( result, "Could not remember object" );
+ tmp->Release();
+ tmp = NULL;
+
+ // Get and release the remote object a lot of times.
+ time_lout = GetTickCount();
+ for (i = 0; i < NumIterations; i++)
+ {
+ result = client2->get_next( &tmp, &id );
+ ASSERT( result, "Could not pass out interface" );
+ tmp->Release();
+ tmp = NULL;
+ }
+ time_lout = GetTickCount() - time_lout;
+ client2->forget();
+/**/
+ // Print the results.
+ printf( "%d uS / Local Call\n", time_local*1000/NumIterations );
+ printf( "%d uS / Remote Call\n", time_remote*1000/NumIterations );
+ printf( "%d uS / Interface In Call\n", time_in*1000/NumIterations );
+ printf( "%d uS / Interface Out Call\n", time_out*1000/NumIterations );
+ printf( "%d uS / Local Interface In Call\n", time_lin*1000/NumIterations );
+ printf( "%d uS / Local Interface Out Call\n", time_lout*1000/NumIterations );
+
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+ if (tmp != NULL)
+ tmp->Release();
+ if (client1 != NULL)
+ client1->Release();
+ if (client2 != NULL)
+ client2->Release();
+ if (local != NULL)
+ local->Release();
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nPerf Test Passed.\n" );
+ else
+ printf( "\n\nPerf Test Failed.\n" );
+}
+
+ /***************************************************************************/
+void do_perfremote()
+{
+ BOOL success = FALSE;
+ ITest *client1 = NULL;
+ SAptId id;
+ HRESULT result;
+ DWORD time_remote;
+ int i;
+
+ // Initialize OLE.
+ hello( "Perf Remote" );
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+
+ // Create a client.
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &client1 );
+ ASSERT( result, "Could not create instance of test server" );
+
+ // Call once to make sure everything is set up.
+ result = client1->null();
+ ASSERT( result, "Could not make null call" );
+
+ // Call a lot of times.
+ time_remote = GetTickCount();
+ for (i = 0; i < NumIterations; i++)
+ {
+ result = client1->null();
+ ASSERT( result, "Could not make null call" );
+ }
+ time_remote = GetTickCount() - time_remote;
+
+ // Print the results.
+ printf( "%d uS / Remote Call\n", time_remote*1000/NumIterations );
+
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+ if (client1 != NULL)
+ client1->Release();
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nPerf Test Passed.\n" );
+ else
+ printf( "\n\nPerf Test Failed.\n" );
+}
+
+ /***************************************************************************/
+void do_perfrpc()
+{
+ BOOL success = FALSE;
+ ITest *client1 = NULL;
+ SAptId id;
+ HRESULT result;
+ int i;
+ WCHAR *binding = NULL;
+ RPC_BINDING_HANDLE handle = NULL;
+ RPC_BINDING_HANDLE copy = NULL;
+ RPC_BINDING_HANDLE object = NULL;
+ RPC_STATUS status;
+ DWORD time_remote;
+ DWORD time_integrity;
+ DWORD time_copy;
+ DWORD time_copy_secure;
+ DWORD time_object;
+ UUID object_id;
+
+ // Initialize OLE.
+ hello( "Perf RPC" );
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+
+ // Create a client.
+ result = create_instance( *ServerClsid, &client1, &id );
+ ASSERT( result, "Could not create instance of test server" );
+
+ // Ask the server to register rpc.
+ result = client1->register_rpc( TestProtseq, &binding );
+ ASSERT( result, "Could not register rpc interface" );
+
+ // Create a binding handle.
+ status = RpcBindingFromStringBinding( binding, &handle );
+ if (status != RPC_S_OK)
+ {
+ printf( "Could not make binding handle form string binding: 0x%x\n", status );
+ goto cleanup;
+ }
+
+ // Get a binding handle for the object id test.
+ status = RpcBindingCopy( handle, &object );
+ ASSERT( status, "Could not copy binding" );
+
+ // Copy the binding handle once.
+ status = RpcBindingCopy( handle, &copy );
+ ASSERT( status, "Could not copy binding" );
+ RpcBindingFree( &copy );
+ copy = NULL;
+
+ // Time copying the binding handle.
+ time_copy = GetTickCount();
+ for (i = 0; i < NumIterations; i++)
+ {
+ status = RpcBindingCopy( handle, &copy );
+ ASSERT( status, "Could not copy binding" );
+ RpcBindingFree( &copy );
+ copy = NULL;
+ }
+ time_copy = GetTickCount() - time_copy;
+
+ // Make a raw rpc call to make sure everything is set up.
+ nullcall( handle );
+
+ // Call a lot of times.
+ time_remote = GetTickCount();
+ for (i = 0; i < NumIterations; i++)
+ {
+ nullcall( handle );
+ }
+ time_remote = GetTickCount() - time_remote;
+
+ // Set the object id.
+ result = RpcBindingSetObject( object, &object_id );
+ ASSERT( result, "Could not set object id" );
+
+ // Make a raw rpc call to make sure everything is set up.
+ nullcall( object );
+
+ // Call a lot of times.
+ time_object = GetTickCount();
+ for (i = 0; i < NumIterations; i++)
+ {
+ nullcall( object );
+ }
+ time_object = GetTickCount() - time_object;
+
+ // Add security.
+ status = RpcBindingSetAuthInfo( handle, L"none", RPC_C_AUTHN_LEVEL_PKT_INTEGRITY,
+ RPC_C_AUTHN_WINNT, NULL, 0 );
+ ASSERT( status, "Could not set auth info" );
+
+ // Copy the binding handle once.
+ status = RpcBindingCopy( handle, &copy );
+ ASSERT( status, "Could not copy binding" );
+ RpcBindingFree( &copy );
+ copy = NULL;
+
+ // Time copying the binding handle.
+ time_copy_secure = GetTickCount();
+ for (i = 0; i < NumIterations; i++)
+ {
+ status = RpcBindingCopy( handle, &copy );
+ ASSERT( status, "Could not copy binding" );
+ RpcBindingFree( &copy );
+ copy = NULL;
+ }
+ time_copy_secure = GetTickCount() - time_copy_secure;
+
+ // Make a raw rpc call to make sure everything is set up.
+ nullcall( handle );
+
+ // Call a lot of times.
+ time_integrity = GetTickCount();
+ for (i = 0; i < NumIterations; i++)
+ {
+ nullcall( handle );
+ }
+ time_integrity = GetTickCount() - time_integrity;
+
+ // Print the results.
+ printf( "%d uS / Raw RPC Remote Call\n", time_remote*1000/NumIterations );
+ printf( "%d uS / Raw Integrity RPC Remote Call\n", time_integrity*1000/NumIterations );
+ printf( "%d uS / Raw RPC with OID Remote Call\n", time_object*1000/NumIterations );
+ printf( "%d uS / handle copy\n", time_copy*1000/NumIterations );
+ printf( "%d uS / secure handle copy\n", time_copy_secure*1000/NumIterations );
+
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+ if (client1 != NULL)
+ client1->Release();
+ if (binding != NULL)
+ CoTaskMemFree( binding );
+ if (copy != NULL)
+ RpcBindingFree( &copy );
+ if (object != NULL)
+ RpcBindingFree( &object );
+ if (handle != NULL)
+ RpcBindingFree( &handle );
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nPerf Test Passed.\n" );
+ else
+ printf( "\n\nPerf Test Failed.\n" );
+}
+
+ /***************************************************************************/
+void do_perfsec()
+{
+ BOOL success = FALSE;
+ ITest *server = NULL;
+ ITest *copy = NULL;
+ SAptId id;
+ HRESULT result;
+ WCHAR *binding = NULL;
+ //DWORD time_null;
+ DWORD time_impersonate;
+ DWORD time_acl;
+ DWORD time_audit;
+ DWORD i;
+ DWORD j;
+ RPC_BINDING_HANDLE handle = NULL;
+ RPC_STATUS status;
+ TOKEN_USER *token_info = NULL;
+ DWORD info_size = 1024;
+ HANDLE token = NULL;
+ PSID pSID = NULL;
+ DWORD level[4];
+ DWORD time_rpc[4];
+ DWORD time_null[4];
+ DWORD time_ifin[4];
+ DWORD time_ifout[4];
+ CTest local;
+ ITest *server2 = NULL;
+ LARGE_INTEGER start;
+ LARGE_INTEGER nothing;
+ LARGE_INTEGER init_sec_none;
+ LARGE_INTEGER init_sec_con;
+ LARGE_INTEGER reg_sec;
+ LARGE_INTEGER query_proxy;
+ LARGE_INTEGER set_proxy;
+ LARGE_INTEGER copy_proxy;
+ LARGE_INTEGER freq;
+ DWORD get_call;
+ DWORD query_client;
+ DWORD impersonate;
+ DWORD revert;
+ DWORD authn_svc;
+ DWORD authz_svc;
+ DWORD authn_level;
+ DWORD imp_level;
+ DWORD capabilities;
+ WCHAR *principal = NULL;
+ SOLE_AUTHENTICATION_SERVICE svc_list;
+
+ // Initialize OLE.
+ hello( "perfsec" );
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+
+ // Import the security APIs.
+ GCoCopyProxy = (CoCopyProxyFn) Fixup( "CoCopyProxy" );
+ GCoInitializeSecurity = (CoInitializeSecurityFn) Fixup( "CoInitializeSecurity" );
+ GCoQueryProxyBlanket = (CoQueryProxyBlanketFn) Fixup( "CoQueryProxyBlanket" );
+ GCoSetProxyBlanket = (CoSetProxyBlanketFn) Fixup( "CoSetProxyBlanket" );
+ if (GCoCopyProxy == NULL ||
+ GCoInitializeSecurity == NULL ||
+ GCoQueryProxyBlanket == NULL ||
+ GCoSetProxyBlanket == NULL)
+ goto cleanup;
+
+ // Measure the performance of nothing.
+ QueryPerformanceFrequency( &freq );
+ QueryPerformanceCounter( &start );
+ QueryPerformanceCounter( &nothing );
+ nothing.QuadPart = 1000000 * (nothing.QuadPart - start.QuadPart) / freq.QuadPart;
+
+ // Measure the performance of initialize.
+ QueryPerformanceCounter( &start );
+ result = MCoInitializeSecurity( NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_NONE,
+ RPC_C_IMP_LEVEL_IMPERSONATE, NULL,
+ EOAC_NONE, NULL );
+ QueryPerformanceCounter( &init_sec_none );
+ init_sec_none.QuadPart = 1000000 * (init_sec_none.QuadPart - start.QuadPart) / freq.QuadPart;
+ ASSERT( result, "Could not initialize security" );
+
+ // Reinitialize.
+ CoUninitialize();
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Reinitialize failed" );
+
+ // Measure the performance of initialize.
+ QueryPerformanceCounter( &start );
+ result = MCoInitializeSecurity( NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_CONNECT,
+ RPC_C_IMP_LEVEL_IMPERSONATE, NULL,
+ EOAC_NONE, NULL );
+ QueryPerformanceCounter( &init_sec_con );
+ init_sec_con.QuadPart = 1000000 * (init_sec_con.QuadPart - start.QuadPart) / freq.QuadPart;
+ ASSERT( result, "Could not initialize security at connect" );
+
+ // Reinitialize.
+ CoUninitialize();
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Reinitialize failed" );
+
+ // Measure the performance of register.
+ svc_list.dwAuthnSvc = RPC_C_AUTHN_WINNT;
+ svc_list.dwAuthzSvc = RPC_C_AUTHZ_NONE;
+ svc_list.pPrincipalName = NULL;
+ QueryPerformanceCounter( &start );
+ result = MCoInitializeSecurity( NULL, 1, &svc_list, NULL,
+ RPC_C_AUTHN_LEVEL_NONE,
+ RPC_C_IMP_LEVEL_IMPERSONATE, NULL,
+ EOAC_NONE, NULL );
+ QueryPerformanceCounter( &reg_sec );
+ reg_sec.QuadPart = 1000000 * (reg_sec.QuadPart - start.QuadPart) / freq.QuadPart;
+ ASSERT( result, "Could not initialize security with authentication services" );
+
+ // Create a client.
+ result = create_instance( *ServerClsid, &server, &id );
+ ASSERT( result, "Could not create instance of test server" );
+
+ // Measure the performance of set proxy.
+ QueryPerformanceCounter( &start );
+ result = MCoSetProxyBlanket( server, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
+ NULL, RPC_C_AUTHN_LEVEL_CONNECT, 0, NULL, 0 );
+ QueryPerformanceCounter( &set_proxy );
+ set_proxy.QuadPart = 1000000 * (set_proxy.QuadPart - start.QuadPart) / freq.QuadPart;
+ ASSERT( result, "Could not set proxy" );
+
+ // Measure the performance of query proxy
+ QueryPerformanceCounter( &start );
+ result = MCoQueryProxyBlanket( server, &authn_svc, &authz_svc, &principal,
+ &authn_level, &imp_level, NULL, &capabilities );
+ QueryPerformanceCounter( &query_proxy );
+ query_proxy.QuadPart = 1000000 * (query_proxy.QuadPart - start.QuadPart) / freq.QuadPart;
+ ASSERT( result, "Could not query_proxy" );
+
+ // Measure the performance of copy proxy.
+ QueryPerformanceCounter( &start );
+ result = MCoCopyProxy( server, (IUnknown **) &copy );
+ QueryPerformanceCounter( &copy_proxy );
+ copy_proxy.QuadPart = 1000000 * (copy_proxy.QuadPart - start.QuadPart) / freq.QuadPart;
+ ASSERT( result, "Could not copy proxy" );
+
+ // Make a call to measure the performance of the server side APIs.
+ result = server->security_performance( &get_call, &query_client, &impersonate,
+ &revert );
+ ASSERT( result, "Could not get server API performance" );
+
+ // Ask the server to register rpc.
+ result = server->register_rpc( TestProtseq, &binding );
+ ASSERT( result, "Could not register rpc interface" );
+
+ // Create a binding handle.
+ status = RpcBindingFromStringBinding( binding, &handle );
+ if (status != RPC_S_OK)
+ {
+ printf( "Could not make binding handle from string binding: 0x%x\n", status );
+ goto cleanup;
+ }
+
+ // Create another remote object.
+ result = server->get_obj_from_this_apt( &server2, &id );
+ ASSERT( result, "Could not get new object." );
+
+ // Have the server remember it.
+ result = server->remember( server2, id );
+ ASSERT( result, "Could not remember object" );
+ server2->Release();
+ server2 = NULL;
+
+ // Try several security levels.
+ level[0] = RPC_C_AUTHN_LEVEL_NONE;
+ level[1] = RPC_C_AUTHN_LEVEL_CONNECT;
+ level[2] = RPC_C_AUTHN_LEVEL_PKT_INTEGRITY;
+ level[3] = RPC_C_AUTHN_LEVEL_PKT_PRIVACY;
+ for (j = 0; j < 4; j++)
+ {
+ // Set security on the RPC binding handle.
+ result = RpcBindingSetAuthInfo( handle, NULL, level[j], RPC_C_AUTHN_WINNT,
+ NULL, RPC_C_AUTHZ_NONE );
+ ASSERT( result, "Could not set rpc auth info" );
+
+ // Set security on the proxy.
+ result = MCoSetProxyBlanket( server, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
+ NULL, level[j], RPC_C_IMP_LEVEL_IMPERSONATE,
+ NULL, EOAC_NONE );
+ ASSERT( result, "Could not set DCOM auth info" );
+
+ // Make a raw rpc call to make sure everything is set up.
+ nullcall( handle );
+
+ // Make some raw rpc calls.
+ time_rpc[j] = GetTickCount();
+ for (i = 0; i < NumIterations; i++)
+ {
+ nullcall( handle );
+ }
+ time_rpc[j] = GetTickCount() - time_rpc[j];
+
+ // Make a null dcom call to make sure everything is set up.
+ result = server->null();
+ ASSERT( result, "Could not make null call" );
+
+ // Put up a popup about the test starting.
+ if (Popup)
+ MessageBox( NULL, L"Now would be a good time to start ICECAP.",
+ L"Not Me", MB_YESNO | MB_ICONEXCLAMATION );
+
+ // Make some null calls.
+ time_null[j] = GetTickCount();
+ for (i = 0; i < NumIterations; i++)
+ {
+ result = server->null();
+ ASSERT( result, "Could not make null call" );
+ }
+ time_null[j] = GetTickCount() - time_null[j];
+
+ // Put up a popup about the test stopping.
+ if (Popup)
+ MessageBox( NULL, L"Now would be a good time to stop ICECAP.",
+ L"Not Me", MB_YESNO | MB_ICONSTOP );
+
+ // Pass an interface in to set everything up.
+ result = server->interface_in( &local );
+ ASSERT( result, "Could not make interface_in call" );
+
+ // Make some interface in calls.
+ time_ifin[j] = GetTickCount();
+ for (i = 0; i < NumIterations; i++)
+ {
+ result = server->interface_in( &local );
+ ASSERT( result, "Could not make interface_in call" );
+ }
+ time_ifin[j] = GetTickCount() - time_ifin[j];
+
+ // Pass an interface out to set everything up.
+ result = server->get_next( &server2, &id );
+ ASSERT( result, "Could not make interface out call" );
+ server2->Release();
+ server2 = NULL;
+
+ // Make some interface_out calls.
+ time_ifout[j] = GetTickCount();
+ for (i = 0; i < NumIterations; i++)
+ {
+ result = server->get_next( &server2, &id );
+ ASSERT( result, "Could not make interface out call" );
+ server2->Release();
+ server2 = NULL;
+ }
+ time_ifout[j] = GetTickCount() - time_ifout[j];
+ }
+
+ // Release the second remote object.
+ result = server->forget();
+ ASSERT( result, "Could not forget" );
+
+ // Print the DCOM call results.
+ for (j = 0; j < 4; j++)
+ {
+ printf( "% 8d uS / Raw RPC Remote Call at level %d\n",
+ time_rpc[j]*1000/NumIterations, level[j] );
+ printf( "% 8d uS / Null Remote Call at level %d\n",
+ time_null[j]*1000/NumIterations, level[j] );
+ printf( "% 8d uS / Interface in Remote Call at level %d\n",
+ time_ifin[j]*1000/NumIterations, level[j] );
+ printf( "% 8d uS / Interface out Remote Call at level %d\n",
+ time_ifout[j]*1000/NumIterations, level[j] );
+ }
+
+ // Print the API call results.
+ printf( "nothing took %duS\n", nothing.u.LowPart );
+ printf( "CoInitializeSecurity at none took %duS\n", init_sec_none.u.LowPart );
+ printf( "CoInitializeSecurity at connect took %duS\n", init_sec_con.u.LowPart );
+ printf( "CoInitializeSecurity with service took %duS\n", reg_sec.u.LowPart );
+ printf( "CoQueryProxyBlanket took %duS\n", query_proxy.u.LowPart );
+ printf( "CoSetProxyBlanket took %duS\n", set_proxy.u.LowPart );
+ printf( "CoCopyProxy took %duS\n", copy_proxy.u.LowPart );
+ printf( "CoGetCallContext took %duS\n", get_call );
+ printf( "CoQueryClientBlanket took %duS\n", query_client );
+ printf( "CoImpersonateClient took %duS\n", impersonate );
+ printf( "CoRevertToSelf took %duS\n", revert );
+
+/*
+ // Open the process's token.
+ OpenProcessToken( GetCurrentProcess(), TOKEN_QUERY, &token );
+ result = GetLastError();
+ ASSERT( result, "Could not OpenProcessToken" );
+
+ // Lookup SID of process token.
+ token_info = (TOKEN_USER *) malloc( info_size );
+ GetTokenInformation( token, TokenUser, token_info, info_size, &info_size );
+ result = GetLastError();
+ ASSERT( result, "Could not GetTokenInformation" );
+ pSID = token_info->User.Sid;
+
+ // Ask the server to make an ACL.
+ result = server->make_acl( (HACKSID *) pSID );
+ ASSERT( result, "Could not make ACL" );
+
+ // Make a raw rpc call to make sure everything is set up.
+ nullcall( handle );
+
+ // Call a lot of times.
+ time_null = GetTickCount();
+ for (i = 0; i < NumIterations; i++)
+ {
+ nullcall( handle );
+ }
+ time_null = GetTickCount() - time_null;
+
+ // Call a lot of times.
+ time_impersonate = GetTickCount();
+ for (i = 0; i < NumIterations; i++)
+ {
+ result = impersonate_call( handle );
+ ASSERT( result, "Could not make impersonate call" );
+ }
+ time_impersonate = GetTickCount() - time_impersonate;
+
+ // Call a lot of times.
+ time_acl = GetTickCount();
+ for (i = 0; i < NumIterations; i++)
+ {
+ result = acl_call( handle );
+ ASSERT( result, "Could not make acl call" );
+ }
+ time_acl = GetTickCount() - time_acl;
+
+ // Call a lot of times.
+ time_audit = GetTickCount();
+ for (i = 0; i < NumIterations; i++)
+ {
+ result = audit_call( handle );
+ ASSERT( result, "Could not make audit call" );
+ }
+ time_audit = GetTickCount() - time_audit;
+
+ // Print the results.
+ printf( "%d uS / Raw RPC Remote Call\n", time_null*1000/NumIterations );
+ printf( "%d uS / Raw Impersonate RPC Remote Call\n", time_impersonate*1000/NumIterations );
+ printf( "%d uS / Raw ACL RPC Remote Call\n", time_acl*1000/NumIterations );
+ printf( "%d uS / Raw audit RPC Remote Call\n", time_audit*1000/NumIterations );
+*/
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+ if (principal != NULL)
+ CoTaskMemFree( principal );
+ if (copy != NULL)
+ copy->Release();
+ if (server != NULL)
+ server->Release();
+ if (server2 != NULL)
+ server2->Release();
+ if (binding != NULL)
+ CoTaskMemFree( binding );
+ if (handle != NULL)
+ RpcBindingFree( &handle );
+ if (token_info != NULL)
+ free( token_info );
+ if (token != NULL)
+ CloseHandle( token );
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nSec Test Passed.\n" );
+ else
+ printf( "\n\nSec Test Failed.\n" );
+}
+
+ /***************************************************************************/
+void do_post()
+{
+ BOOL success = FALSE;
+
+ // Say hello.
+ printf( "Posting a message to window 0x%x\n", NumIterations );
+ success = PostMessageA( (HWND) NumIterations, WM_USER, 0, 0 );
+
+ if (success)
+ printf( "\n\nPostMessageA succeeded.\n" );
+ else
+ printf( "\n\nPostMessageA failed: 0x%x\n", GetLastError() );
+}
+
+ /***************************************************************************/
+void do_reject()
+{
+ BOOL success = FALSE;
+ ITest *client1 = NULL;
+ ITest *client2 = NULL;
+ SAptId id1;
+ SAptId id2;
+ IAdviseSink *advise1 = NULL;
+ IAdviseSink *advise2 = NULL;
+ HRESULT result;
+ CTest *local = NULL;
+
+ // Initialize OLE.
+ hello( "reject" );
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+
+ // Create a local object.
+ local = new CTest;
+ ASSERT_EXPR( local != NULL, "Could not create local instance of test server." );
+
+ // Create a server
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &client1 );
+ ASSERT( result, "Could not create instance of test server" );
+ result = client1->get_id( &id1 );
+ ASSERT( result, "Could not get id of server" );
+
+ // Register the local message filter.
+ result = local->register_message_filter( TRUE );
+ ASSERT( result, "Could not register message filter." );
+
+ // Register the remote message filter.
+ result = client1->register_message_filter( TRUE );
+ ASSERT( result, "Could not register message filter." );
+
+ // Make the server reject the next call.
+ result = client1->reject_next();
+ ASSERT( result, "Could not reject next call" );
+
+ // Make us retry the next rejected call.
+ result = local->retry_next();
+ ASSERT( result, "Could not retry next call" );
+
+ // Call check.
+ result = client1->check( id1 );
+ ASSERT( result, "Could not check server" );
+
+ // Create a local server.
+ result = local->get_obj_from_new_apt( &client2, &id2 );
+ ASSERT( result, "Could not get in process server" );
+
+ // Register the remote message filter.
+ result = client2->register_message_filter( TRUE );
+ ASSERT( result, "Could not register message filter." );
+
+ // Make the server reject the next call.
+ result = client2->reject_next();
+ ASSERT( result, "Could not reject next call" );
+
+ // Make us retry the next rejected call.
+ result = local->retry_next();
+ ASSERT( result, "Could not retry next call" );
+
+ // Call check.
+ result = client2->check( id2 );
+ ASSERT( result, "Could not check server" );
+
+ // Release the message filters.
+ result = local->register_message_filter( FALSE );
+ ASSERT( result, "Could not deregister message filter." );
+ result = client1->register_message_filter( FALSE );
+ ASSERT( result, "Could not deregister message filter." );
+ result = client2->register_message_filter( FALSE );
+ ASSERT( result, "Could not deregister message filter." );
+
+ // Create an advise object on another process
+ result = client1->get_advise( &advise1 );
+ ASSERT( result, "Could not get advise: 0x%x" );
+
+ // Make an async call.
+ advise1->OnSave();
+
+ // Create an advise object on another thread
+ result = client2->get_advise( &advise2 );
+ ASSERT( result, "Could not get advise: 0x%x" );
+
+ // Make an async call.
+ advise2->OnSave();
+
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+ if (advise2 != NULL)
+ advise2->Release();
+ if (advise1 != NULL)
+ advise1->Release();
+ if (client2 != NULL)
+ client2->Release();
+ if (client1 != NULL)
+ client1->Release();
+ if (local != NULL)
+ local->Release();
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nReject Test Passed.\n" );
+ else
+ printf( "\n\nReject Test Failed.\n" );
+}
+
+ /***************************************************************************/
+void do_remote_client()
+{
+ BOOL success = FALSE;
+ ITest *server = NULL;
+ ITest *server2 = NULL;
+ HRESULT result;
+ RPC_BINDING_HANDLE handle = NULL;
+ RPC_STATUS status;
+ WCHAR binding[MAX_NAME];
+ void *buffer = NULL;
+ SAptId id;
+ SAptId id2;
+ HANDLE memory = NULL;
+ IStream *stream = NULL;
+ LARGE_INTEGER pos;
+ DWORD time_rpc;
+ DWORD time_null;
+ DWORD time_marshal;
+ long buf_size;
+ DWORD i;
+
+ // Initialize OLE.
+ hello( "RemoteClient" );
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+
+ // Build binding handle for the server.
+ wsprintf( binding, L"%ws:%ws", TestProtseq, Name );
+ status = RpcBindingFromStringBinding( binding, &handle );
+ if (status != RPC_S_OK)
+ {
+ printf( "Could not make binding handle from string binding: 0x%x\n", status );
+ goto cleanup;
+ }
+
+ // Get a marshalled interface from the server over raw RPC.
+ get_interface_buffer( handle, &buf_size, (unsigned char **) &buffer, &id,
+ (error_status_t *) &status );
+ if (status != RPC_S_OK)
+ {
+ printf( "Could not get buffer containing interface: 0x%x\n", status );
+ goto cleanup;
+ }
+
+ // Allocate memory.
+ memory = GlobalAlloc( GMEM_FIXED, buf_size );
+ ASSERT_EXPR( memory != NULL, "Could not GlobalAlloc." );
+
+ // Create a stream.
+ result = CreateStreamOnHGlobal( memory, TRUE, &stream );
+ ASSERT( result, "Could not create stream" );
+
+ // Write the data.
+ result = stream->Write( buffer, buf_size, NULL );
+ ASSERT( result, "Could not write to stream" );
+
+ // Seek back to the start of the stream.
+ pos.QuadPart = 0;
+ result = stream->Seek( pos, STREAM_SEEK_SET, NULL );
+ ASSERT( result, "Could not seek stream to start" );
+
+ // Unmarshal Interface.
+ result = CoUnmarshalInterface( stream, IID_ITest, (void **) &server );
+ ASSERT( result, "Could not unmarshal interface" );
+
+ // Call once to make sure everything is set up.
+ result = server->null();
+ ASSERT( result, "Could not make null call" );
+
+ // Make a lot of null calls.
+ time_null = GetTickCount();
+ for (i = 0; i < NumIterations; i++)
+ {
+ result = server->null();
+ ASSERT( result, "Could not make null call" );
+ }
+ time_null = GetTickCount() - time_null;
+
+ // Make a lot of marshalling calls.
+ time_marshal = GetTickCount();
+ for (i = 0; i < NumIterations; i++)
+ {
+ result = server->get_obj_from_this_apt( &server2, &id2);
+ ASSERT( result, "Could not make marshal call" );
+ server2->Release();
+ server2 = NULL;
+ }
+ time_marshal = GetTickCount() - time_marshal;
+
+ // Make a lot of RPC calls
+ nullcall( handle );
+ time_rpc = GetTickCount();
+ for (i = 0; i < NumIterations; i++)
+ {
+ nullcall( handle );
+ }
+ time_rpc = GetTickCount() - time_rpc;
+
+ // Print the results.
+ printf( "%d uS / RPC Null Call\n", time_rpc*1000/NumIterations );
+ printf( "%d uS / DCOM Null Call\n", time_null*1000/NumIterations );
+ printf( "%d uS / DCOM Marshal Call\n", time_marshal*1000/NumIterations );
+
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+ if (server2 != NULL)
+ server2->Release();
+ if (server != NULL)
+ server->Release();
+ if (handle != NULL)
+ RpcBindingFree( &handle );
+ if (buffer != NULL)
+ midl_user_free( buffer );
+ if (stream != NULL)
+ stream->Release();
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nRemoteClient Test Passed.\n" );
+ else
+ printf( "\n\nRemoteClient Test Failed.\n" );
+}
+
+ /***************************************************************************/
+void do_remote_server()
+{
+ BOOL success = FALSE;
+ SAptId id;
+ HRESULT result;
+ RPC_STATUS status;
+ RPC_BINDING_VECTOR *bindings = NULL;
+
+ // Initialize OLE.
+ hello( "RemoteServer" );
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+
+ // Set up thread switching.
+ GlobalThreadId = GetCurrentThreadId();
+
+ // Create a local server
+ GlobalTest = new CTest;
+ ASSERT( !GlobalTest, "Could not create local server" );
+
+ // Register a protseq.
+ status = RpcServerUseProtseq( TestProtseq, RPC_C_PROTSEQ_MAX_REQS_DEFAULT,
+ NULL );
+ ASSERT( status, "Could not register protseq" );
+
+ // Register the dog interface.
+ status = RpcServerRegisterIf(xIDog_v0_1_s_ifspec,
+ NULL, // MgrTypeUuid
+ NULL); // MgrEpv; null means use default
+ ASSERT( status, "Could not register RPC interface" );
+
+ // Inquire the endpoints.
+ status = RpcServerInqBindings(&bindings);
+ ASSERT( status, "Could not inquire bindings" );
+
+ // Register them in the endpoint mapper.
+ status = RpcEpRegister( xIDog_v0_1_s_ifspec, bindings, NULL, NULL );
+ ASSERT( status, "Could not register with endpoint mapper" );
+
+ // Start RPC listening.
+ status = RpcServerListen( 1, RPC_C_LISTEN_MAX_CALLS_DEFAULT, TRUE );
+ ASSERT( status, "Could not start RPC listening" );
+
+ // Wait until the objects are released.
+ server_loop();
+
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nRemoteServer Test Passed.\n" );
+ else
+ printf( "\n\nRemoteServer Test Failed.\n" );
+}
+
+ /***************************************************************************/
+void do_ring()
+{
+ BOOL success = FALSE;
+ ITest **array = NULL;
+ SAptId *id_array = NULL;
+ HRESULT result;
+ int i;
+ int j;
+ int k;
+ int l;
+ int num_machines;
+ WCHAR this_machine[MAX_NAME];
+ DWORD ignore;
+ int pos;
+ int length;
+ const IID *(all_class_ids[2]);
+ const IID *class_id = ServerClsid;
+
+ // Initialize OLE.
+ hello( "ring" );
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+ CoUninitialize();
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Recalling Initialize failed" );
+ result = initialize_security();
+ ASSERT( result, "Could not initialize security" );
+
+ // Compute the class ids to use.
+ all_class_ids[0] = ServerClsid;
+ i = ServerClsid - &ClassIds[0];
+ all_class_ids[1] = &ClassIds[(i+5) % NUM_CLASS_IDS];
+
+ // Lookup this machine's name.
+ ignore = sizeof(this_machine);
+ GetComputerName( this_machine, &ignore );
+
+ // If the server is this machine, set the number of machines to 1.
+ if (wcscmp(this_machine, Name) == 0)
+ num_machines = 1;
+ else
+ num_machines = 2;
+
+ // Allocate memory to hold all the server pointers.
+ length = NumProcesses * NumThreads * NumObjects * num_machines;
+ array = (ITest **) malloc( sizeof(ITest *) * length );
+ ASSERT_EXPR( array != NULL, "Could not allocate array." );
+ for (i = 0; i < length; i++)
+ array[i] = NULL;
+
+ // Allocate memory to hold all the server ids.
+ id_array = (SAptId *) malloc( sizeof(SAptId) * length );
+ ASSERT_EXPR( id_array != NULL, "Could not allocate id array." );
+
+ // Loop over all the machines.
+ pos = 0;
+ for (l = 0; l < num_machines; l++)
+ {
+ // Loop over all the processes.
+ for (i = 0; i < NumProcesses; i++)
+ {
+ // If the change flag was set, switch between apartment and
+ // free threaded servers.
+ if (Change)
+ class_id = all_class_ids[i&1];
+
+ // Create another server.
+ if (l == 0)
+ result = CoCreateInstance( *class_id, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &array[pos] );
+ else
+ result = create_instance( *class_id, &array[pos], &id_array[pos] );
+ ASSERT( result, "Could not create new server process" );
+ result = array[pos]->get_id( &id_array[pos] );
+ ASSERT( result, "Could not get id for new process" );
+ pos += 1;
+
+ for (j = 0; j < NumThreads; j++)
+ {
+ if (j != 0)
+ {
+ result = array[pos-1]->get_obj_from_new_apt( &array[pos],
+ &id_array[pos] );
+ ASSERT( result, "Could not get in process server" );
+ pos += 1;
+ }
+ for (k = 1; k < NumObjects; k++)
+ {
+ result = array[pos-1]->get_obj_from_this_apt( &array[pos],
+ &id_array[pos] );
+ ASSERT( result, "Could not get in thread server" );
+ pos += 1;
+ }
+ }
+ }
+ }
+
+ // Hook up the ring.
+ for (i = 0; i < length-1; i++)
+ {
+ result = array[i]->remember( array[i+1], id_array[i+1] );
+ ASSERT( result, "Could not connect ring" );
+ }
+ result = array[length-1]->remember( array[0], id_array[0] );
+ ASSERT( result, "Could not connect ring" );
+
+ // Call around the ring.
+ for (i = 0; i < NumIterations; i++)
+ {
+ result = array[0]->ring( length );
+ ASSERT( result, "Could not call around the ring" );
+ }
+
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+
+ // Release all the servers. Start from the end so the main threads do
+ // not go away till all the secondary threads are done.
+ if (array != NULL)
+ for (i = length-1; i >= 0; i--)
+ if (array[i] != NULL)
+ {
+ result = array[i]->forget();
+ if (result != S_OK)
+ printf( "Could not forget server %x: 0x%x\n", i, result );
+ array[i]->Release();
+ }
+
+ // Release the memory holding the interface pointers.
+ if (array != NULL)
+ free(array);
+
+ // Release the memory for ids.
+ if (id_array != NULL)
+ free( id_array );
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nRing Test Passed.\n" );
+ else
+ printf( "\n\nRing Test Failed.\n" );
+}
+
+ /***************************************************************************/
+void do_rpc()
+{
+ BOOL success = FALSE;
+ ITest *client1 = NULL;
+ CTest *local = NULL;
+ SAptId id1;
+ SAptId id2;
+ HRESULT result;
+ WCHAR *binding = NULL;
+ RPC_BINDING_HANDLE handle = NULL;
+ RPC_STATUS status;
+
+ // Initialize OLE.
+ hello( "rpc" );
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+
+ // Create a free threaded server.
+ result = CoCreateInstance( ClassIds[free_auto_none], NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &client1 );
+ ASSERT( result, "Could not create instance of test server" );
+ result = client1->get_id( &id1 );
+ ASSERT( result, "Could not get id of server" );
+
+ // Ask the server to register rpc.
+ result = client1->register_rpc( TestProtseq, &binding );
+ ASSERT( result, "Could not register rpc interface" );
+
+ // Create a binding handle.
+ status = RpcBindingFromStringBinding( binding, &handle );
+ if (status != RPC_S_OK)
+ {
+ printf( "Could not make binding handle from string binding: 0x%x\n", status );
+ goto cleanup;
+ }
+
+ // Make a raw rpc call.
+ result = check_client( handle, (unsigned long *) &status );
+ if (status != RPC_S_OK)
+ {
+ printf( "Could not make RPC call: 0x%x\n", status );
+ goto cleanup;
+ }
+ ASSERT( result, "Server could not check client's id" );
+
+ // Create a local object.
+ local = new CTest;
+ ASSERT_EXPR( local != NULL, "Could not create local object." );
+ result = local->get_id( &id2 );
+ ASSERT( result, "Could not get local id" );
+
+ // Pass an interface through a raw rpc call.
+ result = test( handle, local, id2, (unsigned long *) &status );
+ ASSERT( status, "Com fault testing interface with raw rpc" );
+ ASSERT( result, "Could not pass interface through raw rpc" );
+
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+ if (local != NULL)
+ local->Release();
+ if (client1 != NULL)
+ client1->Release();
+ if (binding != NULL)
+ CoTaskMemFree( binding );
+ if (handle != NULL)
+ RpcBindingFree( &handle );
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nRpc Test Passed.\n" );
+ else
+ printf( "\n\nRpc Test Failed.\n" );
+}
+
+ /***************************************************************************/
+/*
+ This routine tests various cases of the client or server going away.
+ All permutations of the following variables are tested.
+
+ Clean exit (release and uninit) vs Dirty exit
+ 1 COM thread/process vs 2 COM threads/process
+ Client dies vs Server dies
+ In process death vs Out of process death
+*/
+void do_rundown()
+{
+ BOOL success = FALSE;
+ ITest *client = NULL;
+ ITest *client2 = NULL;
+ SAptId client_id;
+ SAptId client_id2;
+ HRESULT result;
+
+ // Initialize OLE.
+ hello( "rundown" );
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+
+ // Create a client.
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &client );
+ ASSERT( result, "Could not create instance of test server" );
+ result = client->get_id( &client_id );
+ ASSERT( result, "Could not get client id" );
+
+ // Run clean tests with one thread per process.
+ success = do_rundown1( &client, &client_id, 0 );
+ if (!success)
+ goto cleanup;
+
+ // Run clean tests with two threads per process.
+ success = do_rundown2( &client, &client_id, 0 );
+ if (!success)
+ goto cleanup;
+
+ // Run dirty tests with one thread per process.
+ success = do_rundown1( &client, &client_id, dirty_s );
+ if (!success)
+ goto cleanup;
+
+ // Run dirty tests with two threads per process.
+ success = do_rundown2( &client, &client_id, dirty_s );
+ if (!success)
+ goto cleanup;
+ success = FALSE;
+
+ // Create helper.
+ result = client->get_obj_from_new_apt( &client2, &client_id2 );
+ ASSERT( result, "Could not get in process server" );
+
+ // Start the test.
+ result = client->recurse_disconnect( client2, NumRecursion );
+ ASSERT( result, "Could not disconnect in a call" );
+ client2->Release();
+ client2 = NULL;
+ client->Release();
+ client = NULL;
+
+ // Create a client.
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &client );
+ ASSERT( result, "Could not create instance of test server" );
+ result = client->get_id( &client_id );
+ ASSERT( result, "Could not get client id" );
+
+ // Tell the client to reinitialize.
+ result = client->reinitialize();
+ ASSERT( result, "Could not reinitialize client" );
+
+ // Give the reinitialize a chance to complete before continuing.
+ printf( "Waiting 5 seconds for reinitialize to complete.\n" );
+ Sleep(5000);
+
+ // Create another object on the same client.
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &client2 );
+ ASSERT( result, "Could not create instance of test server" );
+
+ // Check the client.
+ result = client2->get_id( &client_id );
+ ASSERT( result, "Could not get_id from client" );
+
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+ if (client2 != NULL)
+ client2->Release();
+ if (client != NULL)
+ client->Release();
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nRundown Test Passed.\n" );
+ else
+ printf( "\n\nRundown Test Failed.\n" );
+}
+
+ /***************************************************************************/
+/*
+ This is a helper routine for do_rundown. It always executes with one
+ thread per process of each type (thus a process might have one client and
+ one server thread). It takes a parameter to indicate whether to execute
+ clean or dirty deaths. It executes all permuations of the remaining
+ variables, listed below. Note that the order of execution is important
+ to reduce the number of process creations. Note that the routine takes
+ a client process on entry and returns a different client process on
+ exit.
+
+ Client death vs Server death
+ In process vs Out of process
+*/
+BOOL do_rundown1( ITest **client, SAptId *client_id, DWORD dirty )
+{
+ BOOL success = FALSE;
+ ITest *server = NULL;
+ HRESULT result;
+ SAptId server_id;
+/**/
+ // Create in process server.
+ result = (*client)->get_obj_from_new_apt( &server, &server_id );
+ ASSERT( result, "Could not get in process server" );
+
+ // Ping.
+ result = (*client)->remember( server, server_id );
+ ASSERT( result, "Could not remember server" );
+ result = (*client)->call_next();
+ ASSERT( result, "Could not call server" );
+
+ // Kill server.
+ result = server->set_state( dirty, THREAD_PRIORITY_NORMAL );
+ ASSERT( result, "Could not set_state on server" );
+ result = server->exit();
+ server->Release();
+ server = NULL;
+ ASSERT( result, "Could not exit server" );
+
+ // Query client.
+ result = (*client)->call_dead();
+ ASSERT( result, "Wrong error calling dead server" );
+/**/
+ // Switch the client to server so the process doesn't go away when we kill
+ // the client. Then create an in process client.
+ server = *client;
+ server_id = *client_id;
+ *client = NULL;
+/**/
+ result = server->get_obj_from_new_apt( client, client_id );
+ ASSERT( result, "Could not get in process client" );
+
+ // Ping.
+ result = (*client)->remember( server, server_id );
+ ASSERT( result, "Could not remember server" );
+ result = (*client)->call_next();
+ ASSERT( result, "Could not call server" );
+
+ // Kill client.
+ result = (*client)->set_state( dirty, THREAD_PRIORITY_NORMAL );
+ ASSERT( result, "Could not set_state on client" );
+ (*client)->Release();
+ *client = NULL;
+
+ // Query server.
+ result = server->check( server_id );
+ ASSERT( result, "Could not check server" );
+
+ // Create out of process client.
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) client );
+ ASSERT( result, "Could not create out of process client" );
+ result = (*client)->get_id( client_id );
+ ASSERT( result, "Could not get client id" );
+
+ // Ping.
+ result = (*client)->remember( server, server_id );
+ ASSERT( result, "Could not remember server" );
+ result = (*client)->call_next();
+ ASSERT( result, "Could not call server" );
+
+ // Kill client.
+ result = (*client)->set_state( dirty, THREAD_PRIORITY_NORMAL );
+ ASSERT( result, "Could not set_state on client" );
+ (*client)->Release();
+ *client = NULL;
+
+ // Query server.
+ result = server->check( server_id );
+ ASSERT( result, "Could not check server" );
+/**/
+ // Create out of process client.
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) client );
+ ASSERT( result, "Could not create out of process client" );
+ result = (*client)->get_id( client_id );
+ ASSERT( result, "Could not get client id" );
+
+ // Ping.
+ result = (*client)->remember( server, server_id );
+ ASSERT( result, "Could not remember server" );
+ result = (*client)->call_next();
+ ASSERT( result, "Could not call server" );
+
+ // Kill server.
+ result = server->set_state( dirty, THREAD_PRIORITY_NORMAL );
+ ASSERT( result, "Could not set_state on server" );
+ result = server->exit();
+ server->Release();
+ server = NULL;
+ if ((dirty & dirty_s) == 0)
+ ASSERT( result, "Could not exit server" );
+
+ // Query client.
+ result = (*client)->call_dead();
+ ASSERT( result, "Wrong error calling dead server" );
+
+ success = TRUE;
+cleanup:
+ if (server != NULL)
+ server->Release();
+ return success;
+}
+
+ /***************************************************************************/
+/*
+ This is a helper routine for do_rundown. It always executes with two
+ threads per process of each type (thus a process might have two client and
+ two server threads). It takes a parameter to indicate whether to execute
+ clean or dirty deaths. It executes all permuations of the remaining
+ variables, listed below. Note that the order of execution is important
+ to reduce the number of process creations. Note that the routine takes
+ a client process on entry and returns a different client process on
+ exit.
+
+ Client death vs Server death
+ In process vs Out of process
+*/
+BOOL do_rundown2( ITest **client1, SAptId *client1_id, DWORD dirty )
+{
+ BOOL success = FALSE;
+ ITest *server1 = NULL;
+ ITest *server2 = NULL;
+ ITest *client2 = NULL;
+ SAptId client2_id;
+ SAptId server1_id;
+ SAptId server2_id;
+ HRESULT result;
+
+ // Create in process client.
+ result = (*client1)->get_obj_from_new_apt( &client2, &client2_id );
+ ASSERT( result, "Could not get in process client2" );
+
+ // Create in process server.
+ result = (*client1)->get_obj_from_new_apt( &server1, &server1_id );
+ ASSERT( result, "Could not get in process server1" );
+
+ // Create in process server.
+ result = (*client1)->get_obj_from_new_apt( &server2, &server2_id );
+ ASSERT( result, "Could not get in process server2" );
+
+ // Ping 1.
+ result = (*client1)->remember( server1, server1_id );
+ ASSERT( result, "Could not remember server1" );
+ result = (*client1)->call_next();
+ ASSERT( result, "Could not call server1" );
+
+ // Ping 2.
+ result = client2->remember( server2, server2_id );
+ ASSERT( result, "Could not remember server2" );
+ result = client2->call_next();
+ ASSERT( result, "Could not call server2" );
+
+ // Kill server1.
+ result = server1->set_state( dirty, THREAD_PRIORITY_NORMAL );
+ ASSERT( result, "Could not set_state on server1" );
+ result = server1->exit();
+ server1->Release();
+ server1 = NULL;
+ ASSERT( result, "Could not exit server1" );
+
+ // Query client1.
+ result = (*client1)->call_dead();
+ ASSERT( result, "Wrong error calling dead server1" );
+
+ // Query client2.
+ result = client2->call_next();
+ ASSERT( result, "Could not call server2" );
+
+ // Query server2.
+ result = server2->check( server2_id );
+ ASSERT( result, "Could not check server2" );
+
+ // Switch the client1 to server1 so the process doesn't go away when we kill
+ // the client1. Then create an in process client1.
+ server1 = *client1;
+ server1_id = *client1_id;
+ *client1 = NULL;
+ result = server1->get_obj_from_new_apt( client1, client1_id );
+ ASSERT( result, "Could not get in process client1" );
+
+ // Ping 1.
+ result = (*client1)->remember( server1, server1_id );
+ ASSERT( result, "Could not remember server1" );
+ result = (*client1)->call_next();
+ ASSERT( result, "Could not call server1" );
+
+ // Ping 2.
+ result = client2->call_next();
+ ASSERT( result, "Could not call server2" );
+
+ // Kill client1.
+ result = (*client1)->set_state( dirty, THREAD_PRIORITY_NORMAL );
+ ASSERT( result, "Could not set_state on client1" );
+ (*client1)->Release();
+ *client1 = NULL;
+
+ // Query server1.
+ result = server1->check( server1_id );
+ ASSERT( result, "Could not check server1" );
+
+ // Query server2.
+ result = server2->check( server2_id );
+ ASSERT( result, "Could not check server2" );
+
+ // Query client2.
+ result = client2->call_next();
+ ASSERT( result, "Could not call server2" );
+ client2->Release();
+ client2 = NULL;
+
+ // Create out of process client1.
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) client1 );
+ ASSERT( result, "Could not create out of process client1" );
+ result = (*client1)->get_id( client1_id );
+ ASSERT( result, "Could not get client1 id" );
+
+ // Create in process client 2.
+ result = (*client1)->get_obj_from_new_apt( &client2, &client2_id );
+ ASSERT( result, "Could not get in process client2" );
+
+ // Ping 1.
+ result = (*client1)->remember( server1, server1_id );
+ ASSERT( result, "Could not remember server1" );
+ result = (*client1)->call_next();
+ ASSERT( result, "Could not call server1" );
+
+ // Ping 2.
+ result = client2->remember( server2, server2_id );
+ ASSERT( result, "Could not remember server2" );
+ result = client2->call_next();
+ ASSERT( result, "Could not call server2" );
+
+ // Kill client2 so process does not exit.
+ result = client2->set_state( dirty, THREAD_PRIORITY_NORMAL );
+ ASSERT( result, "Could not set_state on client2" );
+ client2->Release();
+ client2 = NULL;
+
+ // Query server1.
+ result = server1->check( server1_id );
+ ASSERT( result, "Could not check server1" );
+
+ // Query server2.
+ result = server2->check( server2_id );
+ ASSERT( result, "Could not check server2" );
+
+ // Query client1.
+ result = (*client1)->call_next();
+ ASSERT( result, "Could not call server1" );
+
+ // Create in process client 2.
+ result = (*client1)->get_obj_from_new_apt( &client2, &client2_id );
+ ASSERT( result, "Could not get in process client2" );
+
+ // Ping 1.
+ result = (*client1)->call_next();
+ ASSERT( result, "Could not call server1" );
+
+ // Ping 2.
+ result = client2->remember( server2, server2_id );
+ ASSERT( result, "Could not remember server2" );
+ result = client2->call_next();
+ ASSERT( result, "Could not call server2" );
+
+ // Kill server2 so the server process does not go away.
+ result = server2->set_state( dirty, THREAD_PRIORITY_NORMAL );
+ ASSERT( result, "Could not set_state on server2" );
+ result = server2->exit();
+ server2->Release();
+ server2 = NULL;
+ if ((dirty & dirty_s) == 0)
+ ASSERT( result, "Could not exit server2" );
+
+ // Query client1.
+ result = (*client1)->call_next();
+ ASSERT( result, "Could not call server1" );
+
+ // Query client2.
+ result = client2->call_dead();
+ ASSERT( result, "Wrong error calling dead server2" );
+
+ // Query server1.
+ result = server1->check( server1_id );
+ ASSERT( result, "Could not check server1" );
+
+ success = TRUE;
+cleanup:
+ if (server1 != NULL)
+ server1->Release();
+ if (server2 != NULL)
+ server2->Release();
+ if (client2 != NULL)
+ client2->Release();
+ return success;
+}
+
+ /***************************************************************************/
+void do_securerefs()
+{
+ BOOL success = FALSE;
+ ITest *server = NULL;
+ ITest *server2 = NULL;
+ ITest *local = NULL;
+ SAptId id_server;
+ SAptId id_server2;
+ SAptId id_local;
+ HRESULT result;
+ SOLE_AUTHENTICATION_SERVICE svc_list;
+
+ hello( "securerefs" );
+
+ // Try CoInitializeSecurity before CoInit.
+ result = MCoInitializeSecurity( NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_NONE,
+ RPC_C_IMP_LEVEL_IMPERSONATE, NULL,
+ EOAC_NONE, NULL );
+ ASSERT_EXPR( result != S_OK, "Initialized security before OLE" );
+
+ // Initialize OLE.
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+
+ // Set security to automatic none.
+ result = MCoInitializeSecurity( NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_NONE,
+ RPC_C_IMP_LEVEL_IMPERSONATE, NULL,
+ EOAC_NONE, NULL );
+ ASSERT( result, "Could not initialize security to none" );
+
+ if (ThreadMode == COINIT_APARTMENTTHREADED)
+ {
+ // Create a local server
+ result = new_apartment_test( &local, &id_local, NULL );
+ ASSERT( result, "Could not create local instance of test server" );
+
+ // Call the local server.
+ result = local->check( id_local );
+ ASSERT( result, "Could not call local server" )
+
+ // Release the local server.
+ local->Release();
+ local = NULL;
+ }
+
+ // Create a server possibly on a remote machine.
+ result = create_instance( *ServerClsid, &server, &id_server );
+ ASSERT( result, "Could not create instance of test server" );
+ ASSERT_EXPR( server != NULL, "Create instance returned NULL." );
+
+ // Call the server.
+ result = server->check( id_server );
+ ASSERT( result, "Could not call local server" )
+
+ // Release the server.
+ server->Release();
+ server = NULL;
+
+ // Uninitialize.
+ CoUninitialize();
+
+ // Reinitialize.
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Reinitialize failed" );
+
+ // Initialize security with secure refs but bad authn level.
+ result = MCoInitializeSecurity( NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_NONE,
+ RPC_C_IMP_LEVEL_IMPERSONATE, NULL,
+ EOAC_SECURE_REFS, NULL );
+ ASSERT_EXPR( result != S_OK, "CoInitializeSecurity succeeded with bad parameters" );
+
+ // Initialize security with secure refs.
+ result = MCoInitializeSecurity( NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_CONNECT,
+ RPC_C_IMP_LEVEL_IMPERSONATE, NULL,
+ EOAC_SECURE_REFS, NULL );
+ ASSERT( result, "Could not initialize secure refs" );
+
+ if (ThreadMode == COINIT_APARTMENTTHREADED)
+ {
+ // Create a local server
+ result = new_apartment_test( &local, &id_local, NULL );
+ ASSERT( result, "Could not create local instance of test server" );
+
+ // Call the local server.
+ result = local->check( id_local );
+ ASSERT( result, "Could not call local server" )
+
+ // Release the local server.
+ local->Release();
+ local = NULL;
+ }
+
+ // Create a server possibly on a remote machine.
+ result = create_instance( *ServerClsid, &server, &id_server );
+ ASSERT( result, "Could not create instance of test server" );
+ ASSERT_EXPR( server != NULL, "Create instance returned NULL." );
+
+ // Call the server.
+ result = server->check( id_server );
+ ASSERT( result, "Could not call local server" )
+
+ // Release the server.
+ server->Release();
+ server = NULL;
+
+ // Create a server possibly on a remote machine.
+ result = create_instance( *ServerClsid, &server, &id_server );
+ ASSERT( result, "Could not create instance of test server" );
+ ASSERT_EXPR( server != NULL, "Create instance returned NULL." );
+
+ // Create a server on this machine.
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &server2 );
+ ASSERT( result, "Could not create out of process server2" );
+ result = server2->get_id( &id_server2 );
+ ASSERT( result, "Could not get server2 id" );
+
+ // Have the second server remember the first.
+ result = server2->remember( server, id_server );
+ ASSERT( result, "Could not remember server" );
+ result = server2->call_next();
+ ASSERT( result, "Could not call server" );
+
+ // Release some extra public references.
+ success = do_securerefs_helper( &server );
+ if (!success) goto cleanup;
+ success = FALSE;
+
+ // The server should be gone, have the second server try to call.
+ result = server2->call_next();
+ ASSERT_EXPR( result != S_OK, "Call to dead server succeeded" );
+
+ // Have the second server forget the first.
+ result = server2->forget();
+ ASSERT( result, "Could not forget server" );
+
+ // Create a possible machine remote server.
+ result = create_instance( *ServerClsid, &server, &id_server );
+ ASSERT( result, "Could not create instance of test server" );
+ ASSERT_EXPR( server != NULL, "Create instance returned NULL." );
+
+ // Tell the second server to remember it.
+ result = server2->remember( server, id_server );
+ ASSERT( result, "Could not remember server" );
+ result = server2->call_next();
+ ASSERT( result, "Could not call server" );
+
+ // Release all local references.
+ server->Release();
+ server = NULL;
+
+ // Have the second server call it.
+ result = server2->call_next();
+ ASSERT( result, "Could not call server" );
+
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+ if (server2 != NULL)
+ server2->Release();
+ if (server != NULL)
+ server->Release();
+ if (local != NULL)
+ local->Release();
+
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nSecureRefs Test Passed.\n" );
+ else
+ printf( "\n\nSecureRefs Test Failed.\n" );
+}
+
+ /***************************************************************************/
+BOOL do_securerefs_helper( ITest **server )
+{
+ ULONG size;
+ HRESULT result;
+ HANDLE memory = NULL;
+ BOOL success;
+ IStream *stream = NULL;
+ LARGE_INTEGER pos;
+
+ // Find out how much memory to allocate.
+ result = CoGetMarshalSizeMax( &size, IID_ITest, *server, 0, NULL,
+ MSHLFLAGS_NORMAL );
+ ASSERT( result, "Could not get marshal size" );
+
+ // Allocate memory.
+ memory = GlobalAlloc( GMEM_FIXED, size );
+ ASSERT_EXPR( memory != NULL, "Could not get memory." );
+
+ // Create a stream.
+ result = CreateStreamOnHGlobal( memory, TRUE, &stream );
+ ASSERT( result, "Could not create stream" );
+
+ // Marshal the proxy.
+ result = CoMarshalInterface( stream, IID_ITest, *server, 0, NULL,
+ MSHLFLAGS_NORMAL );
+ ASSERT( result, "Could not marshal interface" );
+
+ // Release the proxy.
+ (*server)->Release();
+ *server = NULL;
+
+ // Seek back to the start of the stream.
+ pos.QuadPart = 0;
+ result = stream->Seek( pos, STREAM_SEEK_SET, NULL );
+ ASSERT( result, "Could not seek to start" );
+
+ // Unmarshal another copy.
+ result = CoUnmarshalInterface( stream, IID_ITest, (void **) server );
+ ASSERT( result, "Could not unmarshal from stream" );
+
+ // Release the proxy.
+ (*server)->Release();
+ *server = NULL;
+
+ // Seek back to the start of the stream.
+ pos.QuadPart = 0;
+ result = stream->Seek( pos, STREAM_SEEK_SET, NULL );
+ ASSERT( result, "Could not seek to start" );
+
+ // Unmarshal another copy.
+ result = CoUnmarshalInterface( stream, IID_ITest, (void **) server );
+ ASSERT( result, "Could not unmarshal from stream" );
+
+ // Release the proxy.
+ (*server)->Release();
+ *server = NULL;
+
+ success = TRUE;
+cleanup:
+ // The stream releases the memory.
+ if (stream != NULL)
+ stream->Release();
+ return success;
+}
+
+ /***************************************************************************/
+void do_security()
+{
+ BOOL success = FALSE;
+ ITest *server = NULL;
+ ITest *local = NULL;
+ ITest *server2 = NULL;
+ ITest *local2 = NULL;
+ SAptId id_server;
+ SAptId id_local;
+ SAptId id_server2;
+ SAptId id_local2;
+ HRESULT result;
+
+ // Initialize OLE.
+ hello( "security" );
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+
+ // Test automatic security.
+ success = do_security_auto();
+ if (!success)
+ goto cleanup;
+ success = FALSE;
+
+ // Uninitialize.
+ CoUninitialize();
+
+ // Reinitialize.
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Reinitialize failed" );
+
+ // Set security to automatic none.
+ result = MCoInitializeSecurity( NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_NONE,
+ RPC_C_IMP_LEVEL_IMPERSONATE, NULL,
+ EOAC_NONE, NULL );
+ ASSERT( result, "Could not initialize security to none" );
+
+ // Create a local server
+ result = new_apartment_test( &local, &id_local, NULL );
+ ASSERT( result, "Could not create local instance of test server" );
+
+ // Create a client possibly on a remote machine.
+ result = create_instance( *ServerClsid, &server, &id_server );
+ ASSERT( result, "Could not create instance of test server" );
+ ASSERT_EXPR( server != NULL, "Create instance returned NULL." );
+
+ // Test proxy copy for a local object.
+ if (ThreadMode != COINIT_MULTITHREADED)
+ {
+ success = do_security_copy( local, id_local );
+ if (!success)
+ goto cleanup;
+ success = FALSE;
+ }
+
+ // Test proxy copy for a remote object.
+ success = do_security_copy( server, id_server );
+ if (!success)
+ goto cleanup;
+ success = FALSE;
+
+ // Test delegation
+ if (ThreadMode != COINIT_MULTITHREADED)
+ {
+ // Create a local server
+ result = new_apartment_test( &local2, &id_local2, NULL );
+ ASSERT( result, "Could not create local instance of test server" );
+
+ success = do_security_delegate( local, id_local, local2, id_local2 );
+ if (!success)
+ goto cleanup;
+ success = FALSE;
+ }
+
+ // Create a client possibly on a remote machine.
+ result = create_instance( *ServerClsid, &server2, &id_server2 );
+ ASSERT( result, "Could not create instance of test server" );
+ ASSERT_EXPR( server2 != NULL, "Create instance returned NULL." );
+
+ // Test delegation
+ success = do_security_delegate( server, id_server, server2, id_server2 );
+ if (!success)
+ goto cleanup;
+ success = FALSE;
+
+ // Try some calls.
+ if (ThreadMode != COINIT_MULTITHREADED)
+ {
+ success = do_security_handle( local, id_local );
+ if (!success)
+ goto cleanup;
+ success = FALSE;
+ }
+
+ // Try some calls.
+ success = do_security_handle( server, id_server );
+ if (!success)
+ goto cleanup;
+ success = FALSE;
+
+ // Test nested impersonation for a local object.
+ if (ThreadMode != COINIT_MULTITHREADED)
+ {
+ success = do_security_nested( local, id_local );
+ if (!success)
+ goto cleanup;
+ success = FALSE;
+ }
+
+ // Test nested impersonation for a remote object.
+ success = do_security_nested( server, id_server );
+ if (!success)
+ goto cleanup;
+ success = FALSE;
+
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+ if (server2 != NULL)
+ server2->Release();
+ if (local2 != NULL)
+ local2->Release();
+ if (server != NULL)
+ server->Release();
+ if (local != NULL)
+ local->Release();
+
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nSecurity Test Passed.\n" );
+ else
+ printf( "\n\nSecurity Test Failed.\n" );
+}
+
+ /***************************************************************************/
+BOOL do_security_auto( )
+{
+ BOOL success = FALSE;
+ DWORD i;
+ DWORD j;
+ DWORD k;
+ HRESULT result;
+ SOLE_AUTHENTICATION_SERVICE svc_list;
+ ITest *server = NULL;
+ SAptId id_server;
+ DWORD authn_level;
+ DWORD authn_level_out;
+ HANDLE thread = NULL;
+
+ // Figure out the class id offset based on the threading model.
+ if (ThreadMode == COINIT_MULTITHREADED)
+ k = 5;
+ else
+ k = 0;
+
+ // Try all types of security initialization.
+ for (i = 0; i < 5; i++)
+ {
+
+ // Initialize security.
+ switch (i)
+ {
+ case 0:
+ authn_level = RPC_C_AUTHN_LEVEL_NONE;
+ result = MCoInitializeSecurity( NULL, -1, NULL, NULL,
+ RPC_C_AUTHN_LEVEL_NONE,
+ RPC_C_IMP_LEVEL_IMPERSONATE, NULL,
+ EOAC_NONE, NULL );
+ ASSERT( result, "Could not initialize security to none" );
+ break;
+ case 1:
+ authn_level = RPC_C_AUTHN_LEVEL_CONNECT;
+ result = MCoInitializeSecurity( NULL, -1, NULL, NULL,
+ RPC_C_AUTHN_LEVEL_CONNECT,
+ RPC_C_IMP_LEVEL_IMPERSONATE, NULL,
+ EOAC_NONE, NULL );
+ ASSERT( result, "Could not initialize security to connect" );
+ break;
+ case 2:
+ authn_level = RPC_C_AUTHN_LEVEL_PKT_INTEGRITY;
+ result = MCoInitializeSecurity( NULL, -1, NULL, NULL,
+ RPC_C_AUTHN_LEVEL_PKT_INTEGRITY,
+ RPC_C_IMP_LEVEL_IMPERSONATE, NULL,
+ EOAC_NONE, NULL );
+ ASSERT( result, "Could not initialize security to integrity" );
+ break;
+ case 3:
+ authn_level = RPC_C_AUTHN_LEVEL_NONE;
+ svc_list.dwAuthnSvc = RPC_C_AUTHN_WINNT;
+ svc_list.dwAuthzSvc = RPC_C_AUTHZ_NONE;
+ svc_list.pPrincipalName = NULL;
+ result = MCoInitializeSecurity( NULL, 1, &svc_list, NULL,
+ RPC_C_AUTHN_LEVEL_NONE,
+ RPC_C_IMP_LEVEL_IMPERSONATE, NULL,
+ EOAC_NONE, NULL );
+ ASSERT( result, "Could not initialize security with authentication services" );
+ break;
+ case 4:
+ // Try legacy security by doing nothing.
+ authn_level = RPC_C_AUTHN_LEVEL_NONE;
+ break;
+ }
+
+ // Try all types of servers.
+ for (j = 0; j < 5; j++)
+ {
+ // Create a server.
+ result = create_instance( ClassIds[j+k], &server, &id_server );
+ ASSERT( result, "Could not create instance of test server" );
+ ASSERT_EXPR( server != NULL, "Create instance returned NULL." );
+
+ // Call it once.
+ success = do_security_lazy_call( server, id_server, authn_level,
+ RPC_C_IMP_LEVEL_IMPERSONATE,
+ RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
+ ProcessSid );
+ if (!success) goto cleanup;
+ success = FALSE;
+
+ if (j == 1 || j == 2)
+ {
+ // Set the security too low.
+ result = MCoSetProxyBlanket( server, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
+ NULL, RPC_C_AUTHN_LEVEL_NONE,
+ RPC_C_IMP_LEVEL_IMPERSONATE, NULL,
+ EOAC_NONE );
+ ASSERT( result, "Could not set blanket with authentication level none" );
+
+ // Make a bad call. Allow the security provider to up the level.
+ result = server->secure( id_server, RPC_C_AUTHN_LEVEL_NONE,
+ RPC_C_IMP_LEVEL_IMPERSONATE,
+ RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
+ NULL, (HACKSID *) ProcessSid, &authn_level_out );
+ ASSERT_EXPR( result != S_OK ||
+ (j == 1 && authn_level_out >= RPC_C_AUTHN_LEVEL_CONNECT) ||
+ (j == 2 && authn_level_out >= RPC_C_AUTHN_LEVEL_PKT_INTEGRITY),
+ "Bad call succeeded." );
+ }
+
+ // Release it.
+ server->Release();
+ server = NULL;
+ }
+
+ if (ThreadMode == COINIT_APARTMENTTHREADED)
+ {
+ // Create a local server.
+ result = new_apartment_test( &server, &id_server, &thread );
+ ASSERT( result, "Could not create local instance of test server" );
+
+ // Make a local call.
+ success = do_security_lazy_call( server, id_server, authn_level,
+ RPC_C_IMP_LEVEL_IMPERSONATE,
+ RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
+ ProcessSid );
+ if (!success) goto cleanup;
+ success = FALSE;
+
+ // Release it.
+ server->Release();
+ server = NULL;
+
+ // Wait for the helper thread to die.
+ result = WaitForSingleObject( thread, INFINITE );
+ ASSERT_EXPR( result == WAIT_OBJECT_0, "Could not wait for thread." );
+ CloseHandle( thread );
+ thread = NULL;
+ }
+
+ // Uninitialize OLE.
+ CoUninitialize();
+
+ // Reinitialize OLE.
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Reinitialize failed" );
+ }
+
+ success = TRUE;
+cleanup:
+ if (server != NULL)
+ server->Release();
+ if (thread != NULL)
+ CloseHandle( thread );
+ return success;
+}
+
+ /***************************************************************************/
+BOOL do_security_call( ITest *server, SAptId id, DWORD authn_level,
+ DWORD imp_level, DWORD authn_svc, DWORD authz_svc,
+ SID *sid )
+{
+ BOOL success = FALSE;
+ HRESULT result;
+ DWORD authn_level_out;
+ DWORD imp_level_out;
+ DWORD authn_svc_out;
+ DWORD authz_svc_out;
+ OLECHAR *princ_name_out = NULL;
+
+ result = MCoSetProxyBlanket( server, authn_svc, authz_svc, NULL,
+ authn_level, imp_level, NULL, EOAC_NONE );
+ ASSERT( result, "Could not set blanket" );
+
+ // Verify the authentication information.
+ result = MCoQueryProxyBlanket( server, &authn_svc_out, &authz_svc_out,
+ &princ_name_out, &authn_level_out,
+ &imp_level_out, NULL, NULL );
+ if (result == S_OK)
+ {
+ ASSERT_EXPR( princ_name_out == NULL, "Got a principle name." );
+ ASSERT_EXPR( authn_level <= authn_level_out, "Wrong authentication level." );
+ ASSERT_EXPR( imp_level == imp_level_out, "Wrong impersonation level." );
+ ASSERT_EXPR( authn_svc == authn_svc_out, "Wrong authentication service." );
+ ASSERT_EXPR( authz_svc == authz_svc_out, "Wrong authorization service." );
+ }
+
+ // Make a call.
+ result = server->secure( id, authn_level, imp_level, authn_svc, authz_svc,
+ NULL, (HACKSID *) sid, &authn_level_out );
+ ASSERT( result, "Secure call failed" );
+
+ success = TRUE;
+cleanup:
+ CoTaskMemFree( princ_name_out );
+ return success;
+}
+
+ /***************************************************************************/
+BOOL do_security_copy( ITest *server, SAptId id )
+{
+ BOOL success = FALSE;
+ ITest *copy1 = NULL;
+ ITest *copy2 = NULL;
+ ITest *copy3 = NULL;
+ HRESULT result;
+
+ // Make a copy.
+ result = MCoCopyProxy( server, (IUnknown **) &copy1 );
+ ASSERT( result, "Could not copy proxy" );
+
+ // Verify that it calls at none.
+ success = do_security_lazy_call( copy1, id, RPC_C_AUTHN_LEVEL_NONE,
+ RPC_C_IMP_LEVEL_IMPERSONATE,
+ RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
+ ProcessSid );
+ if (!success) goto cleanup;
+ success = FALSE;
+
+ // Verify that the original calls at none.
+ success = do_security_lazy_call( server, id, RPC_C_AUTHN_LEVEL_NONE,
+ RPC_C_IMP_LEVEL_IMPERSONATE,
+ RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
+ ProcessSid );
+ if (!success) goto cleanup;
+ success = FALSE;
+
+ // Call on the original at connect.
+ success = do_security_call( server, id, RPC_C_AUTHN_LEVEL_CONNECT,
+ RPC_C_IMP_LEVEL_IMPERSONATE,
+ RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
+ ProcessSid );
+ if (!success) goto cleanup;
+ success = FALSE;
+
+ // Verify that the copy still calls at none.
+ success = do_security_lazy_call( copy1, id, RPC_C_AUTHN_LEVEL_NONE,
+ RPC_C_IMP_LEVEL_IMPERSONATE,
+ RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
+ ProcessSid );
+ if (!success) goto cleanup;
+ success = FALSE;
+
+ // Call on the copy at encrypt.
+ success = do_security_call( copy1, id, RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
+ RPC_C_IMP_LEVEL_IMPERSONATE,
+ RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
+ ProcessSid );
+ if (!success) goto cleanup;
+ success = FALSE;
+
+ // Verify that the original still calls at connect.
+ success = do_security_lazy_call( server, id, RPC_C_AUTHN_LEVEL_CONNECT,
+ RPC_C_IMP_LEVEL_IMPERSONATE,
+ RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
+ ProcessSid );
+ if (!success) goto cleanup;
+ success = FALSE;
+
+ // Free the copy.
+ copy1->Release();
+ copy1 = NULL;
+
+ // Make a copy.
+ result = MCoCopyProxy( server, (IUnknown **) &copy1 );
+ ASSERT( result, "Could not copy proxy" );
+
+ // Verify that the copy calls at none.
+ success = do_security_lazy_call( copy1, id, RPC_C_AUTHN_LEVEL_NONE,
+ RPC_C_IMP_LEVEL_IMPERSONATE,
+ RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
+ ProcessSid );
+ if (!success) goto cleanup;
+ success = FALSE;
+
+ // Copy the copy.
+ result = MCoCopyProxy( copy1, (IUnknown **) &copy2 );
+ ASSERT( result, "Could not copy a copy of a proxy" );
+
+ // Verify the second copy calls at none.
+ success = do_security_lazy_call( copy2, id, RPC_C_AUTHN_LEVEL_NONE,
+ RPC_C_IMP_LEVEL_IMPERSONATE,
+ RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
+ ProcessSid );
+ if (!success) goto cleanup;
+ success = FALSE;
+
+ // Change the first copy to integrity.
+ success = do_security_call( copy1, id, RPC_C_AUTHN_LEVEL_PKT_INTEGRITY,
+ RPC_C_IMP_LEVEL_IMPERSONATE,
+ RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
+ ProcessSid );
+ if (!success) goto cleanup;
+ success = FALSE;
+
+ // Change the second copy to encrypt.
+ success = do_security_call( copy2, id, RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
+ RPC_C_IMP_LEVEL_IMPERSONATE,
+ RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
+ ProcessSid );
+ if (!success) goto cleanup;
+ success = FALSE;
+
+ // Verify that the original is still connect.
+ success = do_security_lazy_call( server, id, RPC_C_AUTHN_LEVEL_CONNECT,
+ RPC_C_IMP_LEVEL_IMPERSONATE,
+ RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
+ ProcessSid );
+ if (!success) goto cleanup;
+ success = FALSE;
+
+ // Querying a copy should return the original.
+ result = copy1->QueryInterface( IID_ITest, (void **) &copy3 );
+ ASSERT( result, "Could not QueryInterface" );
+ ASSERT_EXPR( server == copy3, "QueryInterface did not return the original." );
+ copy3->Release();
+ copy3 = NULL;
+
+ // Free the original.
+ server->Release();
+ server = NULL;
+
+ // Free the second copy.
+ copy2->Release();
+ copy2 = NULL;
+
+ // Make another copy.
+ result = MCoCopyProxy( copy1, (IUnknown **) &copy2 );
+ ASSERT( result, "Could not copy a copy of a proxy" );
+
+ // Verify that it calls at none.
+ success = do_security_lazy_call( copy2, id, RPC_C_AUTHN_LEVEL_NONE,
+ RPC_C_IMP_LEVEL_IMPERSONATE,
+ RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
+ ProcessSid );
+ if (!success) goto cleanup;
+ success = FALSE;
+
+ // Query for the original.
+ result = copy1->QueryInterface( IID_ITest, (void **) &server );
+ ASSERT( result, "Could not QueryInterface" );
+
+ // Verify that it calls at connect.
+ success = do_security_lazy_call( server, id, RPC_C_AUTHN_LEVEL_CONNECT,
+ RPC_C_IMP_LEVEL_IMPERSONATE,
+ RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
+ ProcessSid );
+ if (!success) goto cleanup;
+ success = FALSE;
+
+ // Verify that the first copy is still at integrity
+ success = do_security_lazy_call( copy1, id, RPC_C_AUTHN_LEVEL_PKT_INTEGRITY,
+ RPC_C_IMP_LEVEL_IMPERSONATE,
+ RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
+ ProcessSid );
+ if (!success) goto cleanup;
+ success = FALSE;
+
+ success = TRUE;
+cleanup:
+ if (copy1 != NULL)
+ copy1->Release();
+ if (copy2 != NULL)
+ copy2->Release();
+ if (copy3 != NULL)
+ copy3->Release();
+ return success;
+}
+
+ /***************************************************************************/
+BOOL do_security_delegate( ITest *server, SAptId id, ITest *server2,
+ SAptId id2 )
+{
+ BOOL success = FALSE;
+ HRESULT result;
+
+ // Make a call.
+ result = server->delegate( server2, id2, (HACKSID *) ProcessSid );
+ ASSERT( result, "Delegate call failed" );
+
+ success = TRUE;
+cleanup:
+ return success;
+}
+
+ /***************************************************************************/
+BOOL do_security_handle( ITest *server, SAptId id )
+{
+ BOOL success = FALSE;
+
+ // Make a call with no security.
+ success = do_security_call( server, id, RPC_C_AUTHN_LEVEL_NONE,
+ RPC_C_IMP_LEVEL_IMPERSONATE,
+ RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, ProcessSid );
+ if (!success)
+ return FALSE;
+
+ // Make a call with connect security.
+ success = do_security_call( server, id, RPC_C_AUTHN_LEVEL_CONNECT,
+ RPC_C_IMP_LEVEL_IMPERSONATE,
+ RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, ProcessSid );
+ if (!success)
+ return FALSE;
+
+ // Make a call with integrity security.
+ success = do_security_call( server, id, RPC_C_AUTHN_LEVEL_PKT_INTEGRITY,
+ RPC_C_IMP_LEVEL_IMPERSONATE,
+ RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, ProcessSid );
+ if (!success)
+ return FALSE;
+
+
+ // Make a call with encrypt security.
+ success = do_security_call( server, id, RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
+ RPC_C_IMP_LEVEL_IMPERSONATE,
+ RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, ProcessSid );
+ if (!success)
+ return FALSE;
+
+ // Make a call with no security.
+ success = do_security_call( server, id, RPC_C_AUTHN_LEVEL_NONE,
+ RPC_C_IMP_LEVEL_IDENTIFY,
+ RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, ProcessSid );
+ if (!success)
+ return FALSE;
+
+ // Make a call with connect security.
+ success = do_security_call( server, id, RPC_C_AUTHN_LEVEL_CONNECT,
+ RPC_C_IMP_LEVEL_IDENTIFY,
+ RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, ProcessSid );
+ if (!success)
+ return FALSE;
+
+ // Make a call with integrity security.
+ success = do_security_call( server, id, RPC_C_AUTHN_LEVEL_PKT_INTEGRITY,
+ RPC_C_IMP_LEVEL_IDENTIFY,
+ RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, ProcessSid );
+ if (!success)
+ return FALSE;
+
+
+ // Make a call with encrypt security.
+ success = do_security_call( server, id, RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
+ RPC_C_IMP_LEVEL_IDENTIFY,
+ RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, ProcessSid );
+ if (!success)
+ return FALSE;
+
+ // Finally, its all over.
+ return TRUE;
+}
+
+ /***************************************************************************/
+BOOL do_security_lazy_call( ITest *server, SAptId id, DWORD authn_level,
+ DWORD imp_level, DWORD authn_svc, DWORD authz_svc,
+ SID *sid )
+{
+ BOOL success = FALSE;
+ HRESULT result;
+ DWORD authn_level_out;
+ DWORD imp_level_out;
+ DWORD authn_svc_out;
+ DWORD authz_svc_out;
+ OLECHAR *princ_name_out = NULL;
+
+ // Verify the authentication information.
+ result = MCoQueryProxyBlanket( server, &authn_svc_out, &authz_svc_out,
+ &princ_name_out, &authn_level_out,
+ &imp_level_out, NULL, NULL );
+ if (result == S_OK)
+ {
+ ASSERT_EXPR( princ_name_out == NULL, "Got a principle name." );
+ ASSERT_EXPR( authn_level <= authn_level_out, "Wrong authentication level." );
+ ASSERT_EXPR( imp_level == imp_level_out, "Wrong impersonation level." );
+ ASSERT_EXPR( authn_svc == authn_svc_out, "Wrong authentication service." );
+ ASSERT_EXPR( authz_svc == authz_svc_out, "Wrong authorization service." );
+ }
+
+ // Make a call.
+ result = server->secure( id, authn_level, imp_level, authn_svc, authz_svc,
+ NULL, (HACKSID *) sid, &authn_level_out );
+ ASSERT( result, "Secure call failed" );
+
+ success = TRUE;
+cleanup:
+ CoTaskMemFree( princ_name_out );
+ return success;
+}
+
+ /***************************************************************************/
+BOOL do_security_nested( ITest *server, SAptId id )
+{
+ HRESULT result;
+ CTest test;
+ BOOL success = FALSE;
+ IServerSecurity *security = NULL;
+ TOKEN_USER *token_info = NULL;
+ DWORD info_size = 1024;
+ HANDLE token = NULL;
+ PSID me = NULL;
+
+ // Make a recursive call. The proxy is set to encrypt from the previous test.
+ result = server->recurse_secure( &test, 3, 1, (HACKSID *) ProcessSid );
+ ASSERT( result, "Could not make recursive call with impersonation." );
+
+ // Try to get call context.
+ result = MCoGetCallContext( IID_IServerSecurity, (void **) &security );
+ ASSERT_EXPR( result != S_OK, "Get call context succeeded outside a call." );
+
+ // Open the thread token.
+ if (OpenThreadToken( GetCurrentThread(), TOKEN_QUERY, TRUE, &token ))
+ result = S_OK;
+ else
+ result = GetLastError();
+ ASSERT_EXPR( result == NOERROR || result == ERROR_NO_TOKEN, "Could not OpenThreadToken" );
+
+ // Lookup SID of thread token.
+ token_info = (TOKEN_USER *) malloc( info_size );
+ ASSERT_EXPR( token_info != NULL, "Could not allocate memory for token info." );
+ if (result == NOERROR)
+ {
+ GetTokenInformation( token, TokenUser, token_info, info_size, &info_size );
+ result = GetLastError();
+ ASSERT( result, "Could not GetTokenInformation" );
+ me = token_info->User.Sid;
+
+ // The SID on the thread token should equal the process token.
+ ASSERT_EXPR( EqualSid( me, ProcessSid ), "Wrong thread token." );
+ }
+
+ success = TRUE;
+cleanup:
+ if (security != NULL)
+ security->Release();
+ if (token_info != NULL)
+ free(token_info);
+ if (token != NULL)
+ CloseHandle( token );
+ return success;
+}
+
+ /***************************************************************************/
+void do_send()
+{
+ LRESULT result;
+
+ // Say hello.
+ printf( "Sending a message to window 0x%x\n", NumIterations );
+ result = SendMessageA( (HWND) NumIterations, WM_USER, 0, 0 );
+
+ if (result == 0)
+ printf( "\n\nSendMessageA succeeded.\n" );
+ else
+ printf( "\n\nSendMessageA failed: 0x%x\n", result );
+}
+
+ /***************************************************************************/
+void do_server( )
+{
+ HRESULT result;
+ BOOL success = FALSE;
+ SOLE_AUTHENTICATION_SERVICE svc_list;
+
+ // Initialize OLE.
+ hello( "server" );
+ printf( "Initializing thread 0x%x\n", GetCurrentThreadId() );
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+ result = initialize_security();
+ ASSERT( result, "Could not initialize security" );
+
+ // Create our class factory
+ ClassFactory = new CTestCF();
+ ASSERT_EXPR( ClassFactory != NULL, "Could not create class factory." );
+
+ // Register our class with OLE
+ result = CoRegisterClassObject(*ServerClsid, ClassFactory, CLSCTX_LOCAL_SERVER,
+ REGCLS_SINGLEUSE, &Registration);
+ ASSERT( result, "CoRegisterClassObject failed" );
+
+ // CoRegister bumps reference count so we don't have to!
+ ClassFactory->Release();
+
+ // Do whatever we have to do till it is time to pay our taxes and die.
+ server_loop();
+
+ // Deregister out class - should release object as well
+ if (!dirty_thread())
+ {
+ result = CoRevokeClassObject(Registration);
+ ASSERT( result, "CoRevokeClassObject failed" );
+ }
+
+ success = TRUE;
+cleanup:
+ if (!dirty_thread())
+ {
+ printf( "Uninitializing thread 0x%x\n", GetCurrentThreadId() );
+ CoUninitialize();
+ }
+ else
+ printf( "\n\nI didn't clean up\n" );
+
+ if (success)
+ printf( "\n\nServer Passed.\n" );
+ else
+ printf( "\n\nServer Failed.\n" );
+}
+
+
+ /***************************************************************************/
+void do_sid()
+{
+ BOOL success = FALSE;
+ BOOL call_success;
+ SID *pSID = NULL;
+ DWORD cbSID = 1024;
+ WCHAR *lpszDomain = NULL;
+ DWORD cchDomainName = 80;
+ SID_NAME_USE sid_use;
+ HRESULT result = S_OK;
+ DWORD i;
+
+ // Say hello.
+ printf( "Looking up sid for %ws.\n", Name );
+
+ // Lookup the name.
+ pSID = (SID *) LocalAlloc(LPTR, cbSID*2);
+ lpszDomain = (WCHAR *) LocalAlloc(LPTR, cchDomainName*2);
+ ASSERT_EXPR( pSID != NULL && lpszDomain != NULL, "LocalAlloc" );
+ call_success = LookupAccountName(NULL,
+ Name,
+ pSID,
+ &cbSID,
+ lpszDomain,
+ &cchDomainName,
+ &sid_use);
+ result = GetLastError();
+ ASSERT( result, "Could not LookupAccountName" );
+ ASSERT_EXPR( call_success, "LookupAccountName failed." );
+ ASSERT_EXPR( IsValidSid(pSID), "Got a bad SID." );
+ printf( "SID\n" );
+ printf( " Revision: 0x%02x\n", pSID->Revision );
+ printf( " SubAuthorityCount: 0x%x\n", pSID->SubAuthorityCount );
+ printf( " IdentifierAuthority: 0x%02x%02x%02x%02x%02x%02x\n",
+ pSID->IdentifierAuthority.Value[0],
+ pSID->IdentifierAuthority.Value[1],
+ pSID->IdentifierAuthority.Value[2],
+ pSID->IdentifierAuthority.Value[3],
+ pSID->IdentifierAuthority.Value[4],
+ pSID->IdentifierAuthority.Value[5] );
+ for (i = 0; i < pSID->SubAuthorityCount; i++)
+ printf( " SubAuthority[%d]: 0x%08x\n", i,
+ pSID->SubAuthority[i] );
+ printf( " Domain: %ws\n", lpszDomain );
+ printf( " SID_NAME_USE: 0x%x\n", sid_use );
+
+ success = TRUE;
+cleanup:
+ if (lpszDomain != NULL)
+ LocalFree((HLOCAL) lpszDomain);
+ if (pSID != NULL)
+ LocalFree(pSID);
+
+ if (success)
+ printf( "\n\nSid succeeded.\n" );
+ else
+ printf( "\n\nSid failed.\n" );
+}
+
+ /***************************************************************************/
+void do_simple_rundown()
+{
+ BOOL success = FALSE;
+ ITest *client1 = NULL;
+ CTest *local = NULL;
+ SAptId id1;
+ SAptId local_id;
+ HRESULT result;
+
+ // Initialize OLE.
+ hello( "simple rundown" );
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+
+ // Create a server
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &client1 );
+ ASSERT( result, "Could not create server" );
+ result = client1->get_id( &id1 );
+ ASSERT( result, "Could not get id" );
+
+ // Create a local object.
+ local = new CTest;
+ ASSERT_EXPR( local != NULL, "Could not create a local object." );
+ result = local->get_id( &local_id );
+ ASSERT( result, "Could not get id" );
+
+ // Tell it to remember this object.
+ result = client1->remember( local, local_id );
+ ASSERT( result, "Could not remember local object" );
+ local->Release();
+ local = NULL;
+
+ // Tell the other apartment to die.
+ result = client1->set_state( dirty_s, THREAD_PRIORITY_NORMAL );
+ ASSERT( result, "Could not set exit dirty" );
+ result = client1->exit();
+
+ // Wait araound till no one references the local object.
+ printf( "Wait for object to rundown. This could take 12 minutes.\n" );
+ server_loop();
+
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+ if (client1 != NULL)
+ client1->Release();
+ if (local != NULL)
+ local->Release();
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nSimple Rundown Test Passed.\n" );
+ else
+ printf( "\n\nSimple Rundown Test Failed.\n" );
+}
+
+ /***************************************************************************/
+void do_thread()
+{
+ BOOL success = FALSE;
+ ITest *client1 = NULL;
+ ITest *client2 = NULL;
+ ITest *client3 = NULL;
+ ITest *client4 = NULL;
+ SAptId id1;
+ SAptId id2;
+ SAptId id4;
+ HRESULT result;
+ GUID guid;
+
+ // Initialize OLE.
+ hello( "thread" );
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+
+ // Create a client on this thread.
+ client3 = new CTest;
+ ASSERT_EXPR( client3 != NULL, "Could not create a local object." );
+
+ // Create a client on another thread in this process
+ result = client3->get_obj_from_new_apt( &client4, &id4 );
+ ASSERT( result, "Could not get in process client" );
+
+ // Create a server
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &client1 );
+ ASSERT( result, "Could not create instance of test server" );
+ result = client1->get_id( &id1 );
+ ASSERT( result, "Could not get id of server" );
+
+ // Create an object in another apartment in the server.
+ result = client1->get_obj_from_new_apt( &client2, &id2 );
+ ASSERT( result, "Could not get in process server" );
+
+ // Check each object.
+ result = client1->check( id1 );
+ ASSERT( result, "Could not check server 1" );
+ result = client2->check( id2 );
+ ASSERT( result, "Could not check server 2" );
+
+ // Pass a server to the other thread in this process.
+ result = client4->remember( client1, id1 );
+ ASSERT( result, "Client could not remember server" );
+
+ // Release the second object.
+ client2->Release();
+ client2 = NULL;
+
+ // Check the first object.
+ result = client1->check( id1 );
+ ASSERT( result, "Could not check server 1" );
+
+ // Check the first object from another thread.
+ result = client4->call_next();
+ ASSERT( result, "Could not check server 1 from thread 2" );
+
+ // Release the first object from this thread.
+ client1->Release();
+ client1 = NULL;
+
+ // Check the first object from another thread.
+ result = client4->call_next();
+ ASSERT( result, "Could not check server 1 from thread 2" );
+
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+ if (client2 != NULL)
+ client2->Release();
+ if (client1 != NULL)
+ client1->Release();
+ if (client3 != NULL)
+ client3->Release();
+ if (client4 != NULL)
+ client4->Release();
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nThread Test Passed.\n" );
+ else
+ printf( "\n\nThread Test Failed.\n" );
+}
+
+ /***************************************************************************/
+typedef struct
+{
+ ATOM wclass;
+ HWND wdriver;
+ HWND whelper;
+ HANDLE hdriver;
+ HANDLE hhelper;
+ HRESULT result;
+} SSwitchData;
+
+SSwitchData gSwitch;
+
+LRESULT do_three_wndproc(HWND window, UINT message, WPARAM unused, LPARAM params);
+DWORD _stdcall do_three_helper( void *nothing );
+
+void do_three()
+{
+ BOOL success = FALSE;
+ ITest *server = NULL;
+ HRESULT result;
+ int i;
+ WNDCLASS wclass;
+ HANDLE thread = NULL;
+ DWORD thread_id;
+ MSG msg;
+
+ // Initialize OLE.
+ hello( "three" );
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+
+ // Create a remote server.
+ result = CoCreateInstance( *ServerClsid, NULL, CLSCTX_LOCAL_SERVER,
+ IID_ITest, (void **) &server );
+ ASSERT( result, "Could not create server" );
+
+ // Register a window class.
+ wclass.style = 0;
+ wclass.lpfnWndProc = do_three_wndproc;
+ wclass.cbClsExtra = 0;
+ wclass.cbWndExtra = 0;
+ wclass.hInstance = NULL;
+ wclass.hIcon = NULL;
+ wclass.hCursor = NULL;
+ wclass.hbrBackground = (HBRUSH) (COLOR_BACKGROUND + 1);
+ wclass.lpszMenuName = NULL;
+ wclass.lpszClassName = L"That's me";
+ gSwitch.wclass = RegisterClass( &wclass );
+ ASSERT_EXPR( gSwitch.wclass != 0, "Could not register class." );
+
+ // Create a window.
+ gSwitch.wdriver = CreateWindowEx(0,
+ L"That's me",
+ L"My window",
+ // must use WS_POPUP so the window does not get
+ // assigned a hot key by user.
+ (WS_DISABLED | WS_POPUP),
+ CW_USEDEFAULT,
+ CW_USEDEFAULT,
+ CW_USEDEFAULT,
+ CW_USEDEFAULT,
+ NULL,
+ NULL,
+ NULL, // hinst
+ NULL);
+ ASSERT_EXPR( gSwitch.wdriver != NULL, "Could not create window." );
+
+ // Create an event.
+ gSwitch.hdriver = CreateEventA( NULL, FALSE, FALSE, NULL );
+ ASSERT_EXPR( gSwitch.hdriver != NULL, "Could not create event." );
+
+ // Create a thread.
+ thread = CreateThread( NULL, 0, do_three_helper, NULL, 0, &thread_id );
+ ASSERT_EXPR( thread != NULL, "Could not create thread." );
+ CloseHandle( thread );
+
+ // Wait for the thread to initialize.
+ result = WaitForSingleObject( gSwitch.hdriver, INFINITE );
+ ASSERT_EXPR( result == WAIT_OBJECT_0, "Could not wait for thread." );
+ ASSERT( gSwitch.result, "Helper thread failed." );
+
+ // Test some thread switches
+ for (i = 0; i < NumIterations; i++)
+ {
+ // Post a message to the thread.
+ success = PostMessageA( gSwitch.whelper, WM_USER, 0, 0 );
+ ASSERT_EXPR( success, "Could not post message." );
+ success = FALSE;
+
+ // Wait for a post message reply.
+ result = MsgWaitForMultipleObjects( 1, &gSwitch.hdriver, FALSE,
+ 1000, QS_POSTMESSAGE );
+ ASSERT_EXPR( result == WAIT_OBJECT_0+1, "Could not wait for post message." );
+ ASSERT( gSwitch.result, "Helper thread failed." );
+ success = PeekMessage( &msg, gSwitch.wdriver, WM_USER, WM_USER,
+ PM_REMOVE | PM_NOYIELD );
+ ASSERT_EXPR( success, "Could not peek message." );
+ success = FALSE;
+ DispatchMessageA( &msg );
+
+ // Set an event to reply.
+ success = SetEvent( gSwitch.hhelper );
+ ASSERT_EXPR( success, "Could not set event." );
+ success = FALSE;
+
+ // Wait for a set event reply.
+ result = MsgWaitForMultipleObjects( 1, &gSwitch.hdriver, FALSE,
+ 1000, QS_POSTMESSAGE );
+ ASSERT_EXPR( result == WAIT_OBJECT_0, "Could not wait for event." );
+ ASSERT( gSwitch.result, "Helper thread failed." );
+ }
+
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+ if (server != NULL)
+ server->Release();
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nThree Test Passed.\n" );
+ else
+ printf( "\n\nThree Test Failed.\n" );
+}
+
+ /***************************************************************************/
+LRESULT do_three_wndproc(HWND window, UINT message, WPARAM unused, LPARAM params)
+{
+ return DefWindowProc( window, message, unused, params );
+}
+
+ /***************************************************************************/
+DWORD _stdcall do_three_helper( void *nothing )
+{
+ HRESULT result;
+ BOOL success;
+ MSG msg;
+
+ // Create an event.
+ gSwitch.hhelper = CreateEventA( NULL, FALSE, FALSE, NULL );
+ ASSERT_EXPR( gSwitch.hhelper != NULL, "Could not create event." );
+
+ // Create a window.
+ gSwitch.whelper = CreateWindowEx(0,
+ L"That's me",
+ L"My window",
+ // must use WS_POPUP so the window does not get
+ // assigned a hot key by user.
+ (WS_DISABLED | WS_POPUP),
+ CW_USEDEFAULT,
+ CW_USEDEFAULT,
+ CW_USEDEFAULT,
+ CW_USEDEFAULT,
+ NULL,
+ NULL,
+ NULL, // hinst
+ NULL);
+ ASSERT_EXPR( gSwitch.whelper != NULL, "Could not create window." );
+
+ // Wake up the driver.
+ gSwitch.result = S_OK;
+ success = SetEvent( gSwitch.hdriver );
+ ASSERT_EXPR( success, "Could not set event." );
+
+ // Loop forever.
+ while (TRUE)
+ {
+ // Wait for a message.
+ success = GetMessageA( &msg, NULL, 0, 0 );
+ ASSERT_EXPR( success, "Could not get message." );
+ TranslateMessage (&msg);
+ DispatchMessageA (&msg);
+
+ // Post a reply.
+ success = PostMessageA( gSwitch.wdriver, WM_USER, 0, 0 );
+ ASSERT_EXPR( success, "Could not post message." );
+ success = FALSE;
+
+ // Wait for an event.
+ result = MsgWaitForMultipleObjects( 1, &gSwitch.hhelper, FALSE,
+ 1000, QS_POSTMESSAGE );
+ ASSERT_EXPR( result == WAIT_OBJECT_0, "Could not wait for event." );
+
+ // Set an event to reply.
+ success = SetEvent( gSwitch.hdriver );
+ ASSERT_EXPR( success, "Could not set event." );
+ }
+
+cleanup:
+ gSwitch.result = E_FAIL;
+ success = SetEvent( gSwitch.hdriver );
+ return E_FAIL;
+}
+
+ /***************************************************************************/
+void do_two()
+{
+ BOOL success = FALSE;
+ ITest *client1 = NULL;
+ SAptId id1;
+ HRESULT result;
+ DWORD i;
+ LARGE_INTEGER freq;
+ LARGE_INTEGER start;
+ LARGE_INTEGER nothing;
+ LARGE_INTEGER init_sec_none;
+ LARGE_INTEGER open;
+ LARGE_INTEGER get_sid;
+ HANDLE hToken = NULL;
+ BYTE aMemory[1024];
+ TOKEN_USER *pTokenUser = (TOKEN_USER *) &aMemory;
+ DWORD lNameLen = 1000;
+ DWORD lDomainLen = 1000;
+ DWORD lIgnore;
+ DWORD lSidLen;
+ WCHAR name[1000];
+ WCHAR domain[1000];
+ LARGE_INTEGER lookup;
+ DWORD xlookup;
+ SID_NAME_USE sIgnore;
+
+ // Initialize OLE.
+ hello( "two" );
+ result = initialize(NULL,ThreadMode);
+ ASSERT( result, "Initialize failed" );
+
+ // Measure the performance of nothing.
+ QueryPerformanceFrequency( &freq );
+ QueryPerformanceCounter( &start );
+ QueryPerformanceCounter( &nothing );
+ nothing.QuadPart = 1000000 * (nothing.QuadPart - start.QuadPart) / freq.QuadPart;
+
+ // Open the process's token.
+ QueryPerformanceCounter( &start );
+ success = OpenProcessToken( GetCurrentProcess(), TOKEN_QUERY, &hToken );
+ QueryPerformanceCounter( &open );
+ open.QuadPart = 1000000 * (open.QuadPart - start.QuadPart) / freq.QuadPart;
+ ASSERT_EXPR( success, "Could not open process token." );
+
+ // Lookup SID of process token.
+ QueryPerformanceCounter( &start );
+ success = GetTokenInformation( hToken, TokenUser, pTokenUser, sizeof(aMemory),
+ &lIgnore );
+ QueryPerformanceCounter( &get_sid );
+ get_sid.QuadPart = 1000000 * (get_sid.QuadPart - start.QuadPart) / freq.QuadPart;
+ ASSERT_EXPR( success, "Could not get token information." );
+
+ // Lookup the name from the sid.
+ QueryPerformanceCounter( &start );
+ LookupAccountSid( NULL, pTokenUser->User.Sid, name, &lNameLen,
+ domain, &lDomainLen, &sIgnore );
+ ASSERT_EXPR( success, "Could not lookup account sid." );
+ QueryPerformanceCounter( &lookup );
+ lookup.QuadPart = 1000000 * (lookup.QuadPart - start.QuadPart) / freq.QuadPart;
+
+ // Lookup the name from the sid a lot of times.
+ xlookup = GetTickCount();
+ for (i = 0; i < NumIterations; i++)
+ {
+ LookupAccountSid( NULL, pTokenUser->User.Sid, name, &lNameLen,
+ domain, &lDomainLen, &sIgnore );
+ ASSERT_EXPR( success, "Could not lookup account sid." );
+ }
+ xlookup = (GetTickCount() - xlookup)*1000/NumIterations;
+
+ // Import the security APIs.
+ GCoInitializeSecurity = (CoInitializeSecurityFn) Fixup( "CoInitializeSecurity" );
+ if (GCoInitializeSecurity == NULL)
+ goto cleanup;
+
+ // Measure the performance of initialize.
+ QueryPerformanceCounter( &start );
+ result = MCoInitializeSecurity( NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_NONE,
+ RPC_C_IMP_LEVEL_IMPERSONATE, NULL,
+ EOAC_NONE, NULL );
+ QueryPerformanceCounter( &init_sec_none );
+ init_sec_none.QuadPart = 1000000 * (init_sec_none.QuadPart - start.QuadPart) / freq.QuadPart;
+ ASSERT( result, "Could not initialize security" );
+
+ // Print the timings.
+ printf( "nothing took %duS\n", nothing.u.LowPart );
+ printf( "OpenProcessToken took %duS\n", open.u.LowPart );
+ printf( "GetTokenInformation took %duS\n", get_sid.u.LowPart );
+ printf( "LookupAccountSid took %duS\n", lookup.u.LowPart );
+ printf( "LookupAccountSid multiple took %duS\n", xlookup );
+ printf( "CoInitializeSecurity at none took %duS\n", init_sec_none.u.LowPart );
+
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+ if (client1 != NULL)
+ client1->Release();
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nTwo Test Passed.\n" );
+ else
+ printf( "\n\nTwo Test Failed.\n" );
+}
+
+ /***************************************************************************/
+void do_uninit()
+{
+ BOOL success = FALSE;
+ ITest *server = NULL;
+ ITest *server2 = NULL;
+ SAptId id;
+ SAptId id2;
+ HRESULT result;
+ DWORD i;
+ HANDLE thread[MAX_THREADS];
+ DWORD thread_id;
+
+ // This test always runs in multithreaded mode. It tests a multithread
+ // only problem and uses freethreaded blocking.
+ ThreadMode = COINIT_MULTITHREADED;
+
+ // Initialize OLE.
+ hello( "uninit" );
+ result = initialize( NULL, ThreadMode );
+ ASSERT( result, "Initialize failed" );
+
+ // Create a possibly remote object.
+ result = create_instance( ClassIds[free_auto_none], &server, &id );
+ ASSERT( result, "Could not create server" );
+
+ // Get another object.
+ result = server->get_obj_from_this_apt( &server2, &id2 );
+ ASSERT( result, "Could not get another object" );
+
+ // Tell the server to remember its neighbor
+ result = server->remember( server2, id2 );
+ ASSERT( result, "Could not remember server" );
+ server2->Release();
+ server2 = NULL;
+
+ // Tell it to wait for a call during shutdown and lower its priority.
+ result = server->set_state( late_dispatch_s, THREAD_PRIORITY_LOWEST );
+ ASSERT( result, "Could not set server state" );
+
+ // Don't create too many threads.
+ if (NumThreads > MAX_THREADS)
+ NumThreads = MAX_THREADS;
+
+ // Create some helper threads.
+ GlobalBool = TRUE;
+ for (i = 0; i < NumThreads; i++)
+ {
+ thread[i] = CreateThread( NULL, 0, do_uninit_helper, server, 0, &thread_id );
+ if (thread[i] == NULL)
+ {
+ printf( "Could not create helper thread number %d.\n", i );
+ goto cleanup;
+ }
+ }
+
+ // Call the server. Marshal an interface. Start shutting down.
+ // Wait before returning.
+ result = server->get_next_slowly( &server2, &id2 );
+ ASSERT( result, "Could not call server during shutdown" );
+
+ // Let the helpers run a while.
+ printf( "Waiting 5 seconds for server to die." );
+ Sleep( 5000 );
+
+ // Tell all the helpers to die.
+ GlobalBool = FALSE;
+ result = WaitForMultipleObjects( NumThreads, thread, TRUE, INFINITE );
+ ASSERT_EXPR( result != WAIT_FAILED, "Could not wait for helper threads to die.\n" );
+
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+ if (server2 != NULL)
+ server2->Release();
+ if (server != NULL)
+ server->Release();
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nUninit Test Passed.\n" );
+ else
+ printf( "\n\nUninit Test Failed.\n" );
+}
+
+ /***************************************************************************/
+DWORD _stdcall do_uninit_helper( void *param )
+{
+ ITest *server = (ITest *) param;
+ ITest *server2;
+ SAptId id;
+
+ // Call the server till the process terminates.
+ while (GlobalBool)
+ server->get_next( &server2, &id );
+
+ return 0;
+}
+
+ /***************************************************************************/
+void do_unknown()
+{
+ BOOL success = FALSE;
+ ITest *server = NULL;
+ IUnknown *unknown = NULL;
+ SAptId id;
+ HRESULT result;
+
+ // Initialize OLE.
+ hello( "unknown" );
+ result = initialize( NULL, ThreadMode );
+ ASSERT( result, "Initialize failed" );
+
+ // Set security to connect with secure references.
+ result = MCoInitializeSecurity( NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_CONNECT,
+ RPC_C_IMP_LEVEL_IMPERSONATE, NULL,
+ EOAC_SECURE_REFS, NULL );
+ ASSERT( result, "Could not initialize security to connect" );
+
+ if (ThreadMode == COINIT_APARTMENTTHREADED)
+ {
+ // Create a local server
+ result = new_apartment_test( &server, &id, NULL );
+ ASSERT( result, "Could not create local instance of test server" );
+ result = server->QueryInterface( IID_IUnknown, (void **) &unknown );
+ ASSERT( result, "Could not get IUnknown" );
+
+ // Test IUnknown
+ success = do_unknown_helper( unknown );
+ if (!success) goto cleanup;
+ success = FALSE;
+
+ // Release the local server.
+ unknown->Release();
+ unknown = NULL;
+ server->Release();
+ server = NULL;
+ }
+
+ // Create a possibly remote object.
+ result = create_instance( *ServerClsid, &server, &id );
+ ASSERT( result, "Could not create server" );
+ result = server->QueryInterface( IID_IUnknown, (void **) &unknown );
+ ASSERT( result, "Could not get IUnknown" );
+
+ // Test IUnknown
+ success = do_unknown_helper( unknown );
+ if (!success) goto cleanup;
+ success = FALSE;
+
+ // Finally, its all over.
+ success = TRUE;
+cleanup:
+ if (unknown != NULL)
+ unknown->Release();
+ if (server != NULL)
+ server->Release();
+ CoUninitialize();
+
+ if (success)
+ printf( "\n\nUnknown Test Passed.\n" );
+ else
+ printf( "\n\nUnknown Test Failed.\n" );
+}
+
+ /***************************************************************************/
+BOOL do_unknown_call( IUnknown *server, DWORD authn, DWORD imp, REFIID iid )
+{
+ BOOL success = FALSE;
+ HRESULT result;
+ DWORD authn_level_out;
+ DWORD imp_level_out;
+ DWORD authn_svc_out;
+ DWORD authz_svc_out;
+ OLECHAR *princ_name_out = NULL;
+ ITest *test = NULL;
+
+ result = MCoSetProxyBlanket( server, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
+ NULL, authn, imp, NULL, EOAC_NONE );
+ ASSERT( result, "Could not set blanket" );
+
+ // Verify the authentication information.
+ result = MCoQueryProxyBlanket( server, &authn_svc_out, &authz_svc_out,
+ &princ_name_out, &authn_level_out,
+ &imp_level_out, NULL, NULL );
+ if (result == S_OK)
+ {
+ ASSERT_EXPR( princ_name_out == NULL, "Got a principle name." );
+ ASSERT_EXPR( authn <= authn_level_out, "Wrong authentication level." );
+ ASSERT_EXPR( imp == imp_level_out, "Wrong impersonation level." );
+ ASSERT_EXPR( RPC_C_AUTHN_WINNT == authn_svc_out, "Wrong authentication service." );
+ ASSERT_EXPR( RPC_C_AUTHZ_NONE == authz_svc_out, "Wrong authorization service." );
+ }
+
+ // Query for the interface.
+ result = server->QueryInterface( iid, (void **) &test );
+ ASSERT( result, "Could not query interface" );
+
+ success = TRUE;
+cleanup:
+ CoTaskMemFree( princ_name_out );
+ if (test != NULL)
+ test->Release();
+ return success;
+}
+
+ /***************************************************************************/
+BOOL do_unknown_helper( IUnknown *server )
+{
+ BOOL success;
+
+ // Make an unsecure impersonate query.
+ success = do_unknown_call( server, RPC_C_AUTHN_LEVEL_NONE,
+ RPC_C_IMP_LEVEL_IMPERSONATE, IID_ITestNoneImp );
+ if (!success) return FALSE;
+
+ // Make a connect level impersonate query.
+ success = do_unknown_call( server, RPC_C_AUTHN_LEVEL_CONNECT,
+ RPC_C_IMP_LEVEL_IMPERSONATE, IID_ITestConnectImp );
+ if (!success) return FALSE;
+
+ // Make an encrypt level impersonate query.
+ success = do_unknown_call( server, RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
+ RPC_C_IMP_LEVEL_IMPERSONATE, IID_ITestEncryptImp );
+ if (!success) return FALSE;
+
+ // Make an unsecure identify query.
+ success = do_unknown_call( server, RPC_C_AUTHN_LEVEL_NONE,
+ RPC_C_IMP_LEVEL_IDENTIFY, IID_ITestNoneId );
+ if (!success) return FALSE;
+
+ // Make a connect level identify query.
+ success = do_unknown_call( server, RPC_C_AUTHN_LEVEL_CONNECT,
+ RPC_C_IMP_LEVEL_IDENTIFY, IID_ITestConnectId );
+ if (!success) return FALSE;
+
+ // Make an encrypt level identify query.
+ success = do_unknown_call( server, RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
+ RPC_C_IMP_LEVEL_IDENTIFY, IID_ITestEncryptId );
+ if (!success) return FALSE;
+ return TRUE;
+}
+
+ /***************************************************************************/
+void *Fixup( char *name )
+{
+ HINSTANCE ole;
+ void *fn;
+
+ // Load ole32.dll
+ ole = LoadLibraryA( "ole32.dll" );
+ if (ole == NULL)
+ {
+ printf( "Could not load ole32.dll to get security function.\n" );
+ return NULL;
+ }
+
+ // Get the function
+ fn = GetProcAddress( ole, name );
+ FreeLibrary( ole );
+ if (fn == NULL)
+ {
+ printf( "Could not find %s in ole32.dll.\n", name );
+ return NULL;
+ }
+
+ // Call function
+ return fn;
+}
+
+ /***************************************************************************/
+HRESULT __stdcall FixupCoCopyProxy(
+ IUnknown *pProxy,
+ IUnknown **ppCopy )
+{
+ HINSTANCE ole;
+ HRESULT result;
+
+ // Load ole32.dll
+ ole = LoadLibraryA( "ole32.dll" );
+ if (ole == NULL)
+ {
+ printf( "Could not load ole32.dll to get security function.\n" );
+ return E_NOTIMPL;
+ }
+
+ // Get the function
+ GCoCopyProxy = (CoCopyProxyFn) GetProcAddress( ole, "CoCopyProxy" );
+ FreeLibrary( ole );
+ if (GCoCopyProxy == NULL)
+ {
+ printf( "Could not find security in ole32.dll.\n" );
+ return E_NOTIMPL;
+ }
+
+ // Call function
+ return GCoCopyProxy( pProxy, ppCopy );
+}
+
+ /***************************************************************************/
+HRESULT __stdcall FixupCoGetCallContext( REFIID riid, void **ppInterface )
+{
+ HINSTANCE ole;
+ HRESULT result;
+
+ // Load ole32.dll
+ ole = LoadLibraryA( "ole32.dll" );
+ if (ole == NULL)
+ {
+ printf( "Could not load ole32.dll to get security function.\n" );
+ return E_NOTIMPL;
+ }
+
+ // Get the function
+ GCoGetCallContext = (CoGetCallContextFn)
+ GetProcAddress( ole, "CoGetCallContext" );
+ FreeLibrary( ole );
+ if (GCoGetCallContext == NULL)
+ {
+ printf( "Could not find security in ole32.dll.\n" );
+ return E_NOTIMPL;
+ }
+
+ // Call function
+ return GCoGetCallContext( riid, ppInterface );
+}
+
+ /***************************************************************************/
+HRESULT __stdcall FixupCoImpersonateClient()
+{
+ HINSTANCE ole;
+ HRESULT result;
+
+ // Load ole32.dll
+ ole = LoadLibraryA( "ole32.dll" );
+ if (ole == NULL)
+ {
+ printf( "Could not load ole32.dll to get security function.\n" );
+ return E_NOTIMPL;
+ }
+
+ // Get the function
+ GCoImpersonateClient = (CoImpersonateClientFn)
+ GetProcAddress( ole, "CoImpersonateClient" );
+ FreeLibrary( ole );
+ if (GCoImpersonateClient == NULL)
+ {
+ printf( "Could not find security in ole32.dll.\n" );
+ return E_NOTIMPL;
+ }
+
+ // Call function
+ return GCoImpersonateClient();
+}
+
+ /***************************************************************************/
+HRESULT __stdcall FixupCoInitializeSecurity(
+ SECURITY_DESCRIPTOR *pSecDesc,
+ DWORD cAuthSvc,
+ SOLE_AUTHENTICATION_SERVICE *asAuthSvc,
+ WCHAR *pPrincName,
+ DWORD dwAuthnLevel,
+ DWORD dwImpLevel,
+ RPC_AUTH_IDENTITY_HANDLE pAuthInfo,
+ DWORD dwCapabilities,
+ void *pReserved )
+{
+ HINSTANCE ole;
+ HRESULT result;
+
+ // Load ole32.dll
+ ole = LoadLibraryA( "ole32.dll" );
+ if (ole == NULL)
+ {
+ printf( "Could not load ole32.dll to get security function.\n" );
+ return E_NOTIMPL;
+ }
+
+ // Get the function
+ GCoInitializeSecurity = (CoInitializeSecurityFn)
+ GetProcAddress( ole, "CoInitializeSecurity" );
+ FreeLibrary( ole );
+ if (GCoInitializeSecurity == NULL)
+ {
+ printf( "Could not find security in ole32.dll.\n" );
+ return E_NOTIMPL;
+ }
+
+ // Call function
+ return GCoInitializeSecurity( pSecDesc, cAuthSvc, asAuthSvc, pPrincName,
+ dwAuthnLevel, dwImpLevel, pAuthInfo,
+ dwCapabilities, pReserved );
+}
+
+ /***************************************************************************/
+HRESULT __stdcall FixupCoQueryAuthenticationServices( DWORD *pcbAuthSvc,
+ SOLE_AUTHENTICATION_SERVICE **asAuthSvc )
+{
+ HINSTANCE ole;
+ HRESULT result;
+
+ // Load ole32.dll
+ ole = LoadLibraryA( "ole32.dll" );
+ if (ole == NULL)
+ {
+ printf( "Could not load ole32.dll to get security function.\n" );
+ return E_NOTIMPL;
+ }
+
+ // Get the function
+ GCoQueryAuthenticationServices = (CoQueryAuthenticationServicesFn)
+ GetProcAddress( ole, "CoQueryAuthenticationServices" );
+ FreeLibrary( ole );
+ if (GCoQueryAuthenticationServices == NULL)
+ {
+ printf( "Could not find security in ole32.dll.\n" );
+ return E_NOTIMPL;
+ }
+
+ // Call function
+ return GCoQueryAuthenticationServices( pcbAuthSvc, asAuthSvc );
+}
+
+ /***************************************************************************/
+HRESULT __stdcall FixupCoQueryClientBlanket(
+ DWORD *pAuthnSvc,
+ DWORD *pAuthzSvc,
+ OLECHAR **pServerPrincName,
+ DWORD *pAuthnLevel,
+ DWORD *pImpLevel,
+ RPC_AUTHZ_HANDLE *pPrivs,
+ DWORD *pCapabilities )
+{
+ HINSTANCE ole;
+ HRESULT result;
+
+ // Load ole32.dll
+ ole = LoadLibraryA( "ole32.dll" );
+ if (ole == NULL)
+ {
+ printf( "Could not load ole32.dll to get security function.\n" );
+ return E_NOTIMPL;
+ }
+
+ // Get the function
+ GCoQueryClientBlanket = (CoQueryClientBlanketFn)
+ GetProcAddress( ole, "CoQueryClientBlanket" );
+ FreeLibrary( ole );
+ if (GCoQueryClientBlanket == NULL)
+ {
+ printf( "Could not find security in ole32.dll.\n" );
+ return E_NOTIMPL;
+ }
+
+ // Call function
+ return GCoQueryClientBlanket( pAuthnSvc, pAuthzSvc, pServerPrincName,
+ pAuthnLevel, pImpLevel, pPrivs, pCapabilities );
+}
+
+ /***************************************************************************/
+HRESULT __stdcall FixupCoQueryProxyBlanket(
+ IUnknown *pProxy,
+ DWORD *pAuthnSvc,
+ DWORD *pAuthzSvc,
+ OLECHAR **pServerPrincName,
+ DWORD *pAuthnLevel,
+ DWORD *pImpLevel,
+ RPC_AUTH_IDENTITY_HANDLE *pAuthInfo,
+ DWORD *pCapabilities )
+{
+ HINSTANCE ole;
+ HRESULT result;
+
+ // Load ole32.dll
+ ole = LoadLibraryA( "ole32.dll" );
+ if (ole == NULL)
+ {
+ printf( "Could not load ole32.dll to get security function.\n" );
+ return E_NOTIMPL;
+ }
+
+ // Get the function
+ GCoQueryProxyBlanket = (CoQueryProxyBlanketFn)
+ GetProcAddress( ole, "CoQueryProxyBlanket" );
+ FreeLibrary( ole );
+ if (GCoQueryProxyBlanket == NULL)
+ {
+ printf( "Could not find security in ole32.dll.\n" );
+ return E_NOTIMPL;
+ }
+
+ // Call function
+ return GCoQueryProxyBlanket( pProxy, pAuthnSvc, pAuthzSvc, pServerPrincName,
+ pAuthnLevel, pImpLevel, pAuthInfo, pCapabilities );
+}
+
+ /***************************************************************************/
+HRESULT __stdcall FixupCoRevertToSelf()
+{
+ HINSTANCE ole;
+ HRESULT result;
+
+ // Load ole32.dll
+ ole = LoadLibraryA( "ole32.dll" );
+ if (ole == NULL)
+ {
+ printf( "Could not load ole32.dll to get security function.\n" );
+ return E_NOTIMPL;
+ }
+
+ // Get the function
+ GCoRevertToSelf = (CoRevertToSelfFn) GetProcAddress( ole, "CoRevertToSelf" );
+ FreeLibrary( ole );
+ if (GCoRevertToSelf == NULL)
+ {
+ printf( "Could not find security in ole32.dll.\n" );
+ return E_NOTIMPL;
+ }
+
+ // Call function
+ return GCoRevertToSelf();
+}
+
+ /***************************************************************************/
+HRESULT __stdcall FixupCoSetProxyBlanket(
+ IUnknown *pProxy,
+ DWORD dwAuthnSvc,
+ DWORD dwAuthzSvc,
+ OLECHAR *pServerPrincName,
+ DWORD dwAuthnLevel,
+ DWORD dwImpLevel,
+ RPC_AUTH_IDENTITY_HANDLE *pAuthInfo,
+ DWORD dwCapabilities )
+{
+ HINSTANCE ole;
+ HRESULT result;
+
+ // Load ole32.dll
+ ole = LoadLibraryA( "ole32.dll" );
+ if (ole == NULL)
+ {
+ printf( "Could not load ole32.dll to get security function.\n" );
+ return E_NOTIMPL;
+ }
+
+ // Get the function
+ GCoSetProxyBlanket = (CoSetProxyBlanketFn)
+ GetProcAddress( ole, "CoSetProxyBlanket" );
+ FreeLibrary( ole );
+ if (GCoSetProxyBlanket == NULL)
+ {
+ printf( "Could not find security in ole32.dll.\n" );
+ return E_NOTIMPL;
+ }
+
+ // Call function
+ return GCoSetProxyBlanket( pProxy, dwAuthnSvc, dwAuthzSvc, pServerPrincName,
+ dwAuthnLevel, dwImpLevel, pAuthInfo, dwCapabilities );
+}
+
+ /***************************************************************************/
+HRESULT __stdcall FixupCoSwitchCallContext( IUnknown *pNewObject, IUnknown **ppOldObject )
+{
+ HINSTANCE ole;
+ HRESULT result;
+
+ // Load ole32.dll
+ ole = LoadLibraryA( "ole32.dll" );
+ if (ole == NULL)
+ {
+ printf( "Could not load ole32.dll to get security function.\n" );
+ return E_NOTIMPL;
+ }
+
+ // Get the function
+ GCoSwitchCallContext = (CoSwitchCallContextFn)
+ GetProcAddress( ole, "CoSwitchCallContext" );
+ FreeLibrary( ole );
+ if (GCoSwitchCallContext == NULL)
+ {
+ printf( "Could not find security in ole32.dll.\n" );
+ return E_NOTIMPL;
+ }
+
+ // Call function
+ return GCoSwitchCallContext( pNewObject, ppOldObject );
+}
+
+ /***************************************************************************/
+DWORD get_sequence()
+{
+ if (ThreadMode == COINIT_MULTITHREADED)
+ return ProcessAptData.sequence++;
+ else
+ {
+ SAptData *tls_data = (SAptData *) TlsGetValue( TlsIndex );
+ return tls_data->sequence++;
+ }
+}
+
+ /***************************************************************************/
+void hello( char *test )
+{
+ // Say hello.
+ if (ThreadMode == COINIT_SINGLETHREADED)
+ printf( "Running %s test in single threaded mode.\n", test );
+ else if (ThreadMode == COINIT_APARTMENTTHREADED)
+ printf( "Running %s test in apartment threaded mode.\n", test );
+ else
+ printf( "Running %s test in multithreaded mode.\n", test );
+}
+
+ /***************************************************************************/
+void increment_object_count()
+{
+ if (ThreadMode == COINIT_MULTITHREADED)
+ {
+ InterlockedIncrement( &ProcessAptData.object_count );
+ ProcessAptData.what_next = wait_wn;
+ }
+ else
+ {
+ SAptData *tls_data = (SAptData *) TlsGetValue( TlsIndex );
+ tls_data->object_count += 1;
+ tls_data->what_next = wait_wn;
+ }
+
+}
+
+ /***************************************************************************/
+HRESULT initialize( void *reserved, ULONG flags )
+{
+ HINSTANCE ole;
+ INIT_FN init_ex;
+ HRESULT result;
+
+ // For the apartment model, just use CoInitialize.
+ if (flags == COINIT_APARTMENTTHREADED)
+ return CoInitialize( NULL );
+
+ // For free threading, try to find the CoInitializeEx API.
+ ole = LoadLibraryA( "ole32.dll" );
+ if (ole == NULL)
+ {
+ printf( "Could not load ole32.dll to get CoInitializeEx.\n" );
+ return E_NOTIMPL;
+ }
+
+ // Get CoInitializeEx.
+ init_ex = (INIT_FN) GetProcAddress( ole, "CoInitializeEx" );
+ if (init_ex == NULL)
+ {
+ FreeLibrary( ole );
+ printf( "Could not find CoInitializeEx in ole32.dll.\n" );
+ return E_NOTIMPL;
+ }
+
+ // Call CoInitializeEx.
+ result = init_ex( reserved, flags );
+ FreeLibrary( ole );
+ return result;
+}
+
+ /***************************************************************************/
+HRESULT initialize_security()
+{
+ HRESULT result;
+ SOLE_AUTHENTICATION_SERVICE svc_list;
+
+ // Initialize security.
+ if (GlobalSecurityModel == basic_sm)
+ {
+ printf( "Basic security model.\n" );
+ svc_list.dwAuthnSvc = RPC_C_AUTHN_WINNT;
+ svc_list.dwAuthzSvc = RPC_C_AUTHZ_NONE;
+ svc_list.pPrincipalName = NULL;
+ result = MCoInitializeSecurity( NULL, 1, &svc_list, NULL, GlobalAuthnLevel,
+ RPC_C_IMP_LEVEL_IMPERSONATE, NULL,
+ EOAC_NONE, NULL );
+ }
+ else if (GlobalSecurityModel == auto_sm)
+ {
+ printf( "Automatic security model.\n" );
+ result = MCoInitializeSecurity( NULL, -1, NULL, NULL, GlobalAuthnLevel,
+ RPC_C_IMP_LEVEL_IMPERSONATE, NULL,
+ EOAC_NONE, NULL );
+ }
+ else
+ {
+ printf( "Legacy security model.\n" );
+ result = S_OK;
+ }
+ return result;
+}
+
+ /***************************************************************************/
+void interrupt()
+{
+ while (GlobalInterruptTest)
+ {
+ GlobalTest->check( GlobalApt );
+ check_for_request();
+ }
+ GlobalTest->Release();
+}
+
+ /***************************************************************************/
+void interrupt_marshal()
+{
+ int i;
+
+ for (i = 0; i < NUM_MARSHAL_LOOP; i++ )
+ {
+ GlobalTest->recurse( GlobalTest2, 1 );
+ check_for_request();
+ }
+ GlobalTest->Release();
+ GlobalTest2->Release();
+ what_next( wait_wn );
+}
+
+ /***************************************************************************
+ Function: main
+
+ Synopsis: Executes the BasicBnd test
+
+ Effects: None
+
+
+ Returns: Exits with exit code 0 if success, 1 otherwise
+
+***************************************************************************/
+
+int _cdecl main(int argc, char *argv[])
+{
+ HRESULT result;
+ SAptData tls_data;
+ BOOL success = TRUE;
+ DWORD ignore;
+ TOKEN_USER *token_info = NULL;
+ DWORD info_size = 1024;
+ HANDLE token = NULL;
+
+ // Initialize Globals.
+ MainThread = GetCurrentThreadId();
+ ignore = sizeof(Name);
+ GetComputerName( Name, &ignore );
+
+ // Create an event for termination notification.
+ Done = CreateEventA( NULL, FALSE, FALSE, NULL );
+ if (Done == NULL)
+ {
+ printf( "Could not create event.\n" );
+ return 0;
+ }
+
+ // Get an event for signalling raw RPCs.
+ RawEvent = CreateEventA( NULL, FALSE, FALSE, NULL );
+ if (RawEvent == NULL)
+ {
+ printf( "Could not create event.\n" );
+ return 0;
+ }
+
+ // Allocate a TLS index.
+ TlsIndex = TlsAlloc();
+ if (TlsIndex == 0xffffffff)
+ {
+ printf( "Could not allocate TLS index.\n" );
+ return 0;
+ }
+
+ // Open the process's token.
+ OpenProcessToken( GetCurrentProcess(), TOKEN_QUERY, &token );
+ result = GetLastError();
+ if (result != 0)
+ {
+ printf( "Could not OpenProcessToken.\n" );
+ return 0;
+ }
+
+ // Lookup SID of process token.
+ token_info = (TOKEN_USER *) malloc( info_size );
+ if (token_info == NULL)
+ {
+ printf( "Could not allocate memory for token info.\n" );
+ return 0;
+ }
+ GetTokenInformation( token, TokenUser, token_info, info_size, &info_size );
+ result = GetLastError();
+ if (result != 0)
+ {
+ printf( "Could not GetTokenInformation.\n" );
+ return 0;
+ }
+ ProcessSid = (SID *) token_info->User.Sid;
+ CloseHandle( token );
+
+ // Parse the parameters.
+ if (!parse( argc, argv ))
+ return 0;
+
+ // Make sure the registry is set.
+ if (!registry_setup( argv[0] ))
+ return 0;
+
+ // Initiailize the apartment global data for the multithreaded mode.
+ if (ThreadMode == COINIT_MULTITHREADED)
+ {
+ ProcessAptData.object_count = 0;
+ ProcessAptData.what_next = setup_wn;
+ ProcessAptData.exit_dirty = FALSE;
+ ProcessAptData.sequence = 0;
+ }
+
+ // In the single threaded mode, stick a pointer to the object count
+ // in TLS.
+ else
+ {
+ tls_data.object_count = 0;
+ tls_data.what_next = setup_wn;
+ tls_data.exit_dirty = FALSE;
+ tls_data.sequence = 0;
+ TlsSetValue( TlsIndex, &tls_data );
+ }
+
+ // Switch to the correct test.
+ switch_test();
+
+ // Cleanup.
+ TlsFree( TlsIndex );
+ CloseHandle( Done );
+ return 1;
+}
+
+ /*************************************************************************/
+void __RPC_FAR * __RPC_API midl_user_allocate( size_t count )
+{
+ return malloc(count);
+}
+
+ /*************************************************************************/
+void __RPC_USER midl_user_free( void __RPC_FAR * p )
+{
+ free( p );
+}
+
+ /*************************************************************************/
+HRESULT new_apartment_test( ITest ** test, SAptId *id, HANDLE *thread_out )
+{
+ new_apt_params params;
+ HANDLE thread;
+ DWORD thread_id;
+ DWORD status;
+ HRESULT result;
+ IClassFactory *factory;
+
+ // Create an event.
+ params.stream = NULL;
+ params.ready = CreateEventA( NULL, FALSE, FALSE, NULL );
+ if (params.ready == NULL)
+ return E_OUTOFMEMORY;
+
+ // Start a new thread/apartment.
+ thread = CreateThread( NULL, 0, apartment_base, &params, 0, &thread_id );
+ if (thread == NULL)
+ {
+ result = E_OUTOFMEMORY;
+ goto cleanup;
+ }
+
+ // Wait till it has marshalled a class factory.
+ status = WaitForSingleObject( params.ready, INFINITE );
+ if (status != WAIT_OBJECT_0 || params.stream == NULL)
+ {
+ result = E_FAIL;
+ goto cleanup;
+ }
+
+ // Unmarshal the class factory.
+ result = CoUnmarshalInterface( params.stream, IID_IClassFactory,
+ (void **) &factory );
+ params.stream->Release();
+ if (FAILED(result))
+ goto cleanup;
+
+ // Create a test object.
+ result = factory->CreateInstance( NULL, IID_ITest, (void **) test );
+ factory->Release();
+ if (*test != NULL)
+ (*test)->get_id( id );
+
+cleanup:
+ if (thread_out != NULL && SUCCEEDED(result))
+ *thread_out = thread;
+ else
+ CloseHandle( thread );
+ if (params.ready != NULL)
+ CloseHandle( params.ready );
+ return result;
+}
+
+ /*************************************************************************/
+/* Parse the arguments. */
+BOOL parse( int argc, char *argv[] )
+{
+ int i;
+ int len;
+ char buffer[80];
+
+ WhatTest = lots_wt;
+ ThreadMode = COINIT_APARTMENTTHREADED;
+
+ // Parse each item, skip the command name
+ for (i = 1; i < argc; i++)
+ {
+ if (_stricmp( argv[i], "Apartment" ) == 0)
+ ThreadMode = COINIT_APARTMENTTHREADED;
+
+ else if (_stricmp( argv[i], "-auto" ) == 0)
+ {
+ if (argv[++i] == NULL)
+ {
+ printf( "You must include an authentication level after the -auto option.\n" );
+ return FALSE;
+ }
+ sscanf( argv[i], "%d", &GlobalAuthnLevel );
+ GlobalSecurityModel = auto_sm;
+ }
+
+ else if (_stricmp( argv[i], "-b" ) == 0)
+ DebugBreak();
+
+ else if (_stricmp( argv[i], "-basic" ) == 0)
+ GlobalSecurityModel = basic_sm;
+
+ else if (_stricmp( argv[i], "-c" ) == 0)
+ Change = TRUE;
+
+ else if (_stricmp( argv[i], "Cancel" ) == 0)
+ WhatTest = cancel_wt;
+
+ else if (_stricmp( argv[i], "Crash" ) == 0)
+ WhatTest = crash_wt;
+
+ else if (_stricmp( argv[i], "Cstress" ) == 0)
+ WhatTest = cstress_wt;
+
+ else if (_stricmp( argv[i], "-d" ) == 0)
+ {
+ if (argv[++i] == NULL)
+ {
+ printf( "You must include a debugger after the -d option.\n" );
+ return FALSE;
+ }
+ WriteClass = TRUE;
+ if (_stricmp( argv[i], "none" ) == 0)
+ strcpy( Debugger, "" );
+ // MultiByteToWideChar( CP_ACP, 0, "", 0, Debugger, sizeof(Debugger) );
+ else
+ strcpy( Debugger, argv[i] );
+ // MultiByteToWideChar( CP_ACP, 0, argv[i], strlen(argv[i], Debugger,
+ // sizeof(Debugger) );
+ if (WhatTest = lots_wt)
+ WhatTest = none_wt;
+ }
+
+ else if (_stricmp( argv[i], "-Embedding" ) == 0)
+ WhatTest = server_wt;
+
+ else if (_stricmp( argv[i], "-i" ) == 0)
+ {
+ if (argv[++i] == NULL)
+ {
+ printf( "You must include an iteration count after the -i option.\n" );
+ return FALSE;
+ }
+ sscanf( argv[i], "%d", &NumIterations );
+ }
+
+ else if (_stricmp( argv[i], "Hook" ) == 0)
+ WhatTest = hook_wt;
+
+ else if (_stricmp( argv[i], "-legacy" ) == 0)
+ GlobalSecurityModel = legacy_sm;
+
+ else if (_stricmp( argv[i], "load_client" ) == 0)
+ WhatTest = load_client_wt;
+
+ else if (_stricmp( argv[i], "Load_Server" ) == 0)
+ WhatTest = load_server_wt;
+
+ else if (_stricmp( argv[i], "Mmarshal" ) == 0)
+ WhatTest = mmarshal_wt;
+
+ else if (_stricmp( argv[i], "Multi" ) == 0)
+ ThreadMode = COINIT_MULTITHREADED;
+
+ else if (_stricmp( argv[i], "-n" ) == 0)
+ {
+ if (argv[++i] == NULL)
+ {
+ printf( "You must include a name after the -n option.\n" );
+ return FALSE;
+ }
+ MultiByteToWideChar( CP_ACP, 0, argv[i], strlen(argv[i]), Name,
+ sizeof(Name) );
+ Name[strlen(argv[i])] = 0;
+ }
+
+ else if (_stricmp( argv[i], "Null" ) == 0)
+ WhatTest = null_wt;
+
+ else if (_stricmp( argv[i], "One" ) == 0)
+ WhatTest = one_wt;
+
+ else if (_stricmp( argv[i], "Perf" ) == 0)
+ WhatTest = perf_wt;
+
+ else if (_stricmp( argv[i], "PerfRemote" ) == 0)
+ WhatTest = perfremote_wt;
+
+ else if (_stricmp( argv[i], "PerfRpc" ) == 0)
+ WhatTest = perfrpc_wt;
+
+ else if (_stricmp( argv[i], "PerfSec" ) == 0)
+ WhatTest = perfsec_wt;
+
+ else if (_stricmp( argv[i], "Post" ) == 0)
+ WhatTest = post_wt;
+
+ else if (_stricmp( argv[i], "-o" ) == 0)
+ {
+ if (argv[++i] == NULL)
+ {
+ printf( "You must include an object count after the -o option.\n" );
+ return FALSE;
+ }
+ sscanf( argv[i], "%d", &NumObjects );
+ }
+
+ else if (_stricmp( argv[i], "-o" ) == 0)
+ {
+ if (argv[++i] == NULL)
+ {
+ printf( "You must include an object count after the -o option.\n" );
+ return FALSE;
+ }
+ sscanf( argv[i], "%d", &NumObjects );
+ }
+
+ else if (_stricmp( argv[i], "-p" ) == 0)
+ {
+ if (argv[++i] == NULL)
+ {
+ printf( "You must include a process count after the -p option.\n" );
+ return FALSE;
+ }
+ sscanf( argv[i], "%d", &NumProcesses );
+ }
+
+ else if (_stricmp( argv[i], "-popup" ) == 0)
+ Popup = TRUE;
+
+ else if (_stricmp( argv[i], "-r" ) == 0)
+ {
+ if (argv[++i] == NULL)
+ {
+ printf( "You must include a recursion count after the -r option.\n" );
+ return FALSE;
+ }
+ sscanf( argv[i], "%d", &NumRecursion );
+ }
+
+ else if (_stricmp( argv[i], "Reject" ) == 0)
+ WhatTest = reject_wt;
+
+ else if (_stricmp( argv[i], "Remote_client" ) == 0)
+ WhatTest = remote_client_wt;
+
+ else if (_stricmp( argv[i], "Remote_server" ) == 0)
+ WhatTest = remote_server_wt;
+
+ else if (_stricmp( argv[i], "Ring" ) == 0)
+ WhatTest = ring_wt;
+
+ else if (_stricmp( argv[i], "Rpc" ) == 0)
+ WhatTest = rpc_wt;
+
+ else if (_stricmp( argv[i], "Rundown" ) == 0)
+ WhatTest = rundown_wt;
+
+ else if (_stricmp( argv[i], "-s" ) == 0)
+ {
+ if (argv[++i] == NULL)
+ {
+ printf( "You must include a protocol sequence after the -s option.\n" );
+ return FALSE;
+ }
+ MultiByteToWideChar( CP_ACP, 0, argv[i], strlen(argv[i]), TestProtseq,
+ sizeof(TestProtseq) );
+ TestProtseq[strlen(argv[i])] = 0;
+ }
+
+ else if (_stricmp( argv[i], "Security" ) == 0)
+ WhatTest = security_wt;
+
+ else if (_stricmp( argv[i], "SecureRefs" ) == 0)
+ WhatTest = securerefs_wt;
+
+ else if (_stricmp( argv[i], "Send" ) == 0)
+ WhatTest = send_wt;
+
+ else if (_stricmp( argv[i], "-t" ) == 0)
+ {
+ if (argv[++i] == NULL)
+ {
+ printf( "You must include a thread count after the -t option.\n" );
+ return FALSE;
+ }
+ sscanf( argv[i], "%d", &NumThreads );
+ }
+
+ else if (_stricmp( argv[i], "sid" ) == 0)
+ WhatTest = sid_wt;
+
+ else if (_stricmp( argv[i], "Simple_rundown" ) == 0)
+ WhatTest = simple_rundown_wt;
+
+ else if (_stricmp( argv[i], "Thread" ) == 0)
+ WhatTest = thread_wt;
+
+ else if (_stricmp( argv[i], "Three" ) == 0)
+ WhatTest = three_wt;
+
+ else if (_stricmp( argv[i], "Two" ) == 0)
+ WhatTest = two_wt;
+
+ else if (_stricmp( argv[i], "Uninit" ) == 0)
+ WhatTest = uninit_wt;
+
+ else if (_stricmp( argv[i], "Unknown" ) == 0)
+ WhatTest = unknown_wt;
+
+ else
+ {
+ printf( "You don't know what you are doing!\n" );
+ printf( "This program tests the channel.\n" );
+ printf( "\n" );
+ printf( "Apartment Apartment threading mode.\n" );
+ printf( "Cancel Cancel test.\n" );
+ printf( "Crash Crash test.\n" );
+ printf( "Cstress Cancel stress test.\n" );
+ printf( "Hook Channel hook test.\n" );
+ printf( "Load_Client Remote load performance - client.\n" );
+ printf( "Load_Server Remote load performance - server.\n" );
+ printf( "Mmarshal Multiple marshal test.\n" );
+ printf( "Multi Multithreaded mode.\n" );
+ printf( "Null Apartment null call test.\n" );
+ printf( "One Used for testing new tests.\n" );
+ printf( "Perf Performance test.\n" );
+ printf( "PerfRemote Remote call performance test.\n" );
+ printf( "PerfRpc Raw RPC performance test.\n" );
+ printf( "PerfSec Security performance test.\n" );
+ printf( "Post Post a message to window specified by -i.\n" );
+ printf( "Reject Reject test.\n" );
+ printf( "Remote_Client Remote performance - client.\n" );
+ printf( "Remote_Server Remote performance - server.\n" );
+ printf( "Ring Run ring test.\n" );
+ printf( "Rpc Test both RPC and OLE calls.\n" );
+ printf( "Rundown Rundown test.\n" );
+ printf( "SecureRefs Secure Addref/Release Test.\n" );
+ printf( "Security Security test.\n" );
+ printf( "Send Send a message to window specified by -i.\n" );
+ printf( "Sid Lookup the sid for the name specified by -n\n" );
+ printf( "Simple_Rundown Wait for object exporter to timeout.\n" );
+ printf( "Thread Calling on multiple threads.\n" );
+ printf( "Three Used for reproducing bugs.\n" );
+ printf( "Two Used for reproducing bugs.\n" );
+ printf( "Uninit Calls during uninitialization.\n" );
+ printf( "Unknown IUnknown security.\n" );
+ printf( "\n" );
+ printf( "-auto n Use automatic security set to level n.\n" );
+ printf( "-b Stop in debugger before going on.\n" );
+ printf( "-basic Use basic security.\n" );
+ printf( "-c Change the test.\n" );
+ printf( "-d debugger Debugger to run app under of none.\n" );
+ printf( "-Embedding Server side.\n" );
+ printf( "-legacy Use legacy security.\n" );
+ printf( "-i n Number of iterations.\n" );
+ printf( "-n name String name.\n" );
+ printf( "-o n Number of objects.\n" );
+ printf( "-p n Number of processes.\n" );
+ printf( "-popup Display popups for sync during test.\n" );
+ printf( "-r n Number of recursions.\n" );
+ printf( "-s protseq Change default protocol sequence.\n" );
+ printf( "-t n Number of threads.\n" );
+ printf( "\n" );
+ printf( "The test currently only runs in the single threaded mode\n" );
+ printf( "and requires the apartment model.\n" );
+ printf( "If no test is specified the cancel, crash, null,\n" );
+ printf( "ring, and rundown tests will be run. The options have the\n" );
+ printf( "following default values.\n" );
+ printf( " authn level - %d\n", GlobalAuthnLevel );
+ printf( " iterations - 1000\n" );
+ printf( " name - %ws\n", Name );
+ printf( " objects - 2\n" );
+ printf( " processes - 2\n" );
+ printf( " recurse - 2\n" );
+ printf( " protseq - %ws\n", TestProtseq );
+ printf( " security model - %d\n", GlobalSecurityModel );
+ printf( " threads - 2\n" );
+ return FALSE;
+ }
+ }
+
+ // Figure out the class id based on the thread model and security model.
+ if (GlobalSecurityModel == auto_sm)
+ if (GlobalAuthnLevel == RPC_C_AUTHN_LEVEL_CONNECT)
+ i = 1;
+ else if (GlobalAuthnLevel == RPC_C_AUTHN_LEVEL_PKT_INTEGRITY)
+ i = 2;
+ else
+ i = 0;
+ else if (GlobalSecurityModel == basic_sm)
+ i = 3;
+ else
+ i = 4;
+ if (ThreadMode == COINIT_MULTITHREADED)
+ ServerClsid = &ClassIds[free_auto_none+i];
+ else
+ ServerClsid = &ClassIds[apt_auto_none+i];
+
+ return TRUE;
+}
+
+ /***************************************************************************/
+BOOL registry_setup( char *argv0 )
+{
+ char value[REGISTRY_ENTRY_LEN];
+ LONG value_size;
+ LONG result;
+ char directory[MAX_PATH];
+ char *appname;
+ int i;
+ int j;
+ char *class_id;
+ HKEY key = NULL;
+ DWORD ignore;
+ SECURITY_DESCRIPTOR *sec;
+
+ // Find out if the registry is setup.
+ value_size = sizeof(value);
+ result = RegQueryValueA(
+ HKEY_CLASSES_ROOT,
+ REG_CLASS_EXE,
+ value,
+ &value_size );
+
+ // If the registry is not setup or needs to be rewritten, write it.
+ if (result != ERROR_SUCCESS || WriteClass)
+ {
+ // Write all the interface ids.
+ for (i = 0; i < NUM_INTERFACE_IDS; i++)
+ {
+ // Write the interface name.
+ strcpy( value, "Interface\\{60000200-76d7-11cf-9af1-0020af6e72f4}" );
+ value[18] += i;
+ result = RegSetValueA(
+ HKEY_CLASSES_ROOT,
+ value,
+ REG_SZ,
+ REG_INTERFACE_NAME[i],
+ strlen(REG_INTERFACE_NAME[i]) );
+ ASSERT( result, "Could not set interface name: 0x%x" );
+
+ // Write the interface to proxy class id translation.
+ strcpy( value, "Interface\\{60000200-76d7-11cf-9af1-0020af6e72f4}\\ProxyStubClsid32" );
+ value[18] += i;
+ result = RegSetValueA(
+ HKEY_CLASSES_ROOT,
+ value,
+ REG_SZ,
+ REG_INTERFACE_CLASS,
+ strlen(REG_INTERFACE_CLASS) );
+ ASSERT( result, "Could not set interface class: 0x%x" );
+ }
+
+ // Write the proxy name.
+ result = RegSetValueA(
+ HKEY_CLASSES_ROOT,
+ "CLSID\\{60000200-76d7-11cf-9af1-0020af6e72f4}",
+ REG_SZ,
+ REG_PROXY_NAME,
+ strlen(REG_PROXY_NAME) );
+ ASSERT( result, "Could not set interface name: 0x%x" );
+
+ // Compute the path to the application.
+ result = GetFullPathNameA( argv0, sizeof(directory), directory, &appname );
+ ASSERT_EXPR( result != 0, "Could not GetFullPathName." );
+ result = appname - directory;
+ if (result + strlen(REG_PROXY_DLL) > MAX_PATH ||
+ result + strlen(REG_APP_EXE) + strlen(Debugger) > MAX_PATH)
+ {
+ printf( "Buffer too small.\n" );
+ goto cleanup;
+ }
+
+ // Write the proxy dll path.
+ strcpy( appname, REG_PROXY_DLL );
+ result = RegSetValueA(
+ HKEY_CLASSES_ROOT,
+ "CLSID\\{60000200-76d7-11cf-9af1-0020af6e72f4}\\InprocServer32",
+ REG_SZ,
+ directory,
+ strlen(directory) );
+ ASSERT( result, "Could not set interface name: 0x%x" );
+
+ // Open the registry key for the app id.
+ result = RegCreateKeyExA( HKEY_CLASSES_ROOT,
+ "AppID\\{60000200-76d7-11cf-9af1-0020af6e72f4}",
+ NULL,
+ NULL,
+ REG_OPTION_NON_VOLATILE,
+ KEY_READ | KEY_WRITE,
+ NULL,
+ &key,
+ &ignore );
+ ASSERT( result, "Could not create app id key: 0x%x" );
+
+ // Write the app id.
+ result = RegSetValueExA(
+ key,
+ NULL,
+ NULL,
+ REG_SZ,
+ (UCHAR *) REG_APPID_NAME,
+ strlen(REG_APPID_NAME) );
+ ASSERT( result, "Could not set app id name: 0x%x" );
+
+ // Make a simple security descriptor allowing everyone access.
+ i = GetLengthSid( ProcessSid );
+ sec = (SECURITY_DESCRIPTOR *) CoTaskMemAlloc( sizeof(SECURITY_DESCRIPTOR) +
+ i*2 );
+ ASSERT_EXPR( sec != NULL, "Could not allocate memory." );
+ sec->Revision = SECURITY_DESCRIPTOR_REVISION;
+ sec->Sbz1 = 0;
+ sec->Control = SE_SELF_RELATIVE;
+ sec->Owner = (SID *) sizeof(SECURITY_DESCRIPTOR);
+ sec->Group = (SID *) (sizeof(SECURITY_DESCRIPTOR) + i);
+ sec->Sacl = NULL;
+ sec->Dacl = NULL;
+ memcpy( sec+1, ProcessSid, i );
+ memcpy( ((char *) (sec+1)) + i, ProcessSid, i );
+
+ // Write the launch permissions.
+ result = RegSetValueExA(
+ key,
+ "LaunchPermission",
+ NULL,
+ REG_BINARY,
+ (UCHAR *) sec,
+ sizeof(SECURITY_DESCRIPTOR) + 2*i );
+ ASSERT( result, "Could not set launch permissions: 0x%x" );
+
+ // Write the access permissions.
+ result = RegSetValueExA(
+ key,
+ "AccessPermission",
+ NULL,
+ REG_BINARY,
+ (UCHAR *) sec,
+ sizeof(SECURITY_DESCRIPTOR) + 2*i );
+ ASSERT( result, "Could not set access permissions: 0x%x" );
+
+ // Write the value to run as logged on user.
+ result = RegSetValueExA(
+ key,
+ "RunAs",
+ NULL,
+ REG_SZ,
+ (unsigned char *) REG_LOGGED_ON,
+ strlen(REG_LOGGED_ON) );
+ ASSERT( result, "Could not set RunAs value: 0x%x" );
+ RegCloseKey( key );
+ key = NULL;
+
+ // Open the registry key for the module name.
+ result = RegCreateKeyExA( HKEY_CLASSES_ROOT,
+ "AppID\\app.exe",
+ NULL,
+ NULL,
+ REG_OPTION_NON_VOLATILE,
+ KEY_READ | KEY_WRITE,
+ NULL,
+ &key,
+ &ignore );
+ ASSERT( result, "Could not create module name key: 0x%x" );
+
+ // Write the app id under the module name.
+ result = RegSetValueExA(
+ key,
+ "AppID",
+ NULL,
+ REG_SZ,
+ (unsigned char *) REG_INTERFACE_CLASS,
+ strlen(REG_INTERFACE_CLASS) );
+ ASSERT( result, "Could not set appid value: 0x%x" );
+ RegCloseKey( key );
+ key = NULL;
+
+ // Compute the base application execution command.
+ strcpy( appname, REG_APP_EXE );
+ i = strlen( Debugger );
+ if (i != 0)
+ Debugger[i++] = ' ';
+ strcpy( &Debugger[i], directory );
+ i = strlen( Debugger );
+
+ // Allocate strings for the class id name keys.
+ class_id = (char *) _alloca( strlen(REG_CLASS_ID) + 1 );
+ if (class_id == NULL)
+ {
+ printf( "Could not _alloca string space.\n" );
+ return FALSE;
+ }
+ strcpy( class_id, REG_CLASS_ID );
+
+ // Write all the class ids.
+ for (j = 0; j < NUM_CLASS_IDS; j++)
+ {
+ // Adjust the id in the class strings.
+ class_id[14] = '0'+j;
+
+ // Open the registry key for the app id.
+ result = RegCreateKeyExA( HKEY_CLASSES_ROOT,
+ class_id,
+ NULL,
+ NULL,
+ REG_OPTION_NON_VOLATILE,
+ KEY_READ | KEY_WRITE,
+ NULL,
+ &key,
+ &ignore );
+ ASSERT( result, "Could not create class id key: 0x%x" );
+
+ // Write the application class name for the apartment class.
+ result = RegSetValueExA(
+ key,
+ NULL,
+ NULL,
+ REG_SZ,
+ (UCHAR *) REG_APP_NAME[j],
+ strlen(REG_APP_NAME[j]) );
+ ASSERT( result, "Could not set interface name: 0x%x" );
+
+ // Write the application path.
+ strcpy( &Debugger[i], REG_APP_OPTIONS[j] );
+ result = RegSetValueA(
+ key,
+ "LocalServer32",
+ REG_SZ,
+ Debugger,
+ strlen(Debugger) );
+ ASSERT( result, "Could not set app exe: 0x%x" );
+
+ // Write the application id value.
+ result = RegSetValueExA(
+ key,
+ "AppID",
+ NULL,
+ REG_SZ,
+ (unsigned char *) REG_INTERFACE_CLASS,
+ strlen(REG_INTERFACE_CLASS) );
+ ASSERT( result, "Could not set appid value: 0x%x" );
+ RegCloseKey( key );
+ key = NULL;
+ }
+ }
+
+ return TRUE;
+
+cleanup:
+ if (key != NULL)
+ RegCloseKey( key );
+ return FALSE;
+}
+
+ /***************************************************************************/
+void reinitialize()
+{
+ HRESULT result;
+ SAptData *mine;
+
+ // Get the apartment specific data.
+ if (ThreadMode == COINIT_MULTITHREADED)
+ mine = &ProcessAptData;
+ else
+ mine = (SAptData *) TlsGetValue( TlsIndex );
+ mine->what_next = quit_wn;
+
+ // Revoke the class factory.
+ ClassFactory->AddRef();
+ result = CoRevokeClassObject(Registration);
+ if (!SUCCEEDED(result))
+ {
+ printf( "CoRevokeClassObject failed: %x\n", result );
+ return;
+ }
+
+ // Reinitialize.
+ CoUninitialize();
+ result = initialize(NULL,ThreadMode);
+ if (!SUCCEEDED(result))
+ {
+ printf( "Could not reinitialize server: 0x%x\n", result );
+ return;
+ }
+
+ // Register our class with OLE
+ result = CoRegisterClassObject(*ServerClsid, ClassFactory, CLSCTX_LOCAL_SERVER,
+ REGCLS_SINGLEUSE, &Registration);
+ if (!SUCCEEDED(result))
+ {
+ printf( "CoRegisterClassObject failed: %x\n", result );
+ return;
+ }
+
+ // Make the server loop think we've started over.
+ mine->what_next = setup_wn;
+ mine->object_count = 0;
+}
+
+ /***************************************************************************/
+void server_loop( )
+{
+ register SAptData *mine;
+
+ // Get the apartment specific data.
+ if (ThreadMode == COINIT_MULTITHREADED)
+ mine = &ProcessAptData;
+ else
+ mine = (SAptData *) TlsGetValue( TlsIndex );
+
+ // Do whatever we have to do till it is time to pay our taxes and die.
+ while ((mine->what_next == setup_wn || mine->object_count > 0) &&
+ mine->what_next != quit_wn)
+ switch (mine->what_next)
+ {
+
+ // Wait till a quit arrives.
+ case setup_wn:
+ case wait_wn:
+ wait_for_message();
+ break;
+
+ case callback_wn:
+ callback();
+ mine->what_next = wait_wn;
+ break;
+
+ case catch_wn:
+ __try
+ {
+ mine->what_next = wait_wn;
+ server_loop();
+ }
+ __except(EXCEPTION_EXECUTE_HANDLER)
+ {
+ printf( "Caught exception at top of thread 0x%x\n",
+ GetCurrentThreadId() );
+ mine->what_next = crippled_wn;
+ }
+ break;
+
+ case crippled_wn:
+ crippled();
+ break;
+
+ case interrupt_wn:
+ interrupt();
+ break;
+
+ case interrupt_marshal_wn:
+ interrupt_marshal();
+ break;
+
+ case reinitialize_wn:
+ reinitialize();
+ break;
+
+ case rest_and_die_wn:
+ Sleep(5000);
+ mine->what_next = quit_wn;
+ break;
+ }
+}
+
+
+ /***************************************************************************/
+void switch_test()
+{
+ switch (WhatTest)
+ {
+ case cancel_wt:
+ do_cancel();
+ break;
+
+ case crash_wt:
+ do_crash();
+ break;
+
+ case cstress_wt:
+ do_cstress();
+ break;
+
+ case hook_wt:
+ do_hook();
+ break;
+
+ case load_client_wt:
+ do_load_client();
+ break;
+
+ case load_server_wt:
+ do_load_server();
+ break;
+
+ case lots_wt:
+ do_lots();
+ break;
+
+ case mmarshal_wt:
+ do_mmarshal();
+ break;
+
+ case none_wt:
+ break;
+
+ case null_wt:
+ do_null();
+ break;
+
+ case one_wt:
+ do_one();
+ break;
+
+ case perf_wt:
+ do_perf();
+ break;
+
+ case perfremote_wt:
+ do_perfremote();
+ break;
+
+ case perfrpc_wt:
+ do_perfrpc();
+ break;
+
+ case perfsec_wt:
+ do_perfsec();
+ break;
+
+ case post_wt:
+ do_post();
+ break;
+
+ case reject_wt:
+ do_reject();
+ break;
+
+ case remote_client_wt:
+ do_remote_client();
+ break;
+
+ case remote_server_wt:
+ do_remote_server();
+ break;
+
+ case ring_wt:
+ do_ring();
+ break;
+
+ case rpc_wt:
+ do_rpc();
+ break;
+
+ case rundown_wt:
+ do_rundown();
+ break;
+
+ case securerefs_wt:
+ do_securerefs();
+ break;
+
+ case security_wt:
+ do_security();
+ break;
+
+ case send_wt:
+ do_send();
+ break;
+
+ case server_wt:
+ do_server();
+ break;
+
+ case sid_wt:
+ do_sid();
+ break;
+
+ case simple_rundown_wt:
+ do_simple_rundown();
+ break;
+
+ case thread_wt:
+ do_thread();
+ break;
+
+ case three_wt:
+ do_three();
+ break;
+
+ case two_wt:
+ do_two();
+ break;
+
+ case uninit_wt:
+ do_uninit();
+ break;
+
+ case unknown_wt:
+ do_unknown();
+ break;
+
+ default:
+ printf( "I don't know what to do - %d\n", WhatTest );
+ break;
+ }
+}
+
+ /***************************************************************************/
+DWORD _stdcall thread_helper( void *param )
+{
+ ITest *test = (ITest *) param;
+ HRESULT result;
+
+ // Call the server.
+ result = test->sleep( 2000 );
+
+ // Check the result for multithreaded mode.
+ if (ThreadMode == COINIT_MULTITHREADED)
+ {
+ if (result != S_OK)
+ {
+ printf( "Could not make multiple calls in multithreaded mode: 0x%x\n",
+ result );
+ Multicall_Test = FALSE;
+ }
+ }
+
+ // Check the result for single threaded mode.
+ else
+ {
+ if (SUCCEEDED(result))
+ {
+ Multicall_Test = FALSE;
+ printf( "Call succeeded on wrong thread in single threaded mode: 0x%x.\n",
+ result );
+ }
+#if NEVER
+ 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
+ }
+
+#define DO_DA 42
+ return DO_DA;
+}
+
+ /***************************************************************************/
+DWORD _stdcall status_helper( void *param )
+{
+ long num_calls;
+ long num_clients;
+ long total_clients;
+ DWORD last_time;
+ DWORD this_time;
+ DWORD rate;
+
+ // Wake up periodically and print statistics.
+ last_time = GetTickCount();
+ while (TRUE)
+ {
+ Sleep( STATUS_DELAY );
+ num_calls = InterlockedExchange( &GlobalCalls, 0 );
+ num_clients = GlobalClients;
+ total_clients = GlobalTotal;
+ this_time = GetTickCount();
+ if (num_calls != 0)
+ rate = (this_time - last_time)*1000/num_calls;
+ else
+ rate = 99999999;
+ printf( "Time: %d Calls: %d Clients: %d Total Clients: %d uSec/Call: %d\n",
+ this_time - last_time, num_calls, num_clients, total_clients,
+ rate );
+ last_time = this_time;
+ }
+ return 0;
+}
+
+ /***************************************************************************/
+HRESULT switch_thread( SIMPLE_FN fn, void *param )
+{
+ MSG msg;
+
+ if (ThreadMode == COINIT_MULTITHREADED)
+ {
+ fn( param );
+ return S_OK;
+ }
+ else
+ {
+ if (PostThreadMessage( GlobalThreadId, WM_USER+1, (unsigned int) fn,
+ (long) param ))
+ {
+ GetMessage( &msg, NULL, 0, 0 );
+ return S_OK;
+ }
+ else
+ return E_FAIL;
+ }
+}
+
+ /***************************************************************************/
+void thread_get_interface_buffer( void *p )
+{
+ SGetInterface *getif = (SGetInterface *) p;
+ HANDLE memory = NULL;
+ IStream *stream = NULL;
+ LARGE_INTEGER pos;
+ DWORD size;
+ void *objref;
+ WCHAR name[MAX_COMPUTERNAME_LENGTH+1];
+ DWORD name_size = sizeof(name)/sizeof(WCHAR);
+
+ // Find out how much memory to allocate.
+ getif->status = RPC_S_OUT_OF_RESOURCES;
+ getif->status = CoGetMarshalSizeMax( (unsigned long *) getif->buf_size,
+ IID_ITest, GlobalTest,
+ MSHCTX_DIFFERENTMACHINE,
+ NULL,
+ MSHLFLAGS_NORMAL );
+ ASSERT( getif->status, "Could not marshal server object" );
+
+ // Add the size of the long form extension.
+ ASSERT_EXPR( GetComputerName( name, &name_size ), "Could not get computer name." );
+ *getif->buf_size += 20 + 2*name_size*sizeof(WCHAR);
+
+ // Allocate memory.
+ memory = GlobalAlloc( GMEM_FIXED, *getif->buf_size );
+ ASSERT_EXPR( memory != NULL, "Could not allocate memory." );
+
+ // Create a stream.
+ getif->status = CreateStreamOnHGlobal( memory, TRUE, &stream );
+ ASSERT( getif->status, "Could not create stream" );
+
+ // Marshal the object.
+ getif->status = CoMarshalInterface( stream, IID_ITest, GlobalTest,
+ MSHCTX_DIFFERENTMACHINE,
+ NULL,
+ MSHLFLAGS_NORMAL );
+ ASSERT( getif->status, "Could not marshal object" );
+
+ // Find the object reference in the stream.
+ objref = (void *) GlobalLock( memory );
+
+ // Allocate a buffer for MIDL.
+ *getif->buffer = (unsigned char *) midl_user_allocate( *getif->buf_size );
+ ASSERT_EXPR( *getif->buffer != NULL, "Could not allocate MIDL memory." );
+
+ // Copy the stream to the buffer.
+ memcpy( *getif->buffer, objref, *getif->buf_size );
+ GlobalUnlock( memory );
+
+ // Make sure that the original reference to the object gets released once.
+ if (InterlockedExchange( &GlobalFirst, FALSE ) == TRUE)
+ GlobalTest->Release();
+
+ // Return the buffer.
+ getif->status = RPC_S_OK;
+cleanup:
+ if (stream != NULL)
+ stream->Release();
+ PostThreadMessage( getif->thread, WM_USER, 0, 0 );
+}
+
+ /***************************************************************************/
+void __RPC_USER transmit_crash_to_xmit( transmit_crash __RPC_FAR *c, DWORD __RPC_FAR * __RPC_FAR *x )
+{
+
+ *x = (DWORD *) CoTaskMemAlloc( 4 );
+ **x = 1 / *c;
+ *c -= 1;
+}
+
+ /***************************************************************************/
+void __RPC_USER transmit_crash_from_xmit( DWORD __RPC_FAR *x, transmit_crash __RPC_FAR *c )
+{
+ *c = *x;
+}
+
+ /***************************************************************************/
+void __RPC_USER transmit_crash_free_inst( transmit_crash __RPC_FAR *x )
+{
+}
+
+ /***************************************************************************/
+void __RPC_USER transmit_crash_free_xmit( DWORD __RPC_FAR *x )
+{
+ CoTaskMemFree( x );
+}
+
+ /***************************************************************************/
+void wait_for_message()
+{
+ MSG msg;
+ DWORD status;
+
+ if (ThreadMode == COINIT_MULTITHREADED)
+ {
+ status = WaitForSingleObject( Done, INFINITE );
+ if (status != WAIT_OBJECT_0 )
+ {
+ printf( "Could not wait for event.\n" );
+ }
+ }
+ else
+ {
+ if (GetMessageA( &msg, NULL, 0, 0 ))
+ {
+ if (msg.hwnd == NULL && msg.message == WM_USER+1)
+ ((SIMPLE_FN) msg.wParam)( (void *) msg.lParam );
+ else
+ {
+ TranslateMessage (&msg);
+ DispatchMessageA (&msg);
+ }
+ }
+ }
+}
+
+ /***************************************************************************/
+void wake_up_and_smell_the_roses()
+{
+ if (ThreadMode == COINIT_MULTITHREADED)
+ SetEvent( Done );
+}
+
+ /***************************************************************************/
+void what_next( what_next_en what )
+{
+ if (ThreadMode == COINIT_MULTITHREADED)
+ {
+ ProcessAptData.what_next = what;
+ }
+ else
+ {
+ SAptData *tls_data = (SAptData *) TlsGetValue( TlsIndex );
+ tls_data->what_next = what;
+ }
+}
+
+ /***************************************************************************/
+unsigned long xacl_call( handle_t binding )
+{
+ RPC_STATUS status;
+ RPC_STATUS status2;
+ BOOL success;
+ DWORD granted_access;
+ BOOL access;
+ BOOL ignore;
+ HANDLE token;
+ PRIVILEGE_SET privilege;
+ DWORD privilege_size = sizeof(privilege);
+ GENERIC_MAPPING gmap;
+ LARGE_INTEGER start;
+ LARGE_INTEGER impersonate;
+ LARGE_INTEGER open;
+ LARGE_INTEGER accesscheck;
+ LARGE_INTEGER close;
+ LARGE_INTEGER revert;
+ LARGE_INTEGER freq;
+
+#if 0
+ QueryPerformanceCounter( &start );
+#endif
+ status = RpcImpersonateClient( binding );
+#if 0
+ QueryPerformanceCounter( &impersonate );
+#endif
+ if (status == RPC_S_OK)
+ {
+ // Get the thread token.
+ success = OpenThreadToken( GetCurrentThread(), TOKEN_READ,
+ TRUE, &token );
+#if 0
+ QueryPerformanceCounter( &open );
+#endif
+ if (!success)
+ {
+ printf( "Could not OpenThreadToken.\n" );
+ status = E_FAIL;
+ }
+
+ // Check access.
+ else
+ {
+ gmap.GenericRead = READ_CONTROL;
+ gmap.GenericWrite = READ_CONTROL;
+ gmap.GenericExecute = READ_CONTROL;
+ gmap.GenericAll = READ_CONTROL;
+ privilege.PrivilegeCount = 1;
+ privilege.Control = 0;
+ success = AccessCheck( GlobalSecurityDescriptor, token, READ_CONTROL,
+ &gmap, &privilege, &privilege_size,
+ &granted_access, &access );
+#if 0
+ QueryPerformanceCounter( &accesscheck );
+#endif
+
+ if (!success)
+ {
+ printf( "Bad parameters to AccessCheck: 0x%x.\n",
+ GetLastError() );
+ status = E_FAIL;
+ }
+ else if (!access)
+ {
+ printf( "Could not get access.\n" );
+ status = ERROR_ACCESS_DENIED;
+ }
+ CloseHandle( token );
+#if 0
+ QueryPerformanceCounter( &close );
+#endif
+ }
+ status2 = RpcRevertToSelf();
+#if 0
+ QueryPerformanceCounter( &revert );
+ QueryPerformanceFrequency( &freq );
+ start.QuadPart = 1000000 * (impersonate.QuadPart - start.QuadPart) / freq.QuadPart;
+ printf( "RpcImpersonateClient took %duS\n", start.u.LowPart );
+ impersonate.QuadPart = 1000000 * (open.QuadPart - impersonate.QuadPart) / freq.QuadPart;
+ printf( "OpenThreadToken took %duS\n", impersonate.u.LowPart );
+ open.QuadPart = 1000000 * (accesscheck.QuadPart - open.QuadPart) / freq.QuadPart;
+ printf( "AccessCheckAndAuditAlarm took %duS\n", open.u.LowPart );
+ accesscheck.QuadPart = 1000000 * (close.QuadPart - accesscheck.QuadPart) / freq.QuadPart;
+ printf( "CloseHandle took %duS\n", accesscheck.u.LowPart );
+ close.QuadPart = 1000000 * (revert.QuadPart - close.QuadPart) / freq.QuadPart;
+ printf( "RpcRevertToSelf took %duS\n", close.u.LowPart );
+#endif
+ if (status2 != RPC_S_OK)
+ status = status2;
+ }
+
+ return status;
+}
+
+ /***************************************************************************/
+unsigned long xaudit_call( handle_t binding )
+{
+ RPC_STATUS status;
+ RPC_STATUS status2;
+ BOOL success;
+ DWORD granted_access;
+ BOOL access;
+ BOOL ignore;
+ HANDLE token;
+ GENERIC_MAPPING gmap;
+ LARGE_INTEGER start;
+ LARGE_INTEGER impersonate;
+ LARGE_INTEGER accesscheck;
+ LARGE_INTEGER revert;
+ LARGE_INTEGER freq;
+
+#if 0
+ QueryPerformanceCounter( &start );
+#endif
+ status = RpcImpersonateClient( binding );
+#if 0
+ QueryPerformanceCounter( &impersonate );
+#endif
+ if (status == RPC_S_OK)
+ {
+ // Check access and do audits.
+ gmap.GenericRead = READ_CONTROL;
+ gmap.GenericWrite = READ_CONTROL;
+ gmap.GenericExecute = READ_CONTROL;
+ gmap.GenericAll = READ_CONTROL;
+ success = AccessCheckAndAuditAlarm( L"Test",
+ NULL,
+ L"Test Type Name",
+ L"Test Name",
+ GlobalSecurityDescriptor,
+ READ_CONTROL,
+ &gmap,
+ FALSE,
+ &granted_access,
+ &access,
+ &ignore );
+#if 0
+ QueryPerformanceCounter( &accesscheck );
+#endif
+ if (!success)
+ {
+ printf( "Bad parameters to AccessCheckAndAuditAlarm: 0x%x.\n",
+ GetLastError() );
+ status = E_FAIL;
+ }
+ else if (!access)
+ {
+ printf( "Could not get access.\n" );
+ status = E_FAIL;
+ }
+ status2 = RpcRevertToSelf();
+#if 0
+ QueryPerformanceCounter( &revert );
+ QueryPerformanceFrequency( &freq );
+ start.QuadPart = 1000000 * (impersonate.QuadPart - start.QuadPart) / freq.QuadPart;
+ printf( "RpcImpersonateClient took %duS\n", start.u.LowPart );
+ impersonate.QuadPart = 1000000 * (accesscheck.QuadPart - impersonate.QuadPart) / freq.QuadPart;
+ printf( "AccessCheckAndAuditAlarm took %duS\n", impersonate.u.LowPart );
+ accesscheck.QuadPart = 1000000 * (revert.QuadPart - accesscheck.QuadPart) / freq.QuadPart;
+ printf( "RpcRevertToSelf took %duS\n", accesscheck.u.LowPart );
+#endif
+ if (status2 != RPC_S_OK)
+ status = status2;
+ }
+
+ return status;
+}
+
+ /***************************************************************************/
+unsigned long xcheck_client( handle_t binding, error_status_t *error_status )
+{
+ HANDLE client_token = NULL;
+ HANDLE server_token = NULL;
+ TOKEN_USER *client_sid;
+ TOKEN_USER *server_sid;
+ DWORD count;
+ char buffer1[100];
+ char buffer2[100];
+ HRESULT result = S_OK;
+ RPC_STATUS status;
+ HANDLE process = NULL;
+
+ // Get this process's security token.
+ *error_status = RPC_S_OK;
+ if (!OpenProcessToken( GetCurrentProcess(), TOKEN_QUERY, &server_token ))
+ {
+ printf( "Could not GetProcessToken: 0x%x\n", GetLastError() );
+ result = E_FAIL;
+ goto cleanup;
+ }
+
+ // Get the token's user id.
+ if (!GetTokenInformation( server_token, TokenUser, &buffer1, sizeof(buffer1),
+ &count ))
+ {
+ printf( "Could not GetTokenInformation: 0x%x\n", GetLastError() );
+ result = E_FAIL;
+ goto cleanup;
+ }
+ server_sid = (TOKEN_USER *) &buffer1;
+
+ // Impersonate the client.
+ status = RpcImpersonateClient( binding );
+ if (status != RPC_S_OK)
+ {
+ printf( "Could not impersonate client: 0x%x\n", status );
+ result = MAKE_WIN32( status );
+ goto cleanup;
+ }
+
+ // Get the clients security token.
+ if (!OpenThreadToken( GetCurrentThread(), TOKEN_QUERY, FALSE, &client_token ))
+ {
+ printf( "Could not GetProcessToken: 0x%x\n", GetLastError() );
+ result = E_FAIL;
+ goto cleanup;
+ }
+
+ // Get the token's user id.
+ if (!GetTokenInformation( client_token, TokenUser, &buffer2, sizeof(buffer2),
+ &count ))
+ {
+ printf( "Could not GetTokenInformation: 0x%x\n", GetLastError() );
+ result = E_FAIL;
+ goto cleanup;
+ }
+ client_sid = (TOKEN_USER *) &buffer2;
+
+ // Compare the client and server.
+ if (!EqualSid( server_sid->User.Sid, client_sid->User.Sid))
+ {
+ printf( "Client and server have different SIDs.\n" );
+ result = E_FAIL;
+ goto cleanup;
+ }
+
+ // Try to open this process while impersonating the client.
+ process = OpenProcess( PROCESS_ALL_ACCESS, FALSE, GetCurrentProcessId() );
+ if (process == NULL)
+ {
+ printf( "Could not open process.\n" );
+ result = E_FAIL;
+ goto cleanup;
+ }
+
+ // Undo the impersonation.
+ status = RpcRevertToSelf();
+ if (status != RPC_S_OK)
+ {
+ printf( "Could not revert to self: 0x%x\n", status );
+ result = MAKE_WIN32( status );
+ goto cleanup;
+ }
+
+cleanup:
+ if (client_token != NULL)
+ CloseHandle( client_token );
+ if (server_token != NULL)
+ CloseHandle( server_token );
+ if (process != NULL)
+ CloseHandle( process );
+ return result;
+}
+
+ /***************************************************************************/
+void xget_interface_buffer( handle_t binding, long *buf_size,
+ unsigned char **buffer, SAptId *id,
+ error_status_t *status )
+{
+ SGetInterface get_interface;
+
+ *buffer = NULL;
+ get_interface.buf_size = buf_size;
+ get_interface.buffer = buffer;
+ get_interface.thread = GetCurrentThreadId();
+ *status = switch_thread( thread_get_interface_buffer, (void *) &get_interface );
+ if (*status == RPC_S_OK)
+ *status = get_interface.status;
+ InterlockedIncrement( &GlobalClients );
+ InterlockedIncrement( &GlobalTotal );
+}
+
+ /***************************************************************************/
+unsigned long ximpersonate_call( handle_t binding )
+{
+ RPC_STATUS status;
+
+ status = RpcImpersonateClient( binding );
+ if (status == RPC_S_OK)
+ status = RpcRevertToSelf();
+
+ return status;
+}
+
+ /***************************************************************************/
+void xnullcall( handle_t binding )
+{
+}
+
+ /***************************************************************************/
+void xrelease_interface( handle_t binding, error_status_t *status )
+{
+ *status = RPC_S_OK;
+ InterlockedDecrement( &GlobalClients );
+}
+
+ /***************************************************************************/
+void xset_status( handle_t binding, HRESULT result, error_status_t *status )
+{
+ RawResult = result;
+ *status = RPC_S_OK;
+ SetEvent( RawEvent );
+}
+
+ /***************************************************************************/
+unsigned long xtest( handle_t binding, ITest *obj, SAptId id,
+ error_status_t *status )
+{
+ *status = RPC_S_OK;
+ return obj->check( id );
+}
+
+ /***************************************************************************/
+unsigned long xtransitive( handle_t handle, wchar_t *binding )
+{
+ return 0;
+}
+
+
+
diff --git a/private/oleutest/channel/app/app_i.c b/private/oleutest/channel/app/app_i.c
new file mode 100644
index 000000000..06ffc5e19
--- /dev/null
+++ b/private/oleutest/channel/app/app_i.c
@@ -0,0 +1,28 @@
+#pragma warning(disable:4101) // Ignore variable not use warning
+
+//+-------------------------------------------------------------------------
+//
+// Microsoft Windows
+// Copyright (C) Microsoft Corporation, 1992 - 1993.
+//
+// File: iperf_i.c
+//
+// Contents: IID_IPerf
+//
+// History: Created by Microsoft (R) MIDL Compiler Version 1.10.83
+//
+//--------------------------------------------------------------------------
+typedef struct _IID
+{
+ unsigned long x;
+ unsigned short s1;
+ unsigned short s2;
+ unsigned char c[8];
+} IID;
+
+
+const IID CLSID_ITest =
+{0x60000430, 0xAB0F, 0x101A, {0xB4, 0xAE, 0x08, 0x00, 0x2B, 0x30, 0x61, 0x2C}};
+
+const IID CLSID_ITestMulti =
+{0x25724a70, 0x283f, 0x11ce, {0x95, 0x31, 0x08, 0x00, 0x2b, 0x2a, 0xb6, 0x12}};
diff --git a/private/oleutest/channel/app/makefile b/private/oleutest/channel/app/makefile
new file mode 100644
index 000000000..8991c0d2e
--- /dev/null
+++ b/private/oleutest/channel/app/makefile
@@ -0,0 +1,20 @@
+############################################################################
+#
+# Copyright (C) 1992, Microsoft Corporation.
+#
+# All rights reserved.
+#
+############################################################################
+
+!ifdef NTMAKEENV
+
+!include $(NTMAKEENV)\makefile.def
+
+!else # NTMAKEENV
+
+default: all
+
+!include $(CAIROLE)\com\makefile
+!include $(DEPENDFILE)
+
+!endif # NTMAKEENV
diff --git a/private/oleutest/channel/app/prxydll.def b/private/oleutest/channel/app/prxydll.def
new file mode 100644
index 000000000..f812a2719
--- /dev/null
+++ b/private/oleutest/channel/app/prxydll.def
@@ -0,0 +1,7 @@
+DESCRIPTION 'Microsoft (R) OLE 2.0 Proxy/Stub DLL 1.00'
+
+EXPORTS
+
+ DllGetClassObject @1
+ DllCanUnloadNow @2
+
diff --git a/private/oleutest/channel/app/sources b/private/oleutest/channel/app/sources
new file mode 100644
index 000000000..02bc2d3bb
--- /dev/null
+++ b/private/oleutest/channel/app/sources
@@ -0,0 +1,70 @@
+
+MAJORCOMP = cairole
+MINORCOMP = com
+
+#
+# This is the name of the target built from the source files specified
+# below. The name should include neither the path nor the file extension.
+#
+
+TARGETNAME= app
+
+#
+# This specifies where the target is to be built. A private target of
+# type LIBRARY or DYNLINK should go to obj, whereas a public target of
+# type LIBRARY or DYNLINK should go to $(BASEDIR)\public\sdk\lib.
+#
+
+TARGETPATH= obj
+
+#
+# This specifies the type of the target, such as PROGRAM, DYNLINK, LIBRARY,
+# etc.
+#
+
+TARGETTYPE= PROGRAM
+
+#DLLDEF= ..\proxy\prxydll.def
+LINKER_FLAGS=-DEF:prxydll.def
+
+INCLUDES= ..\idl;$(BASEDIR)\private\dcomidl\daytona;$(BASEDIR)\private\dcomidl\obj
+
+C_DEFINES= \
+ $(C_DEFINES) \
+ -DFLAT \
+ -DWIN32=100 \
+ -D_NT1X_=100 \
+ -DUNICODE \
+ -D_UNICODE \
+ -DNOEXCEPTIONS \
+ -DCAIROLE_DOWNLEVEL
+
+BLDCRT= 1
+
+SOURCES= \
+ app.cxx \
+ dog_c.c \
+ dog_s.c \
+ itest_p.c \
+ itest_i.c \
+ dlldata.c
+
+
+UMTYPE= console
+UMENTRY=
+UMAPPL=
+UMTEST=
+UMLIBS= \
+ $(BASEDIR)\public\sdk\lib\*\uuid.lib \
+ $(BASEDIR)\public\sdk\lib\*\ole32.lib \
+ $(BASEDIR)\public\sdk\lib\*\rpcndr.lib \
+ $(BASEDIR)\public\sdk\lib\*\rpcrt4.lib \
+ $(BASEDIR)\public\sdk\lib\*\rpcns4.lib \
+ $(BASEDIR)\public\sdk\lib\*\mpr.lib \
+ $(BASEDIR)\public\sdk\lib\*\netapi32.lib \
+ $(BASEDIR)\public\sdk\lib\*\kernel32.lib \
+ $(BASEDIR)\public\sdk\lib\*\user32.lib \
+ $(BASEDIR)\public\sdk\lib\*\advapi32.lib \
+ $(BASEDIR)\public\sdk\lib\*\libcmt.lib \
+ $(BASEDIR)\public\sdk\lib\*\security.lib
+
diff --git a/private/oleutest/channel/dirs b/private/oleutest/channel/dirs
new file mode 100644
index 000000000..cda324fa1
--- /dev/null
+++ b/private/oleutest/channel/dirs
@@ -0,0 +1,38 @@
+!IF 0
+
+Copyright (c) 1989 Microsoft Corporation
+
+Module Name:
+
+ dirs.
+
+Abstract:
+
+ This file specifies the subdirectories of the current directory that
+ contain component makefiles.
+
+
+Author:
+
+ Dean Edwards (DeanE) 11-Jan-1994
+
+!ENDIF
+
+#
+# This is a list of all subdirectories that build required components.
+# Each subdirectory name should appear on a line by itself. The build
+# follows the order in which the subdirectories are specified.
+#
+
+DIRS= \
+ idl \
+ app
+
+#
+# This is a list of all subdirectories that build optional components.
+# Each subdirectory name should appear on a line by itself. The build
+# follows the order in which the subdirectories are specified.
+#
+
+OPTIONAL_DIRS=
+
diff --git a/private/oleutest/channel/idl/dog.acf b/private/oleutest/channel/idl/dog.acf
new file mode 100644
index 000000000..8c67cfe4c
--- /dev/null
+++ b/private/oleutest/channel/idl/dog.acf
@@ -0,0 +1,9 @@
+interface IDog
+
+{
+ check_client ( [comm_status, fault_status] status );
+ get_interface_buffer ( [comm_status, fault_status] status );
+ release_interface ( [comm_status, fault_status] status );
+ set_status ( [comm_status, fault_status] status );
+ test ( [comm_status, fault_status] status );
+}
diff --git a/private/oleutest/channel/idl/dog.idl b/private/oleutest/channel/idl/dog.idl
new file mode 100644
index 000000000..97d6e3d0c
--- /dev/null
+++ b/private/oleutest/channel/idl/dog.idl
@@ -0,0 +1,45 @@
+//+-------------------------------------------------------------------
+//
+// Interface: IDog
+//
+// Purpose: Interface for manipulating performance
+//
+// History: 8 Nov 94 AlexMit Created
+//
+// Notes:
+//
+//--------------------------------------------------------------------
+
+import "itest.idl";
+
+[ uuid(e0b4ab10-fb6d-11cd-b3ae-00aa003c9fdc),
+ version(0.1),
+ pointer_default(unique) ]
+
+interface IDog
+{
+ unsigned long acl_call ( [in] handle_t handle );
+ unsigned long audit_call ( [in] handle_t handle );
+ unsigned long check_client ( [in] handle_t handle,
+ [out] error_status_t *status );
+ void get_interface_buffer ( [in] handle_t handle,
+ [out] long *size,
+ [out, size_is(,*size)] char **buffer,
+ [out] SAptId *id,
+ [out] error_status_t *status );
+ unsigned long impersonate_call ( [in] handle_t handle );
+ void nullcall ( [in] handle_t handle );
+ void release_interface ( [in] handle_t handle,
+ [out] error_status_t *status );
+ void set_status ( [in] handle_t handle,
+ [in] long result,
+ [out] error_status_t *status );
+ unsigned long test ( [in] handle_t handle,
+ [in] ITest *obj,
+ [in] SAptId id,
+ [out] error_status_t *status );
+ unsigned long transitive ( [in] handle_t handle,
+ [in, string] wchar_t *binding );
+}
+
+
diff --git a/private/oleutest/channel/idl/itest.acf b/private/oleutest/channel/idl/itest.acf
new file mode 100644
index 000000000..d11570c04
--- /dev/null
+++ b/private/oleutest/channel/idl/itest.acf
@@ -0,0 +1,4 @@
+interface ITest
+{
+ typedef [allocate(dont_free)] STRING;
+}
diff --git a/private/oleutest/channel/idl/itest.idl b/private/oleutest/channel/idl/itest.idl
new file mode 100644
index 000000000..7f2437650
--- /dev/null
+++ b/private/oleutest/channel/idl/itest.idl
@@ -0,0 +1,192 @@
+//[ ITest_itf
+//+-------------------------------------------------------------------
+//
+// Interface: ITest (ib)
+//
+// Purpose: Interface for manipulating performance
+//
+// History: 5-Oct-93 AlexMit Created
+//
+// Notes:
+//
+//--------------------------------------------------------------------
+
+[
+ object,
+ uuid(60000200-76d7-11cf-9af1-0020af6e72f4),
+ pointer_default(unique)
+]
+
+interface ITest : IUnknown
+{
+ import "unknwn.idl";
+ import "objidl.idl";
+
+ typedef struct
+ {
+ DWORD process;
+ DWORD thread;
+ DWORD sequence;
+ } SAptId;
+
+ typedef struct
+ {
+ UCHAR Value[6];
+ } HACKHACKHACK_SID_IDENTIFIER_AUTHORITY;
+
+ typedef struct
+ {
+ UCHAR Revision;
+ UCHAR SubAuthorityCount;
+ HACKHACKHACK_SID_IDENTIFIER_AUTHORITY IdentifierAuthority;
+#ifdef MIDL_PASS
+ [size_is(SubAuthorityCount)] ULONG SubAuthority[*];
+#else // MIDL_PASS
+ ULONG SubAuthority[ANYSIZE_ARRAY];
+#endif // MIDL_PASS
+ } HACKSID;
+
+ typedef [string] wchar_t *STRING;
+
+ typedef [transmit_as(DWORD)] DWORD transmit_crash;
+
+ HRESULT align ( [in] unsigned char x[17] );
+ HRESULT call_canceled ( [in] long recurse, [in] long cancel,
+ [in] ITest *callback );
+ HRESULT call_dead ();
+ HRESULT call_me_back ( [in] ITest *callback );
+ HRESULT call_next ();
+ HRESULT callback ();
+ HRESULT cancel ();
+ HRESULT cancel_now ();
+ HRESULT cancel_pending_call ( [out] DWORD *thread );
+ HRESULT cancel_stress ( [in] ITest *obj );
+ HRESULT catch_at_top ( [in] BOOL catch_me_im_falling,
+ [in] ITest *callback,
+ [in] STRING binding );
+ HRESULT check ( [in] SAptId id );
+ HRESULT check_hook ( [in] DWORD cg1, [in] DWORD cn1,
+ [in] DWORD sg1, [in] DWORD sn1,
+ [in] DWORD cg2, [in] DWORD cn2,
+ [in] DWORD sg2, [in] DWORD sn2 );
+ HRESULT count ();
+ HRESULT crash_out ( [out] transmit_crash *data );
+ HRESULT delegate ( [in] ITest *obj, [in] SAptId id,
+ [in] HACKSID *caller );
+ HRESULT exit ();
+ HRESULT forget ();
+ HRESULT get_advise ( [out] IAdviseSink **advise );
+ HRESULT get_data ( [in] DWORD isize,
+ [in, unique, size_is(isize)] char *idata,
+ [in] DWORD osize,
+ [out, size_is(,osize)] char **odata );
+ HRESULT get_id ( [out] SAptId *id );
+ HRESULT get_next ( [out] ITest **obj, [out] SAptId *id );
+ HRESULT get_next_slowly ( [out] ITest **obj, [out] SAptId *id );
+ HRESULT get_obj_from_new_apt ( [out] ITest **obj, [out] SAptId *id );
+ HRESULT get_obj_from_this_apt ( [out] ITest **obj, [out] SAptId *id );
+ HRESULT get_sid ( [out] HACKSID **sid );
+ HRESULT interface_in ( [in] ITest *obj );
+ HRESULT interrupt ( [in] ITest *obj, [in] SAptId id, BOOL go );
+ HRESULT interrupt_marshal ( [in] ITest *obj1, [in] ITest *obj2 );
+ HRESULT make_acl ( [in] HACKSID *allow );
+ HRESULT null ();
+ HRESULT out ( [out] ITest **obj );
+ HRESULT pointer ( [in] DWORD *ptr );
+ HRESULT recurse ( [in] ITest *callback, [in] ULONG depth );
+ HRESULT recurse_disconnect ( [in] ITest *callback, [in] ULONG depth );
+ HRESULT recurse_excp ( [in] ITest *callback, [in] ULONG depth );
+ HRESULT recurse_fatal ( [in] ITest *callback,
+ [in] ULONG catch_depth,
+ [in] ULONG throw_depth,
+ [in] BOOL cancel );
+ HRESULT register_hook ( [in] GUID ext, [in] DWORD seq );
+ HRESULT recurse_interrupt ( [in] ITest *callback, [in] ULONG depth );
+ HRESULT recurse_secure ( [in] ITest *callback, [in] ULONG depth,
+ [in] ULONG imp_depth, [in] HACKSID *Caller );
+ HRESULT register_message_filter( BOOL );
+ HRESULT register_rpc ( [in] STRING protseq, [out] STRING *binding );
+ HRESULT reinitialize ();
+ HRESULT reject_next ();
+ HRESULT remember ( [in] ITest *neighbor, [in] SAptId id );
+ HRESULT rest_and_die ();
+ HRESULT retry_next ();
+ HRESULT ring ( [in] DWORD length );
+ HRESULT secure ( [in] SAptId id,
+ [in] DWORD AuthnLevel, [in] DWORD ImpLevel,
+ [in] DWORD AuthnSvc, [in] DWORD AuthzSvc,
+ [in, unique] STRING PrincName,
+ [in] HACKSID *Caller,
+ [out] DWORD *QueryAuthnLevel );
+ HRESULT security_performance ( [out] DWORD *get_call,
+ [out] DWORD *query_client,
+ [out] DWORD *impersonate,
+ [out] DWORD *revert );
+ HRESULT set_state ( [in] DWORD flags, [in] DWORD priority );
+ HRESULT sick ( [in] ULONG throw_val );
+ HRESULT sleep ( [in] ULONG time );
+ HRESULT test ( [in] ULONG gronk );
+
+}
+
+[
+ object,
+ uuid(60000201-76d7-11cf-9af1-0020af6e72f4),
+ pointer_default(unique)
+]
+interface ITestNoneImp : ITest
+{
+ HRESULT dummy();
+}
+
+[
+ object,
+ uuid(60000202-76d7-11cf-9af1-0020af6e72f4),
+ pointer_default(unique)
+]
+interface ITestConnectImp : ITest
+{
+ HRESULT dummy();
+}
+
+[
+ object,
+ uuid(60000203-76d7-11cf-9af1-0020af6e72f4),
+ pointer_default(unique)
+]
+interface ITestEncryptImp : ITest
+{
+ HRESULT dummy();
+}
+
+[
+ object,
+ uuid(60000204-76d7-11cf-9af1-0020af6e72f4),
+ pointer_default(unique)
+]
+interface ITestNoneId : ITest
+{
+ HRESULT dummy();
+}
+
+[
+ object,
+ uuid(60000205-76d7-11cf-9af1-0020af6e72f4),
+ pointer_default(unique)
+]
+interface ITestConnectId : ITest
+{
+ HRESULT dummy();
+}
+
+[
+ object,
+ uuid(60000206-76d7-11cf-9af1-0020af6e72f4),
+ pointer_default(unique)
+]
+interface ITestEncryptId : ITest
+{
+ HRESULT dummy();
+}
+
+//]
diff --git a/private/oleutest/channel/idl/makefile b/private/oleutest/channel/idl/makefile
new file mode 100644
index 000000000..510cce95d
--- /dev/null
+++ b/private/oleutest/channel/idl/makefile
@@ -0,0 +1,9 @@
+############################################################################
+#
+# Copyright (C) 1992, Microsoft Corporation.
+#
+# All rights reserved.
+#
+############################################################################
+
+!include $(NTMAKEENV)\makefile.def
diff --git a/private/oleutest/channel/idl/makefile.inc b/private/oleutest/channel/idl/makefile.inc
new file mode 100644
index 000000000..d74e26319
--- /dev/null
+++ b/private/oleutest/channel/idl/makefile.inc
@@ -0,0 +1,37 @@
+itest.h: itest.idl
+ midl itest.idl \
+ -Zp8 \
+ -I$(INCLUDES:;= -I) \
+ -ms_ext \
+ -c_ext \
+ -Os \
+ -out ..\app \
+ -header ..\idl\itest.h \
+ -iid ..\app\itest_i.c \
+ $(C_DEFINES) \
+ -DMIDL_PASS
+
+dog.h: dog.idl
+ midl dog.idl \
+ -Zp8 \
+ -I$(INCLUDES:;= -I) \
+ -ms_ext \
+ -c_ext \
+ -Os \
+ -out ..\app \
+ -header ..\idl\dog.h \
+ -iid ..\app\dog_i.c \
+ -prefix server x \
+ $(C_DEFINES) \
+ -DMIDL_PASS
+
+#
+# This target compiles all .idl files into their corresponding _?.c?? and
+# .h components
+#
+allidl: itest.h dog.h
+
+clean:
+ erase itest.h >NUL 2>NUL
+ erase dog.h >NUL 2>NUL
+
diff --git a/private/oleutest/channel/idl/pch.cxx b/private/oleutest/channel/idl/pch.cxx
new file mode 100644
index 000000000..984d8d2bf
--- /dev/null
+++ b/private/oleutest/channel/idl/pch.cxx
@@ -0,0 +1,18 @@
+//+-------------------------------------------------------------------------
+//
+// Microsoft Windows
+// Copyright (C) Microsoft Corporation, 1991 - 1992.
+//
+// File: PCH.CXX
+//
+// Contents: Precompiled header
+//
+// History: 12-Jul-93 ShannonC Created
+//
+//--------------------------------------------------------------------------
+
+#include "stdrpc.hxx"
+#pragma hdrstop
+
+
+
diff --git a/private/oleutest/channel/idl/prxydll.def b/private/oleutest/channel/idl/prxydll.def
new file mode 100644
index 000000000..e09e1ce91
--- /dev/null
+++ b/private/oleutest/channel/idl/prxydll.def
@@ -0,0 +1,47 @@
+#if 0
+
+ Microsoft Windows
+ Copyright (C) Microsoft Corporation, 1992 - 1992.
+ All rights reserved.
+
+ This .def file is preprocessed by the compiler to create the version for
+ the current build in the appropriate subdir. Basically, whatever you
+ would have used in your code to control what is compiled when can be
+ used in this file for the same purpose. The following defines are in
+ use at the time this file was written:
+
+ FLAT - Used to indicate a NT/DOS7 build
+ i386 - Intel i386/i486 build
+ MIPS - MIPS R3000/R4000 build
+ ALPHA - DEC Alpha build
+ DBG - Used to control Debug/Retail. Set to 1 if Debug,
+ 0 if Retail.
+ WIN31 - Win16 build
+ __OS2__ - OS/2 build (used by CT mostly)
+
+ If none of these are used, it is assumed the entire file can be used
+ for all builds.
+
+#endif
+
+#ifdef FLAT
+
+LIBRARY ITEST
+
+DESCRIPTION 'Microsoft (R) OLE 2.0 Proxy/Stub DLL 1.00'
+
+EXPORTS
+
+#if defined(i386)
+
+ DllGetClassObject=DllGetClassObject@12 @1
+ DllCanUnloadNow=DllCanUnloadNow@0 @2
+
+#elif defined(_MIPS_)
+
+ DllGetClassObject @1
+ DllCanUnloadNow @2
+
+#endif // i386 - MIPS
+
+#endif // FLAT
diff --git a/private/oleutest/channel/idl/sources b/private/oleutest/channel/idl/sources
new file mode 100644
index 000000000..0112b8e8d
--- /dev/null
+++ b/private/oleutest/channel/idl/sources
@@ -0,0 +1,66 @@
+!IF 0
+
+Copyright (c) 1989 Microsoft Corporation
+
+Module Name:
+
+ sources.
+
+Abstract:
+
+ This file specifies the target component being built and the list of
+ sources files needed to build that component. Also specifies optional
+ compiler switches and libraries that are unique for the component being
+ built.
+
+
+Author:
+
+ Dean Edwards (DeanE) 11-Jan-1993
+
+!ENDIF
+
+MAJORCOMP = comutest
+MINORCOMP = channel
+
+#
+# This is the name of the target built from the source files specified
+# below. The name should include neither the path nor the file extension.
+#
+
+TARGETNAME= idl
+
+#
+# This specifies where the target is to be built. A private target of
+# type LIBRARY or DYNLINK should go to obj, whereas a public target of
+# type LIBRARY or DYNLINK should go to $(BASEDIR)\public\sdk\lib.
+#
+
+TARGETPATH= obj
+
+#
+# This specifies the type of the target, such as PROGRAM, DYNLINK, LIBRARY,
+# etc.
+#
+
+TARGETTYPE= LIBRARY
+
+INCLUDES= $(BASEDIR)\public\sdk\inc
+
+C_DEFINES= $(C_DEFINES)
+
+BLDCRT= 1
+
+SOURCES=
+
+UMTYPE= windows
+UMAPPL=
+UMTEST=
+UMLIBS=
+
+USE_LIBCMT=
+
+NTTARGETFILE0= allidl
+
+PRECOMPILED_INCLUDE=
+
diff --git a/private/oleutest/channel/idl/test.reg b/private/oleutest/channel/idl/test.reg
new file mode 100644
index 000000000..40112de96
--- /dev/null
+++ b/private/oleutest/channel/idl/test.reg
@@ -0,0 +1,24 @@
+
+; registry entries for ITest interface. these map the interfaces
+; to the proxy/stub code in itest.dll
+
+
+\Registry\MACHINE\SOFTWARE\Classes\Interface\{60000494-AB0F-101A-B4AE-08002B30612C}
+ = ITest
+\Registry\MACHINE\SOFTWARE\Classes\Interface\{60000494-AB0F-101A-B4AE-08002B30612C}\ProxyStubClsid32
+ = {60000494-AB0F-101A-B4AE-08002B30612C}
+
+\Registry\MACHINE\SOFTWARE\Classes\CLSID\{60000494-AB0F-101A-B4AE-08002B30612C}
+ = CPrxyITest
+\Registry\MACHINE\SOFTWARE\Classes\CLSID\{60000494-AB0F-101A-B4AE-08002B30612C}\InprocServer32
+ = itest.dll
+
+\Registry\MACHINE\SOFTWARE\Classes\CLSID\{60000430-AB0F-101A-B4AE-08002B30612C}
+ = CTestCF
+\Registry\MACHINE\SOFTWARE\Classes\CLSID\{60000430-AB0F-101A-B4AE-08002B30612C}\LocalServer32
+ = app.exe
+
+
+
+
+ \ No newline at end of file
diff --git a/private/oleutest/channel/idl/test2.reg b/private/oleutest/channel/idl/test2.reg
new file mode 100644
index 000000000..1f8a8407a
--- /dev/null
+++ b/private/oleutest/channel/idl/test2.reg
@@ -0,0 +1,16 @@
+REGEDIT
+
+
+HKEY_CLASSES_ROOT\Interface\{60000494-AB0F-101A-B4AE-08002B30612C} = ITest
+HKEY_CLASSES_ROOT\Interface\{60000494-AB0F-101A-B4AE-08002B30612C}\ProxyStubClsid32 = {60000494-AB0F-101A-B4AE-08002B30612C}
+
+HKEY_CLASSES_ROOT\CLSID\{60000494-AB0F-101A-B4AE-08002B30612C} = CPrxyITest
+HKEY_CLASSES_ROOT\CLSID\{60000494-AB0F-101A-B4AE-08002B30612C}\InprocServer32 = itest.dll
+
+HKEY_CLASSES_ROOT\CLSID\{60000430-AB0F-101A-B4AE-08002B30612C} = CTestCF
+HKEY_CLASSES_ROOT\CLSID\{60000430-AB0F-101A-B4AE-08002B30612C}\LocalServer32 = app.exe
+
+
+
+
+ \ No newline at end of file
diff --git a/private/oleutest/channel/rel.cmd b/private/oleutest/channel/rel.cmd
new file mode 100644
index 000000000..e8b1be215
--- /dev/null
+++ b/private/oleutest/channel/rel.cmd
@@ -0,0 +1,3 @@
+copy proxy\obj\i386\itest.dll \tmp
+copy app\obj\i386\app.exe \tmp
+copy idl\test.reg \tmp
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-16 17:06:53 +0100