static void test_default_handler_run(void)
{
const CLSID test_server_clsid = {0x0f77e570,0x80c3,0x11e2,{0x9e,0x96,0x08,0x00,0x20,0x0c,0x9a,0x66}};
IUnknown *unk;
IRunnableObject *ro;
DWORD class_reg;
HRESULT hres;
if(!GetProcAddress(GetModuleHandle("ole32"), "CoRegisterSurrogateEx")) {
win_skip("skipping OleCreateDefaultHandler tests\n");
return;
}
hres = CoRegisterClassObject(&test_server_clsid, (IUnknown*)&ClassFactory,
CLSCTX_INPROC_SERVER, 0, &class_reg);
ok(hres == S_OK, "CoRegisterClassObject failed: %x\n", hres);
hres = OleCreateDefaultHandler(&test_server_clsid, NULL, &IID_IUnknown, (void**)&unk);
ok(hres == S_OK, "OleCreateDefaultHandler failed: %x\n", hres);
hres = IUnknown_QueryInterface(unk, &IID_IRunnableObject, (void**)&ro);
ok(hres == S_OK, "QueryInterface(IRunnableObject) failed: %x\n", hres);
IUnknown_Release(unk);
hres = IRunnableObject_Run(ro, NULL);
ok(hres == REGDB_E_CLASSNOTREG, "Run returned: %x, expected REGDB_E_CLASSNOTREG\n", hres);
IRunnableObject_Release(ro);
SET_EXPECT(CF_QueryInterface_IMarshal);
CoRevokeClassObject(class_reg);
todo_wine CHECK_CALLED(CF_QueryInterface_IMarshal);
hres = CoRegisterClassObject(&test_server_clsid, (IUnknown*)&ClassFactory,
CLSCTX_LOCAL_SERVER, 0, &class_reg);
ok(hres == S_OK, "CoRegisterClassObject failed: %x\n", hres);
hres = OleCreateDefaultHandler(&test_server_clsid, NULL, &IID_IUnknown, (void**)&unk);
ok(hres == S_OK, "OleCreateDefaultHandler failed: %x\n", hres);
hres = IUnknown_QueryInterface(unk, &IID_IRunnableObject, (void**)&ro);
ok(hres == S_OK, "QueryInterface(IRunnableObject) failed: %x\n", hres);
IUnknown_Release(unk);
SET_EXPECT(CF_QueryInterface_ClassFactory);
SET_EXPECT(CF_CreateInstance);
hres = IRunnableObject_Run(ro, NULL);
todo_wine ok(hres == S_OK, "Run failed: %x\n", hres);
CHECK_CALLED(CF_QueryInterface_ClassFactory);
CHECK_CALLED(CF_CreateInstance);
IRunnableObject_Release(ro);
SET_EXPECT(CF_QueryInterface_IMarshal);
CoRevokeClassObject(class_reg);
todo_wine CHECK_CALLED(CF_QueryInterface_IMarshal);
}
int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow) {
CoInitialize(NULL);
#if 0
// register the type lib
ITypeLib* pTLib = NULL;
LoadTypeLibEx(L"AnyEXETypeInfo.tlb", REGKIND_REGISTER, &pTLib);
pTLib->Release();
#endif
if(strstr(lpCmdLine, "/Embedding") || strstr(lpCmdLine, "-Embedding")) {
ComponentClassFactory cf;
DWORD regID = 0;
CoRegisterClassObject(CLSID_Component, (IClassFactory*)&cf, CLSCTX_LOCAL_SERVER, REGCLS_MULTIPLEUSE, ®ID);
MSG ms;
while(GetMessage(&ms, 0, 0, 0)) {
TranslateMessage(&ms);
DispatchMessage(&ms);
}
CoRevokeClassObject(regID);
}
CoUninitialize();
return 0;
}
// This is called on shut-down, and also when the user unloads the add-in
STDMETHODIMP CDSAddIn::OnDisconnection(VARIANT_BOOL bLastTime)
{
pIApp_.Release();
CoRevokeClassObject( classRegistrationId_);
return S_OK;
}
//==============================================
int g_ReleaseActX_Control() {
g_pRPcoX = NULL; // release the smart pointer object
CoRevokeClassObject(x_dwRegister);
Sleep(x_dwPause); //wait for any threads to finish
x_pIFactory->Release();
// CoUninitialize(); // do not call here: should be called at the very appl. end
return 0;
}
int main(int argc,const char* agrv[])
{
if(argc < 2) {
printf("Usage: talk_server /AUTOMTION | /REGSERVER | /UNREGSERVER\n");
return -1;
}
const char* szCmdParam = agrv[1];
HRESULT hr = CoInitializeEx(0, COINIT_MULTITHREADED);
if (SUCCEEDED(hr))
{
if(0 == u_strcasecmp(agrv[1],"/REGSERVER") || 0 == u_strcasecmp(agrv[1],"-REGSERVER"))
{
printf("/REGSERVER\n");
}
else if(0 == u_strcasecmp(agrv[1],"/UNREGSERVER") || 0 == u_strcasecmp(agrv[1],"-UNREGSERVER"))
{
printf("/UNREGSERVER\n");
}else if(0 == u_strcasecmp(agrv[1],"/AUTOMATION") || 0 == u_strcasecmp(agrv[1],"-AUTOMATION")
|| 0 == u_strcasecmp(agrv[1],"/EMBEDDING") || 0 == u_strcasecmp(agrv[1],"-EMBEDDING") )
{
IUnknown *pUnk = NULL;
DWORD dwReg = 0;
static tgmtl::class_factory<CTalkManager> cf;
hr = cf.QueryInterface(IID_IUnknown,(void **)&pUnk);
if (SUCCEEDED(hr))
{
hr = CoRegisterClassObject(CLSID_TalkToStranger,pUnk,CLSCTX_LOCAL_SERVER,REGCLS_MULTIPLEUSE| REGCLS_SUSPENDED,&dwReg);
if (SUCCEEDED(hr))
hr = CoResumeClassObjects();
if(SUCCEEDED(hr)){
printf("=============================================\n");
printf("Server is Ready!\n");
ModuleAddRef();//this line ensure the server running forever
ModuleServerListen();
}
CoRevokeClassObject(dwReg);
}
//pUnk->Release();
}
else
{
#ifdef WIN32
MessageBoxA(NULL,"UNKNOWN PARAMS","Test",MB_OK);
#endif
}
CoUninitialize();
}
return hr;
}
HRESULT CMainModule::PostMessageLoop()
{
if( m_dwRegister ) {
CoRevokeClassObject( m_dwRegister );
m_dwRegister = 0;
}
AtlAxWinTerm();
return CAtlExeModuleT<CMainModule>::PostMessageLoop();
}
int com_unregister()
{
// If someone has retrieved pointers to any of our objects, and
// not yet Release()'ed them, then we return S_FALSE to indicate
// not to unload this DLL. Also, if someone has us locked, return
// S_FALSE
if (!com_can_unregister())
return 0;
else {
if (MyTypeInfo) MyTypeInfo->lpVtbl->Release(MyTypeInfo);
CoRevokeClassObject(reg_cookie);
return 1;
}
}
STDMETHODIMP
CSurrogate::FreeSurrogate()
{
// tear down all connections with COM
for (int i = 0; i < m_rgdwReg.size(); i++)
CoRevokeClassObject(m_rgdwReg[i]);
// tear down all apartments
{
for (int i = 0; i < m_nMaxThreads; i++)
m_prgSTAs[i].RequestShutdown(30000);
}
// terminate main thread
PostThreadMessage(m_dwThreadId, WM_QUIT, 0, 0);
return S_OK;
}
HRESULT STDAPICALLTYPE
ClassTableRegisterClassObjects(COCLASS_ENTRY *pTable,
DWORD dwClsCtx,
DWORD dwRegCls,
BOOL bResumeClassObjects )
{
HRESULT hr = E_FAIL;
#ifdef _WIN32_DCOM
dwRegCls |= REGCLS_SUSPENDED;
#else
assert(bResumeClassObjects);
#endif
if (pTable)
{
hr = S_OK;
COCLASS_ENTRY *pHead = pTable;
for (; SUCCEEDED(hr) && pTable->pclsid != &GUID_NULL; pTable++)
{
if (pTable->pfnGetClassObject)
{
IUnknown *pUnk = 0;
hr = pTable->pfnGetClassObject(IID_IUnknown, (void**)&pUnk);
if (SUCCEEDED(hr))
{
hr = CoRegisterClassObject(*pTable->pclsid,
pUnk,
dwClsCtx,
dwRegCls,
&pTable->dwReg);
pUnk->Release();
}
}
}
if (SUCCEEDED(hr) && bResumeClassObjects)
hr = CoResumeClassObjects();
if (FAILED(hr)) // unwind if failed
for (pTable--; pTable >= pHead; pTable--)
if (pTable->pfnGetClassObject)
CoRevokeClassObject(pTable->dwReg);
}
return hr;
}
BOOL uninstallIA2Support() {
int i;
LPFNDLLCANUNLOADNOW IA2Dll_DllCanUnloadNow;
if(isIA2Installed) {
for(i=0;i<ARRAYSIZE(ia2Iids);++i) {
CoRegisterPSClsid(ia2Iids[i],_ia2PSClsidBackups[i]);
}
CoRevokeClassObject(IA2RegCooky);
IA2Dll_DllCanUnloadNow=(LPFNDLLCANUNLOADNOW)GetProcAddress(static_cast<HMODULE>(IA2DllHandle),"DllCanUnloadNow");
assert(IA2Dll_DllCanUnloadNow); //IAccessible2 proxy dll must have this function
if(IA2Dll_DllCanUnloadNow()==S_OK) {
CoFreeLibrary(IA2DllHandle);
}
IA2DllHandle=0;
isIA2Installed=FALSE;
}
return TRUE;
}
/*
Stop the COM server (if necessary).
*/
bool qax_stopServer()
{
if (!qAxIsServer || !classRegistration)
return true;
qAxIsServer = false;
const QStringList keys = qAxFactory()->featureList();
int object = 0;
for (QStringList::ConstIterator key = keys.begin(); key != keys.end(); ++key, ++object)
CoRevokeClassObject(classRegistration[object]);
delete []classRegistration;
classRegistration = 0;
Sleep(dwPause); //wait for any threads to finish
return true;
}
HRESULT STDAPICALLTYPE
ClassTableRevokeClassObjects(COCLASS_ENTRY *pTable)
{
HRESULT hr = E_FAIL;
if (pTable)
{
hr = S_OK;
for (; pTable->pclsid != &GUID_NULL; pTable++)
{
if (pTable->pfnGetClassObject)
{
HRESULT hrtemp = CoRevokeClassObject(pTable->dwReg);
if (hrtemp != S_OK)
hr = hrtemp;
}
}
}
return hr;
}
//
// Function: AptThreadProc
//
// Summary: The common apartment model thread procedure for this server.
//
// Args: LPARAM lparam
// Standard Window Proc parameter.
//
// Modifies: .
//
// Returns: DWORD
// Thread procedure return (usually msg.wParam).
// ************************************************************************************************
DWORD WINAPI AptThreadProcIngresObject(LPARAM lparam)
{
HRESULT hError;
MSG msg;
DWORD dwCFRegId;
APT_INIT_DATA* paid = (APT_INIT_DATA*) lparam;
// Initialize COM for this apartment thread. Default of apartment
// model is assumed.
hError = CoInitializeEx(NULL, COINIT_MULTITHREADED);
//
// Now register the class factory with COM.
hError = CoRegisterClassObject(
paid->rclsid,
paid->pcf,
CLSCTX_LOCAL_SERVER,
REGCLS_MULTIPLEUSE,
&dwCFRegId);
if (SUCCEEDED(hError))
{
//
// Provide a message pump for this thread.
while (GetMessage(&msg, 0, 0, 0))
DispatchMessage(&msg);
//
// Unregister the class factory with COM when the thread dies.
CoRevokeClassObject(dwCFRegId);
}
else
{
}
//
// Uninitialize COM in the context of this apartment thread.
CoUninitialize();
return msg.wParam;
}
static void test_CoRegisterPSClsid(void)
{
HRESULT hr;
DWORD dwRegistrationKey;
IStream *stream;
CLSID clsid;
hr = CoRegisterPSClsid(&IID_IWineTest, &CLSID_WineTestPSFactoryBuffer);
ok(hr == CO_E_NOTINITIALIZED, "CoRegisterPSClsid should have returened CO_E_NOTINITIALIZED instead of 0x%08lx\n", hr);
pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
hr = CoRegisterClassObject(&CLSID_WineTestPSFactoryBuffer, (IUnknown *)&PSFactoryBuffer,
CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &dwRegistrationKey);
ok_ole_success(hr, "CoRegisterClassObject");
hr = CoRegisterPSClsid(&IID_IWineTest, &CLSID_WineTestPSFactoryBuffer);
ok_ole_success(hr, "CoRegisterPSClsid");
hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
ok_ole_success(hr, "CreateStreamOnHGlobal");
hr = CoMarshalInterface(stream, &IID_IWineTest, (IUnknown *)&Test_Unknown, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
ok(hr == E_NOTIMPL, "CoMarshalInterface should have returned E_NOTIMPL instead of 0x%08lx\n", hr);
IStream_Release(stream);
hr = CoRevokeClassObject(dwRegistrationKey);
ok_ole_success(hr, "CoRevokeClassObject");
CoUninitialize();
pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
hr = CoGetPSClsid(&IID_IWineTest, &clsid);
ok(hr == REGDB_E_IIDNOTREG, "CoGetPSClsid should have returned REGDB_E_IIDNOTREG instead of 0x%08lx\n", hr);
CoUninitialize();
}
HRESULT register_class_object(BOOL do_reg)
{
HRESULT hres;
static DWORD cookie;
if(do_reg) {
hres = CoRegisterClassObject(&CLSID_InternetExplorer,
(IUnknown*)&InternetExplorerFactory, CLSCTX_SERVER,
REGCLS_MULTIPLEUSE|REGCLS_SUSPENDED, &cookie);
if (FAILED(hres)) {
ERR("failed to register object %08x\n", hres);
return hres;
}
hres = CoResumeClassObjects();
if(SUCCEEDED(hres))
return hres;
ERR("failed to resume object %08x\n", hres);
}
return CoRevokeClassObject(cookie);
}
void quitexeserver()
{
if(!coregflag) return;
CoRevokeClassObject(dwRegCO);
pFactory->Release();
}
int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
bool bExit = false;
CoInitialize(NULL);
// To know which thread has to receive the right message when closing
CFactory::s_dwThreadID = ::GetCurrentThreadId();
// Read the command line.
// This commandline routine is straight from the Inside COM book
char szTokens[] = "-/" ;
char* szToken = strtok(lpCmdLine, szTokens) ;
while (szToken != NULL)
{
if (_stricmp(szToken, "UnregServer") == 0)
{
UnregisterServer( CLSID_SDWSourceContainer,
g_szVerIndProgID,
g_szProgID) ;
// We are done, so exit.
bExit = TRUE ;
}
else if (_stricmp(szToken, "RegServer") == 0)
{
// thanks to the _OUTPROC_SERVER_ define in the settings
// the Registerserver() function is creating a LocalServer32 key
// instead of InprocServer32
RegisterServer( hInstance,
CLSID_SDWSourceContainer,
g_szFriendlyName,
g_szVerIndProgID,
g_szProgID ) ;
// We are done, so exit.
bExit = TRUE ;
}
szToken = strtok(NULL, szTokens) ;
}
// Create the factory
CFactory * pIFact = new CFactory();
// A cookie to store the reg info
DWORD dwRegCookie;
// register the Factory, so COM knows how to create an SDWSourceContainer
CoRegisterClassObject( CLSID_SDWSourceContainer,
static_cast<IUnknown*> (pIFact),
CLSCTX_LOCAL_SERVER,
REGCLS_SINGLEUSE,
&dwRegCookie );
// start an messagepump
if ( !bExit )
{
MSG msg ;
// GetMessage only gives back a 0 if WM_QUIT is send
while (::GetMessage(&msg, 0, 0, 0))
{
::DispatchMessage(&msg) ;
}
}
// release the factory
pIFact->Release();
// Unregister the ClassFactory
CoRevokeClassObject(dwRegCookie);
CoUninitialize();
return 0;
}
