HRESULT CPigEngine::get_AccountDispenser(IPigAccountDispenser** ppDispenser)
{
// Get the computer name of the account server
CComBSTR bstrServer;
RETURN_FAILED(get_AccountServer(&bstrServer));
if (!bstrServer.Length())
{
// Get the computer name of the mission server
RETURN_FAILED(get_MissionServer(&bstrServer));
}
// Check for '.' to indicate this computer
if (1 == bstrServer.Length() && OLESTR('.') == bstrServer[0])
bstrServer.Empty();
// Create the Pig Account Dispenser on the mission server
COSERVERINFO si = {0, bstrServer, NULL, 0};
MULTI_QI mqi = {&IID_IPigAccountDispenser, NULL, S_OK};
RETURN_FAILED(CoCreateInstanceEx(CLSID_PigAccountDispenser, NULL,
CLSCTX_SERVER, &si, 1, &mqi));
// Copy the interface pointer to the [out] parameter
ZSucceeded(mqi.hr);
*ppDispenser = (IPigAccountDispenser*)mqi.pItf;
// Indicate success
return S_OK;
}
HRESULT CPyCOMTest::TestQueryInterface()
{
IUnknown* pObj = 0;
IPyCOMTest * pCOMTest = 0;
HRESULT hr = S_OK;
MULTI_QI mqi[1] = {
&IID_IUnknown, NULL, E_FAIL
};
COSERVERINFO server = {
(DWORD)0, 0, (COAUTHINFO*)NULL, (DWORD)0
};
// Create an instance of the test server
hr = CoCreateInstanceEx(CLSID_PythonTestPyCOMTest, NULL, CLSCTX_LOCAL_SERVER, &server, 1, mqi);
if (FAILED(hr)) { goto exit; }
pObj = mqi[0].pItf;
// Query for the custom interface
hr = pObj->QueryInterface(IID_IPyCOMTest, (LPVOID*)&pCOMTest);
if (FAILED(hr)) { goto exit; }
hr = S_OK;
exit:
if (pObj) { pObj->Release(); pObj = 0; }
if (pCOMTest) { pCOMTest->Release(); pCOMTest = 0; }
return hr;
}
STDMETHODIMP TCUtilImpl::CreateObject(BSTR bstrProgID, BSTR bstrComputer,
IUnknown** ppUnk)
{
// Initialize the [out] parameter
CLEAROUT(ppUnk, (IUnknown*)NULL);
// Convert the specified ProgID to a CLSID
CLSID clsid;
if (!BSTRLen(bstrProgID))
return E_INVALIDARG;
RETURN_FAILED(CLSIDFromProgID(bstrProgID, &clsid));
// Initialize the COSERVERINFO and MULTI_QI structures
COSERVERINFO csi = {0, bstrComputer, NULL, 0};
MULTI_QI mqi[] =
{
{&IID_IUnknown , NULL, S_OK},
{&IID_IDispatch , NULL, S_OK},
{&IID_IConnectionPointContainer, NULL, S_OK},
};
const static ULONG cMQI = sizeofArray(mqi);
// Determine if the specified computer name is definitely local
bool bLocalForSure = true;
if (BSTRLen(bstrComputer))
{
TCHAR szLocal[MAX_COMPUTERNAME_LENGTH + 1];
DWORD cchLocal = sizeofArray(szLocal);
GetComputerName(szLocal, &cchLocal);
USES_CONVERSION;
bLocalForSure = !_tcsicmp(szLocal, OLE2CT(bstrComputer));
}
DWORD dwClsCtx = bLocalForSure ? CLSCTX_SERVER : CLSCTX_REMOTE_SERVER;
// Attempt to create the instance
HRESULT hr = CoCreateInstanceEx(clsid, NULL, dwClsCtx, &csi, cMQI, mqi);
if (FAILED(hr))
{
_TRACE_BEGIN
_TRACE_PART1("TCCreateObject failed: hr=0x%08X", hr);
_TRACE_PART1(", dwClsCtx=%hs", (CLSCTX_SERVER == dwClsCtx) ?
"CLSCTX_SERVER" : "CLSCTX_REMOTE_SERVER");
_TRACE_PART1(", ProgID=\"%ls\"", bstrProgID);
_TRACE_PART1(", Computer= \"%ls\"\n", bstrComputer ?
bstrComputer : L"");
_TRACE_END
return hr;
}
// Copy the IUnknown interface pointer to the [out] parameter
*ppUnk = mqi[0].pItf;
// Release each interface not being returned
for (ULONG i = 1; i < cMQI; ++i)
if (mqi[i].pItf)
mqi[i].pItf->Release();
// Return the result of the QI for IUnknown
return mqi[0].hr;
}
void ServerConnection::connectToRemoteServer( CLSID server_clsid )
{
FRL_EXCEPT_GUARD();
COSERVERINFO server_info;
os::win32::com::zeroMemory( &server_info );
server_info.pwszName = util::duplicateString( unicodeCompatibility( host_name ) );
// setup requested interfaces
MULTI_QI mq_result;
os::win32::com::zeroMemory( &mq_result );
mq_result.pIID = &IID_IOPCServer;
mq_result.pItf = NULL;
mq_result.hr = S_OK;
// call create instance
if( FAILED( CoCreateInstanceEx( server_clsid,
NULL,
CLSCTX_REMOTE_SERVER,
&server_info,
1,
&mq_result) ) )
{
FRL_THROW_S_CLASS( CreateServerObjectError );
}
// check QueryInterface result
if( FAILED(mq_result.hr) )
FRL_THROW_S_CLASS( QueryInterfaceError );
// set pointer to server object
ComPtr<IOPCServer> tmp( (IOPCServer*)mq_result.pItf );
tmp.get()->Release(); // release tmp
server.swap( tmp ); // equal: this->server->ptr = mq_result.pItf
}
void test_remote()
{
HRESULT hr;
COSERVERINFO csi = {0, L"10.204.2.52", 0, 0};
MULTI_QI mqi[] = {&IID_IXenGuestServices, NULL, S_OK};
::CoInitializeEx(NULL, COINIT_MULTITHREADED);
hr = CoCreateInstanceEx(CLSID_XenGuestServices, NULL, CLSCTX_SERVER, &csi, 1, mqi);
}
//------------------------------------------------------------------*
HRESULT COPCConnection::DoConnect()
{
USES_CONVERSION;
HRESULT hr;
_ASSERTE(!m_bConnected);
MULTI_QI queue[1];
queue[0].pIID = &IID_IOPCServer;
queue[0].pItf = NULL;
queue[0].hr = 0;
// set up server node info:
COSERVERINFO serverInfo;
serverInfo.dwReserved1 = 0;
serverInfo.dwReserved2 = 0;
serverInfo.pwszName = T2OLE(m_sMachineName);
serverInfo.pAuthInfo = NULL;
//HACK hardcode from C:\4c2\COM\softing\fc\AddOns\Softing\4CPCTarget\inc\CSC_OnlSrv.idl
//CLSID_OPCServer 379165A5-C2BF-47a8-8F60-73EDE1FD6001
CLSID CLSIDOPCServer; //HACK
CLSIDFromString(L"{5425B8A4-754D-496a-AF31-7D78A530E58D}", &CLSIDOPCServer);//HACK
hr = CoCreateInstanceEx(CLSIDOPCServer, NULL, CLSCTX_REMOTE_SERVER | CLSCTX_LOCAL_SERVER,
&serverInfo, 1, queue);
if (FAILED(hr)) {
return hr;
}
m_pOPCServer = (IOPCServer*) queue[0].pItf;
DWORD dummy;
hr = m_pOPCServer->AddGroup(L"AsyncOPC", TRUE, 1000, 0, NULL, NULL, LOCALE_NEUTRAL,
&m_hGroup1, &dummy, IID_IOPCItemMgt, (IUnknown**)&m_pItemMgt);
if (FAILED(hr)) {
m_pOPCServer->Release();
m_pOPCServer=NULL;
return hr;
}
hr = m_pItemMgt->QueryInterface(IID_IOPCSyncIO, (void **)&m_pSyncIO);
if (FAILED(hr)) {
m_pItemMgt->Release();
m_pItemMgt=NULL;
m_pOPCServer->RemoveGroup(m_hGroup1, TRUE);
m_pOPCServer->Release();
m_pOPCServer=NULL;
return hr;
}
TRACE(_T("COPCConnection::DoConnect to %s\n"), (LPCTSTR)m_sMachineName);
m_bConnected = true;
return S_OK;
}
ecom_StringManipulatorLib::StringManipulator::StringManipulator()
{
HRESULT hr;
hr = CoInitializeEx (NULL, COINIT_APARTMENTTHREADED);
rt.ccom_check_hresult (hr);
p_unknown = NULL;
MULTI_QI a_qi = {&IID_IUnknown, NULL, 0};
hr = CoCreateInstanceEx (CLSID_StringManipulator_, NULL, CLSCTX_INPROC_SERVER, NULL, 1, &a_qi);
rt.ccom_check_hresult (hr);
rt.ccom_check_hresult (a_qi.hr);
p_unknown = a_qi.pItf;
p_IString = 0;
};
void STAClientCall()
{
if (SUCCEEDED(CoInitializeEx(NULL, COINIT_APARTMENTTHREADED)))
{
COSERVERINFO si;
COAUTHINFO ai;
si.pAuthInfo = &ai;
COAUTHIDENTITY authident;
ai.pAuthIdentityData = &authident;
IntializeServerInfo (si);
MULTI_QI mqi;
mqi.pIID = &IID_ICalculator;
mqi.pItf = 0;
mqi.hr = 0;
wprintf(L"\nCalling CoCreateInstanceEx ... ");
if (SUCCEEDED(CoCreateInstanceEx(
CLSID_Calculator,
NULL,
CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER,
&si,
1,
&mqi
)))
{
wprintf(L"done\n");
ICalculator * pCalculator = NULL;
pCalculator = (ICalculator*)mqi.pItf;
__int32 result = 0;
wprintf(L"Calling SumSlow ...");
pCalculator->SumSlow(1,2, &result);
pCalculator->Release();
wprintf(L"done\n");
}
else
{
wprintf(L"failed\n");
}
CoUninitialize();
}
}
// in case either MyCoCreateInstanceEx is directly instead of from MyCoCreateInstance, or MyCoCreateInstanceEx is called from MyCoCreateInstance but MyCoCreateInstance failed to get hooked
HOOKFUNC HRESULT STDAPICALLTYPE MyCoCreateInstanceEx(REFCLSID Clsid, LPUNKNOWN punkOuter, DWORD dwClsCtx, struct _COSERVERINFO* pServerInfo, DWORD dwCount, struct tagMULTI_QI* pResults)
{
debuglog(LCF_MODULE, __FUNCTION__ "(clsid=0x%X, dwCount=%d) called.\n", Clsid.Data1, dwCount);
// check for creating custom objects that skip COM
// DEFINE_LOCAL_GUID(IID_IUnknown,0x00000000,0x0000,0x0000,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46);
for(DWORD i = 0; i < dwCount; i++)
{
if(TrySoundCoCreateInstance(*pResults[i].pIID, (LPVOID*)&pResults[i].pItf))
{
pResults[i].hr = S_OK;
HRESULT rv = S_OK;
bool anyok = false;
for(DWORD j = 0; j < dwCount; j++)
{
if(i != j)
{
pResults[j].hr = pResults[i].pItf->QueryInterface(*pResults[j].pIID, (LPVOID*)pResults[j].pItf);
if(FAILED(pResults[j].hr))
rv = pResults[j].hr;
else
anyok = true;
}
}
if(anyok && FAILED(rv))
rv = CO_S_NOTALLINTERFACES;
return rv;
}
}
// regular creation
HRESULT rv = CoCreateInstanceEx(Clsid, punkOuter, dwClsCtx, pServerInfo, dwCount, pResults);
for(DWORD i = 0; i < dwCount; i++)
if(SUCCEEDED(pResults[i].hr))
HookCOMInterface(*pResults[i].pIID, (LPVOID*)&pResults[i].pItf);
return rv;
}
//**************************************************************************
void OPCServerDlg::OnOK()
{
CWaitCursor wait;
UpdateData();
// Look for a matching server name
POSITION pos = m_Servers.GetHeadPosition();
while( pos )
{
OPCServerInfo* pServerInfo = m_Servers.GetNext( pos );
if(m_Server == pServerInfo->m_ProgID)
{
m_clsid = pServerInfo->m_clsid;
CDialog::OnOK();
}
}
// If not found, Get CLSID from the ProgID
USES_CONVERSION;
IOPCServerList* pServers=NULL;
COSERVERINFO si;
MULTI_QI qi;
si.dwReserved1 = 0;
si.pwszName = NULL;
if( !m_Node.IsEmpty() )
si.pwszName = T2OLE(m_Node.GetBuffer(0));
si.pAuthInfo = NULL;
si.dwReserved2 = 0;
qi.pIID = &IID_IOPCServerList;
qi.pItf = NULL;
qi.hr = 0;
HRESULT hr = CoCreateInstanceEx(CLSID_OPCServerList, NULL, CLSCTX_ALL, &si, 1, &qi);
if (FAILED(hr) || FAILED(qi.hr))
{
CString msg(_T("Please install the OPC 2.0 Components."));
if( !m_Node.IsEmpty() )
msg.Format(_T("Please install the OPC 2.0 Components on %s."), (LPCTSTR)m_Node);
if( FAILED(hr) )
theDoc->ReportError(msg, hr);
else
theDoc->ReportError(msg, qi.hr);
return;
}
pServers = (IOPCServerList*)qi.pItf;
hr = pServers->CLSIDFromProgID(T2OLE(m_Server.GetBuffer(0)), &m_clsid);
pServers->Release();
if (FAILED(hr))
{
CString msg;
msg.Format(_T("Error locating '%s'."), (LPCTSTR)m_Server);
if( !m_Node.IsEmpty() )
msg.Format(_T("Error locating '%s' on %s."), (LPCTSTR)m_Server, (LPCTSTR)m_Node);
AfxMessageBox(msg);
return;
}
CDialog::OnOK();
}
BOOL OPCServerDlg::GetOPCServers(LPTSTR node)
{
CListBox* pList = (CListBox*)GetDlgItem( IDC_SERVER_LIST );
USES_CONVERSION;
CWaitCursor wait;
ASSERT_VALID(pList);
pList->ResetContent();
// New 2.0 method using component categories
IOPCServerList* pServers=NULL;
COSERVERINFO si;
MULTI_QI qi;
si.dwReserved1 = 0;
si.pwszName = NULL;
if( node && node[0] != 0 )
si.pwszName = T2OLE(node);
si.pAuthInfo = NULL;
si.dwReserved2 = 0;
qi.pIID = &IID_IOPCServerList;
qi.pItf = NULL;
qi.hr = 0;
HRESULT hr = CoCreateInstanceEx(CLSID_OPCServerList, NULL, CLSCTX_ALL, &si, 1, &qi);
if (FAILED(hr) || FAILED(qi.hr))
{
CString msg(_T("Error connecting to OPC 2.0 Server Browser."));
if( !m_Node.IsEmpty() )
msg.Format(_T("Error connecting to OPC 2.0 Server Browser on %s."), (LPCTSTR)m_Node);
if( hr == REGDB_E_CLASSNOTREG )
{
CString msg(_T("Please install the OPC 2.0 Components."));
if( !m_Node.IsEmpty() )
msg.Format(_T("Please install the OPC 2.0 Components on %s."), (LPCTSTR)m_Node);
}
if( FAILED(hr) )
theDoc->ReportError(msg, hr);
else
theDoc->ReportError(msg, qi.hr);
}
else
{
pServers = (IOPCServerList*)qi.pItf;
IEnumGUID *pEnumGUID=NULL;
hr = pServers->EnumClassesOfCategories(1, &m_catid, 1, &m_catid, &pEnumGUID);
if( SUCCEEDED(hr) )
{
unsigned long count;
CLSID clsid[NEXT_COUNT];
do
{
hr = pEnumGUID->Next(NEXT_COUNT, clsid, &count);
for( ULONG index=0; index<count; index++ )
{
LPOLESTR pszProgID;
LPOLESTR pszUserType;
HRESULT hr2 = pServers->GetClassDetails(clsid[index], &pszProgID, &pszUserType);
if (SUCCEEDED(hr2))
{
OPCServerInfo* pServerInfo = new OPCServerInfo(pszProgID, pszUserType, clsid[index] );
m_Servers.AddTail( pServerInfo );
CString name;
name.Format( _T("%s (%s)"),
(LPCTSTR)pServerInfo->m_ProgID,
(LPCTSTR)pServerInfo->m_Description );
int pos = pList->AddString( name );
pList->SetItemData( pos, (DWORD)pServerInfo );
if( m_Server == pServerInfo->m_ProgID )
pList->SetCurSel(pos);
CoTaskMemFree(pszProgID);
CoTaskMemFree(pszUserType);
}
}
}
while ( hr==S_OK );
pEnumGUID->Release();
pServers->Release();
return TRUE;
}
else // hr failed
{
CString msg(_T("EnumClassesOfCategories failed:"));
theDoc->ReportError(msg, hr);
}
pServers->Release();
}
// Old 1.0 method: search the registry for OPC entries
if( m_catid != CATID_OPCDAServer10 )
return FALSE;
HKEY hk = HKEY_CLASSES_ROOT;
if( node )
{
DWORD dwR = RegConnectRegistry ((LPTSTR)node, HKEY_CLASSES_ROOT, &hk);
if( dwR != ERROR_SUCCESS )
return FALSE;
}
TCHAR key[MAX_KEYLEN];
DWORD size = MAX_KEYLEN;
FILETIME ft;
for( int index=0; RegEnumKeyEx(hk, index, key, &size, 0, NULL, NULL, &ft)==ERROR_SUCCESS; index++)
{
HKEY hProgID=0;
if(RegOpenKeyEx(hk, key, 0, KEY_QUERY_VALUE, &hProgID )==ERROR_SUCCESS )
{
// Find OPC key
HKEY hOPC=0;
if(RegOpenKeyEx(hProgID, _T("OPC"), 0, KEY_QUERY_VALUE, &hOPC)==ERROR_SUCCESS )
{
// Found OPC key, save this information
CLSID clsid;
DWORD type=REG_SZ;
HKEY hCLSID=0;
if(RegOpenKeyEx(hProgID, _T("CLSID"), 0, KEY_QUERY_VALUE, &hCLSID)==ERROR_SUCCESS )
{
TCHAR clsidString[MAX_KEYLEN];
size=MAX_KEYLEN;
if(RegQueryValueEx(hCLSID, key, 0, &type, (BYTE*)clsidString, &size )==ERROR_SUCCESS )
{
hr = CLSIDFromString( T2OLE(clsidString), &clsid );
if( FAILED(hr))
{
theDoc->ReportError( _T("CLSIDFromString: "), hr );
continue;
}
}
}
TCHAR desc[MAX_KEYLEN];
size=MAX_KEYLEN;
RegQueryValueEx(hOPC, key, 0, &type, (BYTE*)desc, &size);
OPCServerInfo* pServerInfo = new OPCServerInfo(T2OLE(key), L"", clsid );
m_Servers.AddTail( pServerInfo );
int pos = pList->AddString( pServerInfo->m_ProgID );
pList->SetItemData( pos, (DWORD)pServerInfo );
if( m_Server == key )
pList->SetCurSel(pos);
RegCloseKey( hOPC );
}
RegCloseKey( hProgID );
}
size = MAX_KEYLEN;
}
OnSelchangeServerList();
return TRUE;
}
Reference *
Reference::createInstance (
REFCLSID clsid,
const Interface *pInterface,
DWORD clsCtx,
const char *serverHost)
{
// If we know it's a custom interface, then query for an interface pointer
// to that interface, otherwise query for an IUnknown interface.
const IID &iid = (pInterface == 0) ? IID_IUnknown : pInterface->iid();
HRESULT hr;
IUnknown *pUnknown;
// Create an instance of the specified class.
#ifdef _WIN32_DCOM
if (serverHost == 0
|| serverHost[0] == '\0'
|| strcmp(serverHost, "localhost") == 0
|| strcmp(serverHost, "127.0.0.1") == 0) {
// When creating an instance on the local machine, call
// CoCreateInstance instead of CoCreateInstanceEx with a null pointer
// to COSERVERINFO. This works around occasional failures in the RPC
// DLL on Windows NT 4.0, even when connecting to a server on the local
// machine.
hr = CoCreateInstance(
clsid,
NULL,
clsCtx,
iid,
reinterpret_cast<void **>(&pUnknown));
} else {
COSERVERINFO serverInfo;
memset(&serverInfo, 0, sizeof(serverInfo));
_bstr_t serverHostBstr(serverHost);
serverInfo.pwszName = serverHostBstr;
MULTI_QI qi;
qi.pIID = &iid;
qi.pItf = NULL;
qi.hr = 0;
hr = CoCreateInstanceEx(
clsid,
NULL,
clsCtx,
&serverInfo,
1,
&qi);
if (SUCCEEDED(hr)) {
pUnknown = static_cast<IUnknown *>(qi.pItf);
}
}
#else
hr = CoCreateInstance(
clsid,
NULL,
clsCtx,
iid,
reinterpret_cast<void **>(&pUnknown));
#endif
if (FAILED(hr)) {
_com_issue_error(hr);
}
if (pInterface == 0) {
pInterface = findInterface(pUnknown, clsid);
if (pInterface != 0) {
// Get a pointer to the derived interface.
IUnknown *pNew;
hr = pUnknown->QueryInterface(
pInterface->iid(),
reinterpret_cast<void **>(&pNew));
if (SUCCEEDED(hr)) {
pUnknown->Release();
pUnknown = pNew;
}
}
}
return new Reference(pUnknown, pInterface, clsid);
}
LRESULT CLXWebSiteApp::OnFileNewSite(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
// USES_CONVERSION;
CComPtr<ILXFrameworkFrame> lxframe;
m_spAddinSite->GetFrame(&lxframe);
CComQIPtr<IUIWnd> wnd = lxframe;
HWND hWnd;
wnd->get_hwnd(&hWnd);
if (TRUE)
{
CPropertySheet* sheet = new CPropertySheet("New Site", 0, hWnd);
// sheet->SetWizardMode();
// sheet->m_psh.dwFlags |= PSH_WIZARD97;
sheet->SetWatermark(MAKEINTRESOURCE(IDB_NEWSITE_WATERMARK));
CNewSiteData data;
CNewSiteBeginDlg begindlg;
begindlg.m_psp.dwFlags |= PSP_HIDEHEADER;
begindlg.SetHeaderTitle("LocalSite");
CNewSiteFinishDlg finishdlg;
finishdlg.m_psp.dwFlags |= PSP_HIDEHEADER;
finishdlg.SetHeaderTitle("LocalSite");
CNewSiteSingleWorkgroupDlg singleworkdlg;
singleworkdlg.m_data = &data;
singleworkdlg.m_nWorkgroup = 0;
singleworkdlg.SetHeaderTitle("SingleWorkgroup");
CNewSiteLocalSiteOptionsDlg localsitedlg;
localsitedlg.m_data = &data;
localsitedlg.m_nLocalSite = 0;
localsitedlg.SetHeaderTitle("LocalSite");
CNewSiteLocalNameDlg localnamedlg;
localnamedlg.m_data = &data;
localnamedlg.SetHeaderTitle("LocalName");
CNewSiteFTPDlg ftpdlg;
ftpdlg.m_data = &data;
ftpdlg.SetHeaderTitle("FTP");
CNewSiteWorkgroupOptionsDlg workoptionsdlg;
workoptionsdlg.m_data = &data;
workoptionsdlg.SetHeaderTitle("FTP");
CNewSiteWorkgroupLogonDlg worklogondlg;
worklogondlg.m_data = &data;
worklogondlg.m_server = L"213.115.5.39";
worklogondlg.m_username = L"Sigurd";
worklogondlg.m_password = L"testing";
worklogondlg.SetHeaderTitle("Workgroup Logon");
sheet->AddPage(begindlg);
sheet->AddPage(singleworkdlg);
sheet->AddPage(localsitedlg);
sheet->AddPage(localnamedlg);
sheet->AddPage(ftpdlg);
sheet->AddPage(finishdlg);
sheet->AddPage(workoptionsdlg);
sheet->AddPage(worklogondlg);
sheet->DoModal();
if (singleworkdlg.m_nWorkgroup == 0)
{
if (localnamedlg.m_localSitePath.GetLength() && localnamedlg.m_siteName.GetLength())
{
CComObject<CWebSite>* pWebSite;
CComObject<CWebSite>::CreateInstance(&pWebSite);
if (pWebSite)
{
pWebSite->AddRef();
pWebSite->SetApp(this);
HRESULT hr = pWebSite->m_webSite.CoCreateInstance(CLSID_LXLocalWebSite);
if (SUCCEEDED(hr))
{
HRESULT hr = pWebSite->m_webSite->NewDocument(A2BSTR(localnamedlg.m_localSitePath), A2BSTR(localnamedlg.m_siteName));
if (SUCCEEDED(hr))
{
CComQIPtr<IEFrame> eframe = lxframe;
pWebSite->ShowViews(eframe);
return 0;
}
else
{
// TODO, use IErrorInfo etc
MessageBox(hWnd, "Failed to create Local WebSite", "LXWebSite", MB_OK);
}
}
pWebSite->Release();
}
}
}
else if (singleworkdlg.m_nWorkgroup == 1)
{
#if 0
COAUTHIDENTITY cauthid;
cauthid.User = worklogondlg.m_username;
cauthid.UserLength = worklogondlg.m_username.length();
cauthid.Domain = L"WORKGROUP";
cauthid.DomainLength = wcslen(cauthid.Domain);
cauthid.Password = worklogondlg.m_password;
cauthid.PasswordLength = worklogondlg.m_password.length();
cauthid.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
COAUTHINFO cauthi;
cauthi.dwAuthnSvc = RPC_C_AUTHN_WINNT;
cauthi.dwAuthzSvc = RPC_C_AUTHZ_NONE;
cauthi.pwszServerPrincName = NULL;
cauthi.dwAuthnLevel = RPC_C_AUTHN_LEVEL_CONNECT;
cauthi.dwImpersonationLevel = RPC_C_IMP_LEVEL_IMPERSONATE;
cauthi.pAuthIdentityData = &cauthid;
cauthi.dwCapabilities = EOAC_NONE;
COSERVERINFO csi;
csi.dwReserved1 = 0;
csi.pwszName = worklogondlg.m_server;
csi.pAuthInfo = &cauthi;
csi.dwReserved2 = 0;
MULTI_QI qi;
qi.pIID = &XMILLWEBLib::IID_IXmillWebSite;
qi.pItf = NULL;
qi.hr = 0;
HRESULT hr = CoCreateInstanceEx(XMILLWEBLib::CLSID_XmillWebSite, NULL, CLSCTX_SERVER/*CLSCTX_ALL*/, &csi, 1, &qi);
if (SUCCEEDED(qi.hr))
{
XMILLWEBLib::IXmillWebSitePtr webSite;//(L"XMillWeb.WebSite");
CComQIPtr<IClientSecurity> csec = qi.pItf;
hr = CoSetProxyBlanket(qi.pItf,
cauthi.dwAuthnSvc,
cauthi.dwAuthzSvc,
cauthi.pwszServerPrincName,
cauthi.dwAuthnLevel,
cauthi.dwImpersonationLevel,
cauthi.pAuthIdentityData,
cauthi.dwCapabilities);
webSite = qi.pItf;
qi.pItf->Release();
try
{
CComPtr<ILDOMDocument> document;
document.CoCreateInstance(CLSID_LDOMDocument);
VARIANT_BOOL bsuccess;
document->loadXML(L"<website/>", &bsuccess);
CComPtr<ILDOMElement> documentElement;
document->get_documentElement(&documentElement);
documentElement->setAttribute(L"name", L"TestSite1");
BSTR bxml;
document->saveXML(NULL, &bxml);
_bstr_t xml = _bstr_t(bxml, false);
long websiteID = webSite->NewWebSite(xml);
}
catch (_com_error &e)
{
ComError(e);
}
}
#endif
}
}
return 0;
}
LRESULT CLXWebSiteApp::OnFileMountWorkgroupSite(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
CLogonServerDlg dlg;
dlg.m_server = L"213.115.5.45";
dlg.m_username = L"Sigurd";
dlg.m_password = L"testing";
if (dlg.DoModal() == IDOK)
{
#if 0
COAUTHIDENTITY cauthid;
cauthid.User = dlg.m_username;
cauthid.UserLength = dlg.m_username.length();
cauthid.Domain = L"WORKGROUP";
cauthid.DomainLength = wcslen(cauthid.Domain);
cauthid.Password = dlg.m_password;
cauthid.PasswordLength = dlg.m_password.length();
cauthid.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
COAUTHINFO cauthi;
cauthi.dwAuthnSvc = RPC_C_AUTHN_WINNT;
cauthi.dwAuthzSvc = RPC_C_AUTHZ_NONE;
cauthi.pwszServerPrincName = NULL;
cauthi.dwAuthnLevel = RPC_C_AUTHN_LEVEL_CONNECT;
cauthi.dwImpersonationLevel = RPC_C_IMP_LEVEL_IMPERSONATE;
cauthi.pAuthIdentityData = &cauthid;
cauthi.dwCapabilities = EOAC_NONE;
COSERVERINFO csi;
csi.dwReserved1 = 0;
csi.pwszName = dlg.m_server;
csi.pAuthInfo = &cauthi;
csi.dwReserved2 = 0;
MULTI_QI qi[2];
qi[0].pIID = &XMILLWEBLib::IID_IXmillWorkgroup;
qi[0].pItf = NULL;
qi[0].hr = 0;
qi[1].pIID = &XMILLWEBLib::IID_ILFileSystem;
qi[1].pItf = NULL;
qi[1].hr = 0;
HRESULT hr = CoCreateInstanceEx(XMILLWEBLib::CLSID_XmillWorkgroup, NULL, CLSCTX_SERVER/*CLSCTX_ALL*/, &csi, 2, qi);
if (SUCCEEDED(qi[0].hr) && SUCCEEDED(qi[1].hr))
{
//XMILLWEBLib::IXmillWorkgroupPtr workgroup;//(L"XMillWeb.WebSite");
//CComQIPtr<IClientSecurity> csec = qi[0].pItf;
hr = CoSetProxyBlanket(qi[0].pItf,
cauthi.dwAuthnSvc,
cauthi.dwAuthzSvc,
cauthi.pwszServerPrincName,
cauthi.dwAuthnLevel,
cauthi.dwImpersonationLevel,
cauthi.pAuthIdentityData,
cauthi.dwCapabilities);
hr = CoSetProxyBlanket(qi[1].pItf,
cauthi.dwAuthnSvc,
cauthi.dwAuthzSvc,
cauthi.pwszServerPrincName,
cauthi.dwAuthnLevel,
cauthi.dwImpersonationLevel,
cauthi.pAuthIdentityData,
cauthi.dwCapabilities);
//workgroup = qi.pItf;
//qi.pItf->Release();
CComObject<CWorkgroupDocument>* pWorkgroupDocument;
CComObject<CWorkgroupDocument>::CreateInstance(&pWorkgroupDocument);
if (pWorkgroupDocument)
{
pWorkgroupDocument->AddRef();
pWorkgroupDocument->m_workgroup = qi[0].pItf;
pWorkgroupDocument->m_filesystem = qi[1].pItf;
pWorkgroupDocument->ShowView();
}
/*
try
{
_bstr_t result = webSite->TestMethod("Test");
}
catch (_com_error &e)
{
ComError(e);
}
*/
}
else
{
MessageBox(hWnd, "Couldn't connect to Server", "", MB_OK);
}
#endif
}
return 0;
}
//-------------------------------------------------------------------//
// GetComInterface() //
//-------------------------------------------------------------------//
// This simplifies as much as possible the process of grabbing
// a COM interface. You should add parameters to this function,
// including a default whenever possible, as you need more
// functionality.
//-------------------------------------------------------------------//
HRESULT GetComInterface(
GUID guidTarget, // COM interface ID
MULTI_QI* pQI, // Interfaces structure pointer - this will contain the interfaces on successful return!
int nQICount, // Number of requested interfaces
bool bDisplayErrors, // Should we attempt to display errors?
LPCTSTR szCOMInterfaceName // Interface name to display in error msg
) {
// Set this stuff up "freshly" each time.
HRESULT hClientRequest;
COSERVERINFO serverInfo; //assumed to be client machine
COAUTHINFO athn;
serverInfo.pAuthInfo = &athn;
// Set to NULL for local machine.
serverInfo.pwszName = NULL;
serverInfo.dwReserved1 = 0;
serverInfo.dwReserved2 = 0;
athn.dwAuthnLevel = RPC_C_AUTHN_LEVEL_NONE;
athn.dwAuthnSvc = RPC_C_AUTHN_WINNT;
athn.dwAuthzSvc = RPC_C_AUTHZ_NONE;
athn.dwCapabilities = EOAC_NONE;
athn.dwImpersonationLevel = RPC_C_IMP_LEVEL_IMPERSONATE;
athn.pAuthIdentityData = NULL;
athn.pwszServerPrincName = NULL;
// Original example:
/*
HRESULT hClientRequest;
COSERVERINFO serverInfo; //assumed to be client machine
COAUTHINFO athn;
long exists = false;
serverInfo.pAuthInfo = &athn;
// Set to NULL for local machine.
serverInfo.pwszName = NULL;
serverInfo.dwReserved1 = 0;
serverInfo.dwReserved2 = 0;
athn.dwAuthnLevel = RPC_C_AUTHN_LEVEL_NONE;
athn.dwAuthnSvc = RPC_C_AUTHN_WINNT;
athn.dwAuthzSvc = RPC_C_AUTHZ_NONE;
athn.dwCapabilities = EOAC_NONE;
athn.dwImpersonationLevel = RPC_C_IMP_LEVEL_IMPERSONATE;
athn.pAuthIdentityData = NULL;
athn.pwszServerPrincName = NULL;
hClientRequest = CoCreateInstanceEx(CLSID_Xxxx,
NULL,
CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER,
&serverInfo,
1,
&qi);
*/
hClientRequest = CoCreateInstanceEx(
guidTarget,
NULL,
CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER,
&serverInfo,
nQICount, // Number of QI's in MULTI_QI
pQI // pointer to array of MULTI_QI structures
);
DWORD dwErr = GetLastError();
// Consolidate any bad results into hClientRequest.
// We PROBABLY don't need to do this, but just in case...
if ( SUCCEEDED( hClientRequest ) )
for ( int nA = 0; nA < nQICount; nA++ )
if ( !SUCCEEDED( pQI->hr ) )
{
hClientRequest = pQI->hr;
break;
}
// Now test result and report if there was a problem.
if (
!SUCCEEDED( hClientRequest )
&& bDisplayErrors
) {
// Why did it fail?
ustring strMsg = GetComError( hClientRequest, dwErr );
strMsg += _T(" when connecting to the ");
strMsg += szCOMInterfaceName;
strMsg += _T(" COM interface.");
DisplayMessage( strMsg.c_str() );
}
return hClientRequest;
}
// **************************************************************************
// Connect ()
//
// Description:
// Connect to OPC Server. OPC Server's ProgID and machine name must have
// been previously specified.
//
// Parameters:
// none
//
// Returns:
// bool - true if success.
// **************************************************************************
bool CKServer::Connect ()
{
// Program ID of OPC Server should have been defined by now:
ASSERT (!m_strProgID.IsEmpty ());
// Assume we are not connecting to KEPServerEx:
m_bfFlags.bIsKepServerEx = false;
// Perform any necessary cleanup from a previous connection:
Disconnect ();
/*
m_server.EnumClassesOfCategories(
1,
&catids
0,
NULL,
out enumerator);
*/
// Obtain the Class ID of the OPC Server. (GetCLSID() will need the
// OPC Server's Program ID to succeed. That's why we checked it above.)
CLSID clsid;
bool ret = SUCCEEDED (GetCLSID (clsid));
// 2006 debug
//if (ret)
if (true)
{
HRESULT hr;
// Re-intialize Multi-Query Interface:
for (int i = 0; i < sizeof (m_arrMultiQI) / sizeof (MULTI_QI); i++)
{
m_arrMultiQI [i].pItf = NULL;
m_arrMultiQI [i].hr = 0;
}
// Load up the Interface ID's we hope to get pointers for when we
// call CoCreateInstanceEx():
m_arrMultiQI [MQI_IOPCSERVER].pIID = &IID_IOPCServer;
m_arrMultiQI [MQI_IOPCCOMMON].pIID = &IID_IOPCCommon;
m_arrMultiQI [MQI_IOPCCONNPT].pIID = &IID_IConnectionPointContainer;
m_arrMultiQI [MQI_IOPCITEMPROP].pIID = &IID_IOPCItemProperties;
m_arrMultiQI [MQI_IOPCBROWSE].pIID = &IID_IOPCBrowseServerAddressSpace;
m_arrMultiQI [MQI_IOPCPUBLIC].pIID = &IID_IOPCServerPublicGroups;
m_arrMultiQI [MQI_IOPCPERSIST].pIID = &IID_IPersistFile;
// Connect to the OPC Server and query all possible interfaces:
if (m_strRemoteMachine.IsEmpty ())
{
// Since m_strRemoteMachine is empty, we will try to instantiate
// the OPC Server on our local machine.
// CoCreateInstanceEx will launch the OPC Server if necessary, and
// call its QueryInterface for us (bumping its reference count):
hr = CoCreateInstanceEx (
clsid, // CLSID
NULL, // No aggregation
CLSCTX_SERVER, // connect to local, inproc and remote servers
NULL, // remote machine name
sizeof (m_arrMultiQI) / sizeof (MULTI_QI), // number of IIDS to query
m_arrMultiQI); // array of IID pointers to query
}
else
{
// Since m_strRemoteMachine is not empty, we will assume it contains
// a valid remote machine name. We will try to instantiate the OPC
// Server object on the machine with that name.
// First we need to initialize a server info structure:
COSERVERINFO tCoServerInfo;
ZeroMemory (&tCoServerInfo, sizeof (tCoServerInfo));
// Allocate memory for the machine name string:
int nSize = m_strRemoteMachine.GetLength () * sizeof (WCHAR);
tCoServerInfo.pwszName = new WCHAR [nSize];
// Check validity of pointer. If it's bad, there's no point in continuing:
if (!tCoServerInfo.pwszName)
{
ASSERT (FALSE);
return (false);
}
// Copy the machine name string into the server info structure:
#ifdef _UNICODE
// For Unicode builds, the contents of m_strRemoteMachine will
// already be in wide character format, as demanded by COM, so
// copy it as is.
lstrcpyn (tCoServerInfo.pwszName, m_strRemoteMachine, nSize);
#else
// For ANSI builds, the contents of m_strRemoteMachine will not
// be in wide character format, as demanded by COM, so we need
// to reformat:
mbstowcs (tCoServerInfo.pwszName, m_strRemoteMachine, nSize);
#endif//_UNICODE
// CoCreateInstanceEx will launch the OPC Server if necessary, and
// call its QueryInterface for us (bumping its reference count):
hr = CoCreateInstanceEx (
clsid, // CLSID
NULL, // No aggregation
// CLSCTX_SERVER, // connect to local, inproc and remote servers
CLSCTX_REMOTE_SERVER, // lyy
&tCoServerInfo, // remote machine name
sizeof (m_arrMultiQI) / sizeof (MULTI_QI), // number of IIDS to query
m_arrMultiQI); // array of IID pointers to query
// COM requires us to free memory allocated for [out] and [in/out]
// arguments (i.e. name string).
delete [] tCoServerInfo.pwszName;
}
// If CoCreateInstanceEx succeeded, we can check the returned
// interface pointers and save them as member variables:
if (SUCCEEDED (hr))
{
TRACE (_T("OTC: Initializing server %s interfaces.\r\n"), GetProgID ());
// Check IOPCServer interface pointer:
if (SUCCEEDED (m_arrMultiQI [MQI_IOPCSERVER].hr))
{
m_pIServer = (IOPCServer *)m_arrMultiQI [MQI_IOPCSERVER].pItf;
if (m_pIServer == NULL)
{
// Warning success but no valid pointer:
ASSERT (FALSE);
}
}
else
{
if (m_arrMultiQI [MQI_IOPCSERVER].pItf != NULL)
{
// Warning failure but pointer not set to null
ASSERT (FALSE);
}
TRACE (_T("OTC: Failed to query IOPCServer (%08X).\r\n"),
m_arrMultiQI [MQI_IOPCSERVER].hr);
}
// Check IOPCCommon interface pointer:
if (SUCCEEDED (m_arrMultiQI [MQI_IOPCCOMMON].hr))
{
m_pICommon = (IOPCCommon *)m_arrMultiQI [MQI_IOPCCOMMON].pItf;
if (m_pICommon == NULL)
{
// Warning success but no valid pointer:
ASSERT (FALSE);
}
}
else
{
if (m_arrMultiQI [MQI_IOPCCOMMON].pItf != NULL)
{
// Warning failure but pointer not set to null:
ASSERT (FALSE);
}
TRACE (_T("OTC: Failed to query IOPCCommon (%08X).\r\n"),
m_arrMultiQI [MQI_IOPCCOMMON].hr);
}
// Check IConnectionPointContainer interface pointer:
if (SUCCEEDED (m_arrMultiQI [MQI_IOPCCONNPT].hr))
{
m_pIConnPtContainer =
(IConnectionPointContainer *)m_arrMultiQI [MQI_IOPCCONNPT].pItf;
if (m_pIConnPtContainer == NULL)
{
// Warning success but no valid pointer:
ASSERT (FALSE);
}
}
else
{
if (m_arrMultiQI [MQI_IOPCCONNPT].pItf != NULL)
{
// Warning failure but pointer not set to null:
ASSERT (FALSE);
}
TRACE (_T("OTC: Failed to query IConnectionPoint (%08X).\r\n"),
m_arrMultiQI [MQI_IOPCCONNPT].hr);
}
// Check IOPCItemProperties interface pointer:
if (SUCCEEDED (m_arrMultiQI [MQI_IOPCITEMPROP].hr))
{
m_pIItemProps =
(IOPCItemProperties *)m_arrMultiQI [MQI_IOPCITEMPROP].pItf;
if (m_pIItemProps == NULL)
{
// Warning success but no valid pointer:
ASSERT (FALSE);
}
}
else
{
if (m_arrMultiQI [MQI_IOPCITEMPROP].pItf != NULL)
{
// Warning failure but pointer not set to null:
ASSERT (FALSE);
}
TRACE (_T("OTC: Failed to query IOPCItemProperties (%08X).\r\n"),
m_arrMultiQI [MQI_IOPCITEMPROP].hr);
}
// Check IOPCBrowseServerAddressSpace interface pointer:
if (SUCCEEDED (m_arrMultiQI [MQI_IOPCBROWSE].hr))
{
m_pIBrowse =
(IOPCBrowseServerAddressSpace *)m_arrMultiQI [MQI_IOPCBROWSE].pItf;
if (m_pIBrowse == NULL)
{
// Warning success but no valid pointer:
ASSERT (FALSE);
}
}
else
{
if (m_arrMultiQI [MQI_IOPCBROWSE].pItf != NULL)
{
// Warning failure but pointer not set to null:
ASSERT (FALSE);
}
TRACE (_T("OTC: Failed to query IOPCBrowseServerAddressSpace (%08X).\r\n"),
m_arrMultiQI [MQI_IOPCBROWSE].hr);
}
// Check IOPCServerPublicGroups interface pointer:
if (SUCCEEDED (m_arrMultiQI [MQI_IOPCPUBLIC].hr))
{
m_pIPublicGroups =
(IOPCServerPublicGroups *)m_arrMultiQI [MQI_IOPCPUBLIC].pItf;
if (m_pIPublicGroups == NULL)
{
// Warning success but no valid pointer:
ASSERT (FALSE);
}
}
else
{
if (m_arrMultiQI [MQI_IOPCPUBLIC].pItf != NULL)
{
// Warning failure but pointer not set to null:
ASSERT (FALSE);
}
TRACE (_T("OTC: Failed to query IOPCServerPublicGroups (%08X).\r\n"),
m_arrMultiQI [MQI_IOPCPUBLIC].hr);
}
// Check IPersistFile interface pointer:
if (SUCCEEDED (m_arrMultiQI [MQI_IOPCPERSIST].hr))
{
m_pIPersistFile =
(IPersistFile *)m_arrMultiQI [MQI_IOPCPERSIST].pItf;
if (m_pIPersistFile == NULL)
{
// Warning success but no valid pointer:
ASSERT (FALSE);
}
}
else
{
if (m_arrMultiQI [MQI_IOPCPERSIST].pItf != NULL)
{
// Warning failure but pointer not set to null:
ASSERT (FALSE);
}
TRACE (_T("OTC: Failed to query IPersistsFile (%08X).\r\n"),
m_arrMultiQI [MQI_IOPCPERSIST].hr);
}
// Check IConnectionPointContainer interface pointer:
if (m_pIConnPtContainer != NULL)
{
// If the server supports the shutdown interface, provide a sink
// to the server.
// Get connection point pointer:
IConnectionPoint *pCP = NULL;
hr = m_pIConnPtContainer->FindConnectionPoint (IID_IOPCShutdown, &pCP);
// If we got the connection point, instantiate our shutdown sink:
if (SUCCEEDED (hr))
{
try
{
// Instantiate the shutdown sink and add us to its reference count:
m_pIShutdownSink = new IKShutdownSink (this);
m_pIShutdownSink->AddRef ();
// Give the connection point a pointer to our shutdown sink:
// (m_dwCookieShutdownSink is a returned token that uniquely
// identifies this connection.)
hr = pCP->Advise (m_pIShutdownSink, &m_dwCookieShutdownSink);
// We are done with the connection point, so release our reference:
pCP->Release ();
}
catch (...)
{
// If we find ourselves here, either "new" failed or pCP is bad.
ASSERT (FALSE);
hr = E_FAIL;
}
}
}
// We will base our success on the validity of the IOPCServer interface
// pointer. If it is invalid, then we won't be able do do anyting:
m_bConnected = (m_pIServer != NULL);
// Log success or failure:
if (m_bConnected)
LogMsg (IDS_SERVER_CONNECT_SUCCESS, GetProgID ());
else
LogMsg (IDS_SERVER_REQUIRED_IID_UNSUPPORTED, GetProgID (), hr);
}
// CoCreateInstanceEx failed:
else
{
// log failure
LogMsg (IDS_SERVER_CONNECT_FAILURE, GetProgID (), hr);
}
}
// Failed to get Class ID:
else
{
// Log failure:
LogMsg (IDS_SERVER_UNABLE_TO_GET_CLSID, GetProgID ());
}
// Return connected state:
return (m_bConnected);
}
void CreateInst(HTREEITEM item, WCHAR *wszMachineName)
{
TVITEMW tvi;
HTREEITEM hCur;
TVINSERTSTRUCTW tvis;
WCHAR wszTitle[MAX_LOAD_STRING];
WCHAR wszMessage[MAX_LOAD_STRING];
WCHAR wszFlagName[MAX_LOAD_STRING];
WCHAR wszTreeName[MAX_LOAD_STRING];
WCHAR wszRegPath[MAX_LOAD_STRING];
const WCHAR wszFormat[] = { '\n','%','s',' ','(','$','%','x',')','\n','\0' };
CLSID clsid;
COSERVERINFO remoteInfo;
MULTI_QI qi;
IUnknown *obj, *unk;
HRESULT hRes;
memset(&tvi, 0, sizeof(TVITEMW));
tvi.mask = TVIF_TEXT;
tvi.hItem = item;
tvi.cchTextMax = MAX_LOAD_STRING;
tvi.pszText = wszTreeName;
memset(&tvis, 0, sizeof(TVINSERTSTRUCTW));
U(tvis).item.mask = TVIF_TEXT|TVIF_PARAM;
U(tvis).item.cchTextMax = MAX_LOAD_STRING;
tvis.hInsertAfter = TVI_FIRST;
U(tvis).item.pszText = tvi.pszText;
tvis.hParent = item;
tvis.hInsertAfter = TVI_LAST;
if (!SendMessageW(globals.hTree, TVM_GETITEMW, 0, (LPARAM)&tvi)) return;
if(!tvi.lParam || ((ITEM_INFO *)tvi.lParam)->loaded
|| !(((ITEM_INFO *)tvi.lParam)->cFlag&SHOWALL)) return;
if(FAILED(CLSIDFromString(((ITEM_INFO *)tvi.lParam)->clsid, &clsid))) return;
if(wszMachineName)
{
remoteInfo.dwReserved1 = 0;
remoteInfo.dwReserved2 = 0;
remoteInfo.pAuthInfo = NULL;
remoteInfo.pwszName = wszMachineName;
qi.pIID = &IID_IUnknown;
CoCreateInstanceEx(&clsid, NULL, globals.dwClsCtx|CLSCTX_REMOTE_SERVER,
&remoteInfo, 1, &qi);
hRes = qi.hr;
obj = qi.pItf;
}
else hRes = CoCreateInstance(&clsid, NULL, globals.dwClsCtx,
&IID_IUnknown, (void **)&obj);
if(FAILED(hRes))
{
LoadStringW(globals.hMainInst, IDS_CGCOFAIL, wszMessage,
sizeof(wszMessage)/sizeof(wszMessage[0]));
LoadStringW(globals.hMainInst, IDS_ABOUT, wszTitle,
sizeof(wszTitle)/sizeof(wszTitle[0]));
#define CASE_ERR(i) case i: \
MultiByteToWideChar(CP_ACP, 0, #i, -1, wszFlagName, MAX_LOAD_STRING); \
break
switch(hRes)
{
CASE_ERR(REGDB_E_CLASSNOTREG);
CASE_ERR(E_NOINTERFACE);
CASE_ERR(REGDB_E_READREGDB);
CASE_ERR(REGDB_E_KEYMISSING);
CASE_ERR(CO_E_DLLNOTFOUND);
CASE_ERR(CO_E_APPNOTFOUND);
CASE_ERR(E_ACCESSDENIED);
CASE_ERR(CO_E_ERRORINDLL);
CASE_ERR(CO_E_APPDIDNTREG);
CASE_ERR(CLASS_E_CLASSNOTAVAILABLE);
default:
LoadStringW(globals.hMainInst, IDS_ERROR_UNKN, wszFlagName, sizeof(wszFlagName)/sizeof(wszFlagName[0]));
}
wsprintfW(&wszMessage[lstrlenW(wszMessage)], wszFormat,
wszFlagName, (unsigned)hRes);
MessageBoxW(globals.hMainWnd, wszMessage, wszTitle, MB_OK|MB_ICONEXCLAMATION);
return;
}
((ITEM_INFO *)tvi.lParam)->loaded = 1;
((ITEM_INFO *)tvi.lParam)->pU = obj;
tvi.mask = TVIF_STATE;
tvi.state = TVIS_BOLD;
tvi.stateMask = TVIS_BOLD;
SendMessageW(globals.hTree, TVM_SETITEMW, 0, (LPARAM)&tvi);
tvi.mask = TVIF_TEXT;
hCur = (HTREEITEM)SendMessageW(globals.hTree, TVM_GETNEXTITEM,
TVGN_CHILD, (LPARAM)tree.hI);
while(hCur)
{
tvi.hItem = hCur;
if(!SendMessageW(globals.hTree, TVM_GETITEMW, 0, (LPARAM)&tvi) || !tvi.lParam)
{
hCur = (HTREEITEM)SendMessageW(globals.hTree, TVM_GETNEXTITEM,
TVGN_NEXT, (LPARAM)hCur);
continue;
}
CLSIDFromString(((ITEM_INFO *)tvi.lParam)->clsid, &clsid);
hRes = IUnknown_QueryInterface(obj, &clsid, (void *)&unk);
if(SUCCEEDED(hRes))
{
IUnknown_Release(unk);
lstrcpyW(wszRegPath, wszInterface);
lstrcpyW(&wszRegPath[lstrlenW(wszRegPath)], ((ITEM_INFO *)tvi.lParam)->clsid);
U(tvis).item.lParam = CreateITEM_INFO(REGTOP|INTERFACE|REGPATH,
wszRegPath, ((ITEM_INFO *)tvi.lParam)->clsid, NULL);
SendMessageW(globals.hTree, TVM_INSERTITEMW, 0, (LPARAM)&tvis);
}
hCur = (HTREEITEM)SendMessageW(globals.hTree, TVM_GETNEXTITEM,
TVGN_NEXT, (LPARAM)hCur);
}
RefreshMenu(item);
RefreshDetails(item);
}
void lvDCOMInterface::createViRef(BSTR vi_name, bool reentrant, LabVIEW::VirtualInstrumentPtr& vi)
{
epicsThreadOnce(&onceId, initCOM, NULL);
std::wstring ws(vi_name, SysStringLen(vi_name));
HRESULT hr;
if ( (m_lv != NULL) && (m_lv->CheckConnection() == S_OK) )
{
;
}
else if (m_host.size() > 0)
{
std::cerr << "(Re)Making connection to LabVIEW on " << m_host << std::endl;
CComBSTR host(m_host.c_str());
m_pidentity = createIdentity(m_username, m_host, m_password);
COAUTHINFO* pauth = new COAUTHINFO;
COSERVERINFO csi = { 0, NULL, NULL, 0 };
pauth->dwAuthnSvc = RPC_C_AUTHN_WINNT;
pauth->dwAuthnLevel = RPC_C_AUTHN_LEVEL_DEFAULT;
pauth->dwAuthzSvc = RPC_C_AUTHZ_NONE;
pauth->dwCapabilities = EOAC_NONE;
pauth->dwImpersonationLevel = RPC_C_IMP_LEVEL_IMPERSONATE;
pauth->pAuthIdentityData = m_pidentity;
pauth->pwszServerPrincName = NULL;
csi.pwszName = host;
csi.pAuthInfo = pauth;
MULTI_QI mq[ 1 ] = { 0 };
mq[ 0 ].pIID = &IID_IDispatch; // &LabVIEW::DIID__Application; // &IID_IDispatch;
mq[ 0 ].pItf = NULL;
mq[ 0 ].hr = S_OK;
hr = CoCreateInstanceEx( m_clsid, NULL, CLSCTX_REMOTE_SERVER | CLSCTX_LOCAL_SERVER, &csi, 1, mq );
if( FAILED( hr ) )
{
hr = CoCreateInstanceEx( m_clsid, NULL, CLSCTX_ALL, &csi, 1, mq );
}
if( FAILED( hr ) )
{
throw COMexception("CoCreateInstanceEx (LabVIEW) ", hr);
}
if( S_OK != mq[ 0 ].hr || NULL == mq[ 0 ].pItf )
{
throw COMexception("CoCreateInstanceEx (LabVIEW)(mq) ", mq[ 0 ].hr);
}
setIdentity(m_pidentity, mq[ 0 ].pItf);
m_lv.Release();
m_lv.Attach( reinterpret_cast< LabVIEW::_Application* >( mq[ 0 ].pItf ) );
std::cerr << "Successfully connected to LabVIEW on " << m_host << std::endl;
}
else
{
std::cerr << "(Re)Making local connection to LabVIEW" << std::endl;
m_pidentity = NULL;
m_lv.Release();
hr = m_lv.CoCreateInstance(m_clsid, NULL, CLSCTX_LOCAL_SERVER);
if( FAILED( hr ) )
{
throw COMexception("CoCreateInstance (LabVIEW) ", hr);
}
std::cerr << "Successfully connected to local LabVIEW" << std::endl;
}
if (reentrant)
{
vi = m_lv->GetVIReference(vi_name, "", 1, 8);
setIdentity(m_pidentity, vi);
}
else
{
//If a VI is reentrant then always get it as reentrant
vi = m_lv->GetVIReference(vi_name, "", 0, 0);
setIdentity(m_pidentity, vi);
if (vi->IsReentrant)
{
vi = m_lv->GetVIReference(vi_name, "", 1, 8);
setIdentity(m_pidentity, vi);
reentrant = true;
}
}
ViRef viref(vi, reentrant, false);
// LabVIEW::ExecStateEnum::eIdle = 1
// LabVIEW::ExecStateEnum::eRunTopLevel = 2
if (vi->ExecState == LabVIEW::eIdle)
{
if ( checkOption(viStartIfIdle) )
{
std::cerr << "Starting \"" << CW2CT(vi_name) << "\" on " << (m_host.size() > 0 ? m_host : "localhost") << std::endl;
vi->Run(true);
viref.started = true;
}
else if ( checkOption(viWarnIfIdle) )
{
std::cerr << "\"" << CW2CT(vi_name) << "\" is not running on " << (m_host.size() > 0 ? m_host : "localhost") << " and autostart is disabled" << std::endl;
}
}
m_vimap[ws] = viref;
}
