Microsoft/Windows2003-3790
Microsoft/Windows2003-3790
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
50969b0ea2
Windows2003-3790/windows/appcompat/sdbapi/lib/apphelp.c

1450 lines
43 KiB
C
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
/*++
Copyright (c) 1989-2000 Microsoft Corporation
Module Name:
apphelp.c
Abstract:
This module implements high-level functions to access apphelp information
Author:
dmunsil created sometime in 1999
Revision History:
--*/
#include "sdbp.h"
#define SIZE_WSTRING(pwsz) \
(pwsz == NULL ? 0 : (wcslen((LPCWSTR)(pwsz)) * sizeof(WCHAR) + sizeof(UNICODE_NULL)))
BOOL
SdbReadApphelpDetailsData(
IN PDB pdb, // apphelp.sdb handle
OUT PAPPHELP_DATA pData // apphelp data, which is filled with various bits of information
)
/*++
Return: TRUE if the string was read, FALSE if not.
Desc: This function retrieves APPHELP details from apphelp.sdb. The database
should have a valid index on HTMLHELPID. In addition, we assume that
the compiler generated unique entries for the htmlhelpids. Tthat means,
no two items have identical indexes. The logic to do so has been
specifically built into shimdbc. If this ever changes, this function will
have to be changed as well.
--*/
{
BOOL bSuccess = FALSE;
TAGID tiApphelp;
TAGID tiAppTitle;
TAGID tiContact;
TAGID tiDetails;
TAGID tiLink;
TAGID tiURL;
TAGID tiLinkText;
FIND_INFO FindInfo;
if (!SdbIsIndexAvailable(pdb, TAG_APPHELP, TAG_HTMLHELPID)) {
DBGPRINT((sdlError,
"SdbReadApphelpDetailsData",
"HTMLHELPID index in details database is not available.\n"));
return FALSE;
}
tiApphelp = SdbFindFirstDWORDIndexedTag(pdb,
TAG_APPHELP,
TAG_HTMLHELPID,
pData->dwHTMLHelpID,
&FindInfo);
if (!tiApphelp) {
DBGPRINT((sdlError,
"SdbReadApphelpDetailsData",
"Failed to find HTMLHELPID 0x%x in the details database.\n",
pData->dwHTMLHelpID));
return FALSE;
}
//
// Now find the link. We support multiple links but use only one for now.
//
tiLink = SdbFindFirstTag(pdb, tiApphelp, TAG_LINK);
if (tiLink) {
tiURL = SdbFindFirstTag(pdb, tiLink, TAG_LINK_URL);
if (tiURL) {
pData->szURL = SdbGetStringTagPtr(pdb, tiURL);
}
tiLinkText = SdbFindFirstTag(pdb, tiLink, TAG_LINK_TEXT);
if (tiLinkText) {
pData->szLink = SdbGetStringTagPtr(pdb, tiLinkText);
}
}
tiDetails = SdbFindFirstTag(pdb, tiApphelp, TAG_APPHELP_DETAILS);
if (tiDetails) {
pData->szDetails = SdbGetStringTagPtr(pdb, tiDetails);
}
tiContact = SdbFindFirstTag(pdb, tiApphelp, TAG_APPHELP_CONTACT);
if (tiContact) {
pData->szContact = SdbGetStringTagPtr(pdb, tiContact);
}
tiAppTitle = SdbFindFirstTag(pdb, tiApphelp, TAG_APPHELP_TITLE);
if (tiAppTitle) {
pData->szAppTitle = SdbGetStringTagPtr(pdb, tiAppTitle);
}
bSuccess = TRUE;
return bSuccess;
}
BOOL
SdbReadApphelpData(
IN HSDB hSDB, // handle to the database channel
IN TAGREF trExe, // TAGREF of the EXE with data to read
OUT PAPPHELP_DATA pData // data that we read
)
/*++
Return: TRUE if the string was read, FALSE if not.
Desc: Read the data associated with the apphelp entry
into APPHELP_DATA structure. If there are no apphelp data
for this exe, then the function returns FALSE.
One or more members of the APPHELP_DATA structure may
be 0.
--*/
{
TAGID tiAppHelp,
tiAppName,
tiProblemSeverity,
tiFlags,
tiHtmlHelpID;
TAGID tiExe;
PDB pdb;
if (pData != NULL) {
RtlZeroMemory(pData, sizeof(APPHELP_DATA));
}
if (!SdbTagRefToTagID(hSDB, trExe, &pdb, &tiExe)) {
DBGPRINT((sdlError,
"SdbReadApphelpData",
"Failed to get the TAGID for TAGREF 0x%x.\n",
trExe));
return FALSE;
}
tiAppHelp = SdbFindFirstTag(pdb, tiExe, TAG_APPHELP);
if (tiAppHelp == TAGID_NULL) {
//
// This is not an apphelp entry
//
DBGPRINT((sdlInfo,
"SdbReadApphelpData",
"This is not an apphelp entry tiExe 0x%x.\n",
tiExe));
return FALSE;
}
if (pData == NULL) {
return TRUE;
}
pData->trExe = trExe;
//
// Read supplemental flags.
//
tiFlags = SdbFindFirstTag(pdb, tiAppHelp, TAG_FLAGS);
if (tiFlags != TAGID_NULL) {
pData->dwFlags = SdbReadDWORDTag(pdb, tiFlags, 0);
}
//
// Read problem severity for this app.
//
tiProblemSeverity = SdbFindFirstTag(pdb, tiAppHelp, TAG_PROBLEMSEVERITY);
if (tiProblemSeverity != TAGID_NULL) {
pData->dwSeverity = SdbReadDWORDTag(pdb, tiProblemSeverity, 0);
}
if (pData->dwSeverity == 0) {
DBGPRINT((sdlError,
"SdbReadApphelpData",
"Problem severity for tiExe 0x%x missing.\n",
tiExe));
return FALSE;
}
//
// We should have html help id here.
//
tiHtmlHelpID = SdbFindFirstTag(pdb, tiAppHelp, TAG_HTMLHELPID);
if (tiHtmlHelpID != TAGID_NULL) {
pData->dwHTMLHelpID = SdbReadDWORDTag(pdb, tiHtmlHelpID, 0);
}
//
// While we are at it, include app's name for now. We might need it.
//
tiAppName = SdbFindFirstTag(pdb, tiExe, TAG_APP_NAME);
if (tiAppName != TAGID_NULL) {
pData->szAppName = SdbGetStringTagPtr(pdb, tiAppName);
}
return TRUE;
}
BOOL
SDBAPI
SdbEscapeApphelpURL(
LPWSTR szResult, // escaped string (output)
LPDWORD pdwCount, // count of tchars in the buffer pointed to by szResult
LPCWSTR szToEscape // string to escape
)
{
static const BYTE s_grfbitEscape[] =
{
0xFF, 0xFF, // 00 - 0F
0xFF, 0xFF, // 10 - 1F
0xFF, 0x13, // 20 - 2F
0x00, 0xFC, // 30 - 3F
0x00, 0x00, // 40 - 4F
0x00, 0x78, // 50 - 5F
0x01, 0x00, // 60 - 6F
0x00, 0xF8, // 70 - 7F
0xFF, 0xFF, // 80 - 8F
0xFF, 0xFF, // 90 - 9F
0xFF, 0xFF, // A0 - AF
0xFF, 0xFF, // B0 - BF
0xFF, 0xFF, // C0 - CF
0xFF, 0xFF, // D0 - DF
0xFF, 0xFF, // E0 - EF
0xFF, 0xFF, // F0 - FF
};
static const WCHAR s_rgchHex[] = L"0123456789ABCDEF";
WCHAR ch;
DWORD nch = 0;
LPCWSTR lpszURL = szToEscape;
DWORD dwCount = *pdwCount;
// part one -- measure length
while ((ch = *lpszURL++) != L'\0') {
if ((ch & 0xFF00) != 0) { // a unicode char ?
nch += 6;
} else if(s_grfbitEscape[ch >> 3] & (1 << (ch & 7))) {
nch += 3;
} else {
nch += 1;
}
}
nch++; // one more for the final \0
if (dwCount < nch) {
DBGPRINT((sdlError,
"SdbEscapeApphelpURL",
"Not enough storage to escape URL \"%S\" need %ld got %ld\n",
szToEscape,
nch,
dwCount));
*pdwCount = nch;
return FALSE;
}
lpszURL = szToEscape;
while ((ch = *lpszURL++) != L'\0') {
if (ch == L' ') {
*szResult++ = L'+';
} else if ((ch & 0xFF00) != 0) { // a unicode char ?
*szResult++ = L'%';
*szResult++ = L'u';
*szResult++ = s_rgchHex[(ch >> 12) & 0x0F];
*szResult++ = s_rgchHex[(ch >> 8) & 0x0F];
*szResult++ = s_rgchHex[(ch >> 4) & 0x0F];
*szResult++ = s_rgchHex[ ch & 0x0F];
} else if(s_grfbitEscape[ch >> 3] & (1 << (ch & 7))) {
*szResult++ = L'%';
*szResult++ = s_rgchHex[(ch >> 4) & 0x0F];
*szResult++ = s_rgchHex[ ch & 0x0F];
} else {
*szResult++ = ch;
}
}
*szResult = L'\0';
*pdwCount = nch - 1; // do not include the term \0 into a char count
return TRUE;
}
/////////////////////////////////////////////////////////////////////////////////////////////
//
//
// Retrieving apphelp information
//
//
//
PDB
SDBAPI
SdbOpenApphelpDetailsDatabase(
LPCWSTR pwszDetailsDatabasePath
)
{
PDB pdbDetails = NULL;
DWORD dwLength;
WCHAR wszAppHelpSdb[MAX_PATH];
if (pwszDetailsDatabasePath == NULL) {
//
// By default the details database is in %windir%\AppPatch\apphelp.sdb
//
dwLength = SdbpGetStandardDatabasePath(NULL,
SDB_DATABASE_MAIN_DETAILS,
0, // retrieve NT_PATH
wszAppHelpSdb,
CHARCOUNT(wszAppHelpSdb));
if (dwLength != 0 && dwLength < CHARCOUNT(wszAppHelpSdb)) {
pdbDetails = SdbOpenDatabase(wszAppHelpSdb, NT_PATH);
}
} else {
pdbDetails = SdbOpenDatabase(pwszDetailsDatabasePath, DOS_PATH);
}
if (pdbDetails == NULL) {
DBGPRINT((sdlError, "SdbOpenApphelpDetailsDatabase", "Failed to open the details database.\n"));
}
return pdbDetails;
}
BOOL
SdbpReadApphelpBasicInfo(
IN PDB pdb,
IN TAGID tiEntry,
OUT TAGID* ptiApphelp,
OUT LPDWORD lpdwHtmlHelpID,
OUT LPDWORD lpdwProblemSeverity,
OUT LPDWORD lpdwFlags
)
{
TAGID tiAppHelp = TAGID_NULL;
TAGID tiHtmlHelpID = TAGID_NULL;
TAGID tiSeverity = TAGID_NULL;
TAGID tiFlags = TAGID_NULL;
DWORD dwHtmlHelpID = 0;
DWORD dwSeverity = 0;
DWORD dwFlags = 0;
BOOL bReturn = FALSE;
if (tiEntry == TAGID_NULL) {
goto out;
}
assert(ptiApphelp != NULL);
tiAppHelp = SdbFindFirstTag(pdb, tiEntry, TAG_APPHELP);
if (tiAppHelp == TAGID_NULL) {
//
// This is not an apphelp entry
//
DBGPRINT((sdlError, "SdbpReadApphelpBasicInfo",
"This is not an apphelp entry tiExe 0x%x.\n", tiEntry));
goto out;
}
if (lpdwHtmlHelpID != NULL) {
tiHtmlHelpID = SdbFindFirstTag(pdb, tiAppHelp, TAG_HTMLHELPID);
if (tiHtmlHelpID != TAGID_NULL) {
dwHtmlHelpID = SdbReadDWORDTag(pdb, tiHtmlHelpID, 0);
}
*lpdwHtmlHelpID = dwHtmlHelpID;
}
if (lpdwProblemSeverity != NULL) {
tiSeverity = SdbFindFirstTag(pdb, tiAppHelp, TAG_PROBLEMSEVERITY);
if (tiSeverity != TAGID_NULL) {
dwSeverity = SdbReadDWORDTag(pdb, tiSeverity, 0);
}
*lpdwProblemSeverity = dwSeverity;
}
//
// Read supplemental flags.
//
if (lpdwFlags != NULL) {
tiFlags = SdbFindFirstTag(pdb, tiAppHelp, TAG_FLAGS);
if (tiFlags != TAGID_NULL) {
dwFlags = SdbReadDWORDTag(pdb, tiFlags, 0);
}
*lpdwFlags = dwFlags;
}
bReturn = TRUE;
out:
// always set the tiApphelp
*ptiApphelp = tiAppHelp;
return bReturn;
}
HAPPHELPINFOCONTEXT
SDBAPI
SdbOpenApphelpInformationByID(
IN HSDB hSDB,
IN TAGREF trEntry,
IN DWORD dwDatabaseType // pass the type of db you are using
)
{
PAPPHELPINFOCONTEXT pApphelpInfoContext = NULL;
PDB pdb = NULL;
TAGID tiExe = TAGID_NULL;
BOOL bSuccess = FALSE;
if (trEntry == TAGREF_NULL) {
return NULL;
}
//
// if we are here, it is apphelp for sure, so we create the context
//
pApphelpInfoContext = (PAPPHELPINFOCONTEXT)SdbAlloc(sizeof(APPHELPINFOCONTEXT));
if (pApphelpInfoContext == NULL) {
DBGPRINT((sdlError, "SdbOpenApphelpInformation",
"Error allocating memory for apphelp info context\n"));
goto out;
}
pApphelpInfoContext->hSDB = hSDB;
pApphelpInfoContext->pdb = pdb;
pApphelpInfoContext->dwContextFlags |= AHC_HSDB_NOCLOSE; // external hsdb, do not touch it
//
// all we care for -- is whether it's "main" database or not
//
pApphelpInfoContext->dwDatabaseType = dwDatabaseType;
// get the guid for this db
if (!SdbTagRefToTagID(hSDB, trEntry, &pdb, &tiExe)) {
DBGPRINT((sdlError, "SdbOpenApphelpInformationByID",
"Error converting tagref to tagref 0x%lx\n", trEntry));
goto out;
}
pApphelpInfoContext->tiExe = tiExe;
if (!SdbGetDatabaseGUID(hSDB, pdb, &pApphelpInfoContext->guidDB)) {
DBGPRINT((sdlError, "SdbOpenApphelpInformationByID",
"Error reading database guid for tagref 0x%lx\n", trEntry));
goto out;
}
if (!SdbpReadApphelpBasicInfo(pdb,
tiExe,
&pApphelpInfoContext->tiApphelpExe,
&pApphelpInfoContext->dwHtmlHelpID,
&pApphelpInfoContext->dwSeverity,
&pApphelpInfoContext->dwFlags)) {
DBGPRINT((sdlError, "SdbOpenApphelpInformationByID",
"Error reading apphelp basic information, apphelp may not be present for 0x%lx\n", trEntry));
goto out;
}
bSuccess = TRUE;
//
out:
if (!bSuccess) {
if (pApphelpInfoContext != NULL) {
SdbFree(pApphelpInfoContext);
pApphelpInfoContext = NULL;
}
}
return pApphelpInfoContext;
}
HAPPHELPINFOCONTEXT
SDBAPI
SdbOpenApphelpInformation(
IN GUID* pguidDB,
IN GUID* pguidID
)
{
WCHAR szDatabasePath[MAX_PATH];
DWORD dwDatabaseType = 0;
DWORD dwLength;
HSDB hSDB = NULL;
PDB pdb = NULL;
TAGID tiMatch = TAGID_NULL;
FIND_INFO FindInfo;
PAPPHELPINFOCONTEXT pApphelpInfoContext = NULL;
BOOL bSuccess = FALSE;
//
// Resolve and open the database.
//
// NOTE: For now pass the IMAGE_FILE_MACHINE_I386 flag.
// We'll only look into the 32 bit database.
//
hSDB = SdbInitDatabaseEx(HID_NO_DATABASE, NULL, IMAGE_FILE_MACHINE_I386);
if (hSDB == NULL) {
DBGPRINT((sdlError, "SdbOpenApphelpInformation",
"Failed to initialize database\n"));
goto out;
}
//
// First, we need to resolve a db
//
dwLength = SdbResolveDatabase(hSDB,
pguidDB,
&dwDatabaseType,
szDatabasePath,
CHARCOUNT(szDatabasePath));
if (dwLength == 0 || dwLength > CHARCOUNT(szDatabasePath)) {
DBGPRINT((sdlError, "SdbOpenApphelpInformation",
"Failed to resolve database path\n"));
goto out;
}
//
// open database
//
if (!SdbOpenLocalDatabase(hSDB, szDatabasePath)) {
DBGPRINT((sdlError, "SdbOpenApphelpInformation",
"Failed to open database \"%s\"\n", szDatabasePath));
goto out;
}
//
// we have database opened, I presume
//
pdb = ((PSDBCONTEXT)hSDB)->pdbLocal;
//
// we search only the LOCAL database in this case
//
tiMatch = SdbFindFirstGUIDIndexedTag(pdb,
TAG_EXE,
TAG_EXE_ID,
pguidID,
&FindInfo);
// if we have a match...
if (tiMatch == TAGID_NULL) {
DBGPRINT((sdlWarning, "SdbOpenApphelpInformation", "guid was not found in the database\n"));
goto out;
}
//
// if we are here, it is apphelp for sure, so we create the context
//
pApphelpInfoContext = (PAPPHELPINFOCONTEXT)SdbAlloc(sizeof(APPHELPINFOCONTEXT));
if (pApphelpInfoContext == NULL) {
DBGPRINT((sdlError, "SdbOpenApphelpInformation",
"Error allocating memory for apphelp info context\n"));
goto out;
}
pApphelpInfoContext->hSDB = hSDB;
pApphelpInfoContext->pdb = pdb;
pApphelpInfoContext->guidID = *pguidID;
pApphelpInfoContext->guidDB = *pguidDB;
pApphelpInfoContext->tiExe = tiMatch;
pApphelpInfoContext->dwDatabaseType = dwDatabaseType;
if (!SdbpReadApphelpBasicInfo(pdb,
tiMatch,
&pApphelpInfoContext->tiApphelpExe,
&pApphelpInfoContext->dwHtmlHelpID,
&pApphelpInfoContext->dwSeverity,
&pApphelpInfoContext->dwFlags)) {
DBGPRINT((sdlError, "SdbOpenApphelpInformation",
"Error reading apphelp basic information, apphelp may not be present for tagid 0x%lx\n", tiMatch));
goto out;
}
bSuccess = TRUE;
//
// we are done now
//
out:
if (!bSuccess) {
if (hSDB != NULL) {
SdbReleaseDatabase(hSDB);
}
if (pApphelpInfoContext != NULL) {
SdbFree(pApphelpInfoContext);
pApphelpInfoContext = NULL;
}
}
return (HAPPHELPINFOCONTEXT)pApphelpInfoContext;
}
BOOL
SDBAPI
SdbCloseApphelpInformation(
HAPPHELPINFOCONTEXT hctx
)
{
PAPPHELPINFOCONTEXT pApphelpInfoContext = (PAPPHELPINFOCONTEXT)hctx;
if (pApphelpInfoContext != NULL) {
if (pApphelpInfoContext->hSDB != NULL &&
!(pApphelpInfoContext->dwContextFlags & AHC_HSDB_NOCLOSE)) {
SdbReleaseDatabase(pApphelpInfoContext->hSDB);
}
if (pApphelpInfoContext->pdbDetails != NULL &&
!(pApphelpInfoContext->dwContextFlags & AHC_DBDETAILS_NOCLOSE)) {
SdbCloseDatabaseRead(pApphelpInfoContext->pdbDetails);
}
if (pApphelpInfoContext->pwszHelpCtrURL != NULL) {
SdbFree(pApphelpInfoContext->pwszHelpCtrURL);
}
RtlFreeUnicodeString(&pApphelpInfoContext->ustrChmFile);
RtlFreeUnicodeString(&pApphelpInfoContext->ustrDetailsDatabase);
SdbFree(pApphelpInfoContext);
}
return TRUE;
}
DWORD
SDBAPI
SdbpReadApphelpString(
PDB pdb,
TAGID tiParent,
TAG tItem,
LPCWSTR* ppwszCache,
LPVOID* ppResult
)
{
DWORD cbResult = 0;
TAGID tiItem;
LPCWSTR pwszItem = NULL;
if (*ppwszCache != NULL) {
pwszItem = *ppwszCache;
} else {
tiItem = SdbFindFirstTag(pdb, tiParent, tItem);
if (tiItem != TAGID_NULL) {
pwszItem = SdbGetStringTagPtr(pdb, tiItem);
if (pwszItem != NULL) {
*ppwszCache = pwszItem;
}
}
}
cbResult = (DWORD)SIZE_WSTRING(pwszItem);
*ppResult = (LPVOID)pwszItem;
return cbResult;
}
BOOL
SDBAPI
SdbpReadApphelpLinkInformation(
PAPPHELPINFOCONTEXT pApphelpInfoContext
)
{
TAGID tiLink;
TAGID tiApphelp = pApphelpInfoContext->tiApphelpDetails;
PDB pdb = pApphelpInfoContext->pdbDetails;
TAGID tiURL;
TAGID tiLinkText;
if (pApphelpInfoContext->tiLink != TAGID_NULL) {
return TRUE;
}
//
// Now find the link. We support multiple links but use only one for now.
//
tiLink = SdbFindFirstTag(pdb, tiApphelp, TAG_LINK);
if (tiLink == TAGID_NULL) {
return FALSE;
}
tiURL = SdbFindFirstTag(pdb, tiLink, TAG_LINK_URL);
if (tiURL) {
pApphelpInfoContext->pwszLinkURL = SdbGetStringTagPtr(pdb, tiURL);
}
tiLinkText = SdbFindFirstTag(pdb, tiLink, TAG_LINK_TEXT);
if (tiLinkText) {
pApphelpInfoContext->pwszLinkText = SdbGetStringTagPtr(pdb, tiLinkText);
}
pApphelpInfoContext->tiLink = tiLink;
return TRUE;
}
BOOL
SDBAPI
SdbpCreateHelpCenterURL(
IN HAPPHELPINFOCONTEXT hctx,
IN BOOL bOfflineContent OPTIONAL, // pass FALSE
IN BOOL bUseHtmlHelp OPTIONAL, // pass FALSE
IN LPCWSTR pwszChmFile OPTIONAL // pass NULL
);
BOOL
SDBAPI
SdbSetApphelpDebugParameters(
IN HAPPHELPINFOCONTEXT hctx,
IN LPCWSTR pszDetailsDatabase OPTIONAL,
IN BOOL bOfflineContent OPTIONAL, // pass FALSE
IN BOOL bUseHtmlHelp OPTIONAL, // pass FALSE
IN LPCWSTR pszChmFile OPTIONAL // pass NULL
)
{
PAPPHELPINFOCONTEXT pApphelpInfoContext = (PAPPHELPINFOCONTEXT)hctx;
if (pApphelpInfoContext == NULL) {
return FALSE;
}
if (bUseHtmlHelp && !bOfflineContent) {
DBGPRINT((sdlError, "SdbSetApphelpDebugParameters",
"Inconsistent parameters: when using html help -- offline content flag should also be set\n"));
bOfflineContent = TRUE;
}
RtlFreeUnicodeString(&pApphelpInfoContext->ustrDetailsDatabase);
RtlFreeUnicodeString(&pApphelpInfoContext->ustrChmFile);
pApphelpInfoContext->bOfflineContent = bOfflineContent;
pApphelpInfoContext->bUseHtmlHelp = bUseHtmlHelp;
if (pszDetailsDatabase != NULL) {
if (!RtlCreateUnicodeString(&pApphelpInfoContext->ustrDetailsDatabase, pszDetailsDatabase)) {
DBGPRINT((sdlError, "SdbSetApphelpDebugParameters",
"Failed to create unicode string from \"%S\"\n", pszDetailsDatabase));
return FALSE;
}
}
if (pszChmFile != NULL) {
if (!RtlCreateUnicodeString(&pApphelpInfoContext->ustrChmFile, pszChmFile)) {
DBGPRINT((sdlError, "SdbSetApphelpDebugParameters",
"Failed to create unicode string from \"%S\"\n", pszChmFile));
return FALSE;
}
}
return TRUE;
}
DWORD
SDBAPI
SdbQueryApphelpInformation(
HAPPHELPINFOCONTEXT hctx,
APPHELPINFORMATIONCLASS InfoClass,
LPVOID pBuffer, // may be NULL
DWORD cbSize // may be 0 if pBuffer is NULL
)
{
PAPPHELPINFOCONTEXT pApphelpInfoContext = (PAPPHELPINFOCONTEXT)hctx;
LPCWSTR *ppwsz;
TAG tag;
TAGID tiParent;
LPVOID pResult = NULL;
DWORD cbResult = 0;
PDB pdb = NULL;
PDB pdbDetails = NULL;
TAGID tiApphelpDetails = TAGID_NULL;
FIND_INFO FindInfo;
switch (InfoClass) {
case ApphelpLinkURL:
case ApphelpLinkText:
case ApphelpTitle:
case ApphelpDetails:
case ApphelpContact:
pdbDetails = pApphelpInfoContext->pdbDetails;
if (pApphelpInfoContext->pdbDetails == NULL) {
//
// see which db we should open
//
if ((pApphelpInfoContext->ustrDetailsDatabase.Buffer != NULL) ||
(pApphelpInfoContext->dwDatabaseType & SDB_DATABASE_MAIN)) {
pdbDetails = SdbOpenApphelpDetailsDatabase(pApphelpInfoContext->ustrDetailsDatabase.Buffer);
} else {
// we have a case when the apphelp details should be in main db
pApphelpInfoContext->dwContextFlags |= AHC_DBDETAILS_NOCLOSE;
pdbDetails = pApphelpInfoContext->pdb;
}
if (pdbDetails == NULL) {
return cbResult; // apphelp db is not available
}
pApphelpInfoContext->pdbDetails = pdbDetails;
}
tiApphelpDetails = pApphelpInfoContext->tiApphelpDetails;
if (tiApphelpDetails == TAGID_NULL) {
if (!SdbIsIndexAvailable(pdbDetails, TAG_APPHELP, TAG_HTMLHELPID)) {
DBGPRINT((sdlError,
"SdbQueryApphelpInformation",
"HTMLHELPID index in details database is not available.\n"));
return cbResult;
}
tiApphelpDetails = SdbFindFirstDWORDIndexedTag(pdbDetails,
TAG_APPHELP,
TAG_HTMLHELPID,
pApphelpInfoContext->dwHtmlHelpID,
&FindInfo);
if (tiApphelpDetails == TAGID_NULL) {
DBGPRINT((sdlError,
"SdbQueryApphelpInformation",
"Failed to find HTMLHELPID 0x%x in the details database.\n",
pApphelpInfoContext->dwHtmlHelpID));
return cbResult;
}
pApphelpInfoContext->tiApphelpDetails = tiApphelpDetails;
}
break;
default:
break;
}
switch(InfoClass) {
case ApphelpExeTagID:
pResult = &pApphelpInfoContext->tiExe;
cbResult = sizeof(pApphelpInfoContext->tiExe);
break;
case ApphelpExeName:
pdb = pApphelpInfoContext->pdb; // main db
tiParent = pApphelpInfoContext->tiExe;
ppwsz = &pApphelpInfoContext->pwszExeName;
tag = TAG_NAME;
cbResult = SdbpReadApphelpString(pdb, tiParent, tag, ppwsz, &pResult);
break;
case ApphelpAppName:
pdb = pApphelpInfoContext->pdb; // main db
tiParent = pApphelpInfoContext->tiExe;
ppwsz = &pApphelpInfoContext->pwszAppName;
tag = TAG_APP_NAME;
cbResult = SdbpReadApphelpString(pdb, tiParent, tag, ppwsz, &pResult);
break;
case ApphelpVendorName:
pdb = pApphelpInfoContext->pdb; // main db
tiParent = pApphelpInfoContext->tiExe;
ppwsz = &pApphelpInfoContext->pwszVendorName;
tag = TAG_VENDOR;
cbResult = SdbpReadApphelpString(pdb, tiParent, tag, ppwsz, &pResult);
break;
case ApphelpHtmlHelpID:
pResult = &pApphelpInfoContext->dwHtmlHelpID;
cbResult = sizeof(pApphelpInfoContext->dwHtmlHelpID);
break;
case ApphelpProblemSeverity:
pResult = &pApphelpInfoContext->dwSeverity;
cbResult = sizeof(pApphelpInfoContext->dwSeverity);
break;
case ApphelpFlags:
pResult = &pApphelpInfoContext->dwFlags;
cbResult = sizeof(pApphelpInfoContext->dwFlags);
break;
case ApphelpLinkURL:
if (!SdbpReadApphelpLinkInformation(pApphelpInfoContext)) {
break;
}
pResult = (LPWSTR)pApphelpInfoContext->pwszLinkURL;
cbResult = (DWORD)SIZE_WSTRING(pResult);
break;
case ApphelpLinkText:
if (!SdbpReadApphelpLinkInformation(pApphelpInfoContext)) {
break;
}
pResult = (LPWSTR)pApphelpInfoContext->pwszLinkText;
cbResult = (DWORD)SIZE_WSTRING(pResult);
break;
case ApphelpTitle:
pdb = pdbDetails;
tiParent = tiApphelpDetails;
ppwsz = &pApphelpInfoContext->pwszTitle;
tag = TAG_APPHELP_TITLE;
cbResult = SdbpReadApphelpString(pdb, tiParent, tag, ppwsz, &pResult);
break;
case ApphelpDetails:
pdb = pdbDetails;
tiParent = tiApphelpDetails;
ppwsz = &pApphelpInfoContext->pwszDetails;
tag = TAG_APPHELP_DETAILS;
cbResult = SdbpReadApphelpString(pdb, tiParent, tag, ppwsz, &pResult);
break;
case ApphelpContact:
pdb = pdbDetails;
tiParent = tiApphelpDetails;
ppwsz = &pApphelpInfoContext->pwszContact;
tag = TAG_APPHELP_CONTACT;
cbResult = SdbpReadApphelpString(pdb, tiParent, tag, ppwsz, &pResult);
break;
case ApphelpHelpCenterURL:
if (!SdbpCreateHelpCenterURL(hctx,
pApphelpInfoContext->bOfflineContent,
pApphelpInfoContext->bUseHtmlHelp,
pApphelpInfoContext->ustrChmFile.Buffer)) {
break;
}
pResult = pApphelpInfoContext->pwszHelpCtrURL;
cbResult = (DWORD)SIZE_WSTRING(pResult);
break;
case ApphelpDatabaseGUID:
pResult = &pApphelpInfoContext->guidDB;
cbResult = sizeof(pApphelpInfoContext->guidDB);
break;
default:
DBGPRINT((sdlError, "SdbQueryApphelpInformation",
"Bad Apphelp Information class 0x%lx\n", InfoClass));
return 0;
break;
}
if (pBuffer == NULL || cbResult > cbSize) {
return cbResult;
}
if (pResult != NULL && cbResult > 0) {
RtlCopyMemory(pBuffer, pResult, cbResult);
}
return cbResult;
}
typedef HRESULT (STDAPICALLTYPE *PFNUrlUnescapeW)(
LPWSTR pszUrl,
LPWSTR pszUnescaped,
LPDWORD pcchUnescaped,
DWORD dwFlags);
typedef HRESULT (STDAPICALLTYPE *PFNUrlEscapeW)(
LPCWSTR pszURL,
LPWSTR pszEscaped,
LPDWORD pcchEscaped,
DWORD dwFlags
);
//
// if bUseHtmlHelp is set -- then bOfflineContent is also set to TRUE
//
BOOL
SDBAPI
SdbpCreateHelpCenterURL(
IN HAPPHELPINFOCONTEXT hctx,
IN BOOL bOfflineContent OPTIONAL, // pass FALSE
IN BOOL bUseHtmlHelp OPTIONAL, // pass FALSE
IN LPCWSTR pwszChmFile OPTIONAL // pass NULL
)
{
WCHAR szAppHelpURL[2048];
WCHAR szChmURL[1024];
PAPPHELPINFOCONTEXT pApphelpInfo = (PAPPHELPINFOCONTEXT)hctx;
HMODULE hModShlwapi = NULL;
PFNUrlUnescapeW pfnUnescape;
PFNUrlEscapeW pfnEscape;
BOOL bSuccess = FALSE;
int nChURL = 0; // counts used bytes
int cch = 0;
int nch;
size_t cchRemaining;
LPWSTR lpwszUnescaped = NULL;
HRESULT hr;
DWORD nChars;
WCHAR szWindowsDir[MAX_PATH];
BOOL bCustom;
if (pApphelpInfo->pwszHelpCtrURL != NULL) {
return TRUE;
}
if (bUseHtmlHelp) {
bOfflineContent = TRUE;
}
// ping the database
if (0 == SdbQueryApphelpInformation(hctx, ApphelpLinkURL, NULL, 0)) {
return FALSE;
}
//
// check and see whether it's custom apphelp or not
//
bCustom = !(pApphelpInfo->dwDatabaseType & SDB_DATABASE_MAIN);
if (bCustom) {
if (pApphelpInfo->pwszLinkURL != NULL) {
hr = StringCchPrintf(szAppHelpURL,
CHARCOUNT(szAppHelpURL),
L"%ls",
pApphelpInfo->pwszLinkURL);
if (FAILED(hr)) {
DBGPRINT((sdlError, "SdbpCreateHelpCenterURL",
"Custom apphelp URL %s is too long\n", pApphelpInfo->pwszLinkURL));
goto out;
}
// now we are done
goto createApphelpURL;
} else {
// custom apphelp will not fly without a link
DBGPRINT((sdlError, "SdbpCreateHelpCenterURL", "Custom apphelp without a url link\n"));
goto out;
}
}
// unescape the URL
hModShlwapi = LoadLibraryW(L"shlwapi.dll");
if (hModShlwapi == NULL) {
return FALSE;
}
pfnUnescape = (PFNUrlUnescapeW)GetProcAddress(hModShlwapi, "UrlUnescapeW");
pfnEscape = (PFNUrlEscapeW) GetProcAddress(hModShlwapi, "UrlEscapeW");
if (pfnUnescape == NULL || pfnEscape == NULL) {
DBGPRINT((sdlError, "SdbpCreateHelpCenterURL", "Cannot get shlwapi functions\n"));
goto out;
}
if (!bUseHtmlHelp) {
StringCchPrintfEx(szAppHelpURL,
CHARCOUNT(szAppHelpURL),
NULL,
&cchRemaining,
0,
L"hcp://services/redirect?online=");
nChURL = CHARCOUNT(szAppHelpURL) - (int)cchRemaining;
}
if (!bOfflineContent && pApphelpInfo->pwszLinkURL != NULL) {
// unescape the url first using shell
cch = (int)wcslen(pApphelpInfo->pwszLinkURL) + 1;
STACK_ALLOC(lpwszUnescaped, cch * sizeof(WCHAR));
if (lpwszUnescaped == NULL) {
DBGPRINT((sdlError, "SdbpCreateHelpCenterURL",
"Error trying to allocate memory for \"%S\"\n", pApphelpInfo->pwszLinkURL));
goto out;
}
//
// Unescape round 1 - use the shell function (same as used to encode it for xml/database)
//
hr = pfnUnescape((LPTSTR)pApphelpInfo->pwszLinkURL, lpwszUnescaped, (LPDWORD)&cch, 0);
if (!SUCCEEDED(hr)) {
DBGPRINT((sdlError, "SdbCreateHelpCenterURL", "UrlUnescapeW failed on \"%S\"\n", pApphelpInfo->pwszLinkURL));
goto out;
}
//
// round 2 - use our function borrowed from help center
//
cch = (DWORD)(CHARCOUNT(szAppHelpURL) - nChURL);
if (!SdbEscapeApphelpURL(szAppHelpURL + nChURL, (LPDWORD)&cch, lpwszUnescaped)) {
DBGPRINT((sdlError, "SdbCreateHelpCenterURL", "Error escaping URL \"%S\"\n", lpwszUnescaped));
goto out;
}
nChURL += (int)cch;
}
//
// Retrieve the Windows directory.
//
nChars = GetWindowsDirectoryW(szWindowsDir, CHARCOUNT(szWindowsDir));
if (!nChars || nChars > CHARCOUNT(szWindowsDir)) {
DBGPRINT((sdlError, "SdbCreateHelpCenterURL",
"Error trying to retrieve Windows Directory %d.\n", GetLastError()));
goto out;
}
if (pwszChmFile != NULL) {
StringCchPrintf(szChmURL,
CHARCOUNT(szChmURL),
L"mk:@msitstore:%ls::/idh_w2_%d.htm",
pwszChmFile,
pApphelpInfo->dwHtmlHelpID);
} else { // standard chm file
//
// Attention: if we use hDlg here then, upon exit we will need to clean
// up the window.
//
StringCchPrintf(szChmURL,
CHARCOUNT(szChmURL),
L"mk:@msitstore:%ls\\help\\apps.chm::/idh_w2_%d.htm",
szWindowsDir,
pApphelpInfo->dwHtmlHelpID);
}
if (bOfflineContent) {
if (bUseHtmlHelp) {
cch = CHARCOUNT(szAppHelpURL);
hr = pfnEscape(szChmURL, szAppHelpURL, (LPDWORD)&cch, 0);
if (SUCCEEDED(hr)) {
nChURL += (INT)cch;
}
} else { // do not use html help
cch = (DWORD)(CHARCOUNT(szAppHelpURL) - nChURL);
if (!SdbEscapeApphelpURL(szAppHelpURL+nChURL, (LPDWORD)&cch, szChmURL)) {
DBGPRINT((sdlError, "SdbCreateHelpCenterURL", "Error escaping URL \"%S\"\n", szChmURL));
goto out;
}
nChURL += (INT)cch;
}
}
if (!bUseHtmlHelp) {
//
// now offline sequence
//
cch = (DWORD)(CHARCOUNT(szAppHelpURL) - nChURL);
hr = StringCchPrintfEx(szAppHelpURL + nChURL,
cch,
NULL,
&cchRemaining,
0,
L"&offline=");
if (FAILED(hr)) {
goto out;
}
nch = cch - (int)cchRemaining;
nChURL += nch;
cch = (DWORD)(CHARCOUNT(szAppHelpURL) - nChURL);
if (!SdbEscapeApphelpURL(szAppHelpURL+nChURL, (LPDWORD)&cch, szChmURL)) {
DBGPRINT((sdlError, "SdbCreateHelpCenterURL", "Error escaping URL \"%S\"\n", szChmURL));
goto out;
}
nChURL += (int)cch;
}
*(szAppHelpURL + nChURL) = L'\0';
// we are done
// copy data now
createApphelpURL:
pApphelpInfo->pwszHelpCtrURL = (LPWSTR)SdbAlloc(nChURL * sizeof(WCHAR) + sizeof(UNICODE_NULL));
if (pApphelpInfo->pwszHelpCtrURL == NULL) {
DBGPRINT((sdlError, "SdbCreateHelpCenterURL", "Error allocating memory for the URL 0x%lx chars\n", nChURL));
goto out;
}
StringCchCopy(pApphelpInfo->pwszHelpCtrURL, nChURL + sizeof(UNICODE_NULL), szAppHelpURL);
bSuccess = TRUE;
out:
if (lpwszUnescaped != NULL) {
STACK_FREE(lpwszUnescaped);
}
if (hModShlwapi) {
FreeLibrary(hModShlwapi);
}
return bSuccess;
}
//
// returns TRUE if dialog was shown
// if there was an error, input parameter (pRunApp) will NOT
// be touched
BOOL
SdbShowApphelpDialog( // returns TRUE if success, whether we should run the app is in pRunApp
IN PAPPHELP_INFO pAHInfo, // the info necessary to find the apphelp data
IN PHANDLE phProcess, // [optional] returns the process handle of
// the process displaying the apphelp.
// When the process completes, the return value
// (from GetExitCodeProcess()) will be zero
// if the app should not run, or non-zero
// if it should run.
IN OUT BOOL* pRunApp
)
{
//
// basically just launch the apphelp.exe and wait for it to return
//
TCHAR szGuid[64];
TCHAR szCommandLine[MAX_PATH * 2 + 64];
LPTSTR pszEnd = szCommandLine;
STARTUPINFO StartupInfo;
PROCESS_INFORMATION ProcessInfo;
DWORD dwExit = 1; // by default and in case of failure, we allow to run the app
BOOL bReturn = FALSE;
BOOL bRunApp = TRUE; // by default we run the app ?
size_t cchRemaining;
UINT unChars;
cchRemaining = CHARCOUNT(szCommandLine);
unChars = GetSystemDirectory(pszEnd, (UINT)cchRemaining);
//
// if we couldn't get the system directory, we'll just look for it on the path
//
if (unChars > cchRemaining || unChars == 0) {
unChars = 0;
}
pszEnd += unChars;
cchRemaining -= unChars;
if (unChars != 0) {
StringCchCopy(pszEnd, cchRemaining, TEXT("\\ahui.exe"));
} else {
StringCchCopy(pszEnd, cchRemaining, TEXT("ahui.exe"));
}
unChars = (UINT)_tcslen(pszEnd);
pszEnd += unChars;
cchRemaining -= unChars;
RtlZeroMemory(&StartupInfo, sizeof(StartupInfo));
RtlZeroMemory(&ProcessInfo, sizeof(ProcessInfo));
StartupInfo.cb = sizeof(StartupInfo);
if (pAHInfo->tiExe != TAGID_NULL) {
//
// Figure out what the default return value should be
//
if (!SdbGUIDToString(&pAHInfo->guidDB, szGuid, CHARCOUNT(szGuid))) {
DBGPRINT((sdlError, "SdbShowApphelpDialog",
"Failed to convert guid to string.\n"));
goto cleanup;
}
StringCchPrintfEx(pszEnd,
cchRemaining,
&pszEnd,
&cchRemaining,
0,
TEXT(" %s 0x%lX"),
szGuid,
pAHInfo->tiExe);
} else {
if (!pAHInfo->dwHtmlHelpID) {
DBGPRINT((sdlError, "SdbShowApphelpDialog",
"Neither HTMLHELPID nor tiExe provided\n"));
goto cleanup;
}
StringCchPrintfEx(pszEnd,
cchRemaining,
&pszEnd,
&cchRemaining,
0,
TEXT(" /HTMLHELPID:0x%lx"),
pAHInfo->dwHtmlHelpID);
StringCchPrintfEx(pszEnd,
cchRemaining,
&pszEnd,
&cchRemaining,
0,
TEXT(" /SEVERITY:0x%lx"),
pAHInfo->dwSeverity);
if (!SdbIsNullGUID(&pAHInfo->guidID)) {
if (SdbGUIDToString(&pAHInfo->guidID, szGuid, CHARCOUNT(szGuid))) {
StringCchPrintfEx(pszEnd,
cchRemaining,
&pszEnd,
&cchRemaining,
0,
TEXT(" /GUID:%s"),
szGuid);
}
}
if (pAHInfo->lpszAppName != NULL) {
StringCchPrintfEx(pszEnd,
cchRemaining,
&pszEnd,
&cchRemaining,
0,
TEXT(" /APPNAME:\"%s\""),
pAHInfo->lpszAppName);
}
}
if (pAHInfo->bPreserveChoice) {
StringCchPrintfEx(pszEnd,
cchRemaining,
&pszEnd,
&cchRemaining,
0,
TEXT(" /PRESERVECHOICE"));
}
if (pAHInfo->bMSI) {
StringCchPrintfEx(pszEnd,
cchRemaining,
&pszEnd,
&cchRemaining,
0,
TEXT(" /MSI"));
}
if (!CreateProcessW(NULL,
szCommandLine,
NULL,
NULL,
FALSE,
0,
NULL,
NULL,
&StartupInfo, &ProcessInfo)) {
DBGPRINT((sdlError, "SdbShowApphelpDialog",
"Failed to launch apphelp process.\n"));
goto cleanup;
}
//
// check to see if they want to monitor the process themselves
//
if (phProcess) {
bReturn = TRUE;
pRunApp = NULL; // we do this so that we don't touch the bRunApp
*phProcess = ProcessInfo.hProcess;
goto cleanup;
}
//
// otherwise, we'll do the waiting.
//
WaitForSingleObject(ProcessInfo.hProcess, INFINITE);
bReturn = GetExitCodeProcess(ProcessInfo.hProcess, &dwExit);
if (bReturn) {
bRunApp = (0 != dwExit);
}
cleanup:
if (bReturn && pRunApp != NULL) {
*pRunApp = bRunApp;
}
//
// process handle is to be closed only when phProcess is NULL
//
if (phProcess == NULL && ProcessInfo.hProcess) {
CloseHandle(ProcessInfo.hProcess);
}
if (ProcessInfo.hThread) {
CloseHandle(ProcessInfo.hThread);
}
return bReturn;
}
Reference in New Issue Copy Permalink