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;
}
bool CAdminSessionClass::IsEqualBSTR(BSTR bstr1, BSTR bstr2)
{
// Equal if both are empty
if (!BSTRLen(bstr1) && !BSTRLen(bstr2))
return true;
else if (!BSTRLen(bstr2))
return false;
// Compare strings
return 0 == wcscmp(bstr1, bstr2);
}
HRESULT CAGCEventDef::ExpandParams(BSTR bstrFmt, IAGCEvent* pEvent,
CAGCEventDef::XParamStrings& rParams)
{
assert(BSTRLen(bstrFmt));
// Initialize the parsing data
XParseData data =
{pEvent, NULL, &rParams, NULL, NULL, bstrFmt, NULL, false};
// Iterate through the characters of the format string
XStateProc pfnState = ParseState_Base;
for (UINT cch = SysStringLen(bstrFmt); cch && pfnState; --cch)
{
RETURN_FAILED(pfnState(data));
pfnState = data.m_pfnNextState;
++data.m_pszInput;
}
data.m_bEndOfString = true;
while (pfnState)
{
RETURN_FAILED(pfnState(data));
pfnState = data.m_pfnNextState;
}
// Indicate success
return S_OK;
}
HRESULT CAGCEventDef::ExpandFmtString(BSTR bstrFmt, IAGCEvent* pEvent,
BSTR* pbstrOut)
{
assert(BSTRLen(bstrFmt));
assert(pbstrOut);
// Create a growable stream into which we'll write
IStreamPtr spStm;
RETURN_FAILED(CreateStreamOnHGlobal(NULL, true, &spStm));
// Initialize the parsing data
XParseData data =
{pEvent, spStm, NULL, NULL, NULL, bstrFmt, NULL, false};
// Iterate through the characters of the format string
XStateProc pfnState = ParseState_Base;
for (UINT cch = SysStringLen(bstrFmt); cch && pfnState; --cch)
{
RETURN_FAILED(pfnState(data));
pfnState = data.m_pfnNextState;
++data.m_pszInput;
}
data.m_bEndOfString = true;
while (pfnState)
{
RETURN_FAILED(pfnState(data));
pfnState = data.m_pfnNextState;
}
// Get the current seek pointer of the stream (which is it's size)
LARGE_INTEGER li = {0};
ULARGE_INTEGER uli;
RETURN_FAILED(spStm->Seek(li, STREAM_SEEK_CUR, &uli));
UINT cchStream = (UINT)uli.QuadPart / sizeof(OLECHAR);
// Get the HGLOBAL underlying the stream
HGLOBAL hGlobal = NULL;
RETURN_FAILED(GetHGlobalFromStream(spStm, &hGlobal));
assert(hGlobal);
// Lock the HGLOBAL
LPCOLESTR pszOut = reinterpret_cast<LPCOLESTR>(GlobalLock(hGlobal));
assert(pszOut);
// Create a BSTR from the byte stream
*pbstrOut = SysAllocStringLen(pszOut, cchStream);
// Unlock the HGLOBAL
GlobalUnlock(hGlobal);
// Indicate success or failure
return *pbstrOut ? S_OK : E_OUTOFMEMORY;
}
///////////////////////////////////////////////////////
//
// Function: BSTRToChar
//
// Parameters: x- a BSTR string
//
// Action: converts a BSTR string to a char string
//
// Returns: char*- the converted string.
//
///////////////////////////////////////////////////////
char* BSTRtoChar(BSTR x)
{
int len = BSTRLen(x);
char* pstrRet = new char[len+1];
strcpy(pstrRet, "");
for (int i=0; i<len; i++)
{
unsigned int part = x[i];
pstrRet[i] = part;
pstrRet[i+1] = '\0';
}
return pstrRet;
}
IclusterIGC* CPigShip::FindCluster(BSTR bstrSector)
{
if (!BSTRLen(bstrSector))
return NULL;
USES_CONVERSION;
LPCSTR pszSector = OLE2CA(bstrSector);
const ClusterListIGC* pClusters = GetIGC()->GetMission()->GetClusters();
for (ClusterLinkIGC* it = pClusters->first(); it; it = it->next())
{
IclusterIGC* pCluster = it->data();
if (0 == _stricmp(pCluster->GetName(), pszSector))
return pCluster;
}
return NULL;
}
HKEY CTCPropBagOnRegKey::RootKeyFromString(BSTR bstrRegKey, DWORD* cchEaten)
{
// Define a static lookup table
struct XRootKeys
{
LPCOLESTR pszName;
DWORD cchName;
HKEY hkey;
};
const static XRootKeys s_table[] =
{
{L"HKCR\\" , 5, HKEY_CLASSES_ROOT },
{L"HKCU\\" , 5, HKEY_CURRENT_USER },
{L"HKLM\\" , 5, HKEY_LOCAL_MACHINE },
{L"HKCC\\" , 5, HKEY_CURRENT_CONFIG },
{L"HKPD\\" , 5, HKEY_PERFORMANCE_DATA},
{L"HKDD\\" , 5, HKEY_DYN_DATA },
{L"HKEY_CLASSES_ROOT\\" , 18, HKEY_CLASSES_ROOT },
{L"HKEY_CURRENT_USER\\" , 18, HKEY_CURRENT_USER },
{L"HKEY_LOCAL_MACHINE\\" , 19, HKEY_LOCAL_MACHINE },
{L"HKEY_CURRENT_CONFIG\\" , 20, HKEY_CURRENT_CONFIG },
{L"HKEY_PERFORMANCE_DATA\\", 22, HKEY_PERFORMANCE_DATA},
{L"HKEY_DYN_DATA\\" , 14, HKEY_DYN_DATA },
};
const static long s_cEntries = sizeofArray(s_table);
// Search for an allowed root key name
if (BSTRLen(bstrRegKey))
{
for (long i = 0; i < s_cEntries; ++i)
{
if (!wcsnicmp(s_table[i].pszName, bstrRegKey, s_table[i].cchName))
{
*cchName = s_table[i].cchName;
return s_table[i].hkey;
}
}
}
// Could not find the specified string
*cchName = 0;
return NULL;
}
ImodelIGC* CPigShip::FindModel(BSTR bstrModel)
{
if (!BSTRLen(bstrModel))
return NULL;
USES_CONVERSION;
LPCSTR pszModel = OLE2CA(bstrModel);
const ClusterListIGC* pClusters = GetIGC()->GetMission()->GetClusters();
for (ClusterLinkIGC* itCluster = pClusters->first(); itCluster; itCluster = itCluster->next())
{
IclusterIGC* pCluster = itCluster->data();
const ModelListIGC* pModels = pCluster->GetModels();
for (ModelLinkIGC* it = pModels->first(); it; it = it->next())
{
ImodelIGC* pModel = it->data();
if (0 == _stricmp(GetModelName(pModel), pszModel))
return pModel;
}
}
return NULL;
}
HRESULT __fastcall
CAGCEventDef::ParseState_ProcessVar(CAGCEventDef::XParseData& data)
{
// Get the variable as a VT_BSTR variant
UINT cch = data.m_pszVarEnd - data.m_pszVarBegin;
CComVariant varKey;
V_VT(&varKey) = VT_BSTR;
V_BSTR(&varKey) = ::SysAllocStringLen(data.m_pszVarBegin, cch);
if (!V_BSTR(&varKey))
{
data.m_pfnNextState = NULL;
return E_OUTOFMEMORY;
}
// Lookup the variable in the event's properties
CComVariant varValue;
HRESULT hr = data.m_pEvent->get_Property(&varKey, &varValue);
if (FAILED(hr))
{
data.m_pfnNextState = NULL;
return hr;
}
// Just write the variable name as-is if it doesn't exist in the event
if (VT_EMPTY == V_VT(&varValue))
{
// Include the leading and trailing '%' characters
--data.m_pszVarBegin;
++data.m_pszVarEnd;
if (data.m_pParams)
{
cch = data.m_pszVarEnd - data.m_pszVarBegin;
BSTR bstrValue = SysAllocStringLen(data.m_pszVarBegin, cch);
if (!bstrValue)
{
data.m_pfnNextState = NULL;
return E_OUTOFMEMORY;
}
data.m_pParams->push_back(bstrValue);
}
return ParseState_WriteVar(data);
}
// Convert the variant to a string
if (VT_BSTR != V_VT(&varValue))
{
VariantChangeTypeEx(&varValue, &varValue, GetThreadLocale(),
VARIANT_LOCALBOOL | VARIANT_ALPHABOOL, VT_BSTR);
if (VT_BSTR != V_VT(&varValue))
{
data.m_pfnNextState = ParseState_Base;
return S_OK;
}
}
UINT cchValue = BSTRLen(V_BSTR(&varValue));
if (!cchValue)
{
if (data.m_pParams)
{
BSTR bstrValue = SysAllocString(L"");
if (!bstrValue)
{
data.m_pfnNextState = NULL;
return E_OUTOFMEMORY;
}
data.m_pParams->push_back(bstrValue);
}
data.m_pfnNextState = ParseState_Base;
return S_OK;
}
// Write the value string
data.m_pszVarBegin = V_BSTR(&varValue);
data.m_pszVarEnd = data.m_pszVarBegin + cchValue;
RETURN_FAILED(ParseState_WriteVar(data));
if (data.m_pParams)
{
data.m_pParams->push_back(V_BSTR(&varValue));
V_VT(&varValue) = VT_EMPTY; // Detaches the BSTR from the VARIANT
}
// Indicate success
return S_OK;
}
HRESULT CPigEngine::put_AccountServer(BSTR bstrServer)
{
// Get the number of pigs that exist
XLock lock(this);
long cPigs = 0;
if (m_pPigs)
RETURN_FAILED(m_pPigs->get_Count(&cPigs));
// Fail if there are any pigs in existance
if (cPigs)
return AtlReportError(CLSID_PigSession, IDS_E_PROPUT_PIGSEXIST,
IID_IPigSession, 0, _Module.GetResourceInstance());
// Open the registry key of the AppID
CRegKey key;
RETURN_FAILED(_Module.OpenAppIDRegKey(key));
// Save the specified value
USES_CONVERSION;
long lr = key.SetValue(BSTRLen(bstrServer) ? OLE2CT(bstrServer) : TEXT(""),
TEXT("AccountServer"));
if (ERROR_SUCCESS != lr)
return HRESULT_FROM_WIN32(lr);
// Save the string
m_bstrAccountServer = bstrServer;
// Indicate success
return S_OK;
}
