able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/inetsrv/iis/utils/metautil/metaschm.cpp

2184 lines
50 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*===================================================================
Microsoft Denali
Microsoft Confidential.
Copyright 1997 Microsoft Corporation. All Rights Reserved.
Component: MetaUtil object
File: MetaSchm.cpp
Owner: t-BrianM
This file contains implementation of the CMetaSchemaTable object and
other schema related objects.
The CMetaSchemaTable object has COM style reference counting so it
can service objects created by CMetaUtil. I didn't make it a full
blown COM object because all of the class stuff would be a pain to
export.
To reduce the overhead of maintaining this object (which may or
may not be used), all information is loaded on demand, then set
dirty or unloaded when portions of the metabase associated with it
are modified.
===================================================================*/
#include "stdafx.h"
#include "MetaUtil.h"
#include "MUtilObj.h"
#include "MetaSchm.h"
/*------------------------------------------------------------------
* C P r o p I n f o
*/
/*===================================================================
CPropInfo::Init
Constructor
Parameters:
dwId Id of property
Returns:
S_OK on success
===================================================================*/
HRESULT CPropInfo::Init(DWORD dwId)
{
m_dwId = dwId;
return S_OK;
}
/*===================================================================
CPropInfo::SetName
Sets the property name.
Parameters:
tszName Name of property
Returns:
E_OUTOFMEMORY if allocation fails
S_OK on success
===================================================================*/
HRESULT CPropInfo::SetName(LPCTSTR tszName)
{
ASSERT_STRING(tszName);
ASSERT(m_tszName == NULL); // m_tszName not yet set
m_tszName = new TCHAR[_tcslen(tszName) + 1];
if (m_tszName == NULL) {
return E_OUTOFMEMORY;
}
_tcscpy(m_tszName, tszName);
return S_OK;
}
/*===================================================================
CPropInfo::SetTypeInfo
Sets the property name.
Parameters:
pType PropValue structure containing type information.
Returns:
E_OUTOFMEMORY if allocation fails
S_OK on success
===================================================================*/
HRESULT CPropInfo::SetTypeInfo(PropValue *pType)
{
ASSERT_POINTER(pType, PropValue);
ASSERT(m_pType == NULL); // m_pType not yet set
m_pType = new PropValue;
if (m_pType == NULL) {
return E_OUTOFMEMORY;
}
memcpy(m_pType, pType, sizeof(PropValue));
return S_OK;
}
/*------------------------------------------------------------------
* C P r o p I n f o T a b l e
*/
/*===================================================================
CPropInfoTable::CPropInfoTable
Constructor
Parameters:
None
Returns:
Nothing
===================================================================*/
CPropInfoTable::CPropInfoTable() : m_fLoaded(FALSE)
{
// Clear the hash tables
memset(m_rgCPropIdTable, 0, PROPERTY_HASH_SIZE * sizeof(CPropInfo *));
memset(m_rgCPropNameTable, 0, PROPERTY_HASH_SIZE * sizeof(CPropInfo *));
}
/*===================================================================
CPropInfoTable::~CPropInfoTable
Destructor
Parameters:
None
Returns:
Nothing
===================================================================*/
CPropInfoTable::~CPropInfoTable()
{
if (m_fLoaded) {
Unload();
}
}
/*===================================================================
CPropInfoTable::Load
Loads properties from the "_Machine_/Schema/Properties" key into the
property information table. On failure, recovers by unloading
everything.
Parameters:
pIMeta ATL Smart pointer to the metabase
hMDComp Open metabase handle to "_Machine_" key
Returns:
E_OUTOFMEMORY on allocation failure
S_OK on success
===================================================================*/
HRESULT CPropInfoTable::Load(CComPtr<IMSAdminBase> &pIMeta,
METADATA_HANDLE hMDComp)
{
//If it's already loaded, unload then reload
if (m_fLoaded) {
Unload();
}
USES_CONVERSION;
HRESULT hr;
int iDataIndex;
METADATA_RECORD mdrDataRec;
DWORD dwReqDataLen;
DWORD dwReturnBufLen;
UCHAR *lpReturnBuf = NULL;
unsigned int uiLoc;
CPropInfo *pCNewProp;
METADATA_HANDLE hMDNames = NULL;
METADATA_HANDLE hMDTypes = NULL;
//Setup the return buffer
dwReturnBufLen = 1024;
lpReturnBuf = new UCHAR[dwReturnBufLen];
if (lpReturnBuf == NULL)
return E_OUTOFMEMORY;
// Open the Schema/Properties/Names subkey
hr = pIMeta->OpenKey(hMDComp,
L"Schema/Properties/Names",
METADATA_PERMISSION_READ,
MUTIL_OPEN_KEY_TIMEOUT,
&hMDNames);
if (FAILED(hr)) {
delete lpReturnBuf;
return hr;
};
// For each name
iDataIndex = 0;
mdrDataRec.dwMDIdentifier = 0;
mdrDataRec.dwMDAttributes = METADATA_NO_ATTRIBUTES;
mdrDataRec.dwMDUserType = ALL_METADATA;
mdrDataRec.dwMDDataType = ALL_METADATA;
mdrDataRec.dwMDDataLen = dwReturnBufLen;
mdrDataRec.pbMDData = (PBYTE) lpReturnBuf;
mdrDataRec.dwMDDataTag = 0;
hr = pIMeta->EnumData(hMDNames,
NULL,
&mdrDataRec,
iDataIndex,
&dwReqDataLen);
while (SUCCEEDED(hr)) {
// Make sure we got a string
if (mdrDataRec.dwMDDataType != STRING_METADATA) {
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
goto LError;
}
// Create the property object
pCNewProp = new CPropInfo;
if (pCNewProp == NULL) {
hr = E_OUTOFMEMORY;
goto LError;
}
hr = pCNewProp->Init(mdrDataRec.dwMDIdentifier);
if (FAILED(hr)) {
delete pCNewProp;
goto LError;
}
hr = pCNewProp->SetName(W2T(reinterpret_cast<LPWSTR> (lpReturnBuf)));
if (FAILED(hr)) {
delete pCNewProp;
goto LError;
}
// Add it to the Id hash table
uiLoc = IdHash(mdrDataRec.dwMDIdentifier);
pCNewProp->m_pCIdHashNext = m_rgCPropIdTable[uiLoc];
m_rgCPropIdTable[uiLoc] = pCNewProp;
// Add it to the Name hash table
uiLoc = NameHash(pCNewProp->m_tszName);
pCNewProp->m_pCNameHashNext = m_rgCPropNameTable[uiLoc];
m_rgCPropNameTable[uiLoc] = pCNewProp;
iDataIndex++;
mdrDataRec.dwMDIdentifier = 0;
mdrDataRec.dwMDAttributes = METADATA_NO_ATTRIBUTES;
mdrDataRec.dwMDUserType = ALL_METADATA;
mdrDataRec.dwMDDataType = ALL_METADATA;
mdrDataRec.dwMDDataLen = dwReturnBufLen;
mdrDataRec.pbMDData = (PBYTE) lpReturnBuf;
mdrDataRec.dwMDDataTag = 0;
hr = pIMeta->EnumData(hMDNames,
NULL,
&mdrDataRec,
iDataIndex,
&dwReqDataLen);
}
// Make sure we ran out of items
if (HRESULT_CODE(hr) != ERROR_NO_MORE_ITEMS) {
goto LError;
}
// Close the Schema/Properties/Names sub-key
pIMeta->CloseKey(hMDNames);
hMDNames = NULL;
// Open the Schema/Properties/Types sub-key
hr = pIMeta->OpenKey(hMDComp,
L"Schema/Properties/Types",
METADATA_PERMISSION_READ,
MUTIL_OPEN_KEY_TIMEOUT,
&hMDTypes);
if (FAILED(hr)) {
goto LError;
};
// For each type
iDataIndex = 0;
mdrDataRec.dwMDIdentifier = 0;
mdrDataRec.dwMDAttributes = METADATA_NO_ATTRIBUTES;
mdrDataRec.dwMDUserType = ALL_METADATA;
mdrDataRec.dwMDDataType = ALL_METADATA;
mdrDataRec.dwMDDataLen = dwReturnBufLen;
mdrDataRec.pbMDData = (PBYTE) lpReturnBuf;
mdrDataRec.dwMDDataTag = 0;
hr = pIMeta->EnumData(hMDTypes,
NULL,
&mdrDataRec,
iDataIndex,
&dwReqDataLen);
while (SUCCEEDED(hr)) {
// Make sure we got binary data
if (mdrDataRec.dwMDDataType != BINARY_METADATA) {
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
goto LError;
}
// Look for an existing property object for this Id
pCNewProp = GetPropInfo(mdrDataRec.dwMDIdentifier);
if (pCNewProp == NULL) {
// Create the property object
pCNewProp = new CPropInfo;
if (pCNewProp == NULL) {
hr = E_OUTOFMEMORY;
goto LError;
}
hr = pCNewProp->Init(mdrDataRec.dwMDIdentifier);
if (FAILED(hr)) {
delete pCNewProp;
goto LError;
}
// Add it to the Id hash table
uiLoc = IdHash(mdrDataRec.dwMDIdentifier);
pCNewProp->m_pCIdHashNext = m_rgCPropIdTable[uiLoc];
m_rgCPropIdTable[uiLoc] = pCNewProp;
}
// Add type information to the property object
pCNewProp->SetTypeInfo(reinterpret_cast<PropValue *> (lpReturnBuf));
iDataIndex++;
mdrDataRec.dwMDIdentifier = 0;
mdrDataRec.dwMDAttributes = METADATA_NO_ATTRIBUTES;
mdrDataRec.dwMDUserType = ALL_METADATA;
mdrDataRec.dwMDDataType = ALL_METADATA;
mdrDataRec.dwMDDataLen = dwReturnBufLen;
mdrDataRec.pbMDData = (PBYTE) lpReturnBuf;
mdrDataRec.dwMDDataTag = 0;
hr = pIMeta->EnumData(hMDTypes,
NULL,
&mdrDataRec,
iDataIndex,
&dwReqDataLen);
}
// Make sure we ran out of items
if (HRESULT_CODE(hr) != ERROR_NO_MORE_ITEMS) {
goto LError;
}
// Close the Schema/Properties/Types sub-key
pIMeta->CloseKey(hMDTypes);
hMDTypes = NULL;
delete lpReturnBuf;
m_fLoaded = TRUE;
return S_OK;
LError:
if (hMDNames != NULL) {
pIMeta->CloseKey(hMDNames);
}
if (hMDTypes != NULL) {
pIMeta->CloseKey(hMDTypes);
}
if (lpReturnBuf != NULL) {
delete lpReturnBuf;
}
// Cleanup the entries we loaded
Unload();
return hr;
}
/*===================================================================
CPropInfoTable::Unload
Unloads the property information table.
Parameters:
None
Returns:
Nothing
===================================================================*/
void CPropInfoTable::Unload()
{
int iIndex;
CPropInfo *pCDeleteProp;
//Clear the Name table
memset(m_rgCPropNameTable, 0, PROPERTY_HASH_SIZE * sizeof(CPropInfo *));
// For each Id hash table entry
for (iIndex =0; iIndex < PROPERTY_HASH_SIZE; iIndex++) {
// While the entry is not empty
while (m_rgCPropIdTable[iIndex] != NULL) {
// Nuke the first table entry
pCDeleteProp = m_rgCPropIdTable[iIndex];
m_rgCPropIdTable[iIndex] = pCDeleteProp->m_pCIdHashNext;
delete pCDeleteProp;
}
}
m_fLoaded = FALSE;
}
/*===================================================================
CPropInfoTable::GetPropInfo
Gets property information from the table based on property id
Parameters:
dwId Id of property to get
Returns:
NULL if property not found or error
Pointer to CPropInfo class on success
===================================================================*/
CPropInfo *CPropInfoTable::GetPropInfo(DWORD dwId)
{
CPropInfo *pCCurProp;
// Go to the table location
pCCurProp = m_rgCPropIdTable[IdHash(dwId)];
// Look at all of the entries
while ((pCCurProp != NULL) && (pCCurProp->m_dwId != dwId)) {
pCCurProp = pCCurProp->m_pCIdHashNext;
}
return pCCurProp; // Will be NULL if not found
}
/*===================================================================
CPropInfoTable::GetPropInfo
Gets property information from the table based on property name.
Case insensitive.
Parameters:
tszName Name of property to get
Returns:
NULL if property not found or error
Pointer to CPropInfo class on success
===================================================================*/
CPropInfo *CPropInfoTable::GetPropInfo(LPCTSTR tszName)
{
CPropInfo *pCCurProp;
// Go to the table location
pCCurProp = m_rgCPropNameTable[NameHash(tszName)];
// Look at all of the entries
while ((pCCurProp != NULL) &&
(_tcsicmp(pCCurProp->m_tszName, tszName) != 0)) {
pCCurProp = pCCurProp->m_pCNameHashNext;
}
return pCCurProp; // Will be NULL if not found
}
/*===================================================================
CPropInfoTable::NameHash
Private function to get a hash value from a property name for the
name table. Case insensitive.
Parameters:
tszName Name to hash
Returns:
Hash value of name
===================================================================*/
unsigned int CPropInfoTable::NameHash(LPCTSTR tszName)
{
ASSERT_STRING(tszName);
unsigned int uiSum;
unsigned int uiIndex;
uiSum = 0;
for (uiIndex=0; uiIndex < _tcslen(tszName); uiIndex++) {
uiSum += _totlower(tszName[uiIndex]);
}
return (uiSum % PROPERTY_HASH_SIZE);
}
/*------------------------------------------------------------------
* C C l a s s P r o p I n f o
*/
// Everything is inline
/*------------------------------------------------------------------
* C C l a s s I n f o
*/
/*===================================================================
CClassInfo::CClassInfo
Constructor
Parameters:
None
Returns:
Nothing
===================================================================*/
CClassInfo::CClassInfo() : m_tszName(NULL),
m_pCHashNext(NULL),
m_fLoaded(FALSE),
m_pCOptionalPropList(NULL),
m_pCMandatoryPropList(NULL)
{
// Clear the hash table
memset(m_rgCPropTable, 0, CLASS_PROPERTY_HASH_SIZE * sizeof(CClassPropInfo *));
}
/*===================================================================
CClassInfo::Init
Constructor
Parameters:
tszName Name of the class
Returns:
E_OUTOFMEMORY on allocation failure
S_OK on success
===================================================================*/
HRESULT CClassInfo::Init(LPCTSTR tszName)
{
ASSERT_STRING(tszName);
m_tszName = new TCHAR[_tcslen(tszName) + 1];
if (m_tszName == NULL) {
return E_OUTOFMEMORY;
}
_tcscpy(m_tszName, tszName);
return S_OK;
}
/*===================================================================
CClassInfo::~CClassInfo
Destructor
Parameters:
None
Returns:
Nothing
===================================================================*/
CClassInfo::~CClassInfo()
{
Unload();
if (m_tszName != NULL) {
delete m_tszName;
}
}
/*===================================================================
CClassInfo::Load
Loads class properties from the "_Machine_/Schema/Classes/_Class_/Mandatory"
and "_Machine_/Schema/Classes/_Class_/Optional" keys into the class
property information table, mandatory list and optional list. On
failure, recovers by unloading everything.
Parameters:
pIMeta ATL Smart pointer to the metabase
hMDClasses Open metabase handle to "_Machine_/Schema/Classes" key
Returns:
E_OUTOFMEMORY on allocation failure
S_OK on success
===================================================================*/
HRESULT CClassInfo::Load(CComPtr<IMSAdminBase> &pIMeta,
METADATA_HANDLE hMDClasses)
{
USES_CONVERSION;
HRESULT hr;
//If it's already loaded, unload then reload
if (m_fLoaded) {
Unload();
}
// Open the class key
METADATA_HANDLE hMDClass = NULL;
hr = pIMeta->OpenKey(hMDClasses,
T2W(m_tszName),
METADATA_PERMISSION_READ,
1000,
&hMDClass);
if (FAILED(hr)) {
return hr;
}
// Load the class properties
METADATA_HANDLE hMDClassProp = NULL;
int iDataIndex;
METADATA_RECORD mdr;
DWORD dwReqDataLen;
DWORD dwReturnBufLen;
UCHAR *lpReturnBuf = NULL;
unsigned int uiLoc;
CClassPropInfo *pCNewClassProp;
//Setup the return buffer
dwReturnBufLen = 1024;
lpReturnBuf = new UCHAR[dwReturnBufLen];
if (lpReturnBuf == NULL) {
hr = E_OUTOFMEMORY;
goto LError;
}
// Load the mandatory class properties
// Open the Mandatory key
hr = pIMeta->OpenKey(hMDClass,
L"Mandatory",
METADATA_PERMISSION_READ,
1000,
&hMDClassProp);
if (FAILED(hr)) {
goto LError;
}
// For each Mandatory property
iDataIndex = 0;
mdr.dwMDIdentifier = 0;
mdr.dwMDAttributes = METADATA_NO_ATTRIBUTES;
mdr.dwMDUserType = ALL_METADATA;
mdr.dwMDDataType = ALL_METADATA;
mdr.dwMDDataLen = dwReturnBufLen;
mdr.pbMDData = (PBYTE) lpReturnBuf;
mdr.dwMDDataTag = 0;
hr = pIMeta->EnumData(hMDClassProp,
NULL,
&mdr,
iDataIndex,
&dwReqDataLen);
while (SUCCEEDED(hr)|| (HRESULT_CODE(hr) == ERROR_INSUFFICIENT_BUFFER)) {
// Handle insufficent buffer errors
if ((HRESULT_CODE(hr) == ERROR_INSUFFICIENT_BUFFER)) {
// Allocate more memory
delete lpReturnBuf;
dwReturnBufLen = dwReqDataLen;
lpReturnBuf = new UCHAR[dwReturnBufLen];
if (lpReturnBuf == NULL) {
hr = E_OUTOFMEMORY;
goto LError;
}
// Loop again
hr = S_OK;
}
else { //Buffer is big enough, proceed to add the class property
// Create the Class Property object
pCNewClassProp = new CClassPropInfo;
if (pCNewClassProp == NULL) {
hr = E_OUTOFMEMORY;
goto LError;
}
hr = pCNewClassProp->Init(mdr.dwMDIdentifier, TRUE);
if (FAILED(hr)) {
delete pCNewClassProp;
goto LError;
}
//Add it to the mandatory list
pCNewClassProp->m_pCListNext = m_pCMandatoryPropList;
m_pCMandatoryPropList = pCNewClassProp;
//Add it to the hash table
uiLoc = Hash(mdr.dwMDIdentifier);
pCNewClassProp->m_pCHashNext = m_rgCPropTable[uiLoc];
m_rgCPropTable[uiLoc] = pCNewClassProp;
iDataIndex++;
}
mdr.dwMDIdentifier = 0;
mdr.dwMDAttributes = METADATA_NO_ATTRIBUTES;
mdr.dwMDUserType = ALL_METADATA;
mdr.dwMDDataType = ALL_METADATA;
mdr.dwMDDataLen = dwReturnBufLen;
mdr.pbMDData = (PBYTE) lpReturnBuf;
mdr.dwMDDataTag = 0;
hr = pIMeta->EnumData(hMDClassProp,
NULL,
&mdr,
iDataIndex,
&dwReqDataLen);
}
// Make sure we ran out of items
if (HRESULT_CODE(hr) != ERROR_NO_MORE_ITEMS) {
goto LError;
}
// Close the Mandatory key
pIMeta->CloseKey(hMDClassProp);
hMDClassProp = NULL;
// Load the optional class properties
// Open the Optional key
hr = pIMeta->OpenKey(hMDClass,
L"Optional",
METADATA_PERMISSION_READ,
1000,
&hMDClassProp);
if (FAILED(hr)) {
goto LError;
}
// For each Optional property
iDataIndex = 0;
mdr.dwMDIdentifier = 0;
mdr.dwMDAttributes = METADATA_NO_ATTRIBUTES;
mdr.dwMDUserType = ALL_METADATA;
mdr.dwMDDataType = ALL_METADATA;
mdr.dwMDDataLen = dwReturnBufLen;
mdr.pbMDData = (PBYTE) lpReturnBuf;
mdr.dwMDDataTag = 0;
hr = pIMeta->EnumData(hMDClassProp,
NULL,
&mdr,
iDataIndex,
&dwReqDataLen);
while (SUCCEEDED(hr)|| (HRESULT_CODE(hr) == ERROR_INSUFFICIENT_BUFFER)) {
// Handle insufficent buffer errors
if ((HRESULT_CODE(hr) == ERROR_INSUFFICIENT_BUFFER)) {
// Allocate more memory
delete lpReturnBuf;
dwReturnBufLen = dwReqDataLen;
lpReturnBuf = new UCHAR[dwReturnBufLen];
if (lpReturnBuf == NULL) {
hr = E_OUTOFMEMORY;
goto LError;
}
// Loop again
hr = S_OK;
}
else { //Buffer is big enough, proceed to add the class property
// Create the Class Property object
pCNewClassProp = new CClassPropInfo;
if (pCNewClassProp == NULL) {
hr = E_OUTOFMEMORY;
goto LError;
}
hr = pCNewClassProp->Init(mdr.dwMDIdentifier, FALSE);
if (FAILED(hr)) {
delete pCNewClassProp;
goto LError;
}
//Add it to the optional list
pCNewClassProp->m_pCListNext = m_pCOptionalPropList;
m_pCOptionalPropList = pCNewClassProp;
//Add it to the hash table
uiLoc = Hash(mdr.dwMDIdentifier);
pCNewClassProp->m_pCHashNext = m_rgCPropTable[uiLoc];
m_rgCPropTable[uiLoc] = pCNewClassProp;
iDataIndex++;
}
mdr.dwMDIdentifier = 0;
mdr.dwMDAttributes = METADATA_NO_ATTRIBUTES;
mdr.dwMDUserType = ALL_METADATA;
mdr.dwMDDataType = ALL_METADATA;
mdr.dwMDDataLen = dwReturnBufLen;
mdr.pbMDData = (PBYTE) lpReturnBuf;
mdr.dwMDDataTag = 0;
hr = pIMeta->EnumData(hMDClassProp,
NULL,
&mdr,
iDataIndex,
&dwReqDataLen);
}
// Make sure we ran out of items
if (HRESULT_CODE(hr) != ERROR_NO_MORE_ITEMS) {
goto LError;
}
// Close the Optional key
pIMeta->CloseKey(hMDClassProp);
delete lpReturnBuf;
// Close the Class key
pIMeta->CloseKey(hMDClass);
m_fLoaded = TRUE;
return S_OK;
//Error durring loading, back out
LError:
if (hMDClassProp != NULL) {
pIMeta->CloseKey(hMDClassProp);
}
if (hMDClass != NULL) {
pIMeta->CloseKey(hMDClass);
}
if (lpReturnBuf != NULL) {
delete lpReturnBuf;
}
Unload();
return hr;
}
/*===================================================================
CClassInfo::Unload
Unloads the class property information table.
Parameters:
None
Returns:
Nothing
===================================================================*/
void CClassInfo::Unload()
{
int iIndex;
CClassPropInfo *pCDeleteProp;
// Clear the lists
m_pCOptionalPropList = NULL;
m_pCMandatoryPropList = NULL;
// For each hash table entry
for (iIndex =0; iIndex < CLASS_PROPERTY_HASH_SIZE; iIndex++) {
// While the entry is not empty
while (m_rgCPropTable[iIndex] != NULL) {
// Nuke the first table entry
pCDeleteProp = m_rgCPropTable[iIndex];
m_rgCPropTable[iIndex] = pCDeleteProp->m_pCHashNext;
delete pCDeleteProp;
}
}
m_fLoaded = FALSE;
}
/*===================================================================
CClassInfo::GetProperty
Get the CClassPropInfo (class property info) object from the hash
table given the property id.
Parameters:
dwId Identifier of the property to get
Returns:
NULL on failure
Pointer to the CClassPropInfo object on success
===================================================================*/
CClassPropInfo *CClassInfo::GetProperty(DWORD dwId) {
CClassPropInfo *pCCurProp;
// Go to the table location
pCCurProp = m_rgCPropTable[Hash(dwId)];
// Look at all of the entries
while ((pCCurProp != NULL) && (pCCurProp->m_dwId != dwId)) {
pCCurProp = pCCurProp->m_pCHashNext;
}
return pCCurProp; // Will be NULL if not found
}
/*------------------------------------------------------------------
* C C l a s s I n f o T a b l e
*/
/*===================================================================
CClassInfoTable::CClassInfoTable
Constructor
Parameters:
None
Returns:
Nothing
===================================================================*/
CClassInfoTable::CClassInfoTable() : m_fLoaded(FALSE)
{
// Clear the hash table
memset(m_rgCClassTable, 0, CLASS_HASH_SIZE * sizeof(CClassInfo *));
}
/*===================================================================
CClassInfoTable::~CClassInfoTable
Destructor
Parameters:
None
Returns:
Nothing
===================================================================*/
CClassInfoTable::~CClassInfoTable()
{
if (m_fLoaded) {
Unload();
}
}
/*===================================================================
CClassInfoTable::Load
Loads classes from the "_Machine_/Schema/Classes" key into the class
information table. On failure, recovers by unloading everything.
Parameters:
pIMeta ATL Smart pointer to the metabase
hMDComp Open metabase handle to "_Machine_" key
Returns:
E_OUTOFMEMORY on allocation failure
S_OK on success
===================================================================*/
HRESULT CClassInfoTable::Load(CComPtr<IMSAdminBase> &pIMeta,
METADATA_HANDLE hMDComp)
{
ASSERT(pIMeta.p != NULL);
USES_CONVERSION;
HRESULT hr;
//If it's already loaded, unload then reload
if (m_fLoaded) {
Unload();
}
int iKeyIndex;
wchar_t wszSubKey[ADMINDATA_MAX_NAME_LEN];
LPTSTR tszSubKey;
int iLoc;
CClassInfo *pCNewClass;
//Load the classes
METADATA_HANDLE hMDClasses = NULL;
// Open the Schema/Classes subkey
hr = pIMeta->OpenKey(hMDComp,
L"Schema/Classes",
METADATA_PERMISSION_READ,
1000,
&hMDClasses);
if (FAILED(hr)) {
return hr;
};
// For each subkey
iKeyIndex = 0;
hr = pIMeta->EnumKeys(hMDClasses,
NULL,
wszSubKey,
iKeyIndex);
while (SUCCEEDED(hr)) {
tszSubKey = W2T(wszSubKey);
// Create the new class
pCNewClass = new CClassInfo;
if (pCNewClass == NULL) {
hr = E_OUTOFMEMORY;
goto LError;
}
hr = pCNewClass->Init(tszSubKey);
if (FAILED(hr)) {
delete pCNewClass;
goto LError;
}
// Load the class properties
hr = pCNewClass->Load(pIMeta, hMDClasses);
if (FAILED(hr)) {
delete pCNewClass;
goto LError;
}
// Add it to the hash table
iLoc = Hash(tszSubKey);
pCNewClass->m_pCHashNext = m_rgCClassTable[iLoc];
m_rgCClassTable[iLoc] = pCNewClass;
iKeyIndex++;
hr = pIMeta->EnumKeys(hMDClasses,
NULL,
wszSubKey,
iKeyIndex);
}
//Make sure we ran out of items
if (!(HRESULT_CODE(hr) == ERROR_NO_MORE_ITEMS)) {
goto LError;
}
// Close the schema properties key
pIMeta->CloseKey(hMDClasses);
m_fLoaded = TRUE;
return S_OK;
LError:
if (hMDClasses != NULL) {
pIMeta->CloseKey(hMDClasses);
}
// Cleanup the entries we loaded
Unload();
return hr;
}
/*===================================================================
CClassInfo::Unload
Unloads the class information table.
Parameters:
None
Returns:
Nothing
===================================================================*/
void CClassInfoTable::Unload()
{
int iIndex;
CClassInfo *pCDeleteClass;
// For each hash table entry
for (iIndex =0; iIndex < CLASS_HASH_SIZE; iIndex++) {
// While the entry is not empty
while (m_rgCClassTable[iIndex] != NULL) {
// Nuke the first table entry
pCDeleteClass = m_rgCClassTable[iIndex];
m_rgCClassTable[iIndex] = pCDeleteClass->m_pCHashNext;
delete pCDeleteClass;
}
}
m_fLoaded = FALSE;
}
/*===================================================================
CCClasssInfoTable::GetClassInfo
Get the CClassInfo (class info) object from the hash table given
the class name
Parameters:
tszClassName Name of the class to get info for
Returns:
NULL on failure
Pointer to the CClassInfo object on success
===================================================================*/
CClassInfo *CClassInfoTable::GetClassInfo(LPCTSTR tszName)
{
ASSERT_STRING(tszName);
CClassInfo *pCCurClass;
// Go to the table location
pCCurClass = m_rgCClassTable[Hash(tszName)];
// Look at all of the entries
while ((pCCurClass != NULL) &&
(_tcscmp(pCCurClass->m_tszName, tszName) != 0)) {
pCCurClass = pCCurClass->m_pCHashNext;
}
return pCCurClass; // Will be NULL if not found
}
/*===================================================================
CClassInfoTable::Hash
Private function to get a hash value from a class name for the
class table.
Parameters:
tszName Name to hash
Returns:
Hash value of name
===================================================================*/
unsigned int CClassInfoTable::Hash(LPCTSTR tszName)
{
ASSERT_STRING(tszName);
unsigned int uiSum;
unsigned int uiIndex;
uiSum = 0;
for (uiIndex=0; uiIndex < _tcslen(tszName); uiIndex++) {
uiSum += tszName[uiIndex];
}
return (uiSum % CLASS_HASH_SIZE);
}
/*------------------------------------------------------------------
* C M e t a S c h e m a
*/
/*===================================================================
CMetaSchema::Init
Constructor
Parameters:
pIMeta ATL Smart pointer to the metabase
tszMachineName Name of machine the schema is for
Returns:
E_OUTOFMEMORY if allocation fails
S_OK on success
===================================================================*/
HRESULT CMetaSchema::Init(const CComPtr<IMSAdminBase> &pIMeta,
LPCTSTR tszMachineName)
{
ASSERT(pIMeta.p != NULL);
ASSERT_STRING(tszMachineName);
m_pIMeta = pIMeta;
m_tszMachineName = new TCHAR[_tcslen(tszMachineName) + 1];
if (m_tszMachineName == NULL)
return E_OUTOFMEMORY;
_tcscpy(m_tszMachineName, tszMachineName);
return S_OK;
}
/*===================================================================
CMetaSchema::GetPropInfo
Get the CPropInfo (property info) object for a given id
Parameters:
dwId Id of property to get info for
Returns:
NULL on failure
Pointer to the CPropInfo object on success
===================================================================*/
CPropInfo *CMetaSchema::GetPropInfo(DWORD dwId)
{
// Make sure the property table is up to date
if (m_fPropTableDirty) {
HRESULT hr;
hr = LoadPropTable();
if (FAILED(hr)) {
return NULL;
}
}
// Pass on the call
return m_CPropInfoTable.GetPropInfo(dwId);
}
/*===================================================================
CMetaSchema::GetPropInfo
Get the CPropInfo (property info) object for a given name
Parameters:
tszName Name of property to get info for
Returns:
NULL on failure
Pointer to the CPropInfo object on success
===================================================================*/
CPropInfo *CMetaSchema::GetPropInfo(LPCTSTR tszName)
{
ASSERT_STRING(tszName);
// Make sure the property table is up to date
if (m_fPropTableDirty) {
HRESULT hr;
hr = LoadPropTable();
if (FAILED(hr)) {
return NULL;
}
}
// Pass on the call
return m_CPropInfoTable.GetPropInfo(tszName);
}
/*===================================================================
CMetaSchema::GetClassInfo
Get the CClassInfo (class info) object for a given class name
Parameters:
tszClassName Name of the class to get info for
Returns:
NULL on failure
Pointer to the CClassInfo object on success
===================================================================*/
CClassInfo *CMetaSchema::GetClassInfo(LPCTSTR tszClassName) {
ASSERT_STRING(tszClassName);
// Make sure the class table is up to date
if (m_fClassTableDirty) {
HRESULT hr;
hr = LoadClassTable();
if (FAILED(hr)) {
return NULL;
}
}
// Pass on the call
return m_CClassInfoTable.GetClassInfo(tszClassName);
}
/*===================================================================
CMetaSchema:::GetClassPropInfo
Get the CClassPropInfo (class property info) object for a given
class name and property id.
Parameters:
tszClassName Name of the class get property from
dwPropId Id of property to get info for
Returns:
NULL on failure
Pointer to the CClassPropInfo object on success
===================================================================*/
CClassPropInfo *CMetaSchema::GetClassPropInfo(LPCTSTR tszClassName,
DWORD dwPropId)
{
// Make sure the class table is up to date
if (m_fClassTableDirty) {
HRESULT hr;
hr = LoadClassTable();
if (FAILED(hr)) {
return NULL;
}
}
// Get the class
CClassInfo *pCClassInfo;
pCClassInfo = m_CClassInfoTable.GetClassInfo(tszClassName);
if (pCClassInfo == NULL) {
return NULL;
}
else {
// Pass on the call
return pCClassInfo->GetProperty(dwPropId);
}
}
/*===================================================================
CMetaSchema::GetMandatoryClassPropList
Get the list of optional class properties for a class name.
Parameters:
tszClassName Name of the class get the properties from
Returns:
NULL on failure
Pointer to the first optional CClassPropInfo object on success
===================================================================*/
CClassPropInfo *CMetaSchema::GetMandatoryClassPropList(LPCTSTR tszClassName)
{
// Make sure the class table is up to date
if (m_fClassTableDirty) {
HRESULT hr;
hr = LoadClassTable();
if (FAILED(hr)) {
return NULL;
}
}
// Get the class
CClassInfo *pCClassInfo;
pCClassInfo = m_CClassInfoTable.GetClassInfo(tszClassName);
if (pCClassInfo == NULL) {
return NULL;
}
else {
// Pass on the call
return pCClassInfo->GetMandatoryPropList();
}
}
/*===================================================================
CMetaSchema::GetOptionalClassPropList
Get the list of optional class properties for a class name.
Parameters:
tszClassName Name of the class get the properties from
Returns:
NULL on failure
Pointer to the first optional CClassPropInfo object on success
===================================================================*/
CClassPropInfo *CMetaSchema::GetOptionalClassPropList(LPCTSTR tszClassName)
{
// Make sure the class table is up to date
if (m_fClassTableDirty) {
HRESULT hr;
hr = LoadClassTable();
if (FAILED(hr)) {
return NULL;
}
}
// Get the class
CClassInfo *pCClassInfo;
pCClassInfo = m_CClassInfoTable.GetClassInfo(tszClassName);
if (pCClassInfo == NULL) {
return NULL;
}
else {
// Pass on the call
return pCClassInfo->GetOptionalPropList();
}
}
/*===================================================================
CMetaSchema::ChangeNotification
Processes change events effecting the machine where the schema is
located. If the dirty flag for the property and class tables is not
already set a call to Unload() is made to free up memory no longer
needed.
Parameters:
tszChangedKey Cannonized key where change took place
pcoChangeObject Pointer to the change event information
Returns:
Nothing
===================================================================*/
void CMetaSchema::ChangeNotification(LPTSTR tszKey,
MD_CHANGE_OBJECT *pcoChangeObject)
{
ASSERT_POINTER(pcoChangeObject, MD_CHANGE_OBJECT);
USES_CONVERSION;
LPTSTR tszChangedKey;
tszChangedKey = tszKey;
// Skip the slash
if (*tszChangedKey != _T('\0') && *tszChangedKey == _T('/')) {
tszChangedKey++;
}
if (_tcsnicmp(tszChangedKey, _T("schema/"), 7) == 0) {
// It effects a "Schema" subkey
if ((_tcsnicmp(tszChangedKey, _T("schema/properties/"), 18) == 0) ||
(_tcsicmp(tszChangedKey, _T("schema/properties")) == 0)) {
// It effects "Schema/Properties"
if (!m_fPropTableDirty) {
// Unload the prop table
m_CPropInfoTable.Unload();
}
m_fPropTableDirty = TRUE;
}
else if ((_tcsnicmp(tszChangedKey, _T("schema/classes/"), 15) == 0) ||
(_tcsicmp(tszChangedKey, _T("schema/classes")) == 0)) {
// It effects "Schema/Classes"
if (!m_fClassTableDirty) {
// Unload the class table
m_CClassInfoTable.Unload();
}
m_fClassTableDirty = TRUE;
}
}
else if (_tcsicmp(tszChangedKey, _T("schema")) == 0) {
// Just the "Schema" key was changed
if (!m_fPropTableDirty) {
// Unload the prop table
m_CPropInfoTable.Unload();
}
m_fPropTableDirty = TRUE;
if (!m_fClassTableDirty) {
// Unload the class table
m_CClassInfoTable.Unload();
}
m_fClassTableDirty = TRUE;
}
}
/*===================================================================
CMetaSchema::LoadPropTable
(Re)loads a dirty property table
Parameters:
None
Returns:
S_OK on success
===================================================================*/
HRESULT CMetaSchema::LoadPropTable()
{
USES_CONVERSION;
HRESULT hr;
// Open the Machine key
METADATA_HANDLE hMDKey;
hr = m_pIMeta->OpenKey(METADATA_MASTER_ROOT_HANDLE,
L"", // schema path moved to /schema
METADATA_PERMISSION_READ,
MUTIL_OPEN_KEY_TIMEOUT,
&hMDKey);
if (FAILED(hr)) {
return hr;
}
// Load the properties
hr = m_CPropInfoTable.Load(m_pIMeta, hMDKey);
if (FAILED(hr)) {
return hr;
}
// Close the Machine key
m_pIMeta->CloseKey(hMDKey);
m_fPropTableDirty = FALSE;
return S_OK;
}
/*===================================================================
CMetaSchema::LoadClassTable
(Re)loads a dirty class table
Parameters:
None
Returns:
S_OK on success
===================================================================*/
HRESULT CMetaSchema::LoadClassTable()
{
USES_CONVERSION;
HRESULT hr;
// Open the Machine key
METADATA_HANDLE hMDKey;
hr = m_pIMeta->OpenKey(METADATA_MASTER_ROOT_HANDLE,
L"", // schema path moved to /schema
METADATA_PERMISSION_READ,
MUTIL_OPEN_KEY_TIMEOUT,
&hMDKey);
if (FAILED(hr)) {
return hr;
}
// Load the properties
hr = m_CClassInfoTable.Load(m_pIMeta, hMDKey);
if (FAILED(hr)) {
return hr;
}
// Close the Machine key
m_pIMeta->CloseKey(hMDKey);
m_fClassTableDirty = FALSE;
return S_OK;
}
/*------------------------------------------------------------------
* C M e t a S c h e m a T a b l e
*/
/*===================================================================
CMetaSchemaTable::CMetaSchemaTable
Constructor
Parameters:
None
Returns:
Nothing
===================================================================*/
CMetaSchemaTable::CMetaSchemaTable() : m_dwNumRef(1),
m_fLoaded(FALSE)
{
m_CMSAdminBaseSink = new CComObject<CMSAdminBaseSink>;
m_CMSAdminBaseSink->AddRef();
// Clear the hash table
memset(m_rgCSchemaTable, 0, SCHEMA_HASH_SIZE * sizeof(CMetaSchema *));
}
/*===================================================================
CMetaSchemaTable::~CMetaSchemaTable
Destructor
Parameters:
None
Returns:
Nothing
===================================================================*/
CMetaSchemaTable::~CMetaSchemaTable()
{
TRACE0("MetaUtil: CMetaSchemaTable::~CMetaSchemaTable\n");
if (m_fLoaded) {
Unload();
}
DWORD dwTemp;
if (m_CMSAdminBaseSink != NULL) {
dwTemp = m_CMSAdminBaseSink->Release();
TRACE1("MetaUtil: CMetaSchemaTable::~CMetaSchemaTable Release Sink %i\n", dwTemp);
}
}
/*===================================================================
CMetaSchemaTable::Load
Loads/Creates the schema information for all of the machines
Parameters:
None
Returns:
Nothing
===================================================================*/
void CMetaSchemaTable::Load()
{
USES_CONVERSION;
HRESULT hr;
if (m_fLoaded) {
Unload();
}
// Create an instance of the Metabase Admin Base Object
// Need a seperate instance so we pick up changes made
// by our "parent" MetaUtil object family.
hr = ::CoCreateInstance(CLSID_MSAdminBase,
NULL,
CLSCTX_ALL,
IID_IMSAdminBase,
(void **)&m_pIMeta);
if (FAILED(hr)) {
m_pIMeta = NULL;
return;
}
// Build the schema list
int iKeyIndex;
wchar_t wszMDSubKey[ADMINDATA_MAX_NAME_LEN];
CMetaSchema *pCNewSchema;
int iLoc;
// For each subkey of root
iKeyIndex = 0;
hr = m_pIMeta->EnumKeys(METADATA_MASTER_ROOT_HANDLE,
NULL,
wszMDSubKey,
iKeyIndex);
while (SUCCEEDED(hr)) {
// Create the new schema
pCNewSchema = new CMetaSchema;
if (pCNewSchema == NULL) {
goto LError;
}
hr = pCNewSchema->Init(m_pIMeta, W2T(wszMDSubKey));
if (FAILED(hr)) {
delete pCNewSchema;
goto LError;
}
// Add it to the hash table
iLoc = Hash(W2T(wszMDSubKey));
pCNewSchema->m_pCNextSchema = m_rgCSchemaTable[iLoc];
m_rgCSchemaTable[iLoc] = pCNewSchema;
// Next
iKeyIndex++;
hr = m_pIMeta->EnumKeys(METADATA_MASTER_ROOT_HANDLE,
NULL,
wszMDSubKey,
iKeyIndex);
}
// Make sure we ran out of items
if (HRESULT_CODE(hr) != ERROR_NO_MORE_ITEMS) {
goto LError;
}
// Setup notification
if (m_CMSAdminBaseSink != NULL) {
m_CMSAdminBaseSink->Connect(m_pIMeta, this);
}
m_fLoaded = TRUE;
return;
LError:
// Back out of the load
Unload();
}
/*===================================================================
CMetaSchemaTable::Unload
Unloads the schema table.
Parameters:
None
Returns:
Nothing
===================================================================*/
void CMetaSchemaTable::Unload() {
int iIndex;
CMetaSchema *pCDelete;
// Stop notification
if (m_CMSAdminBaseSink != NULL) {
m_CMSAdminBaseSink->Disconnect();
}
m_pIMeta = NULL;
// For each hash table entry
for (iIndex =0; iIndex < SCHEMA_HASH_SIZE; iIndex++) {
// While the entry is not empty
while (m_rgCSchemaTable[iIndex] != NULL) {
// Nuke the first table entry
pCDelete = m_rgCSchemaTable[iIndex];
m_rgCSchemaTable[iIndex] = pCDelete->m_pCNextSchema;
delete pCDelete;
}
}
m_fLoaded = FALSE;
}
/*===================================================================
CMetaSchemaTable::GetPropInfo
Get the CPropInfo (property info) object for a given key and id
Parameters:
tszKey Key the property is located under
dwPropId Id of the property to get info for
Returns:
NULL on failure
Pointer to the CPropInfo object on success
===================================================================*/
CPropInfo *CMetaSchemaTable::GetPropInfo(LPCTSTR tszKey,
DWORD dwPropId)
{
ASSERT_STRING(tszKey);
if (!m_fLoaded) {
Load();
}
CMetaSchema *pCSchema;
pCSchema = GetSchema(tszKey);
// If found then pass the call on
if (pCSchema != NULL) {
return pCSchema->GetPropInfo(dwPropId);
}
else {
return NULL;
}
}
/*===================================================================
CMetaSchemaTable::GetPropInfo
Get the CPropInfo (property info) object for a given key and name
Parameters:
tszKey Key the property is located under
tszPropName Name of the property to get info for
Returns:
NULL on failure
Pointer to the CPropInfo object on success
===================================================================*/
CPropInfo *CMetaSchemaTable::GetPropInfo(LPCTSTR tszKey,
LPCTSTR tszPropName)
{
ASSERT_STRING(tszKey);
ASSERT_STRING(tszPropName);
if (!m_fLoaded) {
Load();
}
CMetaSchema *pCSchema;
pCSchema = GetSchema(tszKey);
// If found then pass the call on
if (pCSchema != NULL) {
return pCSchema->GetPropInfo(tszPropName);
}
else {
return NULL;
}
}
/*===================================================================
CMetaSchemaTable::GetClassInfo
Get the CClassInfo (class info) object for a given key and class name
Parameters:
tszKey Approxiamte key the class is located under. Used
to get the machine name.
tszClassName Name of the class to get info for
Returns:
NULL on failure
Pointer to the CClassInfo object on success
===================================================================*/
CClassInfo *CMetaSchemaTable::GetClassInfo(LPCTSTR tszKey,
LPCTSTR tszClassName)
{
ASSERT_STRING(tszKey);
ASSERT_STRING(tszClassName);
if (!m_fLoaded) {
Load();
}
CMetaSchema *pCSchema;
pCSchema = GetSchema(tszKey);
// If found then pass the call on
if (pCSchema != NULL) {
return pCSchema->GetClassInfo(tszClassName);
}
else {
return NULL;
}
}
/*===================================================================
CMetaSchemaTable::GetClassPropInfo
Get the CClassPropInfo (class property info) object for a given
key, class name and property id.
Parameters:
tszKey Approxiamte key the class is located under. Used
to get the machine name.
tszClassName Name of the class get property from
dwPropId Id of property to get info for
Returns:
NULL on failure
Pointer to the CClassPropInfo object on success
===================================================================*/
CClassPropInfo *CMetaSchemaTable::GetClassPropInfo(LPCTSTR tszKey,
LPCTSTR tszClassName,
DWORD dwPropId)
{
ASSERT_STRING(tszKey);
ASSERT_STRING(tszClassName);
if (!m_fLoaded) {
Load();
}
CMetaSchema *pCSchema;
pCSchema = GetSchema(tszKey);
// If found then pass the call on
if (pCSchema != NULL) {
return pCSchema->GetClassPropInfo(tszClassName, dwPropId);
}
else {
return NULL;
}
}
/*===================================================================
CMetaSchemaTable::GetMandatoryClassPropList
Get the list of mandatory class properties for a given key and class
name.
Parameters:
tszKey Approxiamte key the class is located under. Used
to get the machine name.
tszClassName Name of the class get the properties from
Returns:
NULL on failure
Pointer to the first mandatory CClassPropInfo object on success
===================================================================*/
CClassPropInfo *CMetaSchemaTable::GetMandatoryClassPropList(LPCTSTR tszKey,
LPCTSTR tszClassName)
{
ASSERT_STRING(tszKey);
ASSERT_STRING(tszClassName);
if (!m_fLoaded) {
Load();
}
CMetaSchema *pCSchema;
pCSchema = GetSchema(tszKey);
// If found then pass the call on
if (pCSchema != NULL) {
return pCSchema->GetMandatoryClassPropList(tszClassName);
}
else {
return NULL;
}
}
/*===================================================================
CMetaSchemaTable::GetOptionalClassPropList
Get the list of optional class properties for a given key and class
name.
Parameters:
tszKey Approxiamte key the class is located under. Used
to get the machine name.
tszClassName Name of the class get the properties from
Returns:
NULL on failure
Pointer to the first optional CClassPropInfo object on success
===================================================================*/
CClassPropInfo *CMetaSchemaTable::GetOptionalClassPropList(LPCTSTR tszKey,
LPCTSTR tszClassName)
{
ASSERT_STRING(tszKey);
ASSERT_STRING(tszClassName);
if (!m_fLoaded) {
Load();
}
CMetaSchema *pCSchema;
pCSchema = GetSchema(tszKey);
// If found then pass the call on
if (pCSchema != NULL) {
return pCSchema->GetOptionalClassPropList(tszClassName);
}
else {
return NULL;
}
}
/*===================================================================
CMetaSchemaTable::SinkNotify
Metabase change notification callback from CMSAdminBaseSink. Either
determines a need to reload all of the schema information or sends
the message on to the appropriate CMetaSchema object.
Parameters:
dwMDNumElements Number of change events
pcoChangeObject Array of change events
Returns:
S_OK always
===================================================================*/
HRESULT CMetaSchemaTable::SinkNotify(DWORD dwMDNumElements,
MD_CHANGE_OBJECT pcoChangeObject[])
{
ASSERT(IsValidAddress(pcoChangeObject, dwMDNumElements * sizeof(MD_CHANGE_OBJECT), FALSE));
USES_CONVERSION;
DWORD dwIndex;
CMetaSchema *pCMetaSchema;
// For each event
for (dwIndex = 0; dwIndex < dwMDNumElements; dwIndex++) {
// Figure out what machine it's for
TCHAR tszKey[ADMINDATA_MAX_NAME_LEN];
_tcscpy(tszKey, W2T(pcoChangeObject[dwIndex].pszMDPath));
CannonizeKey(tszKey);
pCMetaSchema = GetSchema(tszKey);
// If the machine is not found
if (pCMetaSchema == NULL) {
// Reload the schema table
Load();
}
else {
// Send it to the appropriate machine
pCMetaSchema->ChangeNotification(tszKey, &(pcoChangeObject[dwIndex]));
}
}
return S_OK;
}
/*===================================================================
CMetaSchemaTable::GetSchema
Get the schema object that contains information on the given key.
Parameters:
tszKey Approxiamte key to get schema information for.
Returns:
NULL on failure
Pointer to the CMetaSchema object on success
===================================================================*/
CMetaSchema *CMetaSchemaTable::GetSchema(LPCTSTR tszKey) {
// Extract the machine name
TCHAR tszMachineName[ADMINDATA_MAX_NAME_LEN];
::GetMachineFromKey(tszKey, tszMachineName);
// Find the right schema
CMetaSchema *pCCurSchema;
pCCurSchema =m_rgCSchemaTable[Hash(tszMachineName)];
while ((pCCurSchema != NULL) &&
(_tcsicmp(pCCurSchema->m_tszMachineName, tszMachineName) != 0)) {
pCCurSchema = pCCurSchema->m_pCNextSchema;
}
return pCCurSchema; // Will be NULL if not found
}
/*===================================================================
CMetaSchemaTable::Hash
Private function to get a hash value from a machine name for the
schema table.
Parameters:
tszName Machinea name to hash
Returns:
Hash value of name
===================================================================*/
unsigned int CMetaSchemaTable::Hash(LPCTSTR tszName) {
ASSERT_STRING(tszName);
unsigned int uiSum;
unsigned int uiIndex;
uiSum = 0;
for (uiIndex=0; uiIndex < _tcslen(tszName); uiIndex++) {
uiSum += _totlower(tszName[uiIndex]);
}
return (uiSum % SCHEMA_HASH_SIZE);
}
/*------------------------------------------------------------------
* C M S A d m i n B a s e S i n k
*/
/*===================================================================
CMSAdminBaseSink::CMSAdminBaseSink
Constructor
Parameters:
None
Returns:
Nothing
===================================================================*/
CMSAdminBaseSink::CMSAdminBaseSink() : m_fConnected(FALSE),
m_dwCookie(0),
m_pCMetaSchemaTable(NULL)
{
}
/*===================================================================
CMSAdminBaseSink::~CMSAdminBaseSink
Destructor
Parameters:
None
Returns:
Nothing
===================================================================*/
CMSAdminBaseSink::~CMSAdminBaseSink()
{
TRACE0("MetaUtil: CMSAdminBaseSink::~CMSAdminBaseSink !!!!!!!!!!!\n");
// Make sure we disconnected
if (m_fConnected) {
Disconnect();
}
}
/*===================================================================
CMSAdminBaseSink::SinkNotify
Entry point for notification events from the metabase admin base
object.
Parameters:
dwMDNumElements Number of change events
pcoChangeObject Array of change events
Returns:
E_FAIL if m_pCMetaSchemaTable == NULL
S_OK on success
===================================================================*/
STDMETHODIMP CMSAdminBaseSink::SinkNotify(DWORD dwMDNumElements,
MD_CHANGE_OBJECT pcoChangeObject[])
{
TRACE0("MetaUtil: CMSAdminBaseSink::SinkNotify\n");
ASSERT(IsValidAddress(pcoChangeObject, dwMDNumElements * sizeof(MD_CHANGE_OBJECT), FALSE));
if (m_pCMetaSchemaTable == NULL) {
return E_FAIL;
}
// Pass on the notification
return m_pCMetaSchemaTable->SinkNotify(dwMDNumElements, pcoChangeObject);
}
/*===================================================================
CMSAdminBaseSink::ShutdownNotify
Entry point for the shutdown notification event from the metabase
admin base object.
Parameters:
None
Returns:
ERROR_NOT_SUPPORTE always
===================================================================*/
STDMETHODIMP CMSAdminBaseSink::ShutdownNotify() {
return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
}
/*===================================================================
CMSAdminBaseSink::Connect
Begins notification of change events. Connects to the metabase admin
base object.
Parameters:
pIMeta Pointer to the metabase admin base object
pCMetaSchemaTable Pointer to the schema table so that events
can be sent back to it.
Returns:
E_NOINTERFACE if can not convert IMSAdminBase to
IConnectionPointContainer.
S_OK on success
===================================================================*/
HRESULT CMSAdminBaseSink::Connect(CComPtr<IMSAdminBase> &pIMeta,
CMetaSchemaTable *pCMetaSchemaTable)
{
ASSERT(pIMeta.p != NULL);
ASSERT_POINTER(pCMetaSchemaTable, CMetaSchemaTable);
HRESULT hr;
if (m_fConnected) {
Disconnect();
}
m_pCMetaSchemaTable = pCMetaSchemaTable;
// Get the connection container
CComQIPtr<IConnectionPointContainer, &IID_IConnectionPointContainer> pIMetaConnContainer;
pIMetaConnContainer = pIMeta;
if (pIMetaConnContainer == NULL) {
// Failure to change interfaces
return E_NOINTERFACE;
}
// Get the connection point
hr = pIMetaConnContainer->FindConnectionPoint(IID_IMSAdminBaseSink, &m_pIMetaConn);
if (FAILED(hr)) {
return hr;
}
// Advise (connect)
AddRef();
m_pIMetaConn->Advise((IMSAdminBaseSink *) this, &m_dwCookie);
m_fConnected = TRUE;
return S_OK;
}
/*===================================================================
CMSAdminBaseSink::Disconnect
Stops notification of change events. Disconnects from the metabase
admin base object.
Parameters:
None
Returns:
Nothing
===================================================================*/
void CMSAdminBaseSink::Disconnect()
{
if (!m_fConnected) {
// Not connected
return;
}
// Stop notification
m_pIMetaConn->Unadvise(m_dwCookie);
// No longer needed
m_pIMetaConn = NULL;
m_pCMetaSchemaTable = NULL;
m_fConnected = FALSE;
}
Reference in a new issue Copy permalink