2705 lines
69 KiB
C++
2705 lines
69 KiB
C++
////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// 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("&"), _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("&"), _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;
|
|
}
|