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

2705 lines
67 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
////////////////////////////////////////////////////////////////////////////////////
//
// File: write.cpp
//
// History: 16-Nov-00 markder Created.
//
// Desc: This file contains all code needed to create SDB files
// from the SdbDatabase internal C++ object.
//
////////////////////////////////////////////////////////////////////////////////////
#include "StdAfx.h"
#include "make.h"
DWORD g_dwCurrentWriteFilter = SDB_FILTER_INCLUDE_ALL;
DATE g_dtCurrentWriteRevisionCutoff = 0;
////////////////////////////////////////////////////////////////////////////////////
//
// Func: GetUniqueCount
//
// Desc: Returns the count of unique index entries given an "ordered"
// array of exes
//
DWORD GetUniqueCount(SdbRefArray<SdbExe>* prgExes, DWORD dwFilter, DATE dtRevisionCutoff, BOOL bWildCard)
{
int i;
SdbExe* pExe;
DWORD dwCount = 0;
ULONGLONG ullKey = 0;
for (i = 0; i < prgExes->GetSize(); ++i) {
pExe = (SdbExe*)prgExes->GetAt(i);
if (!(pExe->m_bWildcardInName ^ bWildCard)) { // XOR is 1 if the args are different and
// is 0 if the args are the same
if ((pExe->m_dwFilter & dwFilter) &&
dtRevisionCutoff <= pExe->m_dtLastRevision) {
if (ullKey != pExe->m_ullKey) {
ullKey = pExe->m_ullKey;
++dwCount;
}
}
}
}
return dwCount;
}
BOOL WriteDatabase(
SdbOutputFile* pOutputFile,
SdbDatabase* pDatabase)
{
BOOL bSuccess = FALSE;
PDB pdb = NULL;
pdb = SdbCreateDatabase(pOutputFile->m_csName, DOS_PATH);
if (pdb == NULL) {
SDBERROR_FORMAT((_T("Error creating database \"%s\".\n"), pOutputFile->m_csName));
goto eh;
}
pDatabase->m_Library.SanitizeTagIDs();
if (!pDatabase->WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
bSuccess = TRUE;
eh:
if (pdb) {
SdbCloseDatabase(pdb);
}
if (bSuccess == FALSE) {
//
// We need to delete the .SDB that has been created. We had an error
// but shimdbc has made the .SDB for the XML till it hit the error. This is typically
// in the case when we hit a tag in the summary part of a XML for a custom SDB
// that is not allowed in the summary part. For e.g if we have
// *********************************************************************
// <LIBRARY>
// <MESSAGE NAME="1" ID="{5DE255AF-350F-4A94-896E-249561039F13}">
// <SUMMARY>
// <B>sd</B>
// </SUMMARY>
// </MESSAGE>
// </LIBRARY>
//
//**********************************************************************
// Such an .SDB is an invalid .SDB and should be removed
//
DeleteFile(pOutputFile->GetFullPath());
}
return bSuccess;
}
VOID SdbLibrary::SanitizeTagIDs(VOID)
{
INT i;
for (i = 0; i < m_rgShims.GetSize(); ++i) {
SdbShim* pShim = (SdbShim*)m_rgShims.GetAt(i);
pShim->m_tiTagID = TAGID_NULL;
}
for (i = 0; i < m_rgPatches.GetSize(); ++i) {
SdbPatch* pPatch = (SdbPatch*)m_rgPatches.GetAt(i);
pPatch->m_tiTagID = TAGID_NULL;
}
for (i = 0; i < m_rgLayers.GetSize(); ++i) {
SdbLayer* pLayer = (SdbLayer*)m_rgLayers.GetAt(i);
pLayer->m_tiTagID = TAGID_NULL;
}
for (i = 0; i < m_rgFiles.GetSize(); ++i) {
SdbFile* pFile = (SdbFile*)m_rgFiles.GetAt(i);
pFile->m_tiTagID = TAGID_NULL;
}
for (i = 0; i < m_rgMsiTransforms.GetSize(); ++i) {
SdbMsiTransform* pTransform = (SdbMsiTransform*)m_rgMsiTransforms.GetAt(i);
pTransform->m_tiTagID = TAGID_NULL;
}
}
BOOL SdbDatabase::WriteToSDB(PDB pdb)
{
BOOL bSuccess = FALSE;
BOOL bAtLeastOneIndex = FALSE;
TAGID tiDatabase;
FILETIME ftBuildStamp;
LARGE_INTEGER liBuildStamp;
DWORD dwHTMLHelpID;
LANGID langID;
DWORD dwUniqueCount = 0;
long i, j;
SdbAppHelp* pAppHelp;
SdbMessage* pMessage;
CString csURL, csLinkText, csContactInfo;
CString csAppTitle, csSummary, csDetails, csID, csDBName;
CString csLanguagesParam, csLangID;
CStringArray rgLanguages;
csLanguagesParam = m_pCurrentOutputFile->GetParameter(_T("LANGUAGES"));
if (csLanguagesParam.GetLength()) {
if (!ParseLanguagesString(csLanguagesParam, &rgLanguages)) {
SDBERROR_FORMAT((_T("Error parsing LANGUAGES parameter in makefile: %s\n"), csLanguagesParam));
goto eh;
}
} else {
rgLanguages.Add(m_pCurrentMakefile->m_csLangID);
}
//
// Allocate indexes
//
dwUniqueCount = GetUniqueCount(&m_rgExes, m_pCurrentOutputFile->m_dwFilter, g_dtCurrentWriteRevisionCutoff, FALSE);
if (m_pCurrentOutputFile->m_dwFilter & (SDB_FILTER_FIX | SDB_FILTER_DRIVER)) {
if (!SdbDeclareIndex(pdb, TAG_EXE, TAG_NAME, dwUniqueCount, TRUE, &m_iiExeIndex)) {
SDBERROR(_T("Error declaring index for Exes.\n"));
goto eh;
}
bAtLeastOneIndex = TRUE;
}
if (m_pCurrentOutputFile->m_dwFilter & SDB_FILTER_FIX) {
if (!SdbDeclareIndex(pdb,
TAG_EXE,
TAG_WILDCARD_NAME,
(DWORD)m_rgWildcardExes.GetFilteredCount(m_pCurrentOutputFile->m_dwFilter, g_dtCurrentWriteRevisionCutoff),
FALSE,
&m_iiWildcardExeIndex)) {
SDBERROR(_T("Error declaring index for wildcard Exes.\n"));
goto eh;
}
if (!SdbDeclareIndex(pdb,
TAG_EXE,
TAG_16BIT_MODULE_NAME,
(DWORD)m_rgModuleExes.GetFilteredCount(m_pCurrentOutputFile->m_dwFilter, g_dtCurrentWriteRevisionCutoff),
FALSE,
&m_iiModuleExeIndex)) {
SDBERROR(_T("Error declaring index for wildcard Exes.\n"));
goto eh;
}
if (!SdbDeclareIndex(pdb,
TAG_SHIM,
TAG_NAME,
(DWORD)m_Library.m_rgShims.GetFilteredCount(m_pCurrentOutputFile->m_dwFilter, 0),
FALSE,
&m_iiShimIndex)) {
SDBERROR(_T("Error declaring index for Shims.\n"));
goto eh;
}
bAtLeastOneIndex = TRUE;
}
if (m_pCurrentOutputFile->m_dwFilter & SDB_FILTER_APPHELP) {
if (!SdbDeclareIndex(pdb,
TAG_APPHELP,
TAG_HTMLHELPID,
(DWORD) (m_rgAppHelps.GetFilteredCount(m_pCurrentOutputFile->m_dwFilter, g_dtCurrentWriteRevisionCutoff)
* rgLanguages.GetSize()),
FALSE,
&m_iiHtmlHelpID)) {
SDBERROR(_T("Error declaring index for HTMLHELPID\n"));
goto eh;
}
bAtLeastOneIndex = TRUE;
}
if (m_pCurrentOutputFile->m_dwFilter & SDB_FILTER_MSI) {
//
// MSI_TRANSFORM index, unique style (it's more efficient) - these are "fixes"
//
if (!SdbDeclareIndex(pdb,
TAG_MSI_TRANSFORM,
TAG_NAME,
(DWORD)m_Library.m_rgMsiTransforms.GetFilteredCount(m_pCurrentOutputFile->m_dwFilter, g_dtCurrentWriteRevisionCutoff),
TRUE,
&m_iiMsiTransformIndex)) {
SDBERROR(_T("Error declaring index for MSI Transforms.\n"));
goto eh;
}
//
// MSI_PACKAGE index, unique style (it's more efficient, again)
//
if (!SdbDeclareIndex(pdb,
TAG_MSI_PACKAGE,
TAG_MSI_PACKAGE_ID,
m_rgMsiPackages.GetFilteredCount(m_pCurrentOutputFile->m_dwFilter, g_dtCurrentWriteRevisionCutoff),
FALSE,
&m_iiMsiPackageIndex)) {
SDBERROR(_T("Error declaring index for MSI Packages.\n"));
goto eh;
}
if (!SdbDeclareIndex(pdb,
TAG_MSI_PACKAGE,
TAG_EXE_ID,
m_rgMsiPackages.GetFilteredCount(m_pCurrentOutputFile->m_dwFilter, g_dtCurrentWriteRevisionCutoff),
TRUE,
&m_iiMsiIDIndex)) {
SDBERROR(_T("Error declaring index for MSI Exe IDs.\n"));
goto eh;
}
bAtLeastOneIndex = TRUE;
}
if (m_pCurrentOutputFile->m_dwFilter & SDB_FILTER_DRIVER) {
if (!SdbDeclareIndex(pdb,
TAG_EXE,
TAG_EXE_ID,
m_rgExes.GetFilteredCount(m_pCurrentOutputFile->m_dwFilter, g_dtCurrentWriteRevisionCutoff),
FALSE,
&m_iiDrvIDIndex)) {
SDBERROR(_T("Error declaring index for DRIVER ID\n"));
goto eh;
}
bAtLeastOneIndex = TRUE;
}
if (bAtLeastOneIndex) {
if (!SdbCommitIndexes(pdb)) {
SDBERROR(_T("Error ending index declarations.\n"));
goto eh;
}
}
//
// Open tag
//
tiDatabase = SdbBeginWriteListTag(pdb, TAG_DATABASE);
if (!tiDatabase) {
SDBERROR(_T("Error writing DATABASE tag\n"));
goto eh;
}
//
// Stamp the build time
//
GetSystemTimeAsFileTime(&ftBuildStamp);
liBuildStamp.LowPart = ftBuildStamp.dwLowDateTime;
liBuildStamp.HighPart = ftBuildStamp.dwHighDateTime;
if (!SdbWriteQWORDTag(pdb, TAG_TIME, liBuildStamp.QuadPart)) {
SDBERROR(_T("Error writing TIME\n"));
goto eh;
}
//
// Stamp the compiler version
//
if (!SdbWriteStringTag(pdb, TAG_COMPILER_VERSION, g_szVersion)) {
SDBERROR(_T("Error writing COMPILER_VERSION\n"));
goto eh;
}
//
// Look for name from makefile
//
csDBName = m_pDB->m_pCurrentOutputFile->GetParameter(_T("DATABASE NAME"));
if (csDBName.IsEmpty()) {
csDBName = m_csName;
}
//
// Write the name of the database
//
if (!SdbWriteStringTag(pdb, TAG_NAME, csDBName)) {
SDBERROR(_T("Error writing TAG_NAME\n"));
goto eh;
}
//
// Look for GUID from makefile
//
csID = m_pDB->m_pCurrentOutputFile->GetParameter(_T("DATABASE ID"));
if (csID.GetLength()) {
if (!GUIDFromString(csID, &m_CurrentDBID)) {
SDBERROR_FORMAT((_T("Bad GUID specified for DATABASE_ID: %s\n"), csID));
goto eh;
}
} else {
//
// Not there, take the ID from the XML file
//
m_CurrentDBID = m_ID;
}
//
// Write the GUID
//
if (!SdbWriteBinaryTag(pdb, TAG_DATABASE_ID, (PBYTE)&m_CurrentDBID, sizeof(m_CurrentDBID))) {
SDBERROR(_T("Error writing TAG_DATABASE_ID\n"));
goto eh;
}
if (m_pCurrentOutputFile->m_dwFilter & ~SDB_FILTER_DRIVER) {
//
// Write the Library
//
if (!m_Library.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
}
//
// Action
//
if (!m_rgAction.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
if (m_pCurrentOutputFile->m_dwFilter & SDB_FILTER_FIX) {
//
// First write all the EXEs with wild-card names
//
if (!SdbStartIndexing(pdb, m_iiWildcardExeIndex)) {
SDBERROR(_T("Error starting to index wildcard Exes.\n"));
goto eh;
}
//
// Wildcard Exes
//
if (!m_rgWildcardExes.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
//
// Done indexing the wildcard exes
//
if (!SdbStopIndexing(pdb, m_iiWildcardExeIndex)) {
SDBERROR(_T("Error stopping indexing wildcard Exes.\n"));
goto eh;
}
//
// Next write all the EXEs with module names
//
if (!SdbStartIndexing(pdb, m_iiModuleExeIndex)) {
SDBERROR(_T("Error starting to index Module Exes.\n"));
goto eh;
}
//
// Module Exes
//
if (!m_rgModuleExes.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
//
// Done indexing the module exes
//
if (!SdbStopIndexing(pdb, m_iiModuleExeIndex)) {
SDBERROR(_T("Error stopping indexing Module Exes.\n"));
goto eh;
}
}
if (m_pCurrentOutputFile->m_dwFilter & (SDB_FILTER_FIX | SDB_FILTER_DRIVER)) {
//
// Go ahead and start indexing normal exes
//
if (!SdbStartIndexing(pdb, m_iiExeIndex)) {
SDBERROR(_T("Error starting to index Exes.\n"));
goto eh;
}
if (m_pCurrentOutputFile->m_dwFilter & SDB_FILTER_DRIVER) {
if (!SdbStartIndexing(pdb, m_iiDrvIDIndex)) {
SDBERROR(_T("Error starting to index driver IDs\n"));
goto eh;
}
}
if (!m_rgExes.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
if (m_pCurrentOutputFile->m_dwFilter & SDB_FILTER_DRIVER) {
if (!SdbStopIndexing(pdb, m_iiDrvIDIndex)) {
SDBERROR(_T("Error stopping indexing driver IDs\n"));
goto eh;
}
}
//
// Done indexing the exes
//
if (!SdbStopIndexing(pdb, m_iiExeIndex)) {
SDBERROR(_T("Error stopping indexing Exes.\n"));
goto eh;
}
}
if (m_pCurrentOutputFile->m_dwFilter & SDB_FILTER_MSI) {
//
// MSI Packages, they are just like EXEs
// but indexed not by name but by their GUID IDs
//
if (!SdbStartIndexing(pdb, m_iiMsiPackageIndex)) {
SDBERROR(_T("Error starting to index MSI Packages.\n"));
goto eh;
}
if (!SdbStartIndexing(pdb, m_iiMsiIDIndex)) {
SDBERROR(_T("Error starting to index MSI packages by exe id\n"));
goto eh;
}
if (!m_rgMsiPackages.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
if (!SdbStopIndexing(pdb, m_iiMsiIDIndex)) {
SDBERROR(_T("Error stopping indexing of MSI packages by exe id\n"));
goto eh;
}
if (!SdbStopIndexing(pdb, m_iiMsiPackageIndex)) {
SDBERROR(_T("Error stopping indexing MSI Packages.\n"));
goto eh;
}
}
if (m_pCurrentOutputFile->m_dwFilter & SDB_FILTER_APPHELP) {
//
// Start indexing apphelps
//
if (!SdbStartIndexing(pdb, m_iiHtmlHelpID)) {
SDBERROR( _T("Error starting to index HTMLHELPID.\n"));
goto eh;
}
for (i = 0; i < m_rgAppHelps.GetSize(); i++) {
pAppHelp = (SdbAppHelp *) m_rgAppHelps[i];
if (!(pAppHelp->m_dwFilter & m_pCurrentOutputFile->m_dwFilter)) {
continue;
}
if (g_dtCurrentWriteRevisionCutoff > pAppHelp->m_dtLastRevision) {
continue;
}
for (j = 0; j < rgLanguages.GetSize(); j++) {
csLangID = rgLanguages[j];
pMessage = (SdbMessage *) m_rgMessages.LookupName(pAppHelp->m_csMessage, csLangID);
if (pMessage == NULL) {
SDBERROR_FORMAT((_T("Localized MESSAGE not found for\n NAME: %s\n HTMLHELPID: %s\n LANG: %s\n"),
pAppHelp->m_csMessage, pAppHelp->m_csName, csLangID));
goto eh;
}
if (!ConstructMessageParts(
pAppHelp,
pMessage,
csLangID,
&dwHTMLHelpID,
&csURL,
&csContactInfo,
&csAppTitle,
&csSummary,
&csDetails)) {
SDBERROR_PROPOGATE();
goto eh;
}
if (g_bStrict) {
if (csURL.IsEmpty()) {
SDBERROR_FORMAT((_T("ERROR: Empty string for URL on\n NAME: %s\n HTMLHELPID: %s\n LANG: %s\n\n"),
pAppHelp->m_pApp->m_csName, pAppHelp->m_csName, csLangID));
goto eh;
}
if (csAppTitle.IsEmpty()) {
SDBERROR_FORMAT((_T("ERROR: Empty string for APP_TITLE on\n NAME: %s\n HTMLHELPID: %s\n LANG: %s\n\n"),
pAppHelp->m_pApp->m_csName, pAppHelp->m_csName, csLangID));
goto eh;
}
if (csSummary.IsEmpty()) {
SDBERROR_FORMAT((_T("ERROR: Empty string for SUMMARY on\n NAME: %s\n HTMLHELPID: %s\n LANG: %s\n\n"),
pAppHelp->m_pApp->m_csName, pAppHelp->m_csName, csLangID));
goto eh;
}
}
if (!WriteAppHelpRefTag(
pdb,
pAppHelp->m_csName,
csLangID == _T("---") ? 0 : m_pCurrentMakefile->GetLangMap(csLangID)->m_lcid,
csURL,
csAppTitle,
csSummary)) {
SDBERROR_PROPOGATE();
goto eh;
}
}
}
//
// Stop indexing apphelps
//
if (!SdbStopIndexing(pdb, m_iiHtmlHelpID)) {
SDBERROR( _T("Error stopping indexing HTMLHELPID.\n"));
goto eh;
}
}
//
// Close tag
//
if (!SdbEndWriteListTag(pdb, tiDatabase)) {
SDBERROR(_T("Error writing TAG_DATABASE\n"));
goto eh;
}
bSuccess = TRUE;
eh:
return bSuccess;
}
BOOL SdbLibrary::WriteToSDB(PDB pdb)
{
BOOL bSuccess = FALSE;
TAGID tiLibrary;
//
// Open tag
//
tiLibrary = SdbBeginWriteListTag(pdb, TAG_LIBRARY);
if (!tiLibrary) {
SDBERROR(_T("Error writing TAG_LIBRARY\n"));
goto eh;
}
if (m_pDB->m_pCurrentOutputFile->m_dwFilter & SDB_FILTER_FIX) {
//
// Global exclusion list
//
if (!m_rgCallers.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
//
// Index the shims
//
if (!SdbStartIndexing(pdb, m_pDB->m_iiShimIndex)) {
SDBERROR(_T("Error starting to index Dlls.\n"));
goto eh;
}
//
// Shims
//
if (!m_rgShims.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
//
// Done indexing the shims
//
if (!SdbStopIndexing(pdb, m_pDB->m_iiShimIndex)) {
SDBERROR(_T("Error stopping indexing shims.\n"));
goto eh;
}
//
// Patches
//
if (!m_rgPatches.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
//
// Flags
//
if (!m_rgFlags.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
}
//
// Included files
//
if (!m_rgFiles.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
if (m_pDB->m_pCurrentOutputFile->m_dwFilter & SDB_FILTER_MSI) {
//
// Msi Transforms, indexed by the their respective name
//
if (!SdbStartIndexing(pdb, m_pDB->m_iiMsiTransformIndex)) {
SDBERROR(_T("Error starting to index MSI Transforms.\n"));
goto eh;
}
if (!m_rgMsiTransforms.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
if (!SdbStopIndexing(pdb, m_pDB->m_iiMsiTransformIndex)) {
SDBERROR(_T("Error stopping indexing MSI Transforms.\n"));
goto eh;
}
}
//
// Close tag
//
if (!SdbEndWriteListTag(pdb, tiLibrary)) {
SDBERROR(_T("Error ending TAG_LIBRARY\n"));
goto eh;
}
if (m_pDB->m_pCurrentOutputFile->m_dwFilter & SDB_FILTER_FIX) {
//
// Layers
//
// BUGBUG: Layers should be *inside* the library
//
if (!m_rgLayers.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
}
bSuccess = TRUE;
eh:
return bSuccess;
}
BOOL SdbExe::WriteToSDB(PDB pdb)
{
BOOL bSuccess = FALSE;
TAGID tiExe;
long i;
ULONGLONG ullFlagsNTVDM1 = 0;
ULONGLONG ullFlagsNTVDM2 = 0;
ULONGLONG ullFlagsNTVDM3 = 0;
//
// Open tag
//
tiExe = SdbBeginWriteListTag(pdb, TAG_EXE);
if (!tiExe) {
SDBERROR(_T("Error writing TAG_EXE\n"));
goto eh;
}
//
// NAME (i.e., EXE filename)
//
if (m_csName.GetLength()) {
if (!SdbWriteStringTag(pdb, TAG_NAME, m_csName)) {
SDBERROR(_T("Error writing TAG_NAME\n"));
goto eh;
}
//
// If there's a wildcard in the name, write WILDCARD_NAME
// as well, for the indexing
//
if (m_bWildcardInName) {
if (!SdbWriteStringTag(pdb, TAG_WILDCARD_NAME, m_csName)) {
SDBERROR(_T("Error writing TAG_WILDCARD_NAME\n"));
goto eh;
}
}
//
// If this is supposed to match on module name, write that out too
//
if (m_bMatchOnModule) {
if (!SdbWriteStringTag(pdb, TAG_16BIT_MODULE_NAME, m_csName)) {
SDBERROR(_T("Error writing TAG_16BIT_MODULE_NAME\n"));
goto eh;
}
}
}
//
// APP_NAME (i.e., application title)
//
if (m_pApp != NULL) {
if (m_pApp->m_csName.GetLength()) {
if (!SdbWriteStringTag(pdb, TAG_APP_NAME, m_pApp->m_csName)) {
SDBERROR(_T("Error writing TAG_APP_NAME\n"));
goto eh;
}
}
}
//
// VENDOR
//
if (m_pApp != NULL) {
if (m_pApp->m_csVendor.GetLength()) {
if (!SdbWriteStringTag(pdb, TAG_VENDOR, m_pApp->m_csVendor)) {
SDBERROR(_T("Error writing TAG_VENDOR\n"));
goto eh;
}
}
}
//
// GUID (Unique ID)
//
if (!SdbWriteBinaryTag(pdb, TAG_EXE_ID, (PBYTE)&m_ID, sizeof(m_ID))) {
SDBERROR(_T("Error writing TAG_EXE_ID\n"));
goto eh;
}
//
// OS SERVICE PACK mask if it's anything other than 0xFFFFFFFF
//
if (m_dwSPMask != 0xFFFFFFFF) {
if (!SdbWriteDWORDTag(pdb, TAG_OS_SERVICE_PACK, m_dwSPMask)) {
SDBERROR(_T("Error writing TAG_OS_SERVICE_PACK\n"));
goto eh;
}
}
//
// Write the MATCH_MODE tag if it's anything other than NORMAL
//
if (m_dwMatchMode != MATCH_DEFAULT) {
BOOL bWriteMatchMode = FALSE;
if (m_pDB->IsStandardDatabase()) {
//
// standard db, we write match mode if it's not "normal"
// since normal is the default
//
bWriteMatchMode = (m_dwMatchMode != MATCHMODE_DEFAULT_MAIN);
} else {
//
// for custom dbs default match mode is additive
//
bWriteMatchMode = (m_dwMatchMode != MATCHMODE_DEFAULT_CUSTOM);
}
if (bWriteMatchMode && !SdbWriteWORDTag(pdb, TAG_MATCH_MODE, (WORD)m_dwMatchMode)) {
SDBERROR(_T("Error writing TAG_MATCH_MODE\n"));
goto eh;
}
}
//
// Write the RUNTIME_PLATFORM tag if it's anything other than RUNTIME_PLATFORM_ANY
//
if (m_dwRuntimePlatform != RUNTIME_PLATFORM_ANY) {
if (!SdbWriteDWORDTag(pdb, TAG_RUNTIME_PLATFORM, m_dwRuntimePlatform)) {
SDBERROR(_T("Error writing RUNTIME_PLATFORM\n"));
goto eh;
}
}
//
// Write the OS_SKU tag if it's anything other than OS_SKU_ALL
//
if (m_dwOSSKU != OS_SKU_ALL) {
if (!SdbWriteDWORDTag(pdb, TAG_OS_SKU, m_dwOSSKU)) {
SDBERROR(_T("Error writing OS_SKU\n"));
goto eh;
}
}
//
// Message reference
//
if (m_AppHelpRef.m_pAppHelp) {
if (!m_AppHelpRef.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
}
//
// Matching Files
//
if (!m_rgMatchingFiles.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
//
// Shim references
//
if (!m_rgShimRefs.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
//
// Flag references
//
if (!m_rgFlagRefs.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
//
// Patches (by reference)
//
if (!m_rgPatches.WriteToSDB(pdb, TRUE)) {
SDBERROR_PROPOGATE();
goto eh;
}
//
// Layers references
//
if (!m_rgLayerRefs.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
if (!m_csSXSManifest.IsEmpty()) {
//
// Add XML header tag
//
WCHAR wszXMLHeader[] = L"<?xml version=\"1.0\" encoding=\"UCS-2\" standalone=\"yes\"?>";
//
// The whole manifest consists of the Unicode byte marker (1 byte), the XML header,
// the manifest itself, and a NULL terminator (1 byte).
//
DWORD dwSXSEntryLen = wcslen(wszXMLHeader) + m_csSXSManifest.GetLength() + 2;
LPWSTR wszSXSEntry = (LPWSTR) (malloc(dwSXSEntryLen * sizeof(WCHAR)));
//
// Begin with 0xFF 0xFE Unicode byte order marker
//
UCHAR* szSXSEntry = (UCHAR*) wszSXSEntry;
szSXSEntry[0] = 0xFF;
szSXSEntry[1] = 0xFE;
//
// Add the XML header
//
StringCchCopy(wszSXSEntry + 1, dwSXSEntryLen, wszXMLHeader);
//
// Add the manifest
//
StringCchCat(wszSXSEntry, dwSXSEntryLen, m_csSXSManifest);
if (!SdbWriteStringTag(pdb, TAG_SXS_MANIFEST, wszSXSEntry)) {
goto eh;
}
free(wszSXSEntry);
}
//
// Data
//
if (!m_rgData.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
//
// Action
//
if (!m_rgAction.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
//
// Close tag
//
if (!SdbEndWriteListTag(pdb, tiExe)) {
SDBERROR(_T("Error ending TAG_EXE\n"));
goto eh;
}
bSuccess = TRUE;
eh:
return bSuccess;
}
BOOL SdbMsiPackage::WriteToSDB(PDB pdb)
{
BOOL bSuccess = FALSE;
TAGID tiMsiPackage;
//
// Open tag
//
tiMsiPackage = SdbBeginWriteListTag(pdb, TAG_MSI_PACKAGE);
if (!tiMsiPackage) {
SDBERROR(_T("Error writing TAG_MSI_PACKAGE\n"));
goto eh;
}
//
// NAME (i.e., EXE filename)
//
if (m_csName.GetLength()) {
if (!SdbWriteStringTag(pdb, TAG_NAME, m_csName)) {
SDBERROR(_T("Error writing TAG_NAME for MSI_PACKAGE\n"));
goto eh;
}
}
//
// APP_NAME (i.e., application title)
//
if (m_pApp != NULL) {
if (m_pApp->m_csName.GetLength()) {
if (!SdbWriteStringTag(pdb, TAG_APP_NAME, m_pApp->m_csName)) {
SDBERROR(_T("Error writing TAG_APP_NAME for MSI_PACKAGE\n"));
goto eh;
}
}
}
//
// GUID (unique ID)
//
if (!SdbWriteBinaryTag(pdb, TAG_EXE_ID, (PBYTE)&m_ID, sizeof(m_ID))) {
SDBERROR(_T("Error writing TAG_EXE_ID\n"));
goto eh;
}
//
// GUID (non-Unique ID)
//
if (!SdbWriteBinaryTag(pdb, TAG_MSI_PACKAGE_ID, (PBYTE)&m_MsiPackageID, sizeof(m_MsiPackageID))) {
SDBERROR(_T("Error writing TAG_MSI_PACKAGE_ID\n"));
goto eh;
}
//
// RUNTIME_PLATFORM data
//
if (m_dwRuntimePlatform != RUNTIME_PLATFORM_ANY) {
if (!SdbWriteDWORDTag(pdb, TAG_RUNTIME_PLATFORM, m_dwRuntimePlatform)) {
SDBERROR(_T("Error writing RUNTIME_PLATFORM\n"));
goto eh;
}
}
//
// Write the OS_SKU tag if it's anything other than OS_SKU_ALL
//
if (m_dwOSSKU != OS_SKU_ALL) {
if (!SdbWriteDWORDTag(pdb, TAG_OS_SKU, m_dwOSSKU)) {
SDBERROR(_T("Error writing OS_SKU\n"));
goto eh;
}
}
//
// Supplemental data
//
if (!m_rgData.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
//
// applicable fixes (reference to transforms)
//
if (!m_rgMsiTransformRefs.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
//
// Message reference
//
if (m_AppHelpRef.m_pAppHelp) {
if (!m_AppHelpRef.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
}
//
// custom actions
//
if (!m_rgCustomActions.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
//
// Close tag
//
if (!SdbEndWriteListTag(pdb, tiMsiPackage)) {
SDBERROR(_T("Error ending TAG_MSI_PACKAGE\n"));
goto eh;
}
bSuccess = TRUE;
eh:
return bSuccess;
}
BOOL SdbMsiCustomAction::WriteToSDB(PDB pdb)
{
TAGID tiMsiCustomAction;
BOOL bSuccess = FALSE;
//
// Open tag
//
tiMsiCustomAction = SdbBeginWriteListTag(pdb, TAG_MSI_CUSTOM_ACTION);
if (!tiMsiCustomAction) {
SDBERROR(_T("Error writing TAG_MSI_CUSTOM_ACTION\n"));
goto eh;
}
//
// NAME (i.e., EXE filename)
//
if (m_csName.GetLength()) {
if (!SdbWriteStringTag(pdb, TAG_NAME, m_csName)) {
SDBERROR(_T("Error writing TAG_NAME for MSI_CUSTOM_ACTION\n"));
goto eh;
}
}
//
// Shim references
//
if (!m_rgShimRefs.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
if (!m_rgLayerRefs.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
//
// Close tag
//
if (!SdbEndWriteListTag(pdb, tiMsiCustomAction)) {
SDBERROR(_T("Error ending TAG_MSI_CUSTOM_ACTION\n"));
goto eh;
}
bSuccess = TRUE;
eh:
return bSuccess;
}
BOOL SdbCaller::WriteToSDB(PDB pdb)
{
BOOL bSuccess = FALSE;
TAGID tiCaller;
//
// Open tag
//
tiCaller = SdbBeginWriteListTag(pdb, TAG_INEXCLUDE);
if (!tiCaller) {
SDBERROR(_T("Error writing TAG_INEXCLUDE\n"));
goto eh;
}
//
// If it's an <INCLUDE> tag, write out the indicator
//
if (m_CallerType == SDB_CALLER_INCLUDE) {
if (!SdbWriteNULLTag(pdb, TAG_INCLUDE)) {
SDBERROR(_T("Error writing TAG_INCLUDE\n"));
goto eh;
}
}
//
// Module
//
if (m_csModule.GetLength()) {
if (!SdbWriteStringTag(pdb, TAG_MODULE, m_csModule)) {
SDBERROR(_T("Error writing TAG_MODULE\n"));
goto eh;
}
}
//
// Close tag
//
if (!SdbEndWriteListTag(pdb, tiCaller)) {
SDBERROR(_T("Error ending TAG_INEXCLUDE\n"));
goto eh;
}
bSuccess = TRUE;
eh:
return bSuccess;
}
BOOL SdbFile::WriteToSDB(PDB pdb)
{
BOOL bSuccess = FALSE;
TAGID tiFile;
CString csFileDir, csFilename;
csFileDir = MakeFullPath(m_pDB->m_pCurrentOutputFile->GetParameter(_T("INCLUDE FILES")));
//
// Check if filtered out
//
if (!(m_dwFilter & m_pDB->m_pCurrentOutputFile->m_dwFilter)) {
//
// Filtered out, return success
//
return TRUE;
}
//
// Open tag
//
tiFile = SdbBeginWriteListTag(pdb, TAG_FILE);
if (!tiFile) {
SDBERROR(_T("Error writing TAG_FILE\n"));
goto eh;
}
//
// NAME
//
if (m_csName.GetLength()) {
if (!SdbWriteStringTag(pdb, TAG_NAME, m_csName)) {
SDBERROR(_T("Error writing TAG_NAME\n"));
goto eh;
}
}
//
// Binary data
//
if (csFileDir.GetLength()) {
csFilename = csFileDir;
csFilename += m_csName;
if (!SdbWriteBinaryTagFromFile(pdb, TAG_FILE_BITS, csFilename)) {
if (g_bStrict) {
SDBERROR_FORMAT((_T("Can't find FILE \"%s\". No bits written.\n"), csFilename));
goto eh;
}
}
} else {
if (g_bStrict) {
SDBERROR_FORMAT((_T("Can't find FILE \"%s\". -f compiler flag required.\n"), m_csName));
goto eh;
}
}
//
// Close tag
//
if (!SdbEndWriteListTag(pdb, tiFile)) {
SDBERROR(_T("Error ending TAG_FILE\n"));
goto eh;
}
m_tiTagID = tiFile; // this is the tagid as it was written into the database
bSuccess = TRUE;
eh:
return bSuccess;
}
BOOL SdbShimRef::WriteToSDB(PDB pdb)
{
BOOL bSuccess = FALSE;
TAGID tiShimRef;
//
// Open tag
//
tiShimRef = SdbBeginWriteListTag(pdb, TAG_SHIM_REF);
if (!tiShimRef) {
SDBERROR(_T("Error writing TAG_SHIM_REF\n"));
goto eh;
}
//
// NAME
//
if (!SdbWriteStringTag(pdb, TAG_NAME, m_csName)) {
SDBERROR(_T("Error writing NAME tag\n"));
goto eh;
}
//
// Write TAGID of the SHIM in the LIBRARY, if any
//
if (m_pShim && m_pShim->m_tiTagID) {
if (!SdbWriteDWORDTag(pdb, TAG_SHIM_TAGID, m_pShim->m_tiTagID)) {
SDBERROR(_T("Error writing TAG_SHIM_TAGID\n"));
goto eh;
}
}
//
// COMMAND_LINE
//
if (m_csCommandLine.GetLength()) {
//
// process this command line first
//
CString csProcessedCmdLine = ProcessShimCmdLine(m_csCommandLine, m_pDB->m_CurrentDBID, tiShimRef);
if (!SdbWriteStringTag(pdb, TAG_COMMAND_LINE, csProcessedCmdLine)) {
SDBERROR(_T("Error writing COMMAND_LINE tag\n"));
goto eh;
}
}
//
// Inclusion/exclusion list
//
if (!m_rgCallers.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
//
// child data tags
//
if (!m_rgData.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
//
// Close tag
//
if (!SdbEndWriteListTag(pdb, tiShimRef)) {
SDBERROR(_T("Error ending TAG_SHIM_REF\n"));
goto eh;
}
bSuccess = TRUE;
eh:
return bSuccess;
}
BOOL SdbShim::WriteToSDB(PDB pdb)
{
BOOL bSuccess = FALSE;
TAGID tiShim;
//
// Open tag
//
tiShim = SdbBeginWriteListTag(pdb, TAG_SHIM);
if (!tiShim) {
SDBERROR(_T("Error writing TAG_SHIM\n"));
goto eh;
}
m_tiTagID = tiShim;
//
// NAME
//
if (m_csName.GetLength()) {
if (!SdbWriteStringTag(pdb, TAG_NAME, m_csName)) {
SDBERROR(_T("Error writing TAG_NAME\n"));
goto eh;
}
}
if (m_csDllFile.GetLength()) {
if (!SdbWriteStringTag(pdb, TAG_DLLFILE, m_csDllFile)) {
SDBERROR(_T("Error writing TAG_DLLFILE\n"));
goto eh;
}
}
//
// DESCRIPTION, only written for general-purpose shims
//
if (m_csDesc.GetLength() && m_Purpose == SDB_PURPOSE_GENERAL) {
//
// Remove all extra white space and new line characters
// via TrimParagraph()
//
if (!SdbWriteStringTag(pdb, TAG_DESCRIPTION, TrimParagraph(m_csDesc))) {
SDBERROR(_T("Error writing TAG_DESCRIPTION\n"));
goto eh;
}
}
//
// Purpose (if general)
//
if (m_Purpose == SDB_PURPOSE_GENERAL) {
if (!SdbWriteNULLTag(pdb, TAG_GENERAL)) {
SDBERROR(_T("Error writing TAG_GENERAL\n"));
goto eh;
}
}
//
// APPLY_ALL_SHIMS flag
//
if (m_bApplyAllShims) {
if (!SdbWriteNULLTag(pdb, TAG_APPLY_ALL_SHIMS)) {
SDBERROR(_T("Error writing TAG_APPLY_ALL_SHIMS\n"));
goto eh;
}
}
//
// Inclusion/exclusion list
//
if (!m_rgCallers.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
//
// Close tag
//
if (!SdbEndWriteListTag(pdb, tiShim)) {
SDBERROR(_T("Error ending TAG_SHIM\n"));
goto eh;
}
bSuccess = TRUE;
eh:
return bSuccess;
}
BOOL SdbPatch::WriteToSDB(PDB pdb)
{
BOOL bSuccess = FALSE;
TAGID tiPatch;
//
// Open tag
//
tiPatch = SdbBeginWriteListTag(pdb, TAG_PATCH);
if (!tiPatch) {
SDBERROR(_T("Error writing TAG_PATCH\n"));
goto eh;
}
m_tiTagID = tiPatch;
//
// NAME
//
if (m_csName.GetLength()) {
if (!SdbWriteStringTag(pdb, TAG_NAME, m_csName)) {
SDBERROR(_T("Error writing TAG_NAME\n"));
goto eh;
}
}
//
// Patch bits
//
if (GetBlobSize()) {
if (!SdbWriteBinaryTag(pdb, TAG_PATCH_BITS, GetBlobBytes(), GetBlobSize())) {
SDBERROR_FORMAT((_T("Error writing patch bytes \"%s\"\n"), m_csName));
goto eh;
}
}
//
// Close tag
//
if (!SdbEndWriteListTag(pdb, tiPatch)) {
SDBERROR(_T("Error ending TAG_PATCH\n"));
goto eh;
}
bSuccess = TRUE;
eh:
return bSuccess;
}
BOOL SdbPatch::WriteRefToSDB(PDB pdb)
{
BOOL bSuccess = FALSE;
TAGID tiPatch;
//
// Open tag
//
tiPatch = SdbBeginWriteListTag(pdb, TAG_PATCH_REF);
if (!tiPatch) {
SDBERROR(_T("Error writing TAG_PATCH\n"));
goto eh;
}
//
// NAME
//
if (m_csName.GetLength()) {
if (!SdbWriteStringTag(pdb, TAG_NAME, m_csName)) {
SDBERROR(_T("Error writing TAG_NAME\n"));
goto eh;
}
}
//
// Write TAGID of the PATCH in the LIBRARY, if any
//
if (m_tiTagID) {
if (!SdbWriteDWORDTag(pdb, TAG_PATCH_TAGID, m_tiTagID)) {
SDBERROR(_T("Error writing TAG_PATCH_TAGID\n"));
goto eh;
}
}
//
// Close tag
//
if (!SdbEndWriteListTag(pdb, tiPatch)) {
SDBERROR(_T("Error ending TAG_PATCH\n"));
goto eh;
}
bSuccess = TRUE;
eh:
return bSuccess;
}
BOOL SdbFlag::WriteToSDB(PDB pdb)
{
BOOL bSuccess = FALSE;
TAGID tiFlag;
//
// Open tag
//
tiFlag = SdbBeginWriteListTag(pdb, TAG_FLAG);
if (!tiFlag) {
SDBERROR(_T("Error writing TAG_FLAG\n"));
goto eh;
}
m_tiTagID = tiFlag;
//
// NAME
//
if (m_csName.GetLength()) {
if (!SdbWriteStringTag(pdb, TAG_NAME, m_csName)) {
SDBERROR(_T("Error writing TAG_NAME\n"));
goto eh;
}
}
//
// DESCRIPTION, only general-purpose descriptions
//
if (m_csDesc.GetLength() && m_Purpose == SDB_PURPOSE_GENERAL) {
//
// Remove all extra white space and new line characters
// via TrimParagraph()
//
if (!SdbWriteStringTag(pdb, TAG_DESCRIPTION, TrimParagraph(m_csDesc))) {
SDBERROR(_T("Error writing TAG_DESCRIPTION\n"));
goto eh;
}
}
//
// Mask
//
if (!SdbWriteQWORDTag(pdb, TagFromType(m_dwType), m_ullMask)) {
SDBERROR(_T("Error writing <FLAG> in <LIBRARY>\n"));
goto eh;
}
//
// Purpose (if general)
//
if (m_Purpose == SDB_PURPOSE_GENERAL) {
if (!SdbWriteNULLTag(pdb, TAG_GENERAL)) {
SDBERROR(_T("Error writing TAG_GENERAL\n"));
goto eh;
}
}
//
// Close tag
//
if (!SdbEndWriteListTag(pdb, tiFlag)) {
SDBERROR(_T("Error ending TAG_FLAG\n"));
goto eh;
}
bSuccess = TRUE;
eh:
return bSuccess;
}
BOOL SdbFlagRef::WriteToSDB(PDB pdb)
{
BOOL bSuccess = FALSE;
TAGID tiFlagRef;
//
// Open tag
//
tiFlagRef = SdbBeginWriteListTag(pdb, TAG_FLAG_REF);
if (!tiFlagRef) {
SDBERROR(_T("Error writing TAG_FLAG_REF\n"));
goto eh;
}
//
// NAME
//
if (!SdbWriteStringTag(pdb, TAG_NAME, m_csName)) {
SDBERROR(_T("Error writing NAME tag\n"));
goto eh;
}
//
// Write TAGID of the FLAG in the LIBRARY, if any
//
if (m_pFlag && m_pFlag->m_tiTagID) {
if (!SdbWriteDWORDTag(pdb, TAG_FLAG_TAGID, m_pFlag->m_tiTagID)) {
SDBERROR(_T("Error writing TAG_FLAG_TAGID\n"));
goto eh;
}
}
//
// Write Command Line tag
//
if (m_csCommandLine.GetLength()) {
if (!SdbWriteStringTag(pdb, TAG_COMMAND_LINE, m_csCommandLine)) {
SDBERROR(_T("Error writing COMMAND_LINE tag for flag\n"));
goto eh;
}
}
//
// Close tag
//
if (!SdbEndWriteListTag(pdb, tiFlagRef)) {
SDBERROR(_T("Error ending TAG_FLAG_REF\n"));
goto eh;
}
bSuccess = TRUE;
eh:
return bSuccess;
}
BOOL SdbMsiTransformRef::WriteToSDB(PDB pdb)
{
BOOL bSuccess = FALSE;
TAGID tiMsiTransformRef;
tiMsiTransformRef = SdbBeginWriteListTag(pdb, TAG_MSI_TRANSFORM_REF);
if (!tiMsiTransformRef) {
SDBERROR(_T("Error writing TAG_MSI_TRANSFORM_REF\n"));
goto eh;
}
//
// write out the reference to the transform by name first
//
if (m_csName.GetLength()) {
if (!SdbWriteStringTag(pdb, TAG_NAME, m_csName)) {
SDBERROR(_T("Error writing TAG_NAME\n"));
goto eh;
}
}
//
// now -- satisfy the judgement by writing reference to the
// actual transform object if available
//
if (m_pMsiTransform != NULL) {
if (!SdbWriteDWORDTag(pdb, TAG_MSI_TRANSFORM_TAGID, m_pMsiTransform->m_tiTagID)) {
SDBERROR(_T("Error writing TAG_MSI_TRANSFORM_TAGID for MSI_TRANSFORM_REF\n"));
goto eh;
}
}
if (!SdbEndWriteListTag(pdb, tiMsiTransformRef)) {
SDBERROR(_T("Error ending TAG_MSI_TRANSFORM_REF\n"));
goto eh;
}
bSuccess = TRUE;
eh:
return bSuccess;
}
BOOL SdbMsiTransform::WriteToSDB(PDB pdb)
{
BOOL bSuccess = FALSE;
TAGID tiMsiTransform;
//
// write out the name of the transform
tiMsiTransform = SdbBeginWriteListTag(pdb, TAG_MSI_TRANSFORM);
if (!tiMsiTransform) {
SDBERROR(_T("Error writing TAG_MSI_TRANSFORM\n"));
goto eh;
}
//
// NAME
//
if (m_csName.GetLength()) {
if (!SdbWriteStringTag(pdb, TAG_NAME, m_csName)) {
SDBERROR(_T("Error writing TAG_NAME\n"));
goto eh;
}
}
//
// MSI transform file name
//
if (m_csMsiTransformFile.GetLength()) {
if (!SdbWriteStringTag(pdb, TAG_MSI_TRANSFORM_FILE, m_csMsiTransformFile)) {
SDBERROR(_T("Error writing TAG_MSI_TRANSFORM_FILE\n"));
goto eh;
}
}
//
// REFERENCE the Actual file bits
//
if (m_pSdbFile != NULL && m_pSdbFile->m_tiTagID != TAGID_NULL) {
if (!SdbWriteDWORDTag(pdb, TAG_MSI_TRANSFORM_TAGID, m_pSdbFile->m_tiTagID)) {
SDBERROR(_T("Error writing TAG_MSI_TRANSFORM_TAGID\n"));
goto eh;
}
}
//
// Close tag
//
if (!SdbEndWriteListTag(pdb, tiMsiTransform)) {
SDBERROR(_T("Error ending TAG_MSI_TRANSFORM\n"));
goto eh;
}
m_tiTagID = tiMsiTransform;
bSuccess = TRUE;
eh:
return bSuccess;
}
BOOL SdbLayer::WriteToSDB(PDB pdb)
{
BOOL bSuccess = FALSE;
TAGID tiLayer;
long i;
//
// Open tag
//
tiLayer = SdbBeginWriteListTag(pdb, TAG_LAYER);
if (!tiLayer) {
SDBERROR(_T("Error writing TAG_LAYER\n"));
goto eh;
}
m_tiTagID = tiLayer;
//
// NAME
//
if (m_csName.GetLength()) {
if (!SdbWriteStringTag(pdb, TAG_NAME, m_csName)) {
SDBERROR(_T("Error writing TAG_NAME\n"));
goto eh;
}
}
//
// Display name
//
if (m_csDisplayName.GetLength()) {
if (!SdbWriteStringTag(pdb, TAG_LAYER_DISPLAYNAME, m_csDisplayName)) {
SDBERROR(_T("Error writing TAG_LAYER_DISPLAYNAME\n"));
goto eh;
}
}
//
// Shim references
//
if (!m_rgShimRefs.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
//
// Flags
//
if (!m_rgFlagRefs.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
//
// Close tag
//
if (!SdbEndWriteListTag(pdb, tiLayer)) {
SDBERROR(_T("Error ending TAG_LAYER\n"));
goto eh;
}
bSuccess = TRUE;
eh:
return bSuccess;
}
BOOL SdbLayerRef::WriteToSDB(PDB pdb)
{
BOOL bSuccess = FALSE;
TAGID tiLayer;
//
// Open tag
//
tiLayer = SdbBeginWriteListTag(pdb, TAG_LAYER);
if (!tiLayer) {
SDBERROR(_T("Error writing TAG_LAYER\n"));
goto eh;
}
//
// NAME
//
if (m_csName.GetLength()) {
if (!SdbWriteStringTag(pdb, TAG_NAME, m_csName)) {
SDBERROR(_T("Error writing TAG_NAME\n"));
goto eh;
}
}
//
// Write TAGID of the LAYER in the LIBRARY, if any
//
if (m_pLayer) {
if (m_pLayer->m_tiTagID) {
if (!SdbWriteDWORDTag(pdb, TAG_LAYER_TAGID, m_pLayer->m_tiTagID)) {
SDBERROR(_T("Error writing TAG_LAYER_TAGID\n"));
goto eh;
}
}
}
//
// child data tags
//
if (!m_rgData.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
//
// Close tag
//
if (!SdbEndWriteListTag(pdb, tiLayer)) {
SDBERROR(_T("Error ending TAG_LAYER\n"));
goto eh;
}
bSuccess = TRUE;
eh:
return bSuccess;
}
BOOL SdbMatchingFile::WriteToSDB(PDB pdb)
{
BOOL bSuccess = FALSE;
TAGID tiMatchingFile;
//
// Open tag
//
tiMatchingFile = SdbBeginWriteListTag(pdb, TAG_MATCHING_FILE);
if (!tiMatchingFile) {
SDBERROR(_T("Error writing TAG_MATCHING_FILE\n"));
goto eh;
}
//
// NAME
//
if (m_csName.GetLength()) {
if (!SdbWriteStringTag(pdb, TAG_NAME, m_csName)) {
SDBERROR(_T("Error writing TAG_NAME\n"));
goto eh;
}
}
//
// platform should be first if it exists -- along with the logic bit
//
if (m_bMatchLogicNot) {
if (!SdbWriteNULLTag(pdb, TAG_MATCH_LOGIC_NOT)) {
SDBERROR(_T("Error writing MATCH_LOGIC_NOT\n"));
goto eh;
}
}
// matching information
if (m_dwMask & SDB_MATCHINGINFO_SIZE) {
if (!SdbWriteDWORDTag(pdb, TAG_SIZE, m_dwSize)) {
SDBERROR(_T("Error writing SIZE\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_CHECKSUM) {
if (!SdbWriteDWORDTag(pdb, TAG_CHECKSUM, m_dwChecksum)) {
SDBERROR(_T("Error writing CHECKSUM\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_COMPANY_NAME) {
if (!SdbWriteStringTag(pdb, TAG_COMPANY_NAME, m_csCompanyName)) {
SDBERROR(_T("Error writing COMPANY_NAME tag\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_PRODUCT_NAME) {
if (!SdbWriteStringTag(pdb, TAG_PRODUCT_NAME, m_csProductName)) {
SDBERROR(_T("Error writing PRODUCT_NAME tag\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_PRODUCT_VERSION) {
if (!SdbWriteStringTag(pdb, TAG_PRODUCT_VERSION, m_csProductVersion)) {
SDBERROR(_T("Error writing PRODUCT_VERSION tag\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_FILE_DESCRIPTION) {
if (!SdbWriteStringTag(pdb, TAG_FILE_DESCRIPTION, m_csFileDescription)) {
SDBERROR(_T("Error writing FILE_DESCRIPTION tag\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_BIN_FILE_VERSION) {
if (!SdbWriteQWORDTag(pdb, TAG_BIN_FILE_VERSION, m_ullBinFileVersion)) {
SDBERROR(_T("Error writing BIN_FILE_VERSION\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_BIN_PRODUCT_VERSION) {
if (!SdbWriteQWORDTag(pdb, TAG_BIN_PRODUCT_VERSION, m_ullBinProductVersion)) {
SDBERROR(_T("Error writing BIN_PRODUCT_VERSION\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_MODULE_TYPE) {
if (!SdbWriteDWORDTag(pdb, TAG_MODULE_TYPE, m_dwModuleType)) {
SDBERROR(_T("Error writing MODULE_TYPE\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_VERFILEDATEHI) {
if (!SdbWriteDWORDTag(pdb, TAG_VERDATEHI, m_dwFileDateMS)) {
SDBERROR(_T("Error writing MODULE_TYPE\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_VERFILEDATELO) {
if (!SdbWriteDWORDTag(pdb, TAG_VERDATELO, m_dwFileDateLS)) {
SDBERROR(_T("Error writing MODULE_TYPE\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_VERFILEOS) {
if (!SdbWriteDWORDTag(pdb, TAG_VERFILEOS, m_dwFileOS)) {
SDBERROR(_T("Error writing VERFILEOS\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_VERFILETYPE) {
if (!SdbWriteDWORDTag(pdb, TAG_VERFILETYPE, m_dwFileType)) {
SDBERROR(_T("Error writing VERFILETYPE\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_PE_CHECKSUM) {
if (!SdbWriteDWORDTag(pdb, TAG_PE_CHECKSUM, m_ulPECheckSum)) {
SDBERROR(_T("Error writing PE_CHECKSUM\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_LINKER_VERSION) {
if (!SdbWriteDWORDTag(pdb, TAG_LINKER_VERSION, m_dwLinkerVersion)) {
SDBERROR(_T("Error writing LINKER_VERSION\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_FILE_VERSION) {
if (!SdbWriteStringTag(pdb, TAG_FILE_VERSION, m_csFileVersion)) {
SDBERROR(_T("Error writing FILE_VERSION\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_ORIGINAL_FILENAME) {
if (!SdbWriteStringTag(pdb, TAG_ORIGINAL_FILENAME, m_csOriginalFileName)) {
SDBERROR(_T("Error writing ORIGINAL_FILENAME\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_INTERNAL_NAME) {
if (!SdbWriteStringTag(pdb, TAG_INTERNAL_NAME, m_csInternalName)) {
SDBERROR(_T("Error writing INTERNAL_NAME\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_LEGAL_COPYRIGHT) {
if (!SdbWriteStringTag(pdb, TAG_LEGAL_COPYRIGHT, m_csLegalCopyright)) {
SDBERROR(_T("Error writing LEGAL_COPYRIGHT\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_16BIT_DESCRIPTION) {
if (!SdbWriteStringTag(pdb, TAG_16BIT_DESCRIPTION, m_cs16BitDescription)) {
SDBERROR(_T("Error writing 16BIT_DESCRIPTION\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_16BIT_MODULE_NAME) {
if (!SdbWriteStringTag(pdb, TAG_16BIT_MODULE_NAME, m_cs16BitModuleName)) {
SDBERROR(_T("Error Writing 16BIT_MODULE_NAME\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_UPTO_BIN_PRODUCT_VERSION) {
if (!SdbWriteQWORDTag(pdb, TAG_UPTO_BIN_PRODUCT_VERSION, m_ullUpToBinProductVersion)) {
SDBERROR(_T("Error writing UPTO_BIN_PRODUCT_VERSION\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_UPTO_BIN_FILE_VERSION) {
if (!SdbWriteQWORDTag(pdb, TAG_UPTO_BIN_FILE_VERSION, m_ullUpToBinFileVersion)) {
SDBERROR(_T("Error writing UPTO_BIN_FILE_VERSION\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_PREVOSMAJORVERSION) {
if (!SdbWriteDWORDTag(pdb, TAG_PREVOSMAJORVER, m_dwPrevOSMajorVersion)) {
SDBERROR(_T("Error writing PREVOSMAJORVER\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_PREVOSMINORVERSION) {
if (!SdbWriteDWORDTag(pdb, TAG_PREVOSMINORVER, m_dwPrevOSMinorVersion)) {
SDBERROR(_T("Error writing PREVOSMINORVER\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_PREVOSPLATFORMID) {
if (!SdbWriteDWORDTag(pdb, TAG_PREVOSPLATFORMID, m_dwPrevOSPlatformID)) {
SDBERROR(_T("Error writing PREVOSPLATFORMID\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_PREVOSBUILDNO) {
if (!SdbWriteDWORDTag(pdb, TAG_PREVOSBUILDNO, m_dwPrevOSBuildNo)) {
SDBERROR(_T("Error writing PREVOSBUILDNO\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_LINK_DATE) {
if (!SdbWriteDWORDTag(pdb, TAG_LINK_DATE, (DWORD) m_timeLinkDate)) {
SDBERROR(_T("Error writing LINK_DATE\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_UPTO_LINK_DATE) {
if (!SdbWriteDWORDTag(pdb, TAG_UPTO_LINK_DATE, (DWORD) m_timeUpToLinkDate)) {
SDBERROR(_T("Error writing UPTO_LINK_DATE\n"));
goto eh;
}
}
if (m_dwMask & SDB_MATCHINGINFO_VER_LANGUAGE) {
if (!SdbWriteDWORDTag(pdb, TAG_VER_LANGUAGE, m_dwVerLanguage)) {
SDBERROR(_T("Error writing VER_LANGUAGE tag\n"));
goto eh;
}
}
//
// Close tag
//
if (!SdbEndWriteListTag(pdb, tiMatchingFile)) {
SDBERROR(_T("Error ending TAG_MATCHING_FILE\n"));
goto eh;
}
bSuccess = TRUE;
eh:
return bSuccess;
}
BOOL SdbAppHelpRef::WriteToSDB(PDB pdb)
{
BOOL bSuccess = FALSE;
TAGID tiAppHelp;
CString cs;
//
// Open tag
//
tiAppHelp = SdbBeginWriteListTag(pdb, TAG_APPHELP);
if (!tiAppHelp) {
SDBERROR(_T("Error writing TAG_APPHELP\n"));
goto eh;
}
if (m_pDB->m_pCurrentOutputFile->m_dwFilter & ~SDB_FILTER_DRIVER) {
//
// If this EXE entry contains only APPHELP entries, set
// a flag.
//
if (m_bApphelpOnly) {
if (!SdbWriteDWORDTag(pdb, TAG_FLAGS, SHIMDB_APPHELP_ONLY)) {
SDBERROR(_T("Error writing FLAGS in APPHELP entry\n"));
goto eh;
}
}
//
// Severity
//
if (!SdbWriteDWORDTag(pdb, TAG_PROBLEMSEVERITY, (DWORD)m_pAppHelp->m_Type)) {
SDBERROR( _T("Error writing PROBLEM_SEVERITY\n"));
goto eh;
}
}
//
// HTMLHELPID
//
if (!SdbWriteDWORDTag(pdb, TAG_HTMLHELPID, (DWORD)_ttol(m_pAppHelp->m_csName))) {
SDBERROR( _T("Error writing HTMLHELPID\n"));
goto eh;
}
//
// Check for service pack parameters.
//
cs = m_pDB->m_pCurrentOutputFile->GetParameter("DATE AFTER WHICH TO USE SERVICE PACK APPHELP SDB");
if (cs.GetLength()) {
COleDateTime odt;
if (!odt.ParseDateTime(cs)) {
SDBERROR_FORMAT((_T("Error parsing DATE AFTER WHICH TO USE SERVICE PACK APPHELP SDB parameter: \"%s\"\n"), cs));
goto eh;
}
if (odt.m_dt <= m_pAppHelp->m_dtLastRevision) {
if (!SdbWriteNULLTag(pdb, TAG_USE_SERVICE_PACK_FILES)) {
SDBERROR( _T("Error writing USE_SERVICE_PACK_FILES\n"));
goto eh;
}
}
}
//
// Close tag
//
if (!SdbEndWriteListTag(pdb, tiAppHelp)) {
SDBERROR(_T("Error ending TAG_APPHELP\n"));
goto eh;
}
bSuccess = TRUE;
eh:
return bSuccess;
}
BOOL SdbDatabase::ConstructMigrationMessage(
SdbWin9xMigration* pMigApp,
SdbMessage* pMessage,
CString* pcsMessage
)
{
BOOL bSuccess = FALSE;
CString csSummaryXML, csRedirURL;
SdbRefArray<SdbMessageField> rgFields;
SdbMessageField TitleField;
SdbMessageField VendorField;
if (pMessage->m_csSummaryXML.IsEmpty()) {
if (pMessage->m_pTemplate != NULL) {
csSummaryXML = pMessage->m_pTemplate->m_csSummaryXML;
}
} else {
csSummaryXML = pMessage->m_csSummaryXML;
}
TitleField.m_csName = _T("TITLE");
TitleField.m_csValue = pMigApp->m_pApp->GetLocalizedAppName();
VendorField.m_csName = _T("VENDOR");
VendorField.m_csValue = pMigApp->m_pApp->GetLocalizedVendorName();
rgFields.Add(&TitleField);
rgFields.Add(&VendorField);
rgFields.Append(pMessage->m_rgFields);
if (!ReplaceFields(csSummaryXML, pcsMessage, &rgFields)) {
SDBERROR_PROPOGATE();
goto eh;
}
csRedirURL = m_pCurrentOutputFile->GetParameter(_T("REDIR URL"));
if (!RedirectLinks(pcsMessage,
m_pCurrentMakefile->GetLangMap(m_pCurrentOutputFile->m_csLangID)->m_lcid, csRedirURL)) {
SDBERROR_PROPOGATE();
goto eh;
}
if (g_bStrict) {
if (pcsMessage->IsEmpty()) {
SDBERROR_FORMAT((_T("ERROR: Empty string for SUMMARY on\n NAME: %s\n MESSAGE: %s\n LANG: %s\n\n"),
pMigApp->m_pApp->m_csName, pMigApp->m_csMessage, m_pCurrentMakefile->m_csLangID));
goto eh;
}
}
//
// Remove redundant spacing
//
*pcsMessage = TrimParagraph(*pcsMessage);
//
// Replace <BR/> with \r\n
//
ReplaceStringNoCase(*pcsMessage, _T("<BR/>"), _T("<BR>"));
ReplaceStringNoCase(*pcsMessage, _T("<P/>"), _T("<BR>"));
ReplaceStringNoCase(*pcsMessage, _T("&amp;"), _T("&"));
bSuccess = TRUE;
eh:
return bSuccess;
}
BOOL SdbDatabase::ConstructMessageParts(
SdbAppHelp* pAppHelp,
SdbMessage* pMessage,
CString& csLangID,
DWORD* pdwHTMLHelpID,
CString* pcsURL,
CString* pcsContactInfo,
CString* pcsAppTitle,
CString* pcsSummary,
CString* pcsDetails)
{
BOOL bSuccess = FALSE;
SdbContactInfo* pContactInfo;
SdbMessageTemplate* pTemplate;
SdbMessageField* pField;
CString csContactInfoXML, csSummaryXML, csDetailsXML;
CString csField, csRedirURL, csBaseURL, csLCID;
long i;
SdbRefArray<SdbMessageField> rgFields;
SdbMessageField TitleField;
SdbMessageField VendorField;
//
// If there's a custom URL for this apphelp, use it. If a base content URL was given
// via the makefile, use that to construct the URL.
//
csBaseURL = m_pCurrentOutputFile->GetParameter(_T("BASE ONLINE CONTENT URL"));
*pdwHTMLHelpID = (DWORD)_ttol(pAppHelp->m_csName);
if (pAppHelp->m_csURL.GetLength()) {
*pcsURL = pAppHelp->m_csURL;
} else if (csBaseURL.GetLength()) {
*pcsURL = csBaseURL;
ReplaceStringNoCase(*pcsURL, _T("$HTMLHELPID$"), pAppHelp->m_csName);
ReplaceStringNoCase(*pcsURL, _T("$LANGID$"), csLangID);
csLCID.Format(_T("%X"), m_pCurrentMakefile->GetLangMap(csLangID)->m_lcid);
ReplaceStringNoCase(*pcsURL, _T("$LCID$"), csLCID);
}
if (pMessage->m_csContactInfoXML.IsEmpty()) {
pContactInfo = (SdbContactInfo *) m_rgContactInfo.LookupName(pAppHelp->m_pApp->m_csVendor, csLangID);
if (pContactInfo == NULL) {
pContactInfo = (SdbContactInfo *) m_rgContactInfo.LookupName(_T("__DEFAULT__"), csLangID);
}
if (pContactInfo == NULL) {
if (g_bStrict) {
SDBERROR_FORMAT((_T("ERROR: Localized CONTACT_INFO not found for\n NAME: %s\n HTMLHELPID: %s\n LANG: %s\n\n"),
pAppHelp->m_pApp->m_csVendor, pAppHelp->m_csName, csLangID));
goto eh;
} else {
csContactInfoXML = pAppHelp->m_pApp->m_csVendorXML;
}
} else {
csContactInfoXML = pContactInfo->m_csXML;
}
} else {
csContactInfoXML = pMessage->m_csContactInfoXML;
}
*pcsAppTitle = pAppHelp->m_pApp->GetLocalizedAppName(csLangID);
if (pMessage->m_csSummaryXML.IsEmpty()) {
if (pMessage->m_pTemplate != NULL) {
csSummaryXML = pMessage->m_pTemplate->m_csSummaryXML;
}
} else {
csSummaryXML = pMessage->m_csSummaryXML;
}
if (pMessage->m_csDetailsXML.IsEmpty()) {
if (pMessage->m_pTemplate != NULL) {
csDetailsXML = pMessage->m_pTemplate->m_csDetailsXML;
}
} else {
csDetailsXML = pMessage->m_csDetailsXML;
}
TitleField.m_csName = _T("TITLE");
TitleField.m_csValue = pAppHelp->m_pApp->GetLocalizedAppName(csLangID);
VendorField.m_csName = _T("VENDOR");
VendorField.m_csValue = pAppHelp->m_pApp->GetLocalizedVendorName(csLangID);
rgFields.Add(&TitleField);
rgFields.Add(&VendorField);
rgFields.Append(pMessage->m_rgFields);
if (!ReplaceFields(csContactInfoXML, pcsContactInfo, &rgFields)) {
SDBERROR_PROPOGATE();
goto eh;
}
if (pcsSummary) {
if (!ReplaceFields(csSummaryXML, pcsSummary, &rgFields)) {
SDBERROR_PROPOGATE();
goto eh;
}
}
if (!ReplaceFields(csDetailsXML, pcsDetails, &rgFields)) {
SDBERROR_PROPOGATE();
goto eh;
}
csRedirURL = m_pCurrentOutputFile->GetParameter(_T("REDIR URL"));
if (!RedirectLinks(pcsContactInfo,
m_pCurrentMakefile->GetLangMap(csLangID)->m_lcid, csRedirURL)) {
SDBERROR_PROPOGATE();
goto eh;
}
if (!RedirectLinks(pcsDetails,
m_pCurrentMakefile->GetLangMap(csLangID)->m_lcid, csRedirURL)) {
SDBERROR_PROPOGATE();
goto eh;
}
//
// Remove redundant spacing
//
*pcsURL = TrimParagraph(*pcsURL);
*pcsAppTitle = TrimParagraph(*pcsAppTitle);
if (pcsSummary) {
*pcsSummary = TrimParagraph(*pcsSummary);
//
// Replace various HTML entities with equivalents
//
ReplaceStringNoCase(*pcsSummary, _T("<BR/>"), _T("\r\n"));
ReplaceStringNoCase(*pcsSummary, _T("<P/>"), _T("\r\n"));
ReplaceStringNoCase(*pcsSummary, _T("&amp;"), _T("&"));
if (-1 != pcsSummary->Find(_T('<'))) {
SDBERROR_FORMAT((_T("ERROR: <SUMMARY> can only contain <BR/> and <P/> formatting tags:\n%s\n"),
*pcsSummary));
goto eh;
}
}
bSuccess = TRUE;
eh:
return bSuccess;
}
BOOL SdbDatabase::WriteAppHelpRefTag(
PDB pdb,
CString csHTMLHelpID,
LCID lcid,
CString csURL,
CString csAppTitle,
CString csSummary)
{
TAGID tiMessageSummary;
TAGID tiLink;
INT i;
BOOL bReturn = FALSE;
tiMessageSummary = SdbBeginWriteListTag(pdb, TAG_APPHELP);
if (!tiMessageSummary) {
SDBERROR(_T("Error writing APPHELP_DETAILS tag\n"));
goto eh;
}
if (!SdbWriteDWORDTag(pdb, TAG_HTMLHELPID, (DWORD)_ttol(csHTMLHelpID))) {
SDBERROR( _T("Error writing HTMLHELPID\n"));
goto eh;
}
if (lcid != 0) {
if (!SdbWriteDWORDTag(pdb, TAG_LANGID, lcid)) {
SDBERROR( _T("Error writing LANGID\n"));
goto eh;
}
}
// for each, write a list tag
tiLink = SdbBeginWriteListTag(pdb,TAG_LINK);
if (!tiLink) {
SDBERROR(_T("Error writing APPHELP LINK tag\n"));
goto eh;
}
if (!SdbWriteStringTag(pdb, TAG_LINK_URL, csURL)) {
SDBERROR(_T("Error writing APPHELP URL tag\n"));
goto eh;
}
if (!SdbEndWriteListTag(pdb, tiLink)) {
SDBERROR(_T("Error closing APPHELP LINK tag\n"));
goto eh;
}
if (!csAppTitle.IsEmpty() &&
!SdbWriteStringTag(pdb, TAG_APPHELP_TITLE, csAppTitle)) {
SDBERROR(_T("Error writing APPHELP_TITLE tag\n"));
goto eh;
}
if (!csSummary.IsEmpty() &&
!SdbWriteStringTag(pdb, TAG_APPHELP_DETAILS, csSummary)) {
SDBERROR(_T("Error writing APPHELP_DETAILS tag\n"));
goto eh;
}
if (!SdbEndWriteListTag(pdb, tiMessageSummary)) {
SDBERROR(_T("Error closing APPHELP_DETAILS tag\n"));
goto eh;
}
bReturn = TRUE;
eh:
return bReturn;
}
BOOL SdbData::WriteToSDB(PDB pdb)
{
BOOL bSuccess = FALSE;
TAGID tiData;
//
// Open tag
//
tiData = SdbBeginWriteListTag(pdb, TAG_DATA);
if (!tiData) {
SDBERROR(_T("Error writing TAG_DATA\n"));
goto eh;
}
//
// NAME
//
if (m_csName.GetLength()) {
if (!SdbWriteStringTag(pdb, TAG_NAME, m_csName)) {
SDBERROR(_T("Error writing TAG_NAME\n"));
goto eh;
}
}
//
// Value type
//
if (!SdbWriteDWORDTag(pdb, TAG_DATA_VALUETYPE, m_DataType)) {
SDBERROR(_T("Error writing TAG_DATA_VALUETYPE for DRIVER_POLICY\n"));
goto eh;
}
//
// Value
//
switch(m_DataType) {
case eValueNone:
break;
case eValueString:
if (m_szValue != NULL && !SdbWriteStringTag(pdb, TAG_DATA_STRING, m_szValue)) {
SDBERROR(_T("Error writing TAG_DATA_STRING\n"));
goto eh;
}
break;
case eValueDWORD:
if (!SdbWriteDWORDTag(pdb, TAG_DATA_DWORD, m_dwValue)) {
SDBERROR(_T("Error writing TAG_DATA_DWORD\n"));
goto eh;
}
break;
case eValueQWORD:
if (!SdbWriteQWORDTag(pdb, TAG_DATA_QWORD, m_ullValue)) {
SDBERROR(_T("Error writing TAG_DATA_QWORD\n"));
goto eh;
}
break;
case eValueBinary:
if (!SdbWriteBinaryTag(pdb, TAG_DATA_BITS, m_pBinValue, m_dwDataSize)) {
SDBERROR(_T("Error writing TAG_DATA_BITS\n"));
goto eh;
}
break;
}
//
// Data
//
if (!m_rgData.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
//
// Close tag
//
if (!SdbEndWriteListTag(pdb, tiData)) {
SDBERROR(_T("Error ending TAG_DATA\n"));
goto eh;
}
bSuccess = TRUE;
eh:
return bSuccess;
}
BOOL SdbAction::WriteToSDB(PDB pdb)
{
BOOL bSuccess = FALSE;
TAGID tiAction;
//
// Open tag
//
tiAction = SdbBeginWriteListTag(pdb, TAG_ACTION);
if (!tiAction) {
SDBERROR(_T("Error writing TAG_ACTION\n"));
goto eh;
}
//
// NAME
//
if (!SdbWriteStringTag(pdb, TAG_NAME, m_csName)) {
SDBERROR(_T("Error writing NAME tag\n"));
goto eh;
}
//
// TYPE
//
if (m_csType.GetLength()) {
if (!SdbWriteStringTag(pdb, TAG_ACTION_TYPE, m_csType)) {
SDBERROR(_T("Error writing TAG_ACTION_TYPE tag\n"));
goto eh;
}
}
//
// child data tags
//
if (!m_rgData.WriteToSDB(pdb)) {
SDBERROR_PROPOGATE();
goto eh;
}
//
// Close tag
//
if (!SdbEndWriteListTag(pdb, tiAction)) {
SDBERROR(_T("Error ending TAG_ACTION\n"));
goto eh;
}
bSuccess = TRUE;
eh:
return bSuccess;
}
Reference in a new issue Copy permalink