/////////////////////////////////////////////////////////////////////////////// // // 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 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 SdbArrayT; template class SdbArray : public SdbArrayT { }; template class SdbRefArray : public SdbArrayT { }; template 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& 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* 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 m_rgFiles; SdbArray m_rgShims; SdbArray m_rgPatches; SdbArray m_rgLayers; SdbArray m_rgFlags; SdbArray m_rgCallers; SdbArray 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 m_rgApps; SdbArray m_rgAction; SdbRefArray m_rgExes; SdbRefArray m_rgWildcardExes; SdbRefArray m_rgModuleExes; // exes that match on module name SdbRefArray m_rgWinNTUpgradeEntries; SdbRefArray m_rgMsiPackages; CString m_csHTMLHelpFirstScreen; SdbArray m_rgContactInfo; SdbArray m_rgMessages; SdbArray m_rgMessageTemplates; SdbArray m_rgHTMLHelpTemplates; SdbArray m_rgHTMLHelpFirstScreens; SdbArray m_rgLocalizedAppNames; SdbArray m_rgLocalizedVendorNames; SdbArray m_rgRedirs; SdbArray m_rgAppHelps; // // Maps used to map IDs to their objects // CMapStringToPtr m_mapExeIDtoExe; SdbExe* LookupExe(DWORD dwTagID); BOOL ReplaceFields(CString csXML, CString* pcsReturn, SdbRefArray* prgFields); BOOL ReplaceFieldsInXML(IXMLDOMNode* cpTargetNode, SdbRefArray* 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 m_rgExes; SdbArray m_rgMsiPackages; SdbArray m_rgWin9xMigEntries; SdbArray m_rgWinNTUpgradeEntries; SdbRefArray 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 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 m_rgData; // // MSI_TRANSFORM stuff designed to fix this package (references transforms in lib) // SdbArray 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 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 m_rgShimRefs; SdbArray 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 m_rgShimRefs; SdbArray m_rgLayerRefs; SdbArray m_rgFlagRefs; SdbArray m_rgMatchingFiles; SdbArray m_rgData; SdbArray m_rgAction; SdbRefArray 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 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 m_rgCallers; SdbArray 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* 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 m_rgShimRefs; SdbArray 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 entries that reference a layer defined // in another database. // class SdbLayerRef : public SdbArrayElement { public: SdbLayerRef() : m_pLayer(NULL) {} SdbLayer* m_pLayer; SdbArray 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 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 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 m_rgMatchingFiles; SdbArray 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_)