You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2075 lines
45 KiB
2075 lines
45 KiB
// compkey.cpp: implementation of the CCompoundKey class
|
|
// Copyright (c)1997-2001 Microsoft Corporation
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
// original author: shawnwu
|
|
// creation date: 4/18/2001
|
|
|
|
#include "precomp.h"
|
|
#include "compkey.h"
|
|
#include "persistmgr.h"
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CompKeyLessThan::operator()
|
|
|
|
Functionality:
|
|
|
|
override () operator
|
|
|
|
Virtual:
|
|
|
|
No.
|
|
|
|
Arguments:
|
|
|
|
pX - left.
|
|
pY - right.
|
|
|
|
Return Value:
|
|
|
|
read code. It's easier that way.
|
|
|
|
Notes:
|
|
We are not really doing much other than call CCompoundKey's operator <.
|
|
|
|
*/
|
|
|
|
bool CompKeyLessThan::operator() (
|
|
IN const CCompoundKey* pX,
|
|
IN const CCompoundKey* pY
|
|
) const
|
|
{
|
|
if (pX == NULL && pY != NULL)
|
|
return true;
|
|
else if (pX != NULL && pY == NULL)
|
|
return false;
|
|
else
|
|
return *pX < *pY;
|
|
}
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CCompoundKey::CCompoundKey
|
|
|
|
Functionality:
|
|
|
|
constructor.
|
|
|
|
Virtual:
|
|
|
|
No.
|
|
|
|
Arguments:
|
|
|
|
dwSize - This will be size of the compound key's capacity to hold values.
|
|
you can't change it.
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
Notes:
|
|
If dwSize == 0, it's considered a null key. Null keys are useful for identifying
|
|
static method calls, and singletons (because they don't have keys)
|
|
|
|
*/
|
|
|
|
CCompoundKey::CCompoundKey (
|
|
IN DWORD dwSize
|
|
)
|
|
:
|
|
m_dwSize(dwSize),
|
|
m_pValues(NULL)
|
|
{
|
|
if (m_dwSize > 0)
|
|
{
|
|
m_pValues = new VARIANT*[m_dwSize];
|
|
if (m_pValues == NULL)
|
|
{
|
|
m_dwSize = 0;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// make sure that we initialize those VARIANT* to NULL
|
|
// because we are going to own them and delete them!
|
|
//
|
|
|
|
::memset(m_pValues, 0, m_dwSize * sizeof(VARIANT*));
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CCompoundKey::~CCompoundKey
|
|
|
|
Functionality:
|
|
|
|
destructor.
|
|
|
|
Virtual:
|
|
|
|
No.
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
Notes:
|
|
Just need to know how to delete a VARIANT*
|
|
|
|
*/
|
|
|
|
CCompoundKey::~CCompoundKey()
|
|
{
|
|
for (DWORD i = 0; i < m_dwSize; i++)
|
|
{
|
|
if (m_pValues[i])
|
|
{
|
|
::VariantClear(m_pValues[i]);
|
|
delete m_pValues[i];
|
|
}
|
|
}
|
|
delete [] m_pValues;
|
|
}
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CCompoundKey::AddKeyPropertyValue
|
|
|
|
Functionality:
|
|
|
|
Add a key property value to this compound key.
|
|
|
|
Virtual:
|
|
|
|
No.
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return Value:
|
|
|
|
WBEM_NO_ERROR if succeeded.
|
|
|
|
WBEM_E_INVALID_PARAMETER if ppVar == NULL;
|
|
|
|
WBEM_E_VALUE_OUT_OF_RANGE is the given index is not in range.
|
|
|
|
Notes:
|
|
CCompoundKey doesn't keep track of property names. Instead, it simply records
|
|
its values. The order this function is called determines what value belongs to
|
|
what property. Caller must keep track of that order. Different compound keys
|
|
become comparable only if they have the same order.
|
|
Also, the in coming parameter *ppVar is owned by the this object after this call
|
|
|
|
*/
|
|
|
|
HRESULT
|
|
CCompoundKey::AddKeyPropertyValue (
|
|
IN DWORD dwIndex,
|
|
IN OUT VARIANT ** ppVar
|
|
)
|
|
{
|
|
if (ppVar == NULL)
|
|
{
|
|
return WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
else if (dwIndex >= m_dwSize)
|
|
{
|
|
return WBEM_E_VALUE_OUT_OF_RANGE;
|
|
}
|
|
|
|
//
|
|
// if there is already a value, then we need to delete the old one
|
|
//
|
|
|
|
if (m_pValues[dwIndex])
|
|
{
|
|
::VariantClear(m_pValues[dwIndex]);
|
|
delete m_pValues[dwIndex];
|
|
}
|
|
|
|
//
|
|
// attach to the new one
|
|
//
|
|
|
|
m_pValues[dwIndex] = *ppVar;
|
|
|
|
//
|
|
// hey, we own it now
|
|
//
|
|
|
|
*ppVar = NULL;
|
|
|
|
return WBEM_NO_ERROR;
|
|
}
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CCompoundKey::GetPropertyValue
|
|
|
|
Functionality:
|
|
|
|
Retrieve a key property value by key property index (caller must know that).
|
|
|
|
Virtual:
|
|
|
|
No.
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return Value:
|
|
|
|
Read code.
|
|
|
|
Notes:
|
|
See AddKeyPropertyValue's notes
|
|
|
|
*/
|
|
|
|
HRESULT
|
|
CCompoundKey::GetPropertyValue (
|
|
IN DWORD dwIndex,
|
|
OUT VARIANT * pVar
|
|
)const
|
|
{
|
|
if (pVar == NULL)
|
|
{
|
|
return WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
else if (dwIndex >= m_dwSize)
|
|
{
|
|
return WBEM_E_VALUE_OUT_OF_RANGE;
|
|
}
|
|
|
|
//
|
|
// make sure that our out-bound parameter is in a empty state
|
|
//
|
|
|
|
::VariantInit(pVar);
|
|
|
|
if (m_pValues[dwIndex])
|
|
{
|
|
return ::VariantCopy(pVar, m_pValues[dwIndex]);
|
|
}
|
|
else
|
|
{
|
|
return WBEM_E_NOT_AVAILABLE;
|
|
}
|
|
}
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CCompoundKey::operator <
|
|
|
|
Functionality:
|
|
|
|
Compare this object with the in-bound parameter and see which compound key
|
|
key is greater. Ultimately, the relation is determined by the variant values
|
|
of each corresponding key property.
|
|
|
|
Virtual:
|
|
|
|
No.
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return Value:
|
|
|
|
Read code.
|
|
|
|
Notes:
|
|
(1) See AddKeyPropertyValue's notes.
|
|
(2) See CompareVariant's notes
|
|
|
|
*/
|
|
|
|
bool
|
|
CCompoundKey::operator < (
|
|
IN const CCompoundKey& right
|
|
)const
|
|
{
|
|
//
|
|
// defensive against potential erroneous comparison.
|
|
// This shouldn't happen in our correct use. But sometimes we write
|
|
// less-than-correct code.
|
|
//
|
|
|
|
if (m_dwSize != right.m_dwSize)
|
|
{
|
|
return (m_dwSize < right.m_dwSize);
|
|
}
|
|
|
|
int iComp = 0;
|
|
|
|
//
|
|
// The first less than or greater than result wins
|
|
//
|
|
|
|
for (int i = 0; i < m_dwSize; i++)
|
|
{
|
|
//
|
|
// if both variants are valid
|
|
//
|
|
|
|
if (m_pValues[i] != NULL && right.m_pValues[i] != NULL)
|
|
{
|
|
//
|
|
// CompareVariant returns the exact same int value
|
|
// as string comparison results
|
|
//
|
|
|
|
iComp = CompareVariant(m_pValues[i], right.m_pValues[i]);
|
|
if (iComp > 0)
|
|
{
|
|
return false;
|
|
}
|
|
else if (iComp < 0)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//
|
|
// else is equal! need to continue comparing the rest of the values
|
|
//
|
|
}
|
|
else if (m_pValues[i] == NULL)
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// right.m_pValues[i] == NULL
|
|
//
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//
|
|
// if reach here, this must be an equal case
|
|
//
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CCompoundKey::CompareVariant
|
|
|
|
Functionality:
|
|
|
|
Compare two variants
|
|
|
|
Virtual:
|
|
|
|
No.
|
|
|
|
Arguments:
|
|
|
|
pVar1 - must not be NULL
|
|
pVar2 - must not be NULL
|
|
|
|
Return Value:
|
|
|
|
less than 0 if pVar1 < pVar2
|
|
Greater than 0 if pVar1 < pVar2
|
|
0 if they are considered equal
|
|
|
|
Notes:
|
|
(1) for efficiency reasons, we don't check the parameters.
|
|
(2) The reason we are doing this is due the fact that WMI will give us inconsistent
|
|
path when boolean are used. Sometimes it gives boolVal=TRUE, sometimes it gives
|
|
boolVal=1. This creates problems for us.
|
|
(3) This function currently only works for our supported vt types.
|
|
(4) type mismatch will only be dealt with if one of them is boolean.
|
|
|
|
*/
|
|
|
|
int
|
|
CCompoundKey::CompareVariant (
|
|
IN VARIANT* pVar1,
|
|
IN VARIANT* pVar2
|
|
)const
|
|
{
|
|
//
|
|
// default to equal because that is the only consistent value
|
|
// in case of failure
|
|
//
|
|
|
|
int iResult = 0;
|
|
|
|
VARIANT varCoerced1;
|
|
::VariantInit(&varCoerced1);
|
|
|
|
VARIANT varCoerced2;
|
|
::VariantInit(&varCoerced2);
|
|
|
|
//
|
|
// if both are strings, then use case-insensitive comparison
|
|
//
|
|
|
|
if (pVar1->vt == pVar2->vt && pVar1->vt == VT_BSTR)
|
|
{
|
|
iResult = _wcsicmp(pVar1->bstrVal, pVar2->bstrVal);
|
|
}
|
|
|
|
//
|
|
// if one is boolean, then coerced both to boolean
|
|
//
|
|
else if (pVar1->vt == VT_BOOL || pVar2->vt == VT_BOOL)
|
|
{
|
|
//
|
|
// in case the coersion fails, we will call the failed one less then the succeeded one.
|
|
// Don't use the WBEM_NO_ERROR even though they are defined to be S_OK. WMI may change it
|
|
// later. So, use the MSDN documented hresult values
|
|
//
|
|
|
|
HRESULT hr1 = ::VariantChangeType(&varCoerced1, pVar1, VARIANT_LOCALBOOL, VT_BOOL);
|
|
HRESULT hr2 = ::VariantChangeType(&varCoerced2, pVar2, VARIANT_LOCALBOOL, VT_BOOL);
|
|
|
|
if (hr1 == S_OK && hr2 == S_OK)
|
|
{
|
|
if (varCoerced1.boolVal == varCoerced2.lVal)
|
|
{
|
|
//
|
|
// equal
|
|
//
|
|
|
|
iResult = 0;
|
|
}
|
|
else if (varCoerced1.boolVal == VARIANT_TRUE)
|
|
{
|
|
//
|
|
// greater
|
|
//
|
|
|
|
iResult = 1;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// less
|
|
//
|
|
|
|
iResult = -1;
|
|
}
|
|
}
|
|
else if (hr1 == S_OK)
|
|
{
|
|
//
|
|
// second coersion fails, we say the second is greater
|
|
//
|
|
|
|
iResult = 1;
|
|
}
|
|
else if (hr2 == S_OK)
|
|
{
|
|
//
|
|
// first coersion fails, we say the first is greater
|
|
//
|
|
|
|
iResult = -1;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// both fails. We are out of luck.
|
|
//
|
|
|
|
iResult = 0;
|
|
}
|
|
}
|
|
|
|
//
|
|
// everything else, coerced both to VI_I4
|
|
//
|
|
|
|
else
|
|
{
|
|
|
|
HRESULT hr1 = ::VariantChangeType(&varCoerced1, pVar1, VARIANT_LOCALBOOL, VT_I4);
|
|
HRESULT hr2 = ::VariantChangeType(&varCoerced2, pVar2, VARIANT_LOCALBOOL, VT_I4);
|
|
|
|
if (hr1 == S_OK && hr2 == S_OK)
|
|
{
|
|
iResult = varCoerced1.lVal - varCoerced2.lVal;
|
|
}
|
|
else if (hr1 == S_OK)
|
|
{
|
|
//
|
|
// second coersion fails, we say the second is greater
|
|
//
|
|
|
|
iResult = 1;
|
|
}
|
|
else if (hr2 == S_OK)
|
|
{
|
|
//
|
|
// first coersion fails, we say the first is greater
|
|
//
|
|
|
|
iResult = -1;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// both fails. We are out of luck.
|
|
//
|
|
|
|
iResult = 0;
|
|
}
|
|
}
|
|
|
|
::VariantClear(&varCoerced1);
|
|
::VariantClear(&varCoerced2);
|
|
|
|
return iResult;
|
|
}
|
|
|
|
//
|
|
// implementation of CExtClassInstCookieList
|
|
//
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CExtClassInstCookieList::CExtClassInstCookie
|
|
|
|
Functionality:
|
|
|
|
constructor.
|
|
|
|
Virtual:
|
|
|
|
No.
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
Notes:
|
|
(1) INVALID_COOKIE is the invalid cookie value.
|
|
(2) No thread safety. Caller must be aware.
|
|
|
|
*/
|
|
|
|
CExtClassInstCookieList::CExtClassInstCookieList ()
|
|
:
|
|
m_dwMaxCookie(INVALID_COOKIE),
|
|
m_pVecNames(NULL),
|
|
m_dwCookieArrayCount(0)
|
|
{
|
|
}
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CExtClassInstCookieList::~CExtClassInstCookieList
|
|
|
|
Functionality:
|
|
|
|
destructor.
|
|
|
|
Virtual:
|
|
|
|
No.
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
Notes:
|
|
(1) No thread safety. Caller must be aware.
|
|
|
|
*/
|
|
|
|
CExtClassInstCookieList::~CExtClassInstCookieList ()
|
|
{
|
|
Cleanup();
|
|
}
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CExtClassInstCookieList::Create
|
|
|
|
Functionality:
|
|
|
|
Given a store and a section name (each class has a section corresponding to it, as
|
|
a matter of fact, the section name is, in current implementation, the class name),
|
|
this function populates its contents.
|
|
|
|
Virtual:
|
|
|
|
No.
|
|
|
|
Arguments:
|
|
|
|
pSceStore - pointer to the CSceStore object prepared to read
|
|
|
|
pszSectionName - section name where this cookie list is to be created.
|
|
|
|
pvecNames - the vector that holds the key property names in order. We rely
|
|
on this vector as our order guidence to push values into our own vector.
|
|
Remember? those two things must match in their order.
|
|
A NULL in-bounding value means it intends to create a NULL key cookie
|
|
|
|
Return Value:
|
|
|
|
Success: WBEM_NO_ERROR
|
|
|
|
Failure: Various HRESULT code. In particular, if the cookie array is incorrectly formated
|
|
( it must be a integer number delimited by : (including the trailing : at the end), then
|
|
we return WBEM_E_INVALID_SYNTAX.
|
|
|
|
Any failure indicates that the cookie list is not created.
|
|
|
|
Notes:
|
|
(1) No thread safety. Caller must be aware.
|
|
|
|
*/
|
|
|
|
HRESULT
|
|
CExtClassInstCookieList::Create (
|
|
IN CSceStore * pSceStore,
|
|
IN LPCWSTR pszSectionName,
|
|
IN std::vector<BSTR> * pvecNames
|
|
)
|
|
{
|
|
//
|
|
// we must have a valid store and a valid section name
|
|
//
|
|
|
|
if (pSceStore == NULL || pszSectionName == NULL)
|
|
{
|
|
return WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
|
|
m_pVecNames = pvecNames;
|
|
|
|
//
|
|
// 1 is reserved for pszListPrefix
|
|
//
|
|
|
|
WCHAR szCookieList[MAX_INT_LENGTH + 1];
|
|
WCHAR szCompKey[MAX_INT_LENGTH + 1];
|
|
|
|
HRESULT hr = WBEM_NO_ERROR;
|
|
|
|
//
|
|
// Assume that we have no cookie array
|
|
//
|
|
|
|
m_dwCookieArrayCount = 0;
|
|
|
|
//
|
|
// cookie list is persisted in the following fashion: "A1=n:m:k:", "A2=n:m:k:", "A3=n:m:k:"
|
|
// where 'A' == pszListPrefix.
|
|
//
|
|
|
|
//
|
|
// enumerate all such possiblilities until we see a non-existent Ai (i is a integer).
|
|
//
|
|
|
|
DWORD dwCount = 1;
|
|
while (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// First, we need to create the cookie list name
|
|
//
|
|
|
|
wsprintf(szCookieList, L"%s%d", pszListPrefix, dwCount++);
|
|
DWORD dwRead = 0;
|
|
|
|
//
|
|
// pszBuffer will hold the contents read from the store.
|
|
// Need to free the memory allocated for pszBuffer
|
|
//
|
|
|
|
LPWSTR pszBuffer = NULL;
|
|
hr = pSceStore->GetPropertyFromStore(pszSectionName, szCookieList, &pszBuffer, &dwRead);
|
|
|
|
if (SUCCEEDED(hr) && pszBuffer)
|
|
{
|
|
//
|
|
// so far, we have this many cookie arrays
|
|
//
|
|
|
|
m_dwCookieArrayCount += 1;
|
|
|
|
LPCWSTR pszCur = pszBuffer;
|
|
DWORD dwCookie = 0;
|
|
|
|
//
|
|
// as long as it is a digit
|
|
//
|
|
|
|
while (iswdigit(*pszCur))
|
|
{
|
|
//
|
|
// conver the first portion as a number
|
|
//
|
|
|
|
dwCookie = _wtol(pszCur);
|
|
|
|
//
|
|
// First, prepare the composite key's name (K1, K2, depending on the dwCookie.)
|
|
//
|
|
|
|
wsprintf(szCompKey, L"%s%d", pszKeyPrefix, dwCookie);
|
|
|
|
//
|
|
// read the composite key of this cookie
|
|
// need to free the memory allocated for pszCompKeyBuffer
|
|
//
|
|
|
|
LPWSTR pszCompKeyBuffer = NULL;
|
|
DWORD dwCompKeyLen = 0;
|
|
|
|
hr = pSceStore->GetPropertyFromStore(pszSectionName, szCompKey, &pszCompKeyBuffer, &dwCompKeyLen);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// AddCompKey can be called for two purposes (simply adding, or adding and requesting a new cookie)
|
|
// Here, we are just adding. But we need a place holder.
|
|
//
|
|
DWORD dwNewCookie = INVALID_COOKIE;
|
|
|
|
//
|
|
// we are truly adding the (compound key, cookie) pair
|
|
//
|
|
|
|
hr = AddCompKey(pszCompKeyBuffer, dwCookie, &dwNewCookie);
|
|
|
|
//
|
|
// increate the max used cookie member if appropriate
|
|
//
|
|
|
|
if (dwCookie > m_dwMaxCookie)
|
|
{
|
|
m_dwMaxCookie = dwCookie;
|
|
}
|
|
}
|
|
|
|
delete [] pszCompKeyBuffer;
|
|
|
|
//
|
|
//skip the current portion of the integer
|
|
//
|
|
|
|
while (iswdigit(*pszCur))
|
|
{
|
|
++pszCur;
|
|
}
|
|
|
|
if (*pszCur == wchCookieSep)
|
|
{
|
|
//
|
|
// skip the ':'
|
|
//
|
|
|
|
++pszCur;
|
|
}
|
|
else if (*pszCur == L'\0')
|
|
{
|
|
//
|
|
// see the end
|
|
//
|
|
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// see an invalid character
|
|
//
|
|
|
|
hr = WBEM_E_INVALID_SYNTAX;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if (hr == WBEM_E_NOT_FOUND)
|
|
{
|
|
// if Ai doesn't exist, we no longer look for A(i+1). For example, if A3 doesn't exist, then we
|
|
// no longer look for A4, A5, etc. So, if property manager fails to get Ai, we consider this as
|
|
// no more data.
|
|
|
|
delete [] pszBuffer;
|
|
pszBuffer = NULL;
|
|
hr = WBEM_NO_ERROR;
|
|
break;
|
|
}
|
|
|
|
delete [] pszBuffer;
|
|
}
|
|
|
|
//
|
|
// in case of failure, set proper default
|
|
//
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
//
|
|
// maybe partial construction, so clean it up
|
|
//
|
|
|
|
Cleanup();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CExtClassInstCookieList::Save
|
|
|
|
Functionality:
|
|
|
|
save the cookie list into a store.
|
|
|
|
Virtual:
|
|
|
|
No.
|
|
|
|
Arguments:
|
|
|
|
pSceStore - pointer to the CSceStore object prepared for save
|
|
|
|
pszSectionName - section name where this cookie list is to be created.
|
|
|
|
Return Value:
|
|
|
|
Success: various potential success code. Use SUCCEEDED to test.
|
|
|
|
Failure: Various HRESULT code.
|
|
|
|
Any failure indicates that the cookie list is not saved properly.
|
|
|
|
Notes:
|
|
(1) No thread safety. Caller must be aware.
|
|
|
|
*/
|
|
|
|
HRESULT
|
|
CExtClassInstCookieList::Save (
|
|
IN CSceStore* pSceStore,
|
|
IN LPCWSTR pszSectionName
|
|
)
|
|
{
|
|
//
|
|
// pszBuffer will hold upto MAX_COOKIE_COUNT_PER_LINE count of cookie info = <cookie number> plus separater
|
|
//
|
|
|
|
LPWSTR pszBuffer = new WCHAR [(MAX_INT_LENGTH + 1) * MAX_COOKIE_COUNT_PER_LINE + 1];
|
|
if (pszBuffer == NULL)
|
|
{
|
|
return WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
|
|
//
|
|
// allocate a generous buffer to hold the key name and cookie array name
|
|
//
|
|
|
|
LPWSTR pszKey = new WCHAR[MAX_INT_LENGTH + wcslen(pszKeyPrefix) + wcslen(pszListPrefix) + 1];
|
|
if (pszKey == NULL)
|
|
{
|
|
delete [] pszBuffer;
|
|
return WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
|
|
DWORD dwCookieArrayCount = 1;
|
|
|
|
int iLenKey = wcslen(pszKeyPrefix);
|
|
int iLen = wcslen(pszListPrefix);
|
|
|
|
if (iLen < iLenKey)
|
|
{
|
|
iLen = iLenKey;
|
|
}
|
|
|
|
HRESULT hr = WBEM_NO_ERROR;
|
|
DWORD dwCookieCount = m_vecCookies.size();
|
|
|
|
//
|
|
// going through all cookies. Since we want to preserve the order
|
|
// this time, we need to use the m_vecCookies to enumerate.
|
|
//
|
|
|
|
DWORD dwIndex = 0;
|
|
|
|
while (dwIndex < dwCookieCount)
|
|
{
|
|
//
|
|
// this loop is to:
|
|
// (1) write the string version of each compound key
|
|
// (2) pack enough cookies into the cookie list (but won't write it)
|
|
//
|
|
|
|
LPWSTR pCur = pszBuffer;
|
|
|
|
for (int i = 0; (i < MAX_COOKIE_COUNT_PER_LINE) && (dwIndex < dwCookieCount); ++i, dwIndex++)
|
|
{
|
|
//
|
|
// packing the cookies into the cookie list. We need to advance our
|
|
// pCur to the next position (of pszBuffer) to write
|
|
//
|
|
|
|
wsprintf(pCur, L"%d%c", m_vecCookies[dwIndex]->dwCookie, wchCookieSep);
|
|
pCur += wcslen(pCur);
|
|
|
|
//
|
|
// now, write Knnn=<compound key>
|
|
//
|
|
|
|
wsprintf(pszKey, L"%s%d", pszKeyPrefix, m_vecCookies[dwIndex]->dwCookie);
|
|
CComBSTR bstrCompKey;
|
|
|
|
//
|
|
// create the string version of the composite key (the <compound key>)
|
|
//
|
|
|
|
hr = CreateCompoundKeyString(&bstrCompKey, m_vecCookies[dwIndex]->pKey);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pSceStore->SavePropertyToStore(pszSectionName, pszKey, (LPCWSTR)bstrCompKey);
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// if everything is alright, now is time to write the cookie list prepared by
|
|
// the previous loop
|
|
//
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// prepare the cookie list name
|
|
//
|
|
|
|
wsprintf(pszKey, L"%s%d", pszListPrefix, dwCookieArrayCount);
|
|
|
|
hr = pSceStore->SavePropertyToStore(pszSectionName, pszKey, pszBuffer);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
|
|
++dwCookieArrayCount;
|
|
}
|
|
|
|
//
|
|
// if everything goes well (all cookie arrays have been saved), then, we need to remove
|
|
// any potential extra cookie arrays Axxx, where the count starts from dwCookieArrayCount to m_dwCookieArrayCount
|
|
//
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// we will delete all left over cookie arrays.
|
|
// In case of error during deleting, we will continue the deletion, but will report the error
|
|
//
|
|
|
|
while (dwCookieArrayCount <= m_dwCookieArrayCount)
|
|
{
|
|
//
|
|
// prepare the cookie list name
|
|
//
|
|
|
|
wsprintf(pszKey, L"%s%d", pszListPrefix, dwCookieArrayCount++);
|
|
|
|
HRESULT hrDelete = pSceStore->DeletePropertyFromStore(pszSectionName, pszKey);
|
|
|
|
//
|
|
// we won't stop the deletion in case of error.
|
|
// But we will report it.
|
|
//
|
|
|
|
if (FAILED(hrDelete))
|
|
{
|
|
hr = hrDelete;
|
|
}
|
|
}
|
|
}
|
|
|
|
delete [] pszBuffer;
|
|
delete [] pszKey;
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CExtClassInstCookieList::DeleteKeyFromStore
|
|
|
|
Functionality:
|
|
|
|
Delete all key properties (Key=<Compound Key String>)
|
|
|
|
Virtual:
|
|
|
|
No.
|
|
|
|
Arguments:
|
|
|
|
pSceStore - pointer to the CSceStore object prepared for save
|
|
|
|
pszSectionName - section name where this cookie list is to be created.
|
|
|
|
dwCookie - the cookie to of the key to be deleted
|
|
|
|
Return Value:
|
|
|
|
Success: WBEM_NO_ERROR.
|
|
|
|
Failure: Various HRESULT code.
|
|
|
|
Any failure indicates that the cookie list is not delete properly.
|
|
|
|
Notes:
|
|
(1) No thread safety. Caller must be aware.
|
|
|
|
*/
|
|
|
|
HRESULT
|
|
CExtClassInstCookieList::DeleteKeyFromStore (
|
|
IN CSceStore* pSceStore,
|
|
IN LPCWSTR pszSectionName,
|
|
IN DWORD dwCookie
|
|
)
|
|
{
|
|
int iLen = wcslen(pszKeyPrefix);
|
|
|
|
//
|
|
// 1 for pszKeyPrefix
|
|
//
|
|
|
|
WCHAR szKey[MAX_INT_LENGTH + 1];
|
|
|
|
wsprintf(szKey, L"%s%d", pszKeyPrefix, dwCookie);
|
|
|
|
return pSceStore->DeletePropertyFromStore(pszSectionName, szKey);
|
|
}
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CExtClassInstCookieList::GetCompKeyCookie
|
|
|
|
Functionality:
|
|
|
|
Given a string version of the compound key (what is really stored in our template),
|
|
find the cookie. If found, also give an interator of the map to that element.
|
|
|
|
Virtual:
|
|
|
|
No.
|
|
|
|
Arguments:
|
|
|
|
pszCompKey - string version of the compound key
|
|
|
|
pIt - The iterator to the map that points to the CCompoundKey
|
|
whose key properties match what is encoded in the pszCompKey
|
|
|
|
Return Value:
|
|
|
|
the cookie if found.
|
|
|
|
INVALID_COOKIE if not found.
|
|
|
|
Notes:
|
|
(1) No thread safety. Caller must be aware.
|
|
|
|
*/
|
|
|
|
DWORD
|
|
CExtClassInstCookieList::GetCompKeyCookie (
|
|
IN LPCWSTR pszCompKey,
|
|
OUT ExtClassCookieIterator * pIt
|
|
)
|
|
{
|
|
CCompoundKey* pKey = NULL;
|
|
|
|
//
|
|
// we need a CCompoundKey to lookup. Convert the string version
|
|
// to a CCompoundKey instance. Need to delete it.
|
|
//
|
|
|
|
HRESULT hr = CreateCompoundKeyFromString(pszCompKey, &pKey);
|
|
if (FAILED(hr))
|
|
{
|
|
*pIt = m_mapCookies.end();
|
|
return INVALID_COOKIE;
|
|
}
|
|
|
|
*pIt = m_mapCookies.find(pKey);
|
|
|
|
DWORD cookie = INVALID_COOKIE;
|
|
|
|
if (*pIt != m_mapCookies.end())
|
|
{
|
|
cookie = (*((ExtClassCookieIterator)(*pIt))).second;
|
|
}
|
|
|
|
delete pKey;
|
|
|
|
return cookie;
|
|
}
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CExtClassInstCookieList::AddCompKey
|
|
|
|
Functionality:
|
|
|
|
Add a string version of the compound key (what is really stored in our template) to
|
|
this object. Since our store really only give string version of the compound key,
|
|
this method is what is used during creation upon reading the compound key string.
|
|
|
|
Virtual:
|
|
|
|
No.
|
|
|
|
Arguments:
|
|
|
|
pszCompKey - string version of the compound key. pszCompKey == pszNullKey means
|
|
to add a static function call instance or a singleton
|
|
|
|
dwDefCookie - Default value for the cookie it is called to add.
|
|
If dwDefCookie == INVALID_COOKIE, we will create a new cookie while adding
|
|
|
|
*pdwNewCookie - pass back the new cookie for the just added compound key
|
|
|
|
Return Value:
|
|
|
|
Will return the cookie for the compound key
|
|
|
|
Notes:
|
|
(1) No thread safety. Caller must be aware.
|
|
(2) Calling this function multiple times for the same cookie is safe because we will
|
|
prevent it from being added more than once.
|
|
|
|
*/
|
|
|
|
HRESULT
|
|
CExtClassInstCookieList::AddCompKey (
|
|
IN LPCWSTR pszCompKey,
|
|
IN DWORD dwDefCookie,
|
|
OUT DWORD * pdwNewCookie
|
|
)
|
|
{
|
|
if (pdwNewCookie == NULL || pszCompKey == NULL || *pszCompKey == L'\0')
|
|
{
|
|
return WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
|
|
HRESULT hr = WBEM_NO_ERROR;
|
|
|
|
CCompoundKey* pKey = NULL;
|
|
|
|
//
|
|
// We really need a CCompoundKey object
|
|
//
|
|
|
|
hr = CreateCompoundKeyFromString(pszCompKey, &pKey);
|
|
if (FAILED(hr))
|
|
{
|
|
*pdwNewCookie = INVALID_COOKIE;
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// make sure that we don't add duplicate keys
|
|
//
|
|
|
|
ExtClassCookieIterator it = m_mapCookies.find(pKey);
|
|
if (it != m_mapCookies.end())
|
|
{
|
|
//
|
|
// already there, just pass back the cookie
|
|
//
|
|
|
|
*pdwNewCookie = (*it).second;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// not present in our map yet
|
|
//
|
|
|
|
*pdwNewCookie = dwDefCookie;
|
|
|
|
if (dwDefCookie == INVALID_COOKIE)
|
|
{
|
|
if (m_dwMaxCookie + 1 == INVALID_COOKIE)
|
|
{
|
|
//
|
|
// If the next cookie is INVALID_COOKIE, we need to search
|
|
// for a free slot. This gets more expansive. But given that
|
|
// it needs to reach 0xFFFFFFFF to have this happen, ordinary
|
|
// situation won't get to this point.
|
|
//
|
|
|
|
hr = GetNextFreeCookie(pdwNewCookie);
|
|
}
|
|
else
|
|
{
|
|
*pdwNewCookie = ++m_dwMaxCookie;
|
|
}
|
|
}
|
|
|
|
//
|
|
// we need to maintain the other vector, which records the order at which
|
|
// cookies are added (so that it can be preserved and used as access order)
|
|
//
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// now, push the pair to the vector, it will take care of the memory
|
|
//
|
|
|
|
CookieKeyPair* pNewCookieKey = new CookieKeyPair;
|
|
if (pNewCookieKey == NULL)
|
|
{
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
else
|
|
{
|
|
pNewCookieKey->dwCookie = *pdwNewCookie;
|
|
pNewCookieKey->pKey = pKey;
|
|
m_vecCookies.push_back(pNewCookieKey);
|
|
|
|
//
|
|
// the map takes the ownership of the memory of pKey
|
|
//
|
|
|
|
m_mapCookies.insert(MapExtClassCookie::value_type(pKey, *pdwNewCookie));
|
|
|
|
pKey = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// if we have added it to the map, pKey == NULL. So harmless
|
|
//
|
|
|
|
delete pKey;
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CExtClassInstCookieList::RemoveCompKey
|
|
|
|
Functionality:
|
|
|
|
Will remove the compound key (given by the string) from the store. This is just a helper
|
|
not intended for outside use.
|
|
|
|
Virtual:
|
|
|
|
No.
|
|
|
|
Arguments:
|
|
|
|
pSceStore - the store
|
|
|
|
pszSectionName - section name
|
|
|
|
pszCompKey - the string version of the compound key to be removed from store
|
|
|
|
Return Value:
|
|
|
|
Will return the cookie for the compound key. INVALID_COOKIE indicate some failure to
|
|
remove the compound key from the store.
|
|
|
|
Notes:
|
|
(1) No thread safety. Caller must be aware.
|
|
|
|
*/
|
|
|
|
DWORD CExtClassInstCookieList::RemoveCompKey (
|
|
IN CSceStore * pSceStore,
|
|
IN LPCWSTR pszSectionName,
|
|
IN LPCWSTR pszCompKey
|
|
)
|
|
{
|
|
if (pszCompKey == NULL || *pszCompKey == L'\0')
|
|
{
|
|
return INVALID_COOKIE;
|
|
}
|
|
|
|
//
|
|
// We really need a CCompoundKey object
|
|
//
|
|
|
|
CCompoundKey* pKey = NULL;
|
|
HRESULT hr = CreateCompoundKeyFromString(pszCompKey, &pKey);
|
|
if (FAILED(hr))
|
|
{
|
|
return INVALID_COOKIE;
|
|
}
|
|
|
|
ExtClassCookieIterator it = m_mapCookies.find(pKey);
|
|
|
|
DWORD dwCookie = INVALID_COOKIE;
|
|
if (it != m_mapCookies.end())
|
|
{
|
|
dwCookie = (*it).second;
|
|
}
|
|
|
|
if (pSceStore && dwCookie != INVALID_COOKIE)
|
|
{
|
|
//
|
|
// found! So, we need to erase it from our map and our vector.
|
|
// make sure that we release the compound key managed by the element
|
|
// of the map and then erase it!
|
|
//
|
|
|
|
//
|
|
// if anything goes wrong with deleting from store, then we don't do it
|
|
//
|
|
|
|
if (SUCCEEDED(DeleteKeyFromStore(pSceStore, pszSectionName, dwCookie)))
|
|
{
|
|
delete (*it).first;
|
|
m_mapCookies.erase(it);
|
|
|
|
//
|
|
// remove it from the vector, too. This is expensive. Again, don't release
|
|
// the pointer of pKey inside the vector's struct element since it's taken care
|
|
// of by the map's release.
|
|
//
|
|
|
|
CookieKeyIterator itCookieKey = m_vecCookies.begin();
|
|
while (itCookieKey != m_vecCookies.end() && (*itCookieKey)->dwCookie != dwCookie)
|
|
{
|
|
++itCookieKey;
|
|
}
|
|
|
|
if (itCookieKey != m_vecCookies.end())
|
|
{
|
|
delete (*itCookieKey);
|
|
m_vecCookies.erase(itCookieKey);
|
|
}
|
|
}
|
|
}
|
|
|
|
return dwCookie;
|
|
}
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CExtClassInstCookieList::Next
|
|
|
|
Functionality:
|
|
|
|
Enumeration
|
|
|
|
Virtual:
|
|
|
|
No.
|
|
|
|
Arguments:
|
|
|
|
pbstrCompoundKey - the string version of the compound key the enumeration finds. May be NULL.
|
|
|
|
pdwCookie - the cookie where the enumeration find. May be NULL.
|
|
|
|
pdwResumeHandle - hint for next enumeration (0 when start enumeration)
|
|
|
|
Return Value:
|
|
|
|
Success: WBEM_E_NO_ERROR
|
|
|
|
Failure: WBEM_S_NO_MORE_DATA if the enueration has reached the end
|
|
WBEM_E_INVALID_PARAMETER if pdwResumeHandle == NULL
|
|
Other errors may also occur.
|
|
|
|
Notes:
|
|
(1) No thread safety. Caller must be aware.
|
|
(2) Pass in 0 to start the first enuemration step
|
|
(3) If caller is only interested in the cookie, then pass pbstrCompoundKey == NULL
|
|
(4) Similarly, if the caller is only interested in the string version of the compounp key,
|
|
then pass pdwCookie.
|
|
|
|
*/
|
|
|
|
HRESULT
|
|
CExtClassInstCookieList::Next (
|
|
OUT BSTR * pbstrCompoundKey,
|
|
OUT DWORD * pdwCookie,
|
|
IN OUT DWORD * pdwResumeHandle
|
|
)
|
|
{
|
|
if (pdwResumeHandle == NULL)
|
|
{
|
|
return WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
|
|
HRESULT hr = WBEM_NO_ERROR;
|
|
|
|
//
|
|
// set some good default values
|
|
//
|
|
|
|
if (pbstrCompoundKey)
|
|
{
|
|
*pbstrCompoundKey = NULL;
|
|
}
|
|
|
|
if (pdwCookie)
|
|
{
|
|
*pdwCookie = INVALID_COOKIE;
|
|
}
|
|
|
|
if (*pdwResumeHandle >= m_vecCookies.size())
|
|
{
|
|
hr = WBEM_S_NO_MORE_DATA;
|
|
}
|
|
else
|
|
{
|
|
if (pbstrCompoundKey)
|
|
{
|
|
hr = CreateCompoundKeyString(pbstrCompoundKey, m_vecCookies[*pdwResumeHandle]->pKey);
|
|
}
|
|
|
|
if (pdwCookie)
|
|
{
|
|
*pdwCookie = m_vecCookies[*pdwResumeHandle]->dwCookie;
|
|
}
|
|
|
|
(*pdwResumeHandle)++;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CExtClassInstCookieList::GetNextFreeCookie
|
|
|
|
Functionality:
|
|
|
|
A private helper to deal with cookie value overflow problem. Will search for
|
|
a unused slot for the next cookie.
|
|
|
|
Virtual:
|
|
|
|
No.
|
|
|
|
Arguments:
|
|
|
|
pdwCookie - will pass back the next available cookie
|
|
|
|
Return Value:
|
|
|
|
Success: WBEM_E_NO_ERROR
|
|
|
|
Failure: WBEM_E_OUT_OF_MEMORY or WBEM_E_INVALID_PARAMETER
|
|
|
|
Notes:
|
|
(1) No thread safety. Caller must be aware.
|
|
(2) ***Warning*** Don't use it directly!
|
|
|
|
*/
|
|
|
|
HRESULT
|
|
CExtClassInstCookieList::GetNextFreeCookie (
|
|
OUT DWORD * pdwCookie
|
|
)
|
|
{
|
|
if (pdwCookie == NULL)
|
|
{
|
|
return WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
|
|
ExtClassCookieIterator it = m_mapCookies.begin();
|
|
ExtClassCookieIterator itEnd = m_mapCookies.end();
|
|
|
|
int iCount = m_mapCookies.size();
|
|
|
|
//
|
|
// remember pigeon hole principle? iCount + 1 holes will definitely have one
|
|
// that is not occupied! So, we will find one in the first iCount + 1 indexes (1 -> iCount + 1)
|
|
//
|
|
|
|
//
|
|
// since we don't want 0, we will waste the first index
|
|
// for easy readability, I opt to wait this bit memory
|
|
//
|
|
|
|
BYTE *pdwUsedCookies = new BYTE[iCount + 2];
|
|
if (pdwUsedCookies == NULL)
|
|
{
|
|
return WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
|
|
//
|
|
// set all slots unused!
|
|
//
|
|
|
|
::memset(pdwUsedCookies, 0, iCount + 2);
|
|
|
|
while(it != itEnd)
|
|
{
|
|
if ((*it).second <= iCount + 1)
|
|
{
|
|
pdwUsedCookies[(*it).second] = 1;
|
|
}
|
|
it++;
|
|
}
|
|
|
|
//
|
|
// look for holes from 1 --> iCount + 1
|
|
//
|
|
|
|
for (int i = 1; i <= iCount + 1; ++i)
|
|
{
|
|
if (pdwUsedCookies[i] == 0)
|
|
break;
|
|
}
|
|
|
|
delete [] pdwUsedCookies;
|
|
|
|
*pdwCookie = i;
|
|
|
|
return WBEM_NO_ERROR;
|
|
|
|
}
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CExtClassInstCookieList::CreateCompoundKeyFromString
|
|
|
|
Functionality:
|
|
|
|
A private helper to deal with cookie value overflow problem. Will search for
|
|
a unused slot for the next cookie.
|
|
|
|
Virtual:
|
|
|
|
No.
|
|
|
|
Arguments:
|
|
|
|
pszCompKeyStr - string version of the compound key
|
|
|
|
ppCompKey - out-bound compound key if the string can be successfully interpreted as
|
|
compound key
|
|
|
|
Return Value:
|
|
|
|
Success: Any success code (use SUCCEEDED(hr) to test) indicates success.
|
|
|
|
Failure: any failure code indicates failure.
|
|
|
|
Notes:
|
|
(1) No thread safety. Caller must be aware.
|
|
(2) As normal, caller is responsible to release *ppCompKey.
|
|
|
|
*/
|
|
|
|
HRESULT
|
|
CExtClassInstCookieList::CreateCompoundKeyFromString (
|
|
IN LPCWSTR pszCompKeyStr,
|
|
OUT CCompoundKey ** ppCompKey
|
|
)
|
|
{
|
|
if (ppCompKey == NULL || pszCompKeyStr == NULL || *pszCompKeyStr == L'\0')
|
|
{
|
|
return WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
|
|
*ppCompKey = NULL;
|
|
|
|
HRESULT hr = WBEM_NO_ERROR;
|
|
|
|
//
|
|
// deal with NULL_KEY
|
|
//
|
|
|
|
bool bIsNullKey = _wcsicmp(pszCompKeyStr, pszNullKey) == 0;
|
|
|
|
if (bIsNullKey)
|
|
{
|
|
//
|
|
// CCompoundKey(0) creates a null key
|
|
//
|
|
|
|
*ppCompKey = new CCompoundKey(0);
|
|
if (*ppCompKey == NULL)
|
|
{
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
if (m_pVecNames == NULL || m_pVecNames->size() == 0)
|
|
{
|
|
//
|
|
// in this case, you really have to pass in pszCompKeyStr as NULL_KEY.
|
|
//
|
|
|
|
return WBEM_E_INVALID_SYNTAX;
|
|
}
|
|
|
|
DWORD dwKeyPropCount = m_pVecNames->size();
|
|
|
|
*ppCompKey = new CCompoundKey(dwKeyPropCount);
|
|
if (*ppCompKey == NULL)
|
|
{
|
|
return WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
|
|
//
|
|
// ready to parse the string version of the compound key
|
|
//
|
|
|
|
//
|
|
// hold the key property name
|
|
//
|
|
|
|
LPWSTR pszName = NULL;
|
|
|
|
//
|
|
// hold the key property value
|
|
//
|
|
|
|
VARIANT* pVar = NULL;
|
|
|
|
//
|
|
// current parsing point
|
|
//
|
|
|
|
LPCWSTR pszCur = pszCompKeyStr;
|
|
|
|
//
|
|
// next token point
|
|
//
|
|
|
|
LPCWSTR pszNext;
|
|
|
|
pVar = new VARIANT;
|
|
|
|
if (pVar == NULL)
|
|
{
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
else
|
|
{
|
|
hr = ::ParseCompoundKeyString(pszCur, &pszName, pVar, &pszNext);
|
|
|
|
|
|
while (SUCCEEDED(hr) && hr != WBEM_S_FALSE)
|
|
{
|
|
//
|
|
// find the index to which the name occupies. Since the number of key properties
|
|
// are always relatively small, we opt not to use fancy algorithms for lookup
|
|
//
|
|
|
|
for (DWORD dwIndex = 0; dwIndex < dwKeyPropCount; dwIndex++)
|
|
{
|
|
if (_wcsicmp((*m_pVecNames)[dwIndex], pszName) == 0)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// dwIndex >= dwKeyPropCount indicates that the name is not recognized!
|
|
//
|
|
|
|
//
|
|
// since we don't care about the names anymore, release it here
|
|
//
|
|
|
|
delete [] pszName;
|
|
pszName = NULL;
|
|
|
|
//
|
|
// a valid name, add it to the compound key, it takes the ownership of the variant memory
|
|
//
|
|
|
|
if (dwIndex < dwKeyPropCount)
|
|
{
|
|
//
|
|
// if successfully added, pVar will be set to NULL by the function
|
|
//
|
|
|
|
hr = (*ppCompKey)->AddKeyPropertyValue(dwIndex, &pVar);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// not recognized name, discard the variant, won't consider as an error
|
|
//
|
|
|
|
::VariantClear(pVar);
|
|
delete pVar;
|
|
pVar = NULL;
|
|
}
|
|
|
|
//
|
|
// start our next around
|
|
//
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pVar = new VARIANT;
|
|
if (pVar == NULL)
|
|
{
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pszCur = pszNext;
|
|
hr = ::ParseCompoundKeyString(pszCur, &pszName, pVar, &pszNext);
|
|
}
|
|
}
|
|
|
|
//
|
|
// final cleanup, regarless of success
|
|
//
|
|
|
|
if (pVar)
|
|
{
|
|
::VariantClear(pVar);
|
|
delete pVar;
|
|
}
|
|
}
|
|
|
|
//
|
|
// if error occurs, clean up our partially created compound key
|
|
//
|
|
|
|
if (FAILED(hr) && *ppCompKey != NULL)
|
|
{
|
|
delete *ppCompKey;
|
|
*ppCompKey = NULL;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CExtClassInstCookieList::CreateCompoundKeyString
|
|
|
|
Functionality:
|
|
|
|
Given a compound key, the function creates a string version of the compound key
|
|
and pass it back to the caller.
|
|
|
|
Virtual:
|
|
|
|
No.
|
|
|
|
Arguments:
|
|
|
|
pszCompKeyStr - string version of the compound key
|
|
|
|
ppCompKey - out-bound compound key if the string can be successfully interpreted as
|
|
compound key
|
|
|
|
Return Value:
|
|
|
|
Success: Any success code (use SUCCEEDED(hr) to test) indicates success.
|
|
|
|
Failure: any failure code indicates failure.
|
|
|
|
Notes:
|
|
(1) No thread safety. Caller must be aware.
|
|
(2) As normal, caller is responsible to release *pbstrCompKey.
|
|
|
|
*/
|
|
|
|
HRESULT
|
|
CExtClassInstCookieList::CreateCompoundKeyString (
|
|
OUT BSTR* pbstrCompKey,
|
|
IN const CCompoundKey* pKey
|
|
)
|
|
{
|
|
HRESULT hr = WBEM_NO_ERROR;
|
|
|
|
if (pbstrCompKey == NULL)
|
|
{
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
|
|
//
|
|
// if no names, or 0 names, or no compound key, then return Null_Key
|
|
//
|
|
|
|
else if (m_pVecNames == NULL || m_pVecNames->size() == 0 || pKey == NULL)
|
|
{
|
|
*pbstrCompKey = ::SysAllocString(pszNullKey);
|
|
|
|
if (*pbstrCompKey == NULL)
|
|
{
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*pbstrCompKey = NULL;
|
|
|
|
DWORD dwCount = m_pVecNames->size();
|
|
|
|
//
|
|
// Somehow, CComBSTR's += operator doesn't work inside loops for several
|
|
// compilations!
|
|
//
|
|
|
|
CComBSTR *pbstrParts = new CComBSTR[dwCount];
|
|
|
|
if (pbstrParts == NULL)
|
|
{
|
|
return WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
|
|
DWORD dwTotalLen = 0;
|
|
|
|
//
|
|
// for each key property, we will format the (prop, value) pair
|
|
// into prop<vt:value> format. All each individual prop<vt:value>
|
|
// will be saved in our arrary for later assembling.
|
|
//
|
|
|
|
for (DWORD dwIndex = 0; dwIndex < dwCount; dwIndex++)
|
|
{
|
|
//
|
|
// don't move these CComXXX out of the loop unless you know precisely
|
|
// what needs to be done for these ATL classes
|
|
//
|
|
|
|
CComVariant var;
|
|
hr = pKey->GetPropertyValue(dwIndex, &var);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
|
|
CComBSTR bstrData;
|
|
|
|
//
|
|
// get the <vt:value> into bstrData
|
|
//
|
|
|
|
hr = ::FormatVariant(&var, &bstrData);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// create the Name<vt:Value> formatted string
|
|
//
|
|
|
|
pbstrParts[dwIndex] = CComBSTR( (*m_pVecNames)[dwIndex] );
|
|
pbstrParts[dwIndex] += bstrData;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
|
|
dwTotalLen += wcslen(pbstrParts[dwIndex]);
|
|
}
|
|
|
|
//
|
|
// Do the final assembling - pack all the bstr's in pbstrParts into the
|
|
// out-bound parameter *pbstrCompKey
|
|
//
|
|
|
|
if (SUCCEEDED(hr) && hr != WBEM_S_FALSE)
|
|
{
|
|
*pbstrCompKey = ::SysAllocStringLen(NULL, dwTotalLen + 1);
|
|
if (*pbstrCompKey != NULL)
|
|
{
|
|
//
|
|
// current copying point
|
|
//
|
|
|
|
LPWSTR pszCur = *pbstrCompKey;
|
|
DWORD dwLen;
|
|
|
|
for (dwIndex = 0; dwIndex < dwCount; dwIndex++)
|
|
{
|
|
dwLen = wcslen(pbstrParts[dwIndex]);
|
|
::memcpy(pszCur, (const void*)(LPCWSTR)(pbstrParts[dwIndex]), dwLen * sizeof(WCHAR));
|
|
pszCur += dwLen;
|
|
}
|
|
|
|
//
|
|
// 0 terminate it
|
|
//
|
|
|
|
(*pbstrCompKey)[dwTotalLen] = L'\0';
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
}
|
|
|
|
delete [] pbstrParts;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CExtClassInstCookieList::Cleanup
|
|
|
|
Functionality:
|
|
|
|
Cleanup.
|
|
|
|
Virtual:
|
|
|
|
No.
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
Notes:
|
|
Since we want to clean up after some partial construction.
|
|
|
|
*/
|
|
|
|
void
|
|
CExtClassInstCookieList::Cleanup ()
|
|
{
|
|
//
|
|
// all those heap CCompoundKey's are released here.
|
|
//
|
|
|
|
ExtClassCookieIterator it = m_mapCookies.begin();
|
|
ExtClassCookieIterator itEnd = m_mapCookies.end();
|
|
|
|
while(it != itEnd)
|
|
{
|
|
delete (*it).first;
|
|
it++;
|
|
}
|
|
|
|
m_mapCookies.clear();
|
|
|
|
//
|
|
// m_vecCookies's content (CookieKeyPair) has a compound key,
|
|
// but that memory is not managed by this vector, (released in the map cleanup above).
|
|
//
|
|
|
|
for (int i = 0; i < m_vecCookies.size(); i++)
|
|
{
|
|
delete m_vecCookies[i];
|
|
}
|
|
|
|
m_vecCookies.clear();
|
|
|
|
m_dwMaxCookie = 0;
|
|
m_dwCookieArrayCount = 0;
|
|
}
|