able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/windows/appcompat/shimdbc/obj.h

1647 lines
46 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
///////////////////////////////////////////////////////////////////////////////
//
// File: obj.h
//
// History: 19-Nov-99 markder Created.
// 16-Nov-00 markder Converted from ShimDatabase.h, rewritten
// 15-Jan-02 jdoherty Modified code to add ID to additional tags.
//
// Desc: This file contains definitions of the SdbDatabase object model.
//
///////////////////////////////////////////////////////////////////////////////
#if !defined(AFX_OBJ_H__5C16373A_D713_46CD_B8BF_7755216C62E0__INCLUDED_)
#define AFX_OBJ_H__5C16373A_D713_46CD_B8BF_7755216C62E0__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include "xml.h"
#include "utils.h"
extern DWORD g_dwCurrentWriteFilter;
extern DATE g_dtCurrentWriteRevisionCutoff;
//
// Common map types
//
typedef CMap<DWORD, DWORD, DWORD, DWORD> CMapDWORDToDWORD;
//
// These definitions are used by SdbMatchingFile::m_dwMask
//
#define SDB_MATCHINGINFO_SIZE 0x00000001
#define SDB_MATCHINGINFO_CHECKSUM 0x00000002
#define SDB_MATCHINGINFO_REGISTRY_ENTRY 0x00000004
#define SDB_MATCHINGINFO_COMPANY_NAME 0x00000008
#define SDB_MATCHINGINFO_PRODUCT_NAME 0x00000010
#define SDB_MATCHINGINFO_PRODUCT_VERSION 0x00000020
#define SDB_MATCHINGINFO_FILE_DESCRIPTION 0x00000040
#define SDB_MATCHINGINFO_BIN_FILE_VERSION 0x00000080
#define SDB_MATCHINGINFO_BIN_PRODUCT_VERSION 0x00000100
#define SDB_MATCHINGINFO_MODULE_TYPE 0x00000200
#define SDB_MATCHINGINFO_VERFILEDATEHI 0x00000400
#define SDB_MATCHINGINFO_VERFILEDATELO 0x00000800
#define SDB_MATCHINGINFO_VERFILEOS 0x00001000
#define SDB_MATCHINGINFO_VERFILETYPE 0x00002000
#define SDB_MATCHINGINFO_PE_CHECKSUM 0x00004000
#define SDB_MATCHINGINFO_FILE_VERSION 0x00008000
#define SDB_MATCHINGINFO_ORIGINAL_FILENAME 0x00010000
#define SDB_MATCHINGINFO_INTERNAL_NAME 0x00020000
#define SDB_MATCHINGINFO_LEGAL_COPYRIGHT 0x00040000
#define SDB_MATCHINGINFO_16BIT_DESCRIPTION 0x00080000
#define SDB_MATCHINGINFO_UPTO_BIN_PRODUCT_VERSION 0x00100000
#define SDB_MATCHINGINFO_PREVOSMAJORVERSION 0x00200000
#define SDB_MATCHINGINFO_PREVOSMINORVERSION 0x00400000
#define SDB_MATCHINGINFO_PREVOSPLATFORMID 0x00800000
#define SDB_MATCHINGINFO_PREVOSBUILDNO 0x01000000
#define SDB_MATCHINGINFO_LINKER_VERSION 0x02000000
#define SDB_MATCHINGINFO_16BIT_MODULE_NAME 0x04000000
#define SDB_MATCHINGINFO_LINK_DATE 0x08000000
#define SDB_MATCHINGINFO_UPTO_LINK_DATE 0x10000000
#define SDB_MATCHINGINFO_VER_LANGUAGE 0x20000000
#define SDB_MATCHINGINFO_UPTO_BIN_FILE_VERSION 0x40000000
//
// Possible MODULE_TYPE values
//
#define SDB_MATCHINGINFO_MODULE_TYPE_UNK 0
#define SDB_MATCHINGINFO_MODULE_TYPE_DOS 1
#define SDB_MATCHINGINFO_MODULE_TYPE_W16 2
#define SDB_MATCHINGINFO_MODULE_TYPE_W32 3
//
// Filters
//
#define SDB_FILTER_EXCLUDE_ALL 0x00000000
#define SDB_FILTER_DEFAULT 0x00000001
#define SDB_FILTER_OVERRIDE 0x00000002
#define SDB_FILTER_FIX 0x00000004
#define SDB_FILTER_APPHELP 0x00000008
#define SDB_FILTER_MSI 0x00000010
#define SDB_FILTER_DRIVER 0x00000020
#define SDB_FILTER_NTCOMPAT 0x00000040
#define SDB_FILTER_INCLUDE_ALL 0xFFFFFFFF
//
// This enumeration is used by SdbFlag::m_dwType
//
enum
{
SDB_FLAG_UNKNOWN = 0,
SDB_FLAG_KERNEL,
SDB_FLAG_USER,
SDB_FLAG_NTVDM1,
SDB_FLAG_NTVDM2,
SDB_FLAG_NTVDM3,
SDB_FLAG_SHELL,
SDB_FLAG_MAX_TYPE
};
//
// This enumeration is used by SdbOutputFile::m_OutputType
//
enum SdbOutputType
{
SDB_OUTPUT_TYPE_UNKNOWN = 0,
SDB_OUTPUT_TYPE_SDB,
SDB_OUTPUT_TYPE_HTMLHELP,
SDB_OUTPUT_TYPE_MIGDB_INX,
SDB_OUTPUT_TYPE_MIGDB_TXT,
SDB_OUTPUT_TYPE_WIN2K_REGISTRY,
SDB_OUTPUT_TYPE_REDIR_MAP,
SDB_OUTPUT_TYPE_NTCOMPAT_INF,
SDB_OUTPUT_TYPE_NTCOMPAT_MESSAGE_INF,
SDB_OUTPUT_TYPE_APPHELP_REPORT
};
//
// This enumeration is used by SdbCaller::m_CallerType
//
enum SdbCallerType
{
SDB_CALLER_EXCLUDE = 0,
SDB_CALLER_INCLUDE
};
//
// This enumeration is used by SdbShim::m_Purpose
//
enum SdbPurpose
{
SDB_PURPOSE_GENERAL = 0,
SDB_PURPOSE_SPECIFIC
};
//
// This enumeration is used by SdbMessage::m_Type
// These values are taken from badapps.h in shell\published
// and are compatible with Win2k, do not change
//
enum SdbAppHelpType
{
SDB_APPHELP_NONE = 0,
SDB_APPHELP_NOBLOCK = 1,
SDB_APPHELP_HARDBLOCK = 2,
SDB_APPHELP_MINORPROBLEM = 3,
SDB_APPHELP_REINSTALL = 4,
SDB_APPHELP_VERSIONSUB = 5,
SDB_APPHELP_SHIM = 6
};
enum SdbMatchOperationType
{
SDB_MATCH_ALL = 0,
SDB_MATCH_ANY
};
//
// This enumeration is used by SdbData::m_DataType
//
enum SdbDataValueType
{
eValueNone = REG_NONE,
eValueDWORD = REG_DWORD,
eValueQWORD = REG_QWORD,
eValueString = REG_SZ,
eValueBinary = REG_BINARY
};
//
// Forward declarations of all classes
//
class SdbApp;
class SdbExe;
class SdbFile;
class SdbShim;
class SdbFlag;
class SdbData;
class SdbAction;
class SdbPatch;
class SdbLayer;
class SdbCaller;
class SdbMessage;
class SdbLibrary;
class SdbShimRef;
class SdbFlagRef;
class SdbAppHelp;
class SdbDatabase;
class SdbLayerRef;
class SdbAppHelpRef;
class SdbMsiPackage;
class SdbContactInfo;
class SdbMsiTransform;
class SdbWinNTUpgrade;
class SdbMatchingFile;
class SdbMessageField;
class SdbWin9xMigration;
class SdbMsiTransformRef;
class SdbMsiCustomAction;
class SdbMessageTemplate;
class SdbMatchingRegistryEntry;
class SdbMakefile;
class SdbInputFile;
class SdbOutputFile;
///////////////////////////////////////////////////////////////////////////////
//
// SdbArrayElement
//
// All elements contained in a SdbArray or SdbRefArray must be derived
// from this base class. It defines the basic m_csName property which is
// used throughout the object model for array lookup, sorting etc.
//
class SdbArrayElement
{
public:
CString m_csName;
ULONGLONG m_ullKey; // 64-bit key used to sort element within array
SdbDatabase* m_pDB; // Pointer to root database object.
DWORD m_dwFilter;
DWORD m_dwSPMask;
DWORD m_dwOSPlatform;
CString m_csOSVersionSpec;
CString m_csLangID;
DATE m_dtLastRevision;
SdbArrayElement() :
m_ullKey(0),
m_pDB(NULL),
m_dwSPMask(0xFFFFFFFF),
m_dwOSPlatform(OS_PLATFORM_ALL),
m_dwFilter(SDB_FILTER_DEFAULT),
m_dtLastRevision(0) {}
virtual ~SdbArrayElement() { }
virtual int Compare(const SdbArrayElement* pElement);
virtual ULONGLONG MakeKey() {
return SdbMakeIndexKeyFromString(m_csName);
}
virtual void PropagateFilter(DWORD dwFilter);
//
// Virtual persistance functions
//
virtual BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
virtual BOOL WriteToSDB(PDB pdb);
virtual BOOL WriteRefToSDB(PDB pdb);
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbArrayT
//
// This template is an extension of CPtrArray which
// designates that the array owns its elements or simply
// references them. If it owns them, it will delete them during
// destruction. Array elements must be derived from SdbArrayElement
// to be properly destructed.
//
// SdbArray and SdbRefArray are class instances of the template.
//
template <class T, BOOL bOwnsElements> class SdbArrayT;
template <class T> class SdbArray : public SdbArrayT<T, TRUE> { };
template <class T> class SdbRefArray : public SdbArrayT<T, FALSE> { };
template <class T, BOOL bOwnsElements> class SdbArrayT : public CPtrArray
{
public:
CMapStringToPtr m_mapName;
//
// 'LookupName' looks up an element in the array by name
//
SdbArrayElement* LookupName( LPCTSTR lpszName, long* piStart = NULL ) {
return LookupName(lpszName, NULL, piStart);
}
SdbArrayElement* LookupName( LPCTSTR lpszName, LPCTSTR lpszLangID, long* piStart = NULL ) {
CString csName;
SdbArrayElement* pElement;
if (lpszLangID) {
csName.Format(_T("%s\\%s"), lpszLangID, lpszName);
} else {
csName = lpszName;
}
csName.MakeUpper();
if (!m_mapName.Lookup(csName, (LPVOID&)pElement)) {
pElement = NULL;
}
return pElement;
}
~SdbArrayT()
{
LONG i = 0;
if( bOwnsElements ) {
for( i = 0; i < (LONG)GetSize(); i++ ) {
delete (SdbArrayElement *) GetAt( i );
}
}
}
//
// 'AddOrdered' will add the element to the array sorted by name
//
int AddOrdered(SdbArrayElement* pElement)
{
INT iLeft = 0;
INT iRight = (INT) (GetSize() - 1);
INT i = -1;
INT iCmp;
BOOL bFound = FALSE;
SdbArrayElement* pElementCompare;
if (0 == pElement->m_ullKey) {
pElement->m_ullKey = pElement->MakeKey();
}
if (iRight >= 0) {
do {
i = (iLeft + iRight) / 2; // middle ground
pElementCompare = (SdbArrayElement*)GetAt(i); // element that we're going to try
iCmp = pElement->Compare(pElementCompare);
if (iCmp <= 0) {
iRight = i - 1;
}
if (iCmp >= 0) {
iLeft = i + 1;
}
} while (iRight >= iLeft);
}
//
// if the element was found -- we insert right where it's at
// if not -- to the right of the current element
//
bFound = (iLeft - iRight) > 1;
if (!bFound) {
i = iRight + 1;
}
CPtrArray::InsertAt(i, pElement);
return i;
}
//
// 'Add' will simply add an element to the array, and add
// to the name map that is used for look up.
//
INT Add(SdbArrayElement* pElement, SdbDatabase* pDB = NULL, BOOL bOrdered = FALSE)
{
CString csName;
pElement->m_pDB = pDB;
csName.MakeUpper();
if (pElement->m_csLangID.GetLength()) {
csName.Format(_T("%s\\%s"), pElement->m_csLangID, pElement->m_csName);
} else {
csName = pElement->m_csName;
}
csName.MakeUpper();
m_mapName.SetAt(csName, (LPVOID)pElement);
// also insert at the right place according to the imposed order
return (INT)(bOrdered ? AddOrdered(pElement) : CPtrArray::Add(pElement));
}
int Append(const SdbArray<T>& rgArray)
{
SdbArrayElement* pElement;
int nFirstElement = -1;
int nThisElement = -1;
//
// Cannot own elements
//
if (!bOwnsElements) {
for (long i = 0; i < rgArray.GetSize(); i++) {
pElement = (SdbArrayElement *) rgArray.GetAt(i);
nThisElement = Add(pElement, pElement->m_pDB);
if (nFirstElement == -1) {
nFirstElement = nThisElement;
}
}
}
return nFirstElement;
}
DWORD GetFilteredCount(DWORD dwFilter, DATE dtRevisionCutoff = 0)
{
DWORD dwCount = 0;
long i = 0;
SdbArrayElement* pElem;
for (i = 0; i < GetSize(); i++) {
pElem = (SdbArrayElement *) GetAt(i);
if ((pElem->m_dwFilter & dwFilter) &&
dtRevisionCutoff <= pElem->m_dtLastRevision) {
dwCount++;
}
}
return dwCount;
}
virtual void PropagateFilter(DWORD dwFilter)
{
long i = 0;
SdbArrayElement* pElem;
for (i = 0; i < GetSize(); i++) {
pElem = (SdbArrayElement *) GetAt(i);
pElem->PropagateFilter(dwFilter);
}
}
//
// 'ReadFromXML' will perform an XQL query on the pParentNode object and
// populate the array with members -- each of which read themselves in from
// the nodes returned by the query.
//
BOOL ReadFromXML(LPCTSTR szXQL, SdbDatabase* pDB, IXMLDOMNode* pParentNode, SdbArray<T>* pOwnerArray = NULL, BOOL bAddOrdered = FALSE, LPCTSTR lpszKeyAttribute = _T("NAME"))
{
BOOL bSuccess = FALSE;
XMLNodeList XQL;
IXMLDOMNodePtr cpNode;
T* pNewObject = NULL;
LONG i;
CString csName;
if (!XQL.Query(pParentNode, szXQL)) {
SDBERROR_PROPOGATE();
goto eh;
}
for (i = 0; i < (LONG)XQL.GetSize(); i++) {
pNewObject = NULL;
if (!XQL.GetItem(i, &cpNode)) {
SDBERROR_PROPOGATE();
goto eh;
}
if (bOwnsElements) {
pNewObject = (T*) new T();
if (pNewObject == NULL) {
CString csFormat;
csFormat.Format(_T("Error allocating new object to read \"%s\" tag"), szXQL);
SDBERROR(csFormat);
goto eh;
}
if (!pNewObject->ReadFromXML(cpNode, pDB)) {
SDBERROR_PROPOGATE();
goto eh;
}
} else {
if (lpszKeyAttribute) {
if (!GetAttribute(lpszKeyAttribute, cpNode, &csName)) {
CString csFormat;
csFormat.Format(_T("Error retrieving %s attribute on tag:\n\n%s\n\n"),
lpszKeyAttribute, szXQL, GetXML(cpNode));
SDBERROR(csFormat);
goto eh;
}
}
if (pOwnerArray == NULL) {
SDBERROR(_T("Internal error: SdbArray::ReadFromXML() requires non-NULL ")
_T("pOwnerArray for reference arrays."));
goto eh;
}
pNewObject = (T*) pOwnerArray->LookupName(csName);
if (!pNewObject && g_bStrict) {
CString csFormat;
csFormat.Format(_T("Tag \"%s\" references unknown LIBRARY item \"%s\":\n\n%s\n\n"),
szXQL, csName, GetXML(cpNode));
SDBERROR(csFormat);
goto eh;
}
}
if (pNewObject) {
Add(pNewObject, pDB, bAddOrdered);
}
cpNode.Release();
}
bSuccess = TRUE;
eh:
return bSuccess;
}
//
// 'WriteToSDB' will write each of the elements in the array out
// to the SDB database specified by pdb.
//
BOOL WriteToSDB(PDB pdb, BOOL bReference = FALSE)
{
LONG i;
T* pOb;
for (i = 0; i < (LONG)GetSize(); i++) {
pOb = (T*) GetAt(i);
if ((g_dwCurrentWriteFilter & pOb->m_dwFilter) &&
(pOb->m_dtLastRevision != 0 ? g_dtCurrentWriteRevisionCutoff <= pOb->m_dtLastRevision : TRUE)) {
if (bReference) {
if (!pOb->WriteRefToSDB(pdb)) {
return FALSE;
}
} else {
if (!pOb->WriteToSDB(pdb)) {
return FALSE;
}
}
}
}
return TRUE;
}
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbLocalizedString
//
// The SdbLocalizedString object is simply a named string that also has a
// LangID associated with it.
//
class SdbLocalizedString : public SdbArrayElement
{
public:
CString m_csValue;
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbLibrary
//
// The SdbLibrary object contains the shims, patches and kernel flags and
// layers that are referenced by App or Exe objects. NOTE: It is possible
// to compile a database without entries in Library, with the assumption
// that any references will be resolved when further databases in the
// search path are opened.
//
class SdbLibrary : public SdbArrayElement
{
public:
SdbArray<SdbFile> m_rgFiles;
SdbArray<SdbShim> m_rgShims;
SdbArray<SdbPatch> m_rgPatches;
SdbArray<SdbLayer> m_rgLayers;
SdbArray<SdbFlag> m_rgFlags;
SdbArray<SdbCaller> m_rgCallers;
SdbArray<SdbMsiTransform> m_rgMsiTransforms;
void PropagateFilter(DWORD dwFilter)
{
SdbArrayElement::PropagateFilter(dwFilter);
m_rgFiles.PropagateFilter(m_dwFilter);
m_rgShims.PropagateFilter(m_dwFilter);
m_rgPatches.PropagateFilter(m_dwFilter);
m_rgLayers.PropagateFilter(m_dwFilter);
m_rgFlags.PropagateFilter(m_dwFilter);
m_rgCallers.PropagateFilter(m_dwFilter);
m_rgMsiTransforms.PropagateFilter(m_dwFilter == SDB_FILTER_EXCLUDE_ALL ? SDB_FILTER_EXCLUDE_ALL : SDB_FILTER_MSI);
}
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
BOOL WriteToSDB(PDB pdb);
//
// method to clear out tagIDs before writing the db out
//
VOID SanitizeTagIDs(VOID);
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbDatabase
//
// This is the base class for the three database classes. It contains
// any common properties between the three.
//
class SdbDatabase : public SdbArrayElement
{
public:
SdbDatabase() :
m_ID(GUID_NULL),
m_pCurrentApp(NULL),
m_pCurrentMakefile(NULL),
m_pCurrentInputFile(NULL),
m_pCurrentOutputFile(NULL),
m_iiWildcardExeIndex(NULL),
m_iiModuleExeIndex(NULL),
m_iiMsiIDIndex(NULL),
m_iiDrvIDIndex(NULL),
m_iiShimIndex(NULL),
m_iiMsiTransformIndex(NULL),
m_iiMsiPackageIndex(NULL)
{
m_Library.m_pDB = this;
}
GUID m_ID;
SdbMakefile* m_pCurrentMakefile;
SdbInputFile* m_pCurrentInputFile;
SdbOutputFile* m_pCurrentOutputFile;
GUID m_CurrentDBID; // last written out dbid
CString m_csCurrentLangID;
IXMLDOMNodePtr m_cpCurrentDatabaseNode;
SdbLibrary m_Library;
//
// Holding variables that are used while reading/writing
//
INDEXID m_iiWildcardExeIndex;
INDEXID m_iiModuleExeIndex;
INDEXID m_iiExeIndex;
INDEXID m_iiShimIndex;
INDEXID m_iiMsiTransformIndex;
INDEXID m_iiMsiPackageIndex;
INDEXID m_iiMsiIDIndex;
INDEXID m_iiDrvIDIndex;
INDEXID m_iiHtmlHelpID;
SdbApp* m_pCurrentApp;
IXMLDOMDocumentPtr m_cpTempXMLDoc;
IXMLDOMNodePtr m_cpTempXML;
SdbArray<SdbApp> m_rgApps;
SdbArray<SdbAction> m_rgAction;
SdbRefArray<SdbExe> m_rgExes;
SdbRefArray<SdbExe> m_rgWildcardExes;
SdbRefArray<SdbExe> m_rgModuleExes; // exes that match on module name
SdbRefArray<SdbWinNTUpgrade> m_rgWinNTUpgradeEntries;
SdbRefArray<SdbMsiPackage> m_rgMsiPackages;
CString m_csHTMLHelpFirstScreen;
SdbArray<SdbContactInfo> m_rgContactInfo;
SdbArray<SdbMessage> m_rgMessages;
SdbArray<SdbMessageTemplate> m_rgMessageTemplates;
SdbArray<SdbLocalizedString> m_rgHTMLHelpTemplates;
SdbArray<SdbLocalizedString> m_rgHTMLHelpFirstScreens;
SdbArray<SdbLocalizedString> m_rgLocalizedAppNames;
SdbArray<SdbLocalizedString> m_rgLocalizedVendorNames;
SdbArray<SdbLocalizedString> m_rgRedirs;
SdbArray<SdbAppHelp> m_rgAppHelps;
//
// Maps used to map IDs to their objects
//
CMapStringToPtr m_mapExeIDtoExe;
SdbExe* LookupExe(DWORD dwTagID);
BOOL ReplaceFields(CString csXML, CString* pcsReturn, SdbRefArray<SdbMessageField>* prgFields);
BOOL ReplaceFieldsInXML(IXMLDOMNode* cpTargetNode, SdbRefArray<SdbMessageField>* prgFields);
BOOL RedirectLinks(CString* pcsXML, LCID lcid, CString csRedirURL);
BOOL HTMLtoText(CString csXML, CString* pcsReturn);
DWORD GetNextSequentialID(CString csType);
BOOL WriteAppHelpRefTag(
PDB pdb,
CString csHTMLHelpID,
LCID langID,
CString csURL,
CString csAppTitle,
CString csSummary);
BOOL ConstructMessageParts(
SdbAppHelp* pAppHelp,
SdbMessage* pMessage,
CString& csLangID,
DWORD* pdwHTMLHelpID,
CString* pcsURL,
CString* pcsContactInformation,
CString* pcsAppTitle,
CString* pcsSummary,
CString* pcsDetails);
BOOL ConstructMigrationMessage(
SdbWin9xMigration* pMigApp,
SdbMessage* pMessage,
CString* pcsMessage);
void PropagateFilter(DWORD dwFilter)
{
SdbArrayElement::PropagateFilter(dwFilter);
m_rgApps.PropagateFilter(m_dwFilter == SDB_FILTER_EXCLUDE_ALL ? SDB_FILTER_EXCLUDE_ALL : SDB_FILTER_FIX);
m_rgAction.PropagateFilter(m_dwFilter == SDB_FILTER_EXCLUDE_ALL ? SDB_FILTER_EXCLUDE_ALL : SDB_FILTER_FIX);
m_Library.PropagateFilter(m_dwFilter == SDB_FILTER_EXCLUDE_ALL ? SDB_FILTER_EXCLUDE_ALL : SDB_FILTER_FIX);
}
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
BOOL WriteToSDB(PDB pdb);
BOOL IsStandardDatabase(VOID);
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbApp
//
// The SdbApp object groups Exe objects by application title and vendor. Note
// that it contains only references to exes: Exe objects are owned by the
// database object.
//
class SdbApp : public SdbArrayElement
{
public:
CString m_csVendor;
CString m_csVendorXML;
CString m_csVersion;
SdbArray<SdbExe> m_rgExes;
SdbArray<SdbMsiPackage> m_rgMsiPackages;
SdbArray<SdbWin9xMigration>
m_rgWin9xMigEntries;
SdbArray<SdbWinNTUpgrade>
m_rgWinNTUpgradeEntries;
SdbRefArray<SdbAppHelpRef> m_rgAppHelpRefs;
CString m_csKeywords;
BOOL m_bSeen;
GUID m_ID;
SdbApp():
m_ID(GUID_NULL){}
CString GetLocalizedAppName();
CString GetLocalizedAppName(CString csLangID);
CString GetLocalizedVendorName();
CString GetLocalizedVendorName(CString csLangID);
void PropagateFilter(DWORD dwFilter)
{
SdbArrayElement::PropagateFilter(dwFilter);
m_rgExes.PropagateFilter(m_dwFilter);
m_rgMsiPackages.PropagateFilter(m_dwFilter == SDB_FILTER_EXCLUDE_ALL ? SDB_FILTER_EXCLUDE_ALL : SDB_FILTER_MSI);
m_rgWin9xMigEntries.PropagateFilter(m_dwFilter);
m_rgWinNTUpgradeEntries.PropagateFilter(m_dwFilter);
}
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbContactInfo
//
// The SdbContactInfo object contains all contact information for the vendor
// portion of the AppHelp dialog. These values can be overridden in the
// AppHelp object.
//
class SdbContactInfo : public SdbArrayElement
{
public:
CString m_csXML;
GUID m_ID;
SdbContactInfo() :
m_ID(GUID_NULL){}
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbMessageTemplate
//
// The SdbMessageTemplate object contains AppHelp messages to be used as 'templates'
// for SdbMessage objects. A SdbMessage object can specify a template and
// use its m_csText and m_csHTML values, or override one of them.
//
class SdbMessageTemplate : public SdbArrayElement
{
public:
CString m_csSummaryXML;
CString m_csDetailsXML;
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbMessage
//
// The SdbMessage object contains all information required for an AppHelp
// dialog in localized form. A SdbAppHelp object references a single
// SdbMessage object, but all of the text is localized in multiple languages.
// A SdbMessage object can derive from a SdbMessageTemplate object, which
// supplies the default m_csText and m_csHTML values.
//
class SdbMessage : public SdbArrayElement
{
public:
SdbMessageTemplate* m_pTemplate;
SdbArray<SdbMessageField> m_rgFields;
CString m_csContactInfoXML; // Overriding ContactInfo object
CString m_csSummaryXML; // Overriding Template object
CString m_csDetailsXML; // Overriding Template object
GUID m_ID;
SdbMessage() :
m_ID(GUID_NULL),
m_pTemplate(NULL) {}
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbAppHelp
//
// The SdbAppHelp object is an instantiation of an AppHelp message. An
// SdbAppHelp is the only object that contains the HTMLHELPID attribute,
// which is needed for each unique AppHelp entry in the CHM file.
//
// HTMLHELPID is stored in SdbAppHelp::m_csName.
//
class SdbAppHelp : public SdbArrayElement
{
public:
CString m_csMessage;
SdbApp* m_pApp;
SdbAppHelpType m_Type;
BOOL m_bBlockUpgrade;
CString m_csURL; // custom URL, if supplied
SdbAppHelp() :
m_bBlockUpgrade(FALSE),
m_Type(SDB_APPHELP_NOBLOCK),
m_pApp(NULL) { }
void PropagateFilter(DWORD dwFilter)
{
//
// We OR this one unconditionally to achieve the following
// effect: If an HTMLHELPID is used at least once, it will
// be included. If it is not used at all (given the current
// filtering), it will never get an SDB_FILTER_APPHELP bit
// set.
//
m_dwFilter |= dwFilter;
}
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbAppHelpRef
//
// The SdbAppHelpRef object is an instantiation of an AppHelp object.
//
class SdbAppHelpRef : public SdbArrayElement
{
public:
BOOL m_bApphelpOnly;
SdbAppHelp* m_pAppHelp;
IXMLDOMNodePtr m_cpNode;
SdbAppHelpRef() :
m_bApphelpOnly(FALSE),
m_pAppHelp(NULL)
{}
void PropagateFilter(DWORD dwFilter)
{
SdbArrayElement::PropagateFilter(dwFilter);
if (m_pAppHelp) {
m_pAppHelp->PropagateFilter(m_dwFilter);
}
}
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
BOOL WriteToSDB(PDB pdb);
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbMessageField
//
// The SdbMessageField object contains a name-value pair that can is used to
// replace fields embedded in templates.
//
class SdbMessageField : public SdbArrayElement
{
public:
CString m_csValue;
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbMatchingFile
//
// The SdbMatchingFile object contains all file information about files that
// must be matched on for app identification. m_dwMask is used to indicate
// which of the criteria contain valid values (see defines at top of file for
// mask).
//
class SdbMatchingFile : public SdbArrayElement
{
public:
DWORD m_dwMask;
DWORD m_dwSize;
DWORD m_dwChecksum;
CString m_csCompanyName;
CString m_csProductName;
CString m_csProductVersion;
CString m_csFileDescription;
ULONGLONG m_ullBinFileVersion;
ULONGLONG m_ullBinProductVersion;
DWORD m_dwVerLanguage;
DWORD m_dwModuleType;
DWORD m_dwFileDateMS;
DWORD m_dwFileDateLS;
DWORD m_dwFileOS;
DWORD m_dwFileType;
ULONG m_ulPECheckSum;
DWORD m_dwLinkerVersion;
CString m_csFileVersion;
CString m_csOriginalFileName;
CString m_csInternalName;
CString m_csLegalCopyright;
CString m_cs16BitDescription;
CString m_cs16BitModuleName;
ULONGLONG m_ullUpToBinProductVersion;
ULONGLONG m_ullUpToBinFileVersion;
DWORD m_dwPrevOSMajorVersion;
DWORD m_dwPrevOSMinorVersion;
DWORD m_dwPrevOSPlatformID;
DWORD m_dwPrevOSBuildNo;
time_t m_timeLinkDate;
time_t m_timeUpToLinkDate;
BOOL m_bMatchLogicNot;
CString m_csServiceName;
CString m_csRegistryEntry;
SdbMatchingFile() :
m_dwMask(NULL),
m_bMatchLogicNot(FALSE) {}
BOOL IsValidForWin2k(CString csXML);
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
BOOL WriteToSDB(PDB pdb);
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbMsiPackage
//
// The SdbMsiPackage object represents an Installer package that must be fixed via
// application of a custom MSI_TRANSFORM
//
class SdbMsiPackage : public SdbArrayElement
{
public:
//
// Pointer to the (parent) app object
//
SdbApp* m_pApp;
//
// supplemental data for MSI_PACKAGE object
// it is used to further identify the package
//
SdbArray<SdbData> m_rgData;
//
// MSI_TRANSFORM stuff designed to fix this package (references transforms in lib)
//
SdbArray<SdbMsiTransformRef> m_rgMsiTransformRefs;
GUID m_MsiPackageID; // package id (non-unique guid)
GUID m_ID; // exe id (unique guid)
//
// RUNTIME_PLATFORM attribute
//
DWORD m_dwRuntimePlatform;
//
// OS_SKU attribute
//
DWORD m_dwOSSKU;
//
// apphelp
//
SdbAppHelpRef m_AppHelpRef;
//
// shims and layers don't cut it, we need another entity here
//
SdbArray<SdbMsiCustomAction> m_rgCustomActions;
//
// we override the default MakeKey function
// in order to sort the content by keys made from guid IDs instead of the name
// secondary sort order will be provided by name
//
virtual ULONGLONG MakeKey() {
return MAKEKEYFROMGUID(&m_ID);
}
SdbMsiPackage() :
m_ID(GUID_NULL),
m_dwRuntimePlatform(RUNTIME_PLATFORM_ANY),
m_dwOSSKU(OS_SKU_ALL) {}
void PropagateFilter(DWORD dwFilter)
{
SdbArrayElement::PropagateFilter(dwFilter);
m_AppHelpRef.PropagateFilter(m_dwFilter == SDB_FILTER_EXCLUDE_ALL ? SDB_FILTER_EXCLUDE_ALL : SDB_FILTER_APPHELP);
m_rgData.PropagateFilter(m_dwFilter);
m_rgMsiTransformRefs.PropagateFilter(m_dwFilter);
m_rgCustomActions.PropagateFilter(m_dwFilter);
}
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
BOOL WriteToSDB(PDB pdb);
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbMsiCustomAction
//
// The SdbMsiCustomAction object encapsulates custom actions and what we do
// for them (shim/etc)
//
class SdbMsiCustomAction : public SdbArrayElement
{
public:
SdbArray<SdbShimRef> m_rgShimRefs;
SdbArray<SdbLayerRef> m_rgLayerRefs;
void PropagateFilter(DWORD dwFilter)
{
SdbArrayElement::PropagateFilter(dwFilter);
m_rgShimRefs.PropagateFilter(m_dwFilter);
m_rgLayerRefs.PropagateFilter(m_dwFilter);
}
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
BOOL WriteToSDB(PDB pdb);
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbMsiTransform
//
// The SdbMsiTransform object encapsulates an MSI_TRANSFORM remedy.
//
class SdbMsiTransform : public SdbArrayElement
{
public:
SdbMsiTransform() :
m_tiTagID(NULL),
m_pSdbFile(NULL) {}
TAGID m_tiTagID; // tagid of this record
SdbFile* m_pSdbFile; // pointer to the transform file
CString m_csMsiTransformFile; // transform filename
CString m_csDesc; // description
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
BOOL WriteToSDB(PDB pdb);
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbMsiTransformRef
//
// The SdbMsiTransformRef object is a reference to an SdbMsiTransform object
// in the library.
//
class SdbMsiTransformRef : public SdbArrayElement
{
public:
SdbMsiTransformRef() :
m_pMsiTransform(NULL) {}
SdbMsiTransform* m_pMsiTransform;
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
BOOL WriteToSDB(PDB pdb);
};
#define MATCH_DEFAULT ((DWORD)-1)
///////////////////////////////////////////////////////////////////////////////
//
// SdbExe
//
// The SdbExe object represents an executable that must be patched/shimmed.
// The m_pApp member can be NULL, or it can contain a pointer to the SdbApp
// object that groups it with other SdbExe objects.
//
class SdbExe : public SdbArrayElement
{
public:
SdbApp* m_pApp;
SdbArray<SdbShimRef> m_rgShimRefs;
SdbArray<SdbLayerRef> m_rgLayerRefs;
SdbArray<SdbFlagRef> m_rgFlagRefs;
SdbArray<SdbMatchingFile> m_rgMatchingFiles;
SdbArray<SdbData> m_rgData;
SdbArray<SdbAction> m_rgAction;
SdbRefArray<SdbPatch> m_rgPatches;
SdbAppHelpRef m_AppHelpRef;
CString m_csSXSManifest;
GUID m_ID;
BOOL m_bWildcardInName;
BOOL m_bMatchOnModule;
DWORD m_dwTagID;
BOOL m_bSeen;
DWORD m_dwMatchMode; // modes include NORMAL, EXCLUSIVE, or ADDITIVE
DWORD m_dwRuntimePlatform;
DWORD m_dwOSSKU;
SdbExe() :
m_pApp(NULL),
m_dwTagID(0),
m_ID(GUID_NULL),
m_dwMatchMode(MATCH_DEFAULT),
m_bWildcardInName(FALSE),
m_dwRuntimePlatform(RUNTIME_PLATFORM_ANY),
m_dwOSSKU(OS_SKU_ALL),
m_bMatchOnModule(FALSE) {m_dwOSPlatform = OS_PLATFORM_I386;}
BOOL IsValidForWin2k(CString csXML);
void PropagateFilter(DWORD dwFilter)
{
SdbArrayElement::PropagateFilter(dwFilter);
m_rgShimRefs.PropagateFilter(m_dwFilter);
m_rgLayerRefs.PropagateFilter(m_dwFilter);
m_rgFlagRefs.PropagateFilter(m_dwFilter);
m_rgMatchingFiles.PropagateFilter(m_dwFilter);
m_rgData.PropagateFilter(m_dwFilter);
m_rgAction.PropagateFilter(m_dwFilter);
m_rgPatches.PropagateFilter(m_dwFilter);
m_AppHelpRef.PropagateFilter(m_dwFilter == SDB_FILTER_EXCLUDE_ALL ? SDB_FILTER_EXCLUDE_ALL : SDB_FILTER_APPHELP);
}
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
BOOL WriteToSDB(PDB pdb);
int Compare(const SdbArrayElement* pElement);
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbFile
//
// The SdbFile object represents a binary file that can be stored in the
// database.
//
class SdbFile : public SdbArrayElement
{
public:
SdbFile() :
m_tiTagID(NULL) {}
TAGID m_tiTagID;
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
BOOL WriteToSDB(PDB pdb);
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbShim
//
// The SdbShim object represents a shim, which contains Win32 API hooks.
// A shim's 'purpose' can be marked as GENERAL or SPECIFIC -- if it is GENERAL,
// it is appropriate for reuse, otherwise it is application specific.
//
class SdbShim : public SdbArrayElement
{
public:
SdbShim() :
m_ID(GUID_NULL),
m_tiTagID(NULL),
m_Purpose(SDB_PURPOSE_SPECIFIC),
m_bApplyAllShims(FALSE) {m_dwOSPlatform = OS_PLATFORM_I386;}
CString m_csShortName;
CString m_csDesc;
TAGID m_tiTagID;
CString m_csDllFile;
SdbPurpose m_Purpose;
BOOL m_bApplyAllShims;
GUID m_ID;
SdbArray<SdbCaller> m_rgCallers;
void PropagateFilter(DWORD dwFilter)
{
SdbArrayElement::PropagateFilter(dwFilter);
m_rgCallers.PropagateFilter(m_dwFilter);
}
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
BOOL WriteToSDB(PDB pdb);
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbCaller
//
// The SdbCaller object contains inclusion/exclusion information for shims.
// It allows hooked APIs to be cased by the calling instruction address. For
// example, it is known that ATL.DLL requires accurate OS version information,
// and so any calls to GetVersionExA from ATL.DLL are assured to call the
// original API, rather than the shim hook. This is achieved by adding
// an EXCLUDE subtag to the SHIM tag.
//
class SdbCaller : public SdbArrayElement
{
public:
CString m_csModule;
SdbCallerType m_CallerType;
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
BOOL WriteToSDB(PDB pdb);
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbShimRef
//
// The SdbShimRef object is simply a reference to a SdbShim object that exists
// in a library. It has separate inclusion/exclusion information, which is
// given higher priority than any such information in the SHIM tag within the
// corresponding library. It can contain an optional command line, which is
// passed in to the shim DLL via GetHookAPIs.
//
class SdbShimRef : public SdbArrayElement
{
public:
SdbShimRef() :
m_dwRecID(NULL),
m_pShim(NULL) {}
DWORD m_dwRecID;
SdbShim* m_pShim;
CString m_csCommandLine;
SdbArray<SdbCaller> m_rgCallers;
SdbArray<SdbData> m_rgData;
void PropagateFilter(DWORD dwFilter)
{
SdbArrayElement::PropagateFilter(dwFilter);
m_rgCallers.PropagateFilter(m_dwFilter);
m_rgData.PropagateFilter(m_dwFilter);
}
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
BOOL WriteToSDB(PDB pdb);
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbPatch
//
// The SdbPatch object contains the patch binary that is parsed by the app
// compat mechanism at run-time. It contains patching instructions, including
// any bits to patch an executable's code with.
//
class SdbPatch : public SdbArrayElement
{
private:
BYTE* m_pBlob;
DWORD m_dwBlobMemSize;
DWORD m_dwBlobSize;
public:
TAGID m_tiTagID;
BOOL m_bUsed;
GUID m_ID;
SdbPatch() :
m_pBlob(NULL),
m_tiTagID(0),
m_dwBlobMemSize(0),
m_dwBlobSize(0),
m_ID(GUID_NULL),
m_bUsed(FALSE) {m_dwOSPlatform = OS_PLATFORM_I386;}
virtual ~SdbPatch()
{
if( m_pBlob != NULL )
delete m_pBlob;
}
PBYTE GetBlobBytes(void) {return m_pBlob;}
DWORD GetBlobSize(void) {return m_dwBlobSize;}
void AddBlobBytes( LPVOID pBytes, DWORD dwSize );
void ClearBlob();
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
BOOL WriteToSDB(PDB pdb);
BOOL WriteRefToSDB(PDB pdb);
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbFlag
//
// The SdbFlag object contains a mask which is used by kernel-mode
// components in special compatibility casing constructs. These flags can be
// turned on by adding the FLAG subtag to an EXE tag.
//
class SdbFlag : public SdbArrayElement
{
public:
CString m_csDesc;
ULONGLONG m_ullMask;
DWORD m_dwType;
TAGID m_tiTagID;
SdbPurpose m_Purpose;
GUID m_ID;
SdbFlag() :
m_ID(GUID_NULL),
m_tiTagID(0),
m_Purpose(SDB_PURPOSE_SPECIFIC),
m_ullMask(0) {m_dwOSPlatform = OS_PLATFORM_I386;}
static ULONGLONG MakeMask(SdbRefArray<SdbFlag>* prgFlags, DWORD dwType);
static TAG TagFromType(DWORD dwType);
BOOL SetType(CString csType);
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
BOOL WriteToSDB(PDB pdb);
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbFlagRef
//
// The SdbFlagRef object is simply a reference to a SdbFlag object that exists
// in a library.
//
class SdbFlagRef : public SdbArrayElement
{
public:
SdbFlagRef() :
m_pFlag(NULL) {}
SdbFlag* m_pFlag;
CString m_csCommandLine;
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
BOOL WriteToSDB(PDB pdb);
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbLayer
//
// The SdbLayer object contains a set of shims and/or kernel flags that can be
// turned on to invoke a "compatibility mode". Presently, if the environment
// variable __COMPAT_LAYER is set to the name of this object, all shims and
// kernel flags contained by the layer will be invoked.
//
class SdbLayer : public SdbArrayElement
{
public:
CString m_csDesc;
CString m_csDisplayName;
TAGID m_tiTagID;
GUID m_ID;
SdbArray<SdbShimRef> m_rgShimRefs;
SdbArray<SdbFlagRef> m_rgFlagRefs;
SdbLayer ():
m_ID(GUID_NULL){m_dwOSPlatform = OS_PLATFORM_I386;}
void PropagateFilter(DWORD dwFilter)
{
SdbArrayElement::PropagateFilter(dwFilter);
m_rgShimRefs.PropagateFilter(m_dwFilter);
m_rgFlagRefs.PropagateFilter(m_dwFilter);
}
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
BOOL WriteToSDB(PDB pdb);
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbLayerRef
//
// The SdbLayerRef object contains a reference to a layer that exists in the
// library. It exists to allow <EXE> entries that reference a layer defined
// in another database.
//
class SdbLayerRef : public SdbArrayElement
{
public:
SdbLayerRef() :
m_pLayer(NULL) {}
SdbLayer* m_pLayer;
SdbArray<SdbData> m_rgData;
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
BOOL WriteToSDB(PDB pdb);
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbData
//
// The SdbData object contains a name-value pair that can be queried
// at runtime for any data.
//
class SdbData : public SdbArrayElement
{
private:
SdbDataValueType m_DataType;
DWORD m_dwDataSize;
//
// nested Data elements
//
SdbArray<SdbData> m_rgData;
public:
union {
DWORD m_dwValue; // m_DataType == REG_DWORD
ULONGLONG m_ullValue; // m_DataType == REG_QWORD
LPTSTR m_szValue; // m_DataType == REG_SZ
LPBYTE m_pBinValue; // m_DataType == REG_BINARY
};
SdbData() :
m_DataType(eValueNone),
m_dwDataSize(0) {}
~SdbData() {
Clear();
}
void PropagateFilter(DWORD dwFilter)
{
SdbArrayElement::PropagateFilter(dwFilter);
m_rgData.PropagateFilter(m_dwFilter);
}
SdbDataValueType GetValueType() { return m_DataType; }
void Clear();
BOOL SetValue(SdbDataValueType DataType, LPCTSTR lpValue);
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
BOOL WriteToSDB(PDB pdb);
};
///////////////////////////////////////////////////////////////////////////////
//
// SdbAction
//
// The SdbAction object contains the type of the action and Data elements that
// provide any data needed to perform this action.
//
class SdbAction: public SdbArrayElement
{
private:
CString m_csType;
SdbArray<SdbData> m_rgData;
public:
SdbAction() {}
~SdbAction() {}
void PropagateFilter(DWORD dwFilter)
{
SdbArrayElement::PropagateFilter(dwFilter);
m_rgData.PropagateFilter(m_dwFilter);
}
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
BOOL WriteToSDB(PDB pdb);
};
class SdbMatchOperation : public SdbArrayElement
{
public:
SdbMatchOperationType m_Type;
SdbArray<SdbMatchingFile> m_rgMatchingFiles;
SdbArray<SdbMatchOperation> m_rgSubMatchOps;
SdbMatchOperation() :
m_Type(SDB_MATCH_ALL) {}
void PropagateFilter(DWORD dwFilter)
{
SdbArrayElement::PropagateFilter(dwFilter);
m_rgMatchingFiles.PropagateFilter(m_dwFilter);
m_rgSubMatchOps.PropagateFilter(m_dwFilter);
}
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
};
class SdbWin9xMigration : public SdbArrayElement
{
public:
SdbWin9xMigration() :
m_pApp(NULL),
m_bShowInSimplifiedView(FALSE) {}
CString m_csSection;
CString m_csMessage;
GUID m_ID;
BOOL m_bShowInSimplifiedView;
SdbApp* m_pApp;
SdbMatchOperation m_MatchOp;
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
};
class SdbMatchingRegistryEntry : public SdbArrayElement
{
public:
CString m_csValueName;
CString m_csValue;
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
};
class SdbWinNTUpgrade : public SdbArrayElement
{
public:
SdbWinNTUpgrade() :
m_ID(GUID_NULL),
m_pApp(NULL) {}
SdbAppHelpRef m_AppHelpRef;
SdbMatchingFile m_MatchingFile;
SdbMatchingRegistryEntry m_MatchingRegistryEntry;
SdbApp* m_pApp;
GUID m_ID;
void PropagateFilter(DWORD dwFilter)
{
SdbArrayElement::PropagateFilter(dwFilter);
m_AppHelpRef.PropagateFilter(m_dwFilter == SDB_FILTER_EXCLUDE_ALL ? SDB_FILTER_EXCLUDE_ALL : SDB_FILTER_NTCOMPAT);
}
BOOL ReadFromXML(IXMLDOMNode* pNode, SdbDatabase* pDB);
};
#endif // !defined(AFX_OBJ_H__5C16373A_D713_46CD_B8BF_7755216C62E0__INCLUDED_)
Reference in a new issue Copy permalink