|
|
/*++
Copyright (c) 1998-1999 Microsoft Corporation
Module Name:
ReadSchema.cpp
Abstract:
Implementation of the helper functions that are used to read schema information from the config stuctures into the metabase.
Author:
Varsha Jayasimha (varshaj) 30-Nov-1999
Revision History:
--*/#include "precomp.hxx"
DWORD GetMetabaseFlags(DWORD i_CatalogFlag){ return i_CatalogFlag & 0x00000003; // First two bits represent metabase flag property.
}
/***************************************************************************++
Routine Description:
Reads the schema fromthe catalog into the schema tree.
Arguments:
[in] Storage pointer. [in] Filetime pointer.
Return Value:
HRESULT
--***************************************************************************/HRESULT ReadSchema(IIS_CRYPTO_STORAGE* i_pStorage, FILETIME* i_pFileTime){ HRESULT hr = S_OK; CMDBaseObject* pboReadSchema = NULL;
if(FAILED(hr)) { goto exit; }
hr = ReadMetaObject(pboReadSchema, (LPWSTR)g_wszSlashSchema, i_pFileTime, TRUE);
if(FAILED(hr)) { goto exit; }
hr = ReadSchemaProperties(pboReadSchema, i_pStorage);
if(FAILED(hr)) { goto exit;
}
hr = ReadProperties(i_pStorage, i_pFileTime);
if(FAILED(hr)) { goto exit; }
hr = ReadClasses(i_pStorage, i_pFileTime);
if(FAILED(hr)) { goto exit; }
exit:
return hr;
} // ReadSchema
/***************************************************************************++
Routine Description:
Reads the properties in the root of the schema.
Arguments:
[in] Pointer to the metabase object. [in] Storage pointer.
Return Value:
HRESULT
--***************************************************************************/HRESULT ReadSchemaProperties(CMDBaseObject* i_pboRead, IIS_CRYPTO_STORAGE* i_pStorage){ HRESULT hr = S_OK;
hr = ReadAdminACL(i_pboRead, i_pStorage);
if(FAILED(hr)) { return hr; }
hr = ReadLargestMetaID(i_pboRead, i_pStorage);
if(FAILED(hr)) { return hr; }
return hr;
} // ReadSchemaProperties
/***************************************************************************++
Routine Description:
Construct the Admin ACL property
Arguments:
[in] Pointer to the metabase object. [in] Storage pointer.
Return Value:
HRESULT
--***************************************************************************/HRESULT ReadAdminACL(CMDBaseObject* i_pboRead, IIS_CRYPTO_STORAGE* ){ BOOL b = FALSE; DWORD dwLength = 0;
PSECURITY_DESCRIPTOR pSD = NULL; PSECURITY_DESCRIPTOR outpSD = NULL; DWORD cboutpSD = 0; PACL pACLNew = NULL; DWORD cbACL = 0; PSID pAdminsSID = NULL; PSID pEveryoneSID = NULL; BOOL bWellKnownSID = FALSE; HRESULT hr = S_OK; DWORD dwRes = 0; DWORD dwMetaIDAdminACL = MD_ADMIN_ACL; DWORD dwAttributesAdminACL = METADATA_INHERIT | METADATA_REFERENCE | METADATA_SECURE; DWORD dwUserTypeAdminACL = IIS_MD_UT_SERVER; DWORD dwDataTypeAdminACL = BINARY_METADATA;
LPVOID a_pv[cMBProperty_NumberOfColumns]; ULONG a_Size[cMBProperty_NumberOfColumns];
//
// Initialize a new security descriptor
//
pSD = (PSECURITY_DESCRIPTOR) LocalAlloc(LPTR, SECURITY_DESCRIPTOR_MIN_LENGTH);
if (!pSD) { hr = E_OUTOFMEMORY; goto exit; }
InitializeSecurityDescriptor(pSD, SECURITY_DESCRIPTOR_REVISION); //
// Get Local Admins Sid
//
dwRes = GetPrincipalSID (L"Administrators", &pAdminsSID, &bWellKnownSID);
if(ERROR_SUCCESS != dwRes) { hr = HRESULT_FROM_WIN32(dwRes); goto exit; }
//
// Get everyone Sid
//
GetPrincipalSID (L"Everyone", &pEveryoneSID, &bWellKnownSID);
//
// Initialize a new ACL, which only contains 2 aaace
//
cbACL = sizeof(ACL) + (sizeof(ACCESS_ALLOWED_ACE) + GetLengthSid(pAdminsSID) - sizeof(DWORD)) + (sizeof(ACCESS_ALLOWED_ACE) + GetLengthSid(pEveryoneSID) - sizeof(DWORD));
pACLNew = (PACL) LocalAlloc(LPTR, cbACL);
if (!pACLNew) { hr = E_OUTOFMEMORY; goto exit; }
InitializeAcl(pACLNew, cbACL, ACL_REVISION);
AddAccessAllowedAce(pACLNew, ACL_REVISION, FILE_GENERIC_READ | FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE, pAdminsSID);
AddAccessAllowedAce(pACLNew, ACL_REVISION, FILE_GENERIC_READ, pEveryoneSID);
//
// Add the ACL to the security descriptor
//
b = SetSecurityDescriptorDacl(pSD, TRUE, pACLNew, FALSE);
if(!b) { hr = GetLastError(); hr = HRESULT_FROM_WIN32(hr); goto exit; }
b = SetSecurityDescriptorOwner(pSD, pAdminsSID, TRUE);
if(!b) { hr = GetLastError(); hr = HRESULT_FROM_WIN32(hr); goto exit; }
b = SetSecurityDescriptorGroup(pSD, pAdminsSID, TRUE);
if(!b) { hr = GetLastError(); hr = HRESULT_FROM_WIN32(hr); goto exit; }
//
// Security descriptor blob must be self relative
//
b = MakeSelfRelativeSD(pSD, outpSD, &cboutpSD);
outpSD = (PSECURITY_DESCRIPTOR)GlobalAlloc(GPTR, cboutpSD);
if (!outpSD) { hr = E_OUTOFMEMORY; goto exit; }
b = MakeSelfRelativeSD(pSD, outpSD, &cboutpSD);
if(!b) { hr = GetLastError(); hr = HRESULT_FROM_WIN32(hr); goto exit; }
//
// below this modify pSD to outpSD
//
//
// Apply the new security descriptor to the file
//
dwLength = GetSecurityDescriptorLength(outpSD);
//
// Apply the new security descriptor to the file
//
//
// Read all the property names. If the property is a flag, then read
// all the flag names as well.
//
a_pv[iMBProperty_Name] = NULL; a_pv[iMBProperty_Location] = (LPWSTR)g_wszSlashSchema; a_pv[iMBProperty_ID] = &dwMetaIDAdminACL; a_pv[iMBProperty_Attributes] = &dwAttributesAdminACL; a_pv[iMBProperty_UserType] = &dwUserTypeAdminACL; a_pv[iMBProperty_Type] = &dwDataTypeAdminACL; a_pv[iMBProperty_Value] = (LPBYTE)outpSD;
a_Size[iMBProperty_Value] = dwLength;
hr = ReadDataObject(i_pboRead, a_pv, a_Size, NULL, // We should not be passing crypto object here, if we do it will attempt to decrypt it because the attribute is sucure.
TRUE);
exit :
//
//Cleanup:
// both of Administrators and Everyone are well-known SIDs, use FreeSid() to free them.
//
if (outpSD) GlobalFree(outpSD);
if (pAdminsSID) FreeSid(pAdminsSID); if (pEveryoneSID) FreeSid(pEveryoneSID); if (pSD) LocalFree((HLOCAL) pSD); if (pACLNew) LocalFree((HLOCAL) pACLNew);
return (hr);}
/***************************************************************************++
Routine Description:
Helper function to read construct the Admin ACL.
Arguments:
Return Value:
HRESULT
--***************************************************************************/DWORD GetPrincipalSID (LPWSTR Principal, PSID *Sid, BOOL *pbWellKnownSID){ SID_IDENTIFIER_AUTHORITY SidIdentifierNTAuthority = SECURITY_NT_AUTHORITY; SID_IDENTIFIER_AUTHORITY SidIdentifierWORLDAuthority = SECURITY_WORLD_SID_AUTHORITY; PSID_IDENTIFIER_AUTHORITY pSidIdentifierAuthority = NULL; BYTE Count = 0; DWORD dwRID[8];
*pbWellKnownSID = TRUE; memset(&(dwRID[0]), 0, 8 * sizeof(DWORD)); if ( wcscmp(Principal,L"Administrators") == 0 ) { //
// Administrators group
//
pSidIdentifierAuthority = &SidIdentifierNTAuthority; Count = 2; dwRID[0] = SECURITY_BUILTIN_DOMAIN_RID; dwRID[1] = DOMAIN_ALIAS_RID_ADMINS;
} else if ( wcscmp(Principal,L"System") == 0) { //
// SYSTEM
//
pSidIdentifierAuthority = &SidIdentifierNTAuthority; Count = 1; dwRID[0] = SECURITY_LOCAL_SYSTEM_RID;
} else if ( wcscmp(Principal,L"Interactive") == 0) { //
// INTERACTIVE
//
pSidIdentifierAuthority = &SidIdentifierNTAuthority; Count = 1; dwRID[0] = SECURITY_INTERACTIVE_RID;
} else if ( wcscmp(Principal,L"Everyone") == 0) { //
// Everyone
//
pSidIdentifierAuthority = &SidIdentifierWORLDAuthority; Count = 1; dwRID[0] = SECURITY_WORLD_RID;
} else { *pbWellKnownSID = FALSE; }
if (*pbWellKnownSID) { if ( !AllocateAndInitializeSid(pSidIdentifierAuthority, (BYTE)Count, dwRID[0], dwRID[1], dwRID[2], dwRID[3], dwRID[4], dwRID[5], dwRID[6], dwRID[7], Sid) ) return GetLastError(); } else { // get regular account sid
DWORD sidSize; WCHAR refDomain [256]; DWORD refDomainSize; DWORD returnValue; SID_NAME_USE snu;
sidSize = 0; refDomainSize = 255;
LookupAccountNameW(NULL, Principal, *Sid, &sidSize, refDomain, &refDomainSize, &snu);
returnValue = GetLastError(); if (returnValue != ERROR_INSUFFICIENT_BUFFER) return returnValue;
*Sid = (PSID) malloc (sidSize); refDomainSize = 255;
if(NULL == *Sid) { return ERROR_NOT_ENOUGH_MEMORY; } else if (!LookupAccountNameW(NULL, Principal, *Sid, &sidSize, refDomain, &refDomainSize, &snu)) { return GetLastError(); } }
return ERROR_SUCCESS;}
/***************************************************************************++
Routine Description:
Reads the largest metabase id available so far from the schema.
Arguments:
[in] Pointer to the metabase object. [in] Storage pointer.
Return Value:
HRESULT
--***************************************************************************/HRESULT ReadLargestMetaID(CMDBaseObject* i_pboRead, IIS_CRYPTO_STORAGE* i_pStorage){ HRESULT hr = S_OK; DWORD* pdwLargestID = NULL; DWORD dwLargestIDDefault = IIS_MD_ADSI_METAID_BEGIN;
DWORD dwMetaIDMetaID = MD_SCHEMA_METAID; DWORD dwAttributesMetaID = METADATA_NO_ATTRIBUTES; DWORD dwUserTypeMetaID = IIS_MD_UT_SERVER; DWORD dwDataTypeMetaID = DWORD_METADATA; ULONG iCol = iTABLEMETA_ExtendedVersion; // Largest ID is stored in this column
ULONG iRow = 0; LPWSTR wszTable = wszTABLE_IIsConfigObject;
LPVOID a_pv[cMBProperty_NumberOfColumns]; ULONG a_Size[cMBProperty_NumberOfColumns];
hr = g_pGlobalISTHelper->m_pISTTableMetaForMetabaseTables->GetRowIndexByIdentity(NULL, (LPVOID*)&wszTable, &iRow);
if(SUCCEEDED(hr)) { hr = g_pGlobalISTHelper->m_pISTTableMetaForMetabaseTables->GetColumnValues(iRow, 1, &iCol, NULL, (LPVOID*)&pdwLargestID); }
if(FAILED(hr)) {
DBGINFOW((DBG_CONTEXT, L"[SetLargestMetaID] Unable to read largest meta id from the meta tables. GetColumnValues failed with hr = 0x%x. Will default it to %d.\n", hr, dwLargestIDDefault));
hr = S_OK;
pdwLargestID = &dwLargestIDDefault; }
a_pv[iMBProperty_Name] = NULL; a_pv[iMBProperty_Location] = (LPWSTR)g_wszSlashSchema; a_pv[iMBProperty_ID] = &dwMetaIDMetaID; a_pv[iMBProperty_Attributes] = &dwAttributesMetaID; a_pv[iMBProperty_UserType] = &dwUserTypeMetaID; a_pv[iMBProperty_Type] = &dwDataTypeMetaID; a_pv[iMBProperty_Value] = (LPBYTE)pdwLargestID;
a_Size[iMBProperty_Value] = sizeof(DWORD);
hr = ReadDataObject(i_pboRead, a_pv, a_Size, i_pStorage, TRUE);
return hr;
}
/***************************************************************************++
Routine Description:
Reads the properties into the schema tree.
Arguments:
[in] Pointer to the metabase object. [in] Storage pointer.
Return Value:
HRESULT
--***************************************************************************/HRESULT ReadProperties(IIS_CRYPTO_STORAGE* i_pStorage, FILETIME* i_pFileTime){ HRESULT hr = S_OK; CMDBaseObject* pboReadProperties = NULL; CMDBaseObject* pboReadNames = NULL; CMDBaseObject* pboReadTypes = NULL; CMDBaseObject* pboReadDefaults = NULL; ULONG i = 0; ULONG iColIndex = 0; LPVOID a_Identity[] = {(LPVOID)g_pGlobalISTHelper->m_wszTABLE_IIsConfigObject, (LPVOID)&iColIndex }; LPWSTR wszTable = NULL; LPVOID a_pv[cCOLUMNMETA_NumberOfColumns]; ULONG a_Size[cCOLUMNMETA_NumberOfColumns]; ULONG a_iCol[] = {iCOLUMNMETA_Table, iCOLUMNMETA_Index, iCOLUMNMETA_InternalName, iCOLUMNMETA_Type, iCOLUMNMETA_MetaFlags, iCOLUMNMETA_SchemaGeneratorFlags, iCOLUMNMETA_DefaultValue, iCOLUMNMETA_StartingNumber, iCOLUMNMETA_EndingNumber, iCOLUMNMETA_ID, iCOLUMNMETA_UserType, iCOLUMNMETA_Attributes }; ULONG cCol = sizeof(a_iCol)/sizeof(ULONG);
//
// Initialize all the meta objects.
//
hr = ReadMetaObject(pboReadProperties, (LPWSTR)g_wszSlashSchemaSlashProperties, i_pFileTime, TRUE);
if(FAILED(hr)) { goto exit; }
hr = ReadMetaObject(pboReadNames, (LPWSTR)g_wszSlashSchemaSlashPropertiesSlashNames, i_pFileTime, TRUE);
if(FAILED(hr)) { goto exit; }
hr = ReadMetaObject(pboReadTypes, (LPWSTR)g_wszSlashSchemaSlashPropertiesSlashTypes, i_pFileTime, TRUE);
if(FAILED(hr)) { goto exit; }
hr = ReadMetaObject(pboReadDefaults, (LPWSTR)g_wszSlashSchemaSlashPropertiesSlashDefaults, i_pFileTime, TRUE);
if(FAILED(hr)) { goto exit; }
//
// Get the row index of the first column and then iterate thru the table until
// e_st_nomorerows or the table difffers
//
hr = g_pGlobalISTHelper->m_pISTColumnMeta->GetRowIndexByIdentity(NULL, a_Identity, &i);
if(FAILED(hr)) { if(E_ST_NOMOREROWS == hr) { hr = S_OK; } goto exit; }
//
// For each property in this table, construct the name, type and default
// in the metabase tree
//
for(;;i++) { hr = g_pGlobalISTHelper->m_pISTColumnMeta->GetColumnValues(i, cCol, a_iCol, a_Size, a_pv);
if(E_ST_NOMOREROWS == hr) { hr = S_OK; break; } else if(FAILED(hr)) { goto exit; }
if(NULL == wszTable) { wszTable = (LPWSTR)a_pv[iCOLUMNMETA_Table]; }
if(wszTable != (LPWSTR)a_pv[iCOLUMNMETA_Table]) { //
// reached another table break
//
break; }
MD_ASSERT(NULL != (DWORD*)a_pv[iCOLUMNMETA_SchemaGeneratorFlags]);
if(fCOLUMNMETA_HIDDEN == (fCOLUMNMETA_HIDDEN & (*(DWORD*)a_pv[iCOLUMNMETA_SchemaGeneratorFlags]))) { //
// Do not read hidden properties. All these properties have the
// "HIDDEN" schemagenerator flag set on them.
//
continue; }
hr = ReadPropertyNames(pboReadNames, a_pv, a_Size, i_pStorage);
if(FAILED(hr)) { goto exit; }
hr = ReadPropertyTypes(pboReadTypes, a_pv, a_Size, i_pStorage);
if(FAILED(hr)) { goto exit; }
if((*(DWORD*)a_pv[iCOLUMNMETA_MetaFlags]) & fCOLUMNMETA_FLAG) { hr = ReadAllFlags(i_pStorage, pboReadTypes, pboReadNames, pboReadDefaults, *(DWORD*)a_pv[iCOLUMNMETA_Index], *(DWORD*)a_pv[iCOLUMNMETA_ID], GetMetabaseFlags(*(DWORD*)a_pv[iCOLUMNMETA_SchemaGeneratorFlags]), *(DWORD*)a_pv[iCOLUMNMETA_Attributes], *(DWORD*)a_pv[iCOLUMNMETA_UserType], (*(DWORD*)a_pv[iCOLUMNMETA_SchemaGeneratorFlags]) & fCOLUMNMETA_MULTISTRING);
if(FAILED(hr)) { goto exit; } }
hr = ReadPropertyDefaults(pboReadDefaults, a_pv, a_Size, i_pStorage);
if(FAILED(hr)) { goto exit; }
}
exit:
return hr;
} // ReadProperties
/***************************************************************************++
Routine Description:
Reads names of properties into the schema.
Arguments:
[in] Pointer to the metabase object. [in] Array that hold catalog schema information about the property. [in] Array that holds count of bytes for the above. [in] Storage pointer.
Return Value:
HRESULT
--***************************************************************************/HRESULT ReadPropertyNames(CMDBaseObject* i_pboRead, LPVOID* i_apv, ULONG* i_aSize, IIS_CRYPTO_STORAGE* i_pStorage){ HRESULT hr = S_OK; LPVOID a_pv[cMBProperty_NumberOfColumns]; ULONG a_Size[cMBProperty_NumberOfColumns]; DWORD dwAttributes = METADATA_NO_ATTRIBUTES; DWORD dwType = STRING_METADATA; DWORD dwUserType = IIS_MD_UT_SERVER;
//
// Read all the property names. If the property is a flag, then read
// all the flag names as well.
//
a_pv[iMBProperty_Name] = i_apv[iCOLUMNMETA_InternalName]; a_pv[iMBProperty_Location] = (LPWSTR)g_wszSlashSchemaSlashPropertiesSlashNames; a_pv[iMBProperty_ID] = i_apv[iCOLUMNMETA_ID]; a_pv[iMBProperty_Attributes] = &dwAttributes; a_pv[iMBProperty_UserType] = &dwUserType; a_pv[iMBProperty_Type] = &dwType; a_pv[iMBProperty_Value] = i_apv[iCOLUMNMETA_InternalName];
a_Size[iMBProperty_Value] = i_aSize[iCOLUMNMETA_InternalName];
hr = ReadDataObject(i_pboRead, a_pv, a_Size, i_pStorage, TRUE);
return hr;
} // ReadPropertyNames
/***************************************************************************++
Routine Description:
Reads names of flags into the schema.
Arguments:
[in] Pointer to the metabase object. [in] Array that hold catalog schema information about the flags. [in] Array that holds count of bytes for the above. [in] Storage pointer.
Return Value:
HRESULT
--***************************************************************************/HRESULT ReadFlagNames(CMDBaseObject* i_pboRead, LPVOID* i_apv, ULONG* i_aSize, IIS_CRYPTO_STORAGE* i_pStorage){ HRESULT hr = S_OK; LPVOID a_pv[cMBProperty_NumberOfColumns]; ULONG a_Size[cMBProperty_NumberOfColumns]; DWORD dwAttributes = METADATA_NO_ATTRIBUTES; DWORD dwType = STRING_METADATA; DWORD dwUserType = IIS_MD_UT_SERVER;
//
// Read all the property names. If the property is a flag, then read
// all the flag names as well.
//
a_pv[iMBProperty_Name] = i_apv[iTAGMETA_InternalName]; a_pv[iMBProperty_Location] = (LPWSTR)g_wszSlashSchemaSlashPropertiesSlashNames; a_pv[iMBProperty_ID] = i_apv[iTAGMETA_ID]; a_pv[iMBProperty_Attributes] = &dwAttributes; a_pv[iMBProperty_UserType] = &dwUserType; a_pv[iMBProperty_Type] = &dwType; a_pv[iMBProperty_Value] = i_apv[iTAGMETA_InternalName];
a_Size[iMBProperty_Value] = i_aSize[iTAGMETA_InternalName];
hr = ReadDataObject(i_pboRead, a_pv, a_Size, i_pStorage, TRUE);
return hr;
} // ReadFlagNames
/***************************************************************************++
Routine Description:
Reads type information about the properties into the schema.
Arguments:
[in] Pointer to the metabase object. [in] Array that hold catalog schema information about the property. [in] Array that holds count of bytes for the above. [in] Storage pointer.
Return Value:
HRESULT
--***************************************************************************/HRESULT ReadPropertyTypes(CMDBaseObject* i_pboRead, LPVOID* i_apv, ULONG* , IIS_CRYPTO_STORAGE* i_pStorage){ HRESULT hr = S_OK; LPVOID a_pv[cMBProperty_NumberOfColumns]; ULONG a_Size[cMBProperty_NumberOfColumns]; DWORD dwAttributes = METADATA_NO_ATTRIBUTES; DWORD dwType = BINARY_METADATA; DWORD dwUserType = IIS_MD_UT_SERVER; PropValue propVal; DWORD dwMetaFlagsEx = *(DWORD*)(i_apv[iCOLUMNMETA_SchemaGeneratorFlags]);
memset(&propVal, 0, sizeof(PropValue));
//
// Read all the property type. If the property is a flag, then read
// all the type for the flag names as well.
//
propVal.dwMetaID = *(DWORD*)(i_apv[iCOLUMNMETA_ID]); propVal.dwPropID = *(DWORD*)(i_apv[iCOLUMNMETA_ID]); // Note: This is different from the meta id if it is a flag.
propVal.dwSynID = SynIDFromMetaFlagsEx(dwMetaFlagsEx); propVal.dwMetaType = GetMetabaseType(*(DWORD*)(i_apv[iCOLUMNMETA_Type]), *(DWORD*)(i_apv[iCOLUMNMETA_MetaFlags]));
if(DWORD_METADATA == propVal.dwMetaType) { propVal.dwMinRange = *(DWORD*)(i_apv[iCOLUMNMETA_StartingNumber]); propVal.dwMaxRange = *(DWORD*)(i_apv[iCOLUMNMETA_EndingNumber]); } else { //
// Ensure that non-DWORDs have no starting/ending numbers
//
propVal.dwMinRange = 0; propVal.dwMaxRange = 0; }
propVal.dwFlags = GetMetabaseFlags(*(DWORD*)i_apv[iCOLUMNMETA_SchemaGeneratorFlags]); propVal.dwMask = 0; // This gets filled in for flag values only.
propVal.dwMetaFlags = *(DWORD*)(i_apv[iCOLUMNMETA_Attributes]); propVal.dwUserGroup = *(DWORD*)(i_apv[iCOLUMNMETA_UserType]); propVal.fMultiValued = ((*(DWORD*)i_apv[iCOLUMNMETA_MetaFlags])&fCOLUMNMETA_MULTISTRING)?1:0; // Ensure that this gets set in the schema as multivalued
propVal.dwDefault = 0; propVal.szDefault = NULL;
a_pv[iMBProperty_Name] = i_apv[iCOLUMNMETA_InternalName]; a_pv[iMBProperty_Location] = (LPWSTR)g_wszSlashSchemaSlashPropertiesSlashTypes; a_pv[iMBProperty_ID] = i_apv[iCOLUMNMETA_ID]; a_pv[iMBProperty_Attributes] = &dwAttributes; a_pv[iMBProperty_UserType] = &dwUserType; a_pv[iMBProperty_Type] = &dwType; a_pv[iMBProperty_Value] = (LPVOID)&propVal;
a_Size[iMBProperty_Value] = sizeof(PropValue);
hr = ReadDataObject(i_pboRead, a_pv, a_Size, i_pStorage, TRUE);
return hr;
} // ReadPropertyTypes
/***************************************************************************++
Routine Description:
Reads all flag properties into the schema.
Arguments:
[in] Storage pointer. [in] Pointer to the metabase object that holds the types tree. [in] Pointer to the metabase object that holds the names tree. [in] Pointer to the metabase object that holds the default value tree. [in] Column index of the parent flag property. [in] Meta Id of the parent flag property. [in] Flags of the parent flag property. [in] Attribute of the parent flag property. [in] Usertype of the parent flag property. [in] Multivalued attribute of the parent flag property.
Return Value:
HRESULT
--***************************************************************************/HRESULT ReadAllFlags(IIS_CRYPTO_STORAGE* i_pStorage, CMDBaseObject* i_pboReadType, CMDBaseObject* i_pboReadName, CMDBaseObject* i_pboReadDefault, DWORD i_dwColumnIndex, DWORD i_dwMetaID, DWORD i_dwFlags, DWORD i_dwAttributes, DWORD i_dwUserType, DWORD i_dwMultivalued){ ULONG i = 0; ULONG iStartRow = 0; HRESULT hr = S_OK; LPVOID a_pvSearch[cTAGMETA_NumberOfColumns]; ULONG aColSearch[] = {iTAGMETA_Table, iTAGMETA_ColumnIndex }; ULONG cColSearch = sizeof(aColSearch)/sizeof(ULONG); LPWSTR wszTable = NULL;
a_pvSearch[iTAGMETA_Table] = g_pGlobalISTHelper->m_wszTABLE_IIsConfigObject; a_pvSearch[iTAGMETA_ColumnIndex] = (LPVOID)&i_dwColumnIndex;
hr = g_pGlobalISTHelper->m_pISTTagMetaByTableAndColumnIndex->GetRowIndexBySearch(iStartRow, cColSearch, aColSearch, NULL, a_pvSearch, &iStartRow);
if(E_ST_NOMOREROWS == hr) { hr = S_OK; goto exit; } else if(FAILED(hr)) { DBGINFOW((DBG_CONTEXT, L"[ReadAllFlags] Unable to read flags. GetRowIndexBySearch failed with hr = 0x%x.\n", hr)); goto exit; }
for(i=iStartRow;;i++) {
LPVOID a_pv[cTAGMETA_NumberOfColumns]; ULONG a_Size[cTAGMETA_NumberOfColumns]; ULONG a_iCol[] = {iTAGMETA_Table, iTAGMETA_ColumnIndex, iTAGMETA_InternalName, iTAGMETA_Value, iTAGMETA_ID }; ULONG cCol = sizeof(a_iCol)/sizeof(ULONG);
hr = g_pGlobalISTHelper->m_pISTTagMetaByTableAndColumnIndex->GetColumnValues(i, cCol, a_iCol, a_Size, a_pv);
if(E_ST_NOMOREROWS == hr) { hr = S_OK; break; } else if(FAILED(hr)) { goto exit; }
if(NULL == wszTable) { // Save the table name from the read cache so that you can do a pointer compare below.
wszTable = (LPWSTR)a_pv[iTAGMETA_Table]; }
if((wszTable != a_pv[iTAGMETA_Table]) || (i_dwColumnIndex != *(DWORD*)a_pv[iTAGMETA_ColumnIndex]) ) { //
// Done with all tags of this column, in this table hence exit.
//
goto exit;
}
hr = ReadFlagTypes(i_pboReadType, i_pStorage, i_dwMetaID, i_dwFlags, i_dwAttributes, i_dwUserType, i_dwMultivalued, a_pv, a_Size);
if(FAILED(hr)) { goto exit; }
hr = ReadFlagNames(i_pboReadName, a_pv, a_Size, i_pStorage);
if(FAILED(hr)) { goto exit; }
hr = ReadFlagDefaults(i_pboReadDefault, a_pv, a_Size, i_pStorage);
if(FAILED(hr)) { goto exit; }
}
exit:
return hr;
} // ReadAllFlagTypes
#define IIS_SYNTAX_ID_BOOL_BITMASK 7
/***************************************************************************++
Routine Description:
Reads all flag type information into the schema.
Arguments:
[in] Pointer to the metabase object that holds the types tree. [in] Storage pointer. [in] Meta Id of the parent flag property. [in] Flags of the parent flag property. [in] Attribute of the parent flag property. [in] Usertype of the parent flag property. [in] Multivalued attribute of the parent flag property. [in] Array that hold catalog schema information about the flag. [in] Array that holds count of bytes for the above.
Return Value:
HRESULT
--***************************************************************************/HRESULT ReadFlagTypes(CMDBaseObject* i_pboRead, IIS_CRYPTO_STORAGE* i_pStorage, DWORD i_dwMetaID, DWORD i_dwFlags, DWORD i_dwAttributes, DWORD i_dwUserType, DWORD i_dwMultivalued, LPVOID* i_apv, ULONG* ){ HRESULT hr = S_OK; LPVOID a_pv[cMBProperty_NumberOfColumns]; ULONG a_Size[cMBProperty_NumberOfColumns]; DWORD dwAttributes = METADATA_NO_ATTRIBUTES; DWORD dwType = BINARY_METADATA; DWORD dwUserType = IIS_MD_UT_SERVER; PropValue propVal; DWORD dwFlagSynID = IIS_SYNTAX_ID_BOOL_BITMASK; DWORD dwFlagType = DWORD_METADATA;
memset(&propVal, 0, sizeof(PropValue));
//
// Read all the property type. If the property is a flag, then read
// all the type for the flag names as well.
//
propVal.dwMetaID = i_dwMetaID; propVal.dwPropID = *(DWORD*)(i_apv[iTAGMETA_ID]); // This is different from the meta id if it is a flag.
propVal.dwSynID = dwFlagSynID; propVal.dwMetaType = dwFlagType;
propVal.dwMaxRange = 0; propVal.dwMinRange = 0;
propVal.dwFlags = i_dwFlags; // Set to parent prop flags
propVal.dwMask = *(DWORD*)(i_apv[iTAGMETA_Value]); // Set to parent prop flags
propVal.dwMetaFlags = i_dwAttributes; // Set to parent prop flags
propVal.dwUserGroup = i_dwUserType; // Set to parent prop flags
propVal.fMultiValued = i_dwMultivalued; // Set to parent prop flags
propVal.dwDefault = 0; propVal.szDefault = NULL;
a_pv[iMBProperty_Name] = NULL; a_pv[iMBProperty_Location] = (LPWSTR)g_wszSlashSchemaSlashPropertiesSlashTypes; a_pv[iMBProperty_ID] = i_apv[iTAGMETA_ID]; a_pv[iMBProperty_Attributes] = &dwAttributes; a_pv[iMBProperty_UserType] = &dwUserType; a_pv[iMBProperty_Type] = &dwType; a_pv[iMBProperty_Value] = (LPVOID)&propVal;
a_Size[iMBProperty_Value] = sizeof(PropValue);
hr = ReadDataObject(i_pboRead, a_pv, a_Size, i_pStorage, TRUE);
return hr;
} // ReadFlagTypes
/***************************************************************************++
Routine Description:
Reads property defaults into the schema.
Arguments:
[in] Pointer to the metabase object that holds property defaults. [in] Array that hold catalog schema information about the property. [in] Array that holds count of bytes for the above. [in] Storage pointer.
Return Value:
HRESULT
--***************************************************************************/HRESULT ReadPropertyDefaults(CMDBaseObject* i_pboRead, LPVOID* i_apv, ULONG* i_aSize, IIS_CRYPTO_STORAGE* i_pStorage){ HRESULT hr = S_OK; LPVOID a_pv[cMBProperty_NumberOfColumns]; ULONG a_Size[cMBProperty_NumberOfColumns]; DWORD dwType = GetMetabaseType(*(DWORD*)i_apv[iCOLUMNMETA_Type], *(DWORD*)i_apv[iCOLUMNMETA_MetaFlags]); LPVOID pvValue = NULL; ULONG cbSize = NULL; DWORD dwZero = 0; DWORD dwAttributes = METADATA_NO_ATTRIBUTES;
//
// Read all the property names. If the property is a flag, then read
// all the flag names as well.
//
a_pv[iMBProperty_Name] = i_apv[iCOLUMNMETA_InternalName]; a_pv[iMBProperty_Location] = (LPWSTR)g_wszSlashSchemaSlashPropertiesSlashDefaults; a_pv[iMBProperty_ID] = i_apv[iCOLUMNMETA_ID]; a_pv[iMBProperty_Attributes] = &dwAttributes; // NO_ATTRIBUTES since it will attempt to decrypt.
a_pv[iMBProperty_UserType] = i_apv[iCOLUMNMETA_UserType]; a_pv[iMBProperty_Type] = &dwType;
if((dwType == DWORD_METADATA) && (NULL == i_apv[iCOLUMNMETA_DefaultValue])) { pvValue = &dwZero; cbSize = sizeof(DWORD); } else if(((dwType == MULTISZ_METADATA) || (dwType == STRING_METADATA) || (dwType == EXPANDSZ_METADATA)) && ((NULL == i_apv[iCOLUMNMETA_DefaultValue]) || (0 == *(BYTE*)(i_apv[iCOLUMNMETA_DefaultValue]))) ) { if(dwType == MULTISZ_METADATA) { pvValue = g_wszEmptyMultisz; // Two nulls.
cbSize = g_cchEmptyMultisz * sizeof(WCHAR); } else if((dwType == STRING_METADATA) || (dwType == EXPANDSZ_METADATA)) { pvValue = g_wszEmptyWsz; cbSize = g_cchEmptyWsz * sizeof(WCHAR); // One null.
} } else { pvValue = i_apv[iCOLUMNMETA_DefaultValue]; cbSize = i_aSize[iCOLUMNMETA_DefaultValue]; }
a_pv[iMBProperty_Value] = pvValue; a_Size[iMBProperty_Value] = cbSize;
hr = ReadDataObject(i_pboRead, a_pv, a_Size, i_pStorage, TRUE);
if(FAILED(hr)) { DBGINFOW((DBG_CONTEXT, L"[ReadPropertyDefaults] Could not read property %s:%d.\npv=%d.\ncb=%d.\n", i_apv[iCOLUMNMETA_InternalName], *(DWORD*)i_apv[iCOLUMNMETA_ID], pvValue, cbSize));
if(NULL != pvValue) { DBGINFOW((DBG_CONTEXT, L"[ReadPropertyDefaults]*pv=%d.\n", *(WORD*)pvValue));
} }
return hr;
} // ReadPropertyDefaults
/***************************************************************************++
Routine Description:
Reads all flag defaults into the schema.
Arguments:
[in] Pointer to the metabase object that holds the defaults. [in] Array that hold catalog schema information about the flag. [in] Array that holds count of bytes for the above. [in] Storage pointer.
Return Value:
HRESULT
--***************************************************************************/HRESULT ReadFlagDefaults(CMDBaseObject* i_pboRead, LPVOID* i_apv, ULONG* , IIS_CRYPTO_STORAGE* i_pStorage){ HRESULT hr = S_OK; LPVOID a_pv[cMBProperty_NumberOfColumns]; ULONG a_Size[cMBProperty_NumberOfColumns]; DWORD dwAttributes = METADATA_NO_ATTRIBUTES; DWORD dwType = DWORD_METADATA; DWORD dwUserType = IIS_MD_UT_SERVER;
//
// TODO: Is this a correct assumption? I noticed that default values for
// flags was being set to 0 or -1. This doesnt make any sense. How can a
// flag have a default value other than its own value? This is not
//captured in our new schema, so just putting it as 0.
//
DWORD dwFlagDefaults = 0;
//
// Read all the property names. If the property is a flag, then read
// all the flag names as well.
//
a_pv[iMBProperty_Name] = i_apv[iTAGMETA_InternalName]; a_pv[iMBProperty_Location] = (LPWSTR)g_wszSlashSchemaSlashPropertiesSlashDefaults; a_pv[iMBProperty_ID] = i_apv[iTAGMETA_ID]; a_pv[iMBProperty_Attributes] = &dwAttributes; a_pv[iMBProperty_UserType] = &dwUserType; a_pv[iMBProperty_Type] = &dwType; a_pv[iMBProperty_Value] = &dwFlagDefaults;
a_Size[iMBProperty_Value] = sizeof(DWORD);
hr = ReadDataObject(i_pboRead, a_pv, a_Size, i_pStorage, TRUE);
return hr;
} // ReadFlagDefaults
/***************************************************************************++
Routine Description:
Reads all classes into the schema.
Arguments:
[in] Storage pointer. [in] Filetime pointer.
Return Value:
HRESULT
--***************************************************************************/HRESULT ReadClasses(IIS_CRYPTO_STORAGE* i_pStorage, FILETIME* i_pFileTime){ HRESULT hr = S_OK; CMDBaseObject* pboReadClasses = NULL; ULONG i = 0; LPVOID a_pv[cTABLEMETA_NumberOfColumns]; ULONG a_Size[cTABLEMETA_NumberOfColumns]; ULONG a_iCol[] = {iTABLEMETA_InternalName, iTABLEMETA_MetaFlags, iTABLEMETA_SchemaGeneratorFlags, iTABLEMETA_ContainerClassList }; ULONG cCol = sizeof(a_iCol)/sizeof(ULONG);
hr = ReadMetaObject(pboReadClasses, (LPWSTR)g_wszSlashSchemaSlashClasses, i_pFileTime, TRUE);
if(FAILED(hr)) { goto exit; }
for(i=0;;i++) { hr = g_pGlobalISTHelper->m_pISTTableMetaForMetabaseTables->GetColumnValues(i, cCol, a_iCol, a_Size, a_pv);
if(E_ST_NOMOREROWS == hr) { hr = S_OK; break; } else if(FAILED(hr)) { goto exit; }
MD_ASSERT(NULL != (DWORD*)a_pv[iTABLEMETA_MetaFlags]);
if(fTABLEMETA_HIDDEN == (fTABLEMETA_HIDDEN & (*(DWORD*)a_pv[iTABLEMETA_MetaFlags]))) { //
// Do not read hidden classes. All these classes have the "HIDDEN" MetaFlag set on them.
// Eg: IIsConfigObject,MetabaseBaseClass, MBProperty, MBPropertyDiff, IIsInheritedProperties
//
continue; }
hr = ReadClass(a_pv, a_Size, i_pStorage, i_pFileTime);
if(FAILED(hr)) { DBGINFOW((DBG_CONTEXT, L"[ReadClasses] Could not read information for class: %s.\nReadClass failed with hr=0x%x.\n", a_pv[iTABLEMETA_InternalName], hr)); }
}
exit:
return hr;
} // ReadClasses
/***************************************************************************++
Routine Description:
Reads a class into the schema.
Arguments:
[in] Array that hold catalog schema information about the class. [in] Array that holds count of bytes for the above. [in] Storage pointer. [in] Filetime pointer.
Return Value:
HRESULT
--***************************************************************************/HRESULT ReadClass(LPVOID* i_apv, ULONG* , IIS_CRYPTO_STORAGE* i_pStorage, FILETIME* i_pFileTime){ HRESULT hr = S_OK; CMDBaseObject* pboReadClass = NULL; WCHAR wszClassPathFixed[MAX_PATH]; ULONG cchClassPath = 0; WCHAR* wszClassPath = wszClassPathFixed; WCHAR* wszEnd = NULL; ULONG cchClassName = (ULONG)wcslen((LPWSTR)i_apv[iTABLEMETA_InternalName]); DWORD dwID = 0; DWORD dwType = DWORD_METADATA; DWORD dwUserType = IIS_MD_UT_SERVER; DWORD dwAttributes = METADATA_NO_ATTRIBUTES; DWORD dwValue = 0; LPVOID a_pv[cMBProperty_NumberOfColumns]; ULONG a_Size[cMBProperty_NumberOfColumns]; LPWSTR wszManditory = NULL; LPWSTR wszOptional = NULL;
//
// Construct the ClassPath and read the meta object.
//
cchClassPath = g_cchSlashSchemaSlashClasses + g_cchSlash + cchClassName;
if((cchClassPath + 1) > MAX_PATH) { wszClassPath = new WCHAR[cchClassPath + 1]; if(NULL == wszClassPath) { hr = E_OUTOFMEMORY; goto exit; } }
wszEnd = wszClassPath; memcpy(wszEnd, g_wszSlashSchemaSlashClasses, g_cchSlashSchemaSlashClasses*sizeof(WCHAR)); wszEnd = wszEnd + g_cchSlashSchemaSlashClasses; memcpy(wszEnd, g_wszSlash, g_cchSlash*sizeof(WCHAR)); wszEnd = wszEnd + g_cchSlash; memcpy(wszEnd, i_apv[iTABLEMETA_InternalName], cchClassName*sizeof(WCHAR)); wszEnd = wszEnd + cchClassName; *wszEnd = L'\0';
hr = ReadMetaObject(pboReadClass, wszClassPath, i_pFileTime, TRUE);
if(FAILED(hr)) { DBGINFOW((DBG_CONTEXT, L"[ReadClasses] ReadMetaObject for class: %s failed with hr=0x%x.\n", wszClassPath, hr)); goto exit; }
//
// Initialize a_pv to write data objects
//
a_pv[iMBProperty_Name] = NULL; a_pv[iMBProperty_ID] = &dwID; a_pv[iMBProperty_Location] = wszClassPath; a_pv[iMBProperty_Attributes] = &dwAttributes; a_pv[iMBProperty_UserType] = &dwUserType; a_pv[iMBProperty_Type] = &dwType;
//
// Read the data object that corresponds to container class property
//
dwID = MD_SCHEMA_CLASS_CONTAINER; dwType = DWORD_METADATA; dwValue = ((*(DWORD*)(i_apv[iTABLEMETA_SchemaGeneratorFlags])) & fTABLEMETA_CONTAINERCLASS)?1:0; // Need to set true or false.
a_pv[iMBProperty_Value] = &dwValue; a_Size[iMBProperty_Value] = sizeof(DWORD);
hr = ReadDataObject(pboReadClass, a_pv, a_Size, i_pStorage, TRUE);
if(FAILED(hr)) { DBGINFOW((DBG_CONTEXT, L"[ReadClasses] ReadDataObject for class: %s, property: Container failed with hr=0x%x.\n", wszClassPath, hr)); goto exit; }
//
// Read the data object that corresponds to container class list property
//
dwID = MD_SCHEMA_CLASS_CONTAINMENT; dwType = STRING_METADATA;
if(NULL == i_apv[iTABLEMETA_ContainerClassList]) { a_pv[iMBProperty_Value] = g_wszEmptyWsz; a_Size[iMBProperty_Value] = (g_cchEmptyWsz)*sizeof(WCHAR); } else { a_pv[iMBProperty_Value] = i_apv[iTABLEMETA_ContainerClassList]; a_Size[iMBProperty_Value] = (ULONG)(wcslen((LPWSTR)i_apv[iTABLEMETA_ContainerClassList])+1)*sizeof(WCHAR); }
hr = ReadDataObject(pboReadClass, a_pv, a_Size, i_pStorage, TRUE);
if(FAILED(hr)) { goto exit; }
//
// Read properties for this class.
//
hr = GetProperties((LPCWSTR)i_apv[iTABLEMETA_InternalName], &wszOptional, &wszManditory);
if(FAILED(hr)) { goto exit; }
//
// Read data object that corresponds to optional property list
//
dwID = MD_SCHEMA_CLASS_OPT_PROPERTIES; dwType = STRING_METADATA;
if(NULL == wszOptional) { a_pv[iMBProperty_Value] = g_wszEmptyWsz; a_Size[iMBProperty_Value] = (g_cchEmptyWsz)*sizeof(WCHAR); } else { a_pv[iMBProperty_Value] = wszOptional; a_Size[iMBProperty_Value] = (ULONG)(wcslen(wszOptional)+1)*sizeof(WCHAR); }
// DBGINFOW((DBG_CONTEXT,
// L"[ReadClasses] Class: %s has Optional Properties: %s.\n",
// wszClassPath,
// a_pv[iMBProperty_Value]));
hr = ReadDataObject(pboReadClass, a_pv, a_Size, i_pStorage, TRUE);
if(FAILED(hr)) { goto exit; }
//
// Read data object that corresponds to maditory property list
//
dwID = MD_SCHEMA_CLASS_MAND_PROPERTIES; dwType = STRING_METADATA;
if(NULL == wszManditory) { a_pv[iMBProperty_Value] = g_wszEmptyWsz; a_Size[iMBProperty_Value] = (g_cchEmptyWsz)*sizeof(WCHAR); } else { a_pv[iMBProperty_Value] = wszManditory; a_Size[iMBProperty_Value] = (ULONG)(wcslen(wszManditory)+1)*sizeof(WCHAR); }
// DBGINFOW((DBG_CONTEXT,
// L"[ReadClasses] Class: %s has Manditory Properties: %s.\n",
// wszClassPath,
// a_pv[iMBProperty_Value]));
hr = ReadDataObject(pboReadClass, a_pv, a_Size, i_pStorage, TRUE);
if(FAILED(hr)) { goto exit; }
exit:
if(wszClassPathFixed != wszClassPath) { delete [] wszClassPath; wszClassPath = NULL; }
if(NULL != wszManditory) { delete [] wszManditory; wszManditory = NULL; }
if(NULL != wszOptional) { delete [] wszOptional; wszOptional = NULL; }
return hr;
} // ReadClasses
/***************************************************************************++
Routine Description:
Given a class it constructs the optional and manditory property lists
Arguments:
[in] Class name. [out] Optional properties. [out] Manditory properties.
Return Value:
HRESULT
--***************************************************************************/HRESULT GetProperties(LPCWSTR i_wszTable, LPWSTR* o_pwszOptional, LPWSTR* o_pwszManditory){
HRESULT hr = S_OK; LPVOID a_pv[cCOLUMNMETA_NumberOfColumns]; ULONG a_iCol[] = { iCOLUMNMETA_Table, iCOLUMNMETA_InternalName, iCOLUMNMETA_Index, iCOLUMNMETA_MetaFlags, iCOLUMNMETA_SchemaGeneratorFlags, iCOLUMNMETA_ID }; ULONG cCol = sizeof(a_iCol)/sizeof(ULONG); WCHAR* wszEndOpt = NULL; WCHAR* wszEndMand = NULL; ULONG cchOptional = 0; ULONG cchManditory = 0; ULONG iColIndex = 0; LPVOID a_Identity[] = {(LPVOID)i_wszTable, (LPVOID)&iColIndex }; LPWSTR wszTable = NULL; ULONG iStartRow = 0; ULONG i = 0;
MD_ASSERT(NULL != o_pwszOptional); MD_ASSERT(NULL != o_pwszManditory);
*o_pwszOptional = NULL; *o_pwszManditory = NULL;
//
// Get the row index of the first column and then iterate thru the table until
// e_st_nomorerows or the table difffers
//
hr = g_pGlobalISTHelper->m_pISTColumnMeta->GetRowIndexByIdentity(NULL, a_Identity, &iStartRow);
if(FAILED(hr)) { if(E_ST_NOMOREROWS == hr) { hr = S_OK; } goto exit; }
//
// Count the optional and maditory property lengths.
//
for(i=iStartRow;;i++) { ULONG* pcCh = NULL;
hr = g_pGlobalISTHelper->m_pISTColumnMeta->GetColumnValues(i, cCol, a_iCol, NULL, a_pv);
if(E_ST_NOMOREROWS == hr) { hr = S_OK; break; } else if(FAILED(hr)) { DBGINFOW((DBG_CONTEXT, L"[GetProperties] GetColumnValues (count) failed with hr = 0x%x. Index: %d\n", hr, i)); goto exit; }
if(NULL == wszTable) { // Save the table name from the read cache so that you can do a pointer compare below.
wszTable = (LPWSTR)a_pv[iCOLUMNMETA_Table]; }
if(wszTable != a_pv[iCOLUMNMETA_Table]) { //
// reached another table break
//
break; }
if(MD_LOCATION == *(DWORD*)a_pv[iCOLUMNMETA_ID]) { //
// Do NOT read in the location property.
//
continue; }
MD_ASSERT(NULL != (DWORD*)a_pv[iCOLUMNMETA_SchemaGeneratorFlags]);
if(fCOLUMNMETA_HIDDEN == (fCOLUMNMETA_HIDDEN & (*(DWORD*)a_pv[iCOLUMNMETA_SchemaGeneratorFlags]))) { //
// Do not read hidden properties. All these properties have the
// "HIDDEN" schemagenerator flag set on them.
//
continue; }
if((*(DWORD*)a_pv[iCOLUMNMETA_SchemaGeneratorFlags]) & fCOLUMNMETA_MANDATORY) { cchManditory = cchManditory + (ULONG)wcslen((LPWSTR)a_pv[iCOLUMNMETA_InternalName]) + 1 ; // For comma
pcCh = &cchManditory; } else { cchOptional = cchOptional + (ULONG)wcslen((LPWSTR)a_pv[iCOLUMNMETA_InternalName]) + 1; // For comma
pcCh = &cchOptional; }
if((*(DWORD*)a_pv[iCOLUMNMETA_MetaFlags]) & fCOLUMNMETA_FLAG) { hr = AddFlagValuesToPropertyList((LPWSTR)i_wszTable, *(DWORD*)a_pv[iCOLUMNMETA_Index], pcCh, NULL);
if(FAILED(hr)) { DBGINFOW((DBG_CONTEXT, L"[GetProperties] AddFlagValuesToPropertyList for %s:%s failed with hr = 0x%x.\n", i_wszTable, a_pv[iCOLUMNMETA_InternalName], hr )); goto exit; }
}
}
if(cchManditory > 0) { *o_pwszManditory = new WCHAR[cchManditory+1]; if(NULL == *o_pwszManditory) { hr = E_OUTOFMEMORY; goto exit; } **o_pwszManditory = 0; wszEndMand = *o_pwszManditory; }
if(cchOptional > 0) { *o_pwszOptional = new WCHAR[cchOptional+1]; if(NULL == *o_pwszOptional) { hr = E_OUTOFMEMORY; goto exit; } **o_pwszOptional= 0; wszEndOpt = *o_pwszOptional; }
//
// Count the optional and maditory property lengths.
//
wszTable = NULL;
for(i=iStartRow; ;i++) { ULONG cchName = 0; LPWSTR* pwszPropertyList = NULL;
hr = g_pGlobalISTHelper->m_pISTColumnMeta->GetColumnValues(i, cCol, a_iCol, NULL, a_pv);
if(E_ST_NOMOREROWS == hr) { hr = S_OK; break; } else if(FAILED(hr)) { DBGINFOW((DBG_CONTEXT, L"[GetProperties] GetColumnValues (copy) failed with hr = 0x%x. Index: %d\n", hr, i)); goto exit; }
if(NULL == wszTable) { // Save the table name from the read cache so that you can do a pointer compare below.
wszTable = (LPWSTR)a_pv[iCOLUMNMETA_Table]; }
if(wszTable != a_pv[iCOLUMNMETA_Table]) { //
// reached another table break
//
break; }
if(MD_LOCATION == *(DWORD*)a_pv[iCOLUMNMETA_ID]) { //
// Do NOT read in the location property.
//
continue; }
MD_ASSERT(NULL != (DWORD*)a_pv[iCOLUMNMETA_SchemaGeneratorFlags]);
if(fCOLUMNMETA_HIDDEN == (fCOLUMNMETA_HIDDEN & (*(DWORD*)a_pv[iCOLUMNMETA_SchemaGeneratorFlags]))) { //
// Do not read hidden properties. All these properties have the
// "HIDDEN" schemagenerator flag set on them.
//
continue; }
cchName = (ULONG)wcslen((LPWSTR)a_pv[iCOLUMNMETA_InternalName]);
if((*(DWORD*)a_pv[iCOLUMNMETA_SchemaGeneratorFlags]) & fCOLUMNMETA_MANDATORY) { MD_ASSERT(wszEndMand != NULL); memcpy(wszEndMand, a_pv[iCOLUMNMETA_InternalName], cchName*sizeof(WCHAR)); wszEndMand = wszEndMand + cchName; memcpy(wszEndMand, g_wszComma, g_cchComma*sizeof(WCHAR)); wszEndMand = wszEndMand + g_cchComma; pwszPropertyList = &wszEndMand; } else { MD_ASSERT(wszEndOpt != NULL); memcpy(wszEndOpt, a_pv[iCOLUMNMETA_InternalName], cchName*sizeof(WCHAR)); wszEndOpt = wszEndOpt + cchName; memcpy(wszEndOpt, g_wszComma, g_cchComma*sizeof(WCHAR)); wszEndOpt = wszEndOpt + g_cchComma; pwszPropertyList = &wszEndOpt; }
if((*(DWORD*)a_pv[iCOLUMNMETA_MetaFlags]) & fCOLUMNMETA_FLAG) { hr = AddFlagValuesToPropertyList((LPWSTR)i_wszTable, *(DWORD*)a_pv[iCOLUMNMETA_Index], NULL, pwszPropertyList);
if(FAILED(hr)) { DBGINFOW((DBG_CONTEXT, L"[GetProperties] AddFlagValuesToPropertyList for %s:%s failed with hr = 0x%x.\n", i_wszTable, a_pv[iCOLUMNMETA_InternalName], hr )); goto exit; } }
}
if(cchManditory > 0) { wszEndMand--; *wszEndMand = L'\0'; }
if(cchOptional > 0) { wszEndOpt--; *wszEndOpt = L'\0'; }
exit:
return hr;
} // GetProperties
/***************************************************************************++
Routine Description:
Adds the flag values to the (optional or manditory) property lists
Arguments:
[in] Class name. [in] index [out] Count of chars. [in out] Property list with all flag values added to it.
Return Value:
HRESULT
--***************************************************************************/HRESULT AddFlagValuesToPropertyList(LPWSTR i_wszTable, ULONG i_dwIndex, ULONG* io_pcCh, LPWSTR* io_pwszPropertyList){
ULONG a_iCol[] = { iTAGMETA_InternalName, iTAGMETA_ColumnIndex, iTAGMETA_Table }; ULONG cCol = sizeof(a_iCol)/sizeof(ULONG); LPVOID a_pv[cTAGMETA_NumberOfColumns];
ULONG aColSearchTag[] = {iTAGMETA_Table, iTAGMETA_ColumnIndex }; ULONG cColSearchTag = sizeof(aColSearchTag)/sizeof(ULONG); ULONG iStartRow = 0; LPWSTR wszEnd = NULL; HRESULT hr = S_OK; LPWSTR wszTable = NULL;
if(NULL != io_pwszPropertyList && NULL != *io_pwszPropertyList) { wszEnd = *io_pwszPropertyList; }
a_pv[iTAGMETA_Table] = i_wszTable; a_pv[iTAGMETA_ColumnIndex] = (LPVOID)&i_dwIndex;
hr = g_pGlobalISTHelper->m_pISTTagMetaByTableAndColumnIndex->GetRowIndexBySearch(iStartRow, cColSearchTag, aColSearchTag, NULL, a_pv, (ULONG*)&iStartRow); if(E_ST_NOMOREROWS == hr) { DBGINFOW((DBG_CONTEXT, L"[AddFlagValuesToPropertyList] No flags found for %s:%d.\n", i_wszTable, i_dwIndex)); hr = S_OK; goto exit; } else if(FAILED(hr)) { DBGINFOW((DBG_CONTEXT, L"[AddFlagValuesToPropertyList] GetRowIndexBySearch for %s failed with hr = 0x%x.\n", wszTABLE_TAGMETA, hr));
goto exit; }
for(ULONG iRow=iStartRow;;iRow++) { ULONG cchName = 0;
hr = g_pGlobalISTHelper->m_pISTTagMetaByTableAndColumnIndex->GetColumnValues(iRow, cCol, a_iCol, NULL, a_pv); if(E_ST_NOMOREROWS == hr) { hr = S_OK; break; } else if(FAILED(hr)) { DBGINFOW((DBG_CONTEXT, L"[AddFlagValuesToPropertyList] GetColumnValues for %s index %i failed with hr = 0x%x.\n", wszTABLE_TAGMETA, iRow, hr)); goto exit; }
if(NULL == wszTable) { wszTable = (LPWSTR)a_pv[iTAGMETA_Table]; }
if((wszTable != (LPWSTR)a_pv[iTAGMETA_Table]) || (i_dwIndex != *(DWORD*)a_pv[iTAGMETA_ColumnIndex]) ) { //
// Reached another table, done with the tags of this table
//
break; }
cchName = (ULONG)wcslen((LPWSTR)a_pv[iTAGMETA_InternalName]);
if(NULL != io_pcCh) { *io_pcCh = *io_pcCh + cchName + 1; // for comma
}
if(NULL != wszEnd) { memcpy(wszEnd, a_pv[iTAGMETA_InternalName], cchName*sizeof(WCHAR)); wszEnd = wszEnd + cchName; memcpy(wszEnd, g_wszComma, g_cchComma*sizeof(WCHAR)); wszEnd = wszEnd + g_cchComma; } }
if(NULL != io_pwszPropertyList) { *io_pwszPropertyList = wszEnd; }
exit:
return hr;
} // AddFlagValuesToPropertyList
|
