741 lines
16 KiB
C++
741 lines
16 KiB
C++
//
|
|
// MODULE: APGTSCFG.CPP
|
|
//
|
|
// PURPOSE: Old commment says "Reads in ini file configuration" but that's not what this does
|
|
// >>> an up-to-date description would be nice.
|
|
//
|
|
// PROJECT: Generic Troubleshooter DLL for Microsoft AnswerPoint
|
|
//
|
|
// COMPANY: Saltmine Creative, Inc. (206)-633-4743 support@saltmine.com
|
|
//
|
|
// AUTHOR: Roman Mach
|
|
//
|
|
// ORIGINAL DATE: 8-2-96
|
|
//
|
|
// NOTES:
|
|
// 1. Based on Print Troubleshooter DLL
|
|
//
|
|
// Version Date By Comments
|
|
//--------------------------------------------------------------------
|
|
// V0.1 - RM Original
|
|
// V0.2 6/4/97 RWM Local Version for Memphis
|
|
// V0.3 04/09/98 JM/OK+ Local Version for NT5
|
|
//
|
|
|
|
//#include "windows.h"
|
|
#include "stdafx.h"
|
|
#include "time.h"
|
|
|
|
#include "apgts.h"
|
|
#include "ErrorEnums.h"
|
|
#include "bnts.h"
|
|
#include "BackupInfo.h"
|
|
#include "cachegen.h"
|
|
#include "apgtsinf.h"
|
|
#include "apgtscmd.h"
|
|
#include "apgtshtx.h"
|
|
#include "apgtscls.h"
|
|
|
|
#include "TSHOOT.h"
|
|
|
|
#include <memory.h>
|
|
|
|
#include "chmread.h"
|
|
//
|
|
//
|
|
CDBLoadConfiguration::CDBLoadConfiguration()
|
|
{
|
|
m_cfg.api.pAPI = NULL;
|
|
m_cfg.api.pTemplate = NULL;
|
|
|
|
InitializeToDefaults();
|
|
|
|
return;
|
|
}
|
|
|
|
VOID CDBLoadConfiguration::ResetTemplate()
|
|
{
|
|
delete m_cfg.api.pTemplate;
|
|
m_cfg.api.pTemplate = new CHTMLInputTemplate(m_cfg.api.szFilepath[BNOFF_HTI]);
|
|
m_cfg.api.pTemplate->Initialize(m_cfg.api.szResPath, m_cfg.api.strFile[BNOFF_HTI]);
|
|
return;
|
|
}
|
|
//
|
|
//
|
|
CDBLoadConfiguration::CDBLoadConfiguration(HMODULE hModule, LPCTSTR szValue)
|
|
{
|
|
Initialize(hModule, szValue);
|
|
return;
|
|
}
|
|
//
|
|
//
|
|
void CDBLoadConfiguration::Initialize(HMODULE hModule, LPCTSTR szValue)
|
|
{
|
|
DWORD dwRErr;
|
|
TCHAR temp[MAXBUF];
|
|
|
|
_tcscpy(temp,_T(""));
|
|
|
|
// do all setting of variables in constructor!
|
|
InitializeToDefaults();
|
|
|
|
ProcessEventReg(hModule);
|
|
|
|
CreatePaths(szValue);
|
|
|
|
InitializeSingleResourceData(szValue);
|
|
|
|
dwRErr = CreateApi(temp);
|
|
if (dwRErr) {
|
|
ReportWFEvent( _T("[apgtscfg]"), //Module Name
|
|
_T("[CDBLoadConfiguration]"), //event
|
|
_T("(A)"),
|
|
temp,
|
|
dwRErr );
|
|
}
|
|
}
|
|
|
|
void CDBLoadConfiguration::SetValues(CHttpQuery &httpQ)
|
|
{
|
|
int value;
|
|
BCache *pAPI = m_cfg.api.pAPI;
|
|
if(pAPI)
|
|
if (httpQ.GetValue1(value))
|
|
pAPI->AddValue(value);
|
|
return;
|
|
}
|
|
|
|
//
|
|
//
|
|
CDBLoadConfiguration::~CDBLoadConfiguration()
|
|
{
|
|
DWORD j;
|
|
if (m_dwFilecount > 0)
|
|
DestroyApi();
|
|
|
|
if (m_cfg.pHandles != NULL) {
|
|
for (j = 0; j < m_cfg.dwHandleCnt; j++)
|
|
if (m_cfg.pHandles[j] != NULL)
|
|
CloseHandle(m_cfg.pHandles[j]);
|
|
|
|
delete [] m_cfg.pHandles;
|
|
}
|
|
}
|
|
|
|
// Call in constructor only!
|
|
//
|
|
VOID CDBLoadConfiguration::InitializeToDefaults()
|
|
{
|
|
m_dwErr = 0;
|
|
m_bncfgsz = MAXBNCFG;
|
|
|
|
_tcscpy(m_szResourcePath, DEF_FULLRESOURCE);
|
|
|
|
ClearCfg(0);
|
|
m_cfg.pHandles = NULL;
|
|
m_cfg.dwHandleCnt = 0;
|
|
|
|
_tcscpy(m_nullstr, _T(""));
|
|
|
|
m_dwFilecount = 0;
|
|
}
|
|
|
|
VOID CDBLoadConfiguration::InitializeSingleResourceData(LPCTSTR szValue)
|
|
{
|
|
LoadSingleTS(szValue);
|
|
InitializeFileTimeList(); // I don't know that this is used.
|
|
return;
|
|
}
|
|
|
|
//
|
|
//
|
|
VOID CDBLoadConfiguration::ProcessEventReg(HMODULE hModule)
|
|
{
|
|
HKEY hk;
|
|
DWORD dwDisposition, dwType, dwValue, dwSize;
|
|
TCHAR path[MAXBUF];
|
|
BOOL bFixit = FALSE;
|
|
|
|
// 1. check if have valid event info
|
|
// 2. if not, create it as appropriate
|
|
|
|
// check presence of event log info...
|
|
|
|
_stprintf(path, _T("%s\\%s"), REG_EVT_PATH, REG_EVT_ITEM_STR);
|
|
|
|
if (RegCreateKeyEx( HKEY_LOCAL_MACHINE,
|
|
path,
|
|
0,
|
|
TS_REG_CLASS,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_READ | KEY_WRITE,
|
|
NULL,
|
|
&hk,
|
|
&dwDisposition) == ERROR_SUCCESS) {
|
|
|
|
if (dwDisposition == REG_CREATED_NEW_KEY) {
|
|
// create entire registry layout for events
|
|
CreateEvtMF(hk, hModule);
|
|
CreateEvtTS(hk);
|
|
}
|
|
else {
|
|
// now make sure all registry elements present
|
|
dwSize = sizeof (path) - 1;
|
|
if (RegQueryValueEx(hk,
|
|
REG_EVT_MF,
|
|
0,
|
|
&dwType,
|
|
(LPBYTE) path,
|
|
&dwSize) != ERROR_SUCCESS) {
|
|
CreateEvtMF(hk, hModule);
|
|
}
|
|
dwSize = sizeof (DWORD);
|
|
if (RegQueryValueEx(hk,
|
|
REG_EVT_TS,
|
|
0,
|
|
&dwType,
|
|
(LPBYTE) &dwValue,
|
|
&dwSize) != ERROR_SUCCESS) {
|
|
CreateEvtTS(hk);
|
|
}
|
|
}
|
|
|
|
RegCloseKey(hk);
|
|
}
|
|
}
|
|
|
|
//
|
|
//
|
|
VOID CDBLoadConfiguration::CreateEvtMF(HKEY hk, HMODULE hModule)
|
|
{
|
|
TCHAR path[MAXBUF];
|
|
DWORD len;
|
|
|
|
if (hModule) {
|
|
if ((len = GetModuleFileName(hModule, path, MAXBUF-1))!=0) {
|
|
path[len] = _T('\0');
|
|
if (RegSetValueEx( hk,
|
|
REG_EVT_MF,
|
|
0,
|
|
REG_EXPAND_SZ,
|
|
(LPBYTE) path,
|
|
len + sizeof(TCHAR)) == ERROR_SUCCESS) {
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
//
|
|
VOID CDBLoadConfiguration::CreateEvtTS(HKEY hk)
|
|
{
|
|
DWORD dwData;
|
|
|
|
dwData = EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE |
|
|
EVENTLOG_INFORMATION_TYPE;
|
|
|
|
if (RegSetValueEx( hk,
|
|
REG_EVT_TS,
|
|
0,
|
|
REG_DWORD,
|
|
(LPBYTE) &dwData,
|
|
sizeof(DWORD)) == ERROR_SUCCESS) {
|
|
}
|
|
}
|
|
|
|
//
|
|
// This may not actually be germane for Local Troubleshooter: probably
|
|
// rather blindly carried over from Online TS.
|
|
// m_dir (which gives us a list of desired files) must already be filled in with file names
|
|
// & paths before this is called. this finishes initializing it.
|
|
VOID CDBLoadConfiguration::InitializeFileTimeList()
|
|
{
|
|
HANDLE hSearch;
|
|
DWORD j;
|
|
|
|
// get a list of files we are interested in
|
|
for (j=0;j<MAXBNFILES;j++) {
|
|
m_dir.file[j].bExist = TRUE;
|
|
m_dir.file[j].bChanged = FALSE;
|
|
|
|
// only hti is independent
|
|
if (j == BNOFF_HTI || j == BNOFF_BES)
|
|
m_dir.file[j].bIndependent = TRUE;
|
|
else
|
|
m_dir.file[j].bIndependent = FALSE;
|
|
|
|
hSearch = FindFirstFile(m_dir.file[j].szFilepath, &m_dir.file[j].FindData);
|
|
if (hSearch == INVALID_HANDLE_VALUE) {
|
|
// file not found usually
|
|
m_dir.file[j].bExist = FALSE;
|
|
}
|
|
else {
|
|
FindClose(hSearch);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
//
|
|
VOID CDBLoadConfiguration::ClearCfg(DWORD off)
|
|
{
|
|
DWORD k;
|
|
|
|
m_cfg.api.pAPI = NULL;
|
|
m_cfg.api.pTemplate = NULL;
|
|
m_cfg.api.waitcount = 0;
|
|
|
|
for (k = 0; k < MAXBNFILES; k++)
|
|
_tcscpy(m_cfg.api.szFilepath[k], _T(""));
|
|
_tcscpy(m_cfg.api.type, _T(""));
|
|
}
|
|
|
|
// Bring content of DSC/HTI files for one troubleshooter into internal memory structures
|
|
// OUTPUT *szErrInfo - info specific to error
|
|
// RETURN 0 on success
|
|
DWORD CDBLoadConfiguration::CreateApi(TCHAR *szErrInfo)
|
|
{
|
|
DWORD j;
|
|
DWORD dwRErr = 0, dwIErr = 0, dwTErr = 0;
|
|
|
|
// get api count and create new objects
|
|
m_cfg.dwApiCnt = m_dwFilecount;
|
|
|
|
// (The following comment sure looks like its carried over from Online TS and has little
|
|
// relevance to Local TS. This routine probably involves a lot of overkill JM 3/98)
|
|
// create new api and other files
|
|
// once these go live we can destroy the others
|
|
// provided there are no users using them
|
|
// copy over list file info
|
|
for (j = 0; j < MAXBNFILES; j++)
|
|
{
|
|
_tcscpy(m_cfg.api.szFilepath[j], m_dir.file[j].szFilepath);
|
|
m_cfg.api.strFile[j] = m_dir.file[j].strFile;
|
|
}
|
|
|
|
_tcscpy(m_cfg.api.szResPath, m_dir.szResPath);
|
|
_tcscpy(m_cfg.api.type, m_dir.type);
|
|
|
|
if (NULL != m_cfg.api.pAPI)
|
|
delete m_cfg.api.pAPI;
|
|
|
|
if ((m_cfg.api.pAPI = new BCache( m_cfg.api.szFilepath[BNOFF_DSC],
|
|
m_cfg.api.type,
|
|
m_szResourcePath,
|
|
m_cfg.api.strFile[BNOFF_DSC])) == NULL) {
|
|
dwRErr = EV_GTS_ERROR_INFENGINE;
|
|
}
|
|
//
|
|
dwTErr = m_cfg.api.pAPI->Initialize(/*m_cfg.pWordExcept*/);
|
|
if (dwTErr) {
|
|
dwIErr = dwTErr;
|
|
_tcscpy(szErrInfo, m_cfg.api.szFilepath[BNOFF_DSC]);
|
|
}
|
|
if (NULL != m_cfg.api.pTemplate)
|
|
delete m_cfg.api.pTemplate;
|
|
if ((m_cfg.api.pTemplate = new CHTMLInputTemplate(m_cfg.api.szFilepath[BNOFF_HTI])) == NULL) {
|
|
dwRErr = EV_GTS_ERROR_TEMPLATE_CREATE;
|
|
}
|
|
|
|
dwTErr = m_cfg.api.pTemplate->Initialize(m_cfg.api.szResPath, m_cfg.api.strFile[BNOFF_HTI]);
|
|
if (dwTErr) {
|
|
dwIErr = dwTErr;
|
|
_tcscpy(szErrInfo, m_cfg.api.szFilepath[BNOFF_HTI]);
|
|
}
|
|
|
|
if (!dwRErr)
|
|
if (dwIErr)
|
|
dwRErr = dwIErr;
|
|
|
|
return dwRErr;
|
|
}
|
|
|
|
//
|
|
//
|
|
VOID CDBLoadConfiguration::DestroyApi()
|
|
{
|
|
DWORD i;
|
|
|
|
for (i=0;i<m_cfg.dwApiCnt;i++) {
|
|
|
|
if (m_cfg.api.pAPI)
|
|
delete m_cfg.api.pAPI;
|
|
|
|
m_cfg.api.pAPI = NULL;
|
|
|
|
if (m_cfg.api.pTemplate)
|
|
delete m_cfg.api.pTemplate;
|
|
|
|
m_cfg.api.pTemplate = NULL;
|
|
|
|
}
|
|
}
|
|
|
|
//
|
|
//
|
|
BNCTL *CDBLoadConfiguration::GetAPI()
|
|
{
|
|
return &m_cfg;
|
|
}
|
|
|
|
//
|
|
//
|
|
BOOL CDBLoadConfiguration::FindAPIFromValue(BNCTL *currcfg,
|
|
LPCTSTR type,
|
|
CHTMLInputTemplate **pIT,
|
|
/*CSearchForm **pBES,*/
|
|
BCache **pAPI,
|
|
DWORD *dwOff)
|
|
{
|
|
*pIT = currcfg->api.pTemplate;
|
|
*pAPI = currcfg->api.pAPI;
|
|
*dwOff = 0;
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
//
|
|
TCHAR *CDBLoadConfiguration::GetHtmFilePath(BNCTL *currcfg, DWORD i)
|
|
{
|
|
if (i >= currcfg->dwApiCnt)
|
|
return m_nullstr;
|
|
|
|
return currcfg->api.szFilepath[BNOFF_HTM];
|
|
}
|
|
|
|
//
|
|
//
|
|
TCHAR *CDBLoadConfiguration::GetBinFilePath(BNCTL *currcfg, DWORD i)
|
|
{
|
|
if (i >= currcfg->dwApiCnt)
|
|
return m_nullstr;
|
|
|
|
return currcfg->api.szFilepath[BNOFF_DSC];
|
|
}
|
|
|
|
//
|
|
//
|
|
TCHAR *CDBLoadConfiguration::GetHtiFilePath(BNCTL *currcfg, DWORD i)
|
|
{
|
|
if (i >= currcfg->dwApiCnt)
|
|
return m_nullstr;
|
|
|
|
return currcfg->api.szFilepath[BNOFF_HTI];
|
|
|
|
}
|
|
|
|
//
|
|
//
|
|
// RETURNS symbolic name of troubleshooter
|
|
TCHAR *CDBLoadConfiguration::GetTagStr(BNCTL *currcfg, DWORD i)
|
|
{
|
|
if (i >= currcfg->dwApiCnt)
|
|
return m_nullstr;
|
|
|
|
return currcfg->api.type;
|
|
}
|
|
|
|
//
|
|
//
|
|
// RETURNS number of [instances of] troubleshooters. Probably a dubious inheritance from
|
|
// Online TS: Local TS should have only one troubleshooting belief network.
|
|
DWORD CDBLoadConfiguration::GetFileCount(BNCTL *currcfg)
|
|
{
|
|
return currcfg->dwApiCnt;
|
|
}
|
|
|
|
// Look in the registry for whether we are using DSC files or DSZ files.
|
|
void CDBLoadConfiguration::GetDSCExtension(CString &strDSCExtension, LPCTSTR szValue)
|
|
{
|
|
HKEY hKey;
|
|
CString strSubKey = TSREGKEY_TL;
|
|
strSubKey += _T("\\");
|
|
strSubKey += szValue;
|
|
if (ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
strSubKey,
|
|
NULL,
|
|
KEY_READ,
|
|
&hKey))
|
|
{
|
|
strDSCExtension = DSC_DEFAULT; // Default to DSZ
|
|
return;
|
|
}
|
|
DWORD dwSize;
|
|
DWORD dwType = REG_SZ;
|
|
long lRes = RegQueryValueEx(hKey,
|
|
TSLCL_FMAINEXT,
|
|
NULL,
|
|
&dwType,
|
|
(BYTE *) strDSCExtension.GetBufferSetLength(10),
|
|
&dwSize);
|
|
strDSCExtension.ReleaseBuffer();
|
|
if (ERROR_MORE_DATA == lRes)
|
|
{
|
|
lRes = RegQueryValueEx(hKey,
|
|
TSLCL_FMAINEXT,
|
|
NULL,
|
|
&dwType,
|
|
(BYTE *) strDSCExtension.GetBufferSetLength(dwSize + 2),
|
|
&dwSize);
|
|
strDSCExtension.ReleaseBuffer();
|
|
if (ERROR_SUCCESS != lRes ||
|
|
strDSCExtension.GetLength() < 1)
|
|
{
|
|
RegCloseKey(hKey);
|
|
strDSCExtension = DSC_DEFAULT;
|
|
return;
|
|
}
|
|
}
|
|
else // ERROR_SUCCESS is true or false
|
|
if (ERROR_SUCCESS != lRes || strDSCExtension.GetLength() < 1)
|
|
{
|
|
RegCloseKey(hKey);
|
|
strDSCExtension = DSC_DEFAULT;
|
|
return;
|
|
}
|
|
RegCloseKey(hKey);
|
|
if (_T('.') != strDSCExtension.GetAt(0))
|
|
strDSCExtension = _T('.') + strDSCExtension;
|
|
return;
|
|
}
|
|
|
|
//
|
|
// LoadSingleTS replaces ProcessLstFile when apgts is used in an
|
|
// ActiveX or OLE control.
|
|
VOID CDBLoadConfiguration::LoadSingleTS(LPCTSTR szValue)
|
|
{
|
|
CString strRefedDSCExtension = _T("");
|
|
ASSERT(1 == MAXBNCFG);
|
|
if (m_dwFilecount >= m_bncfgsz) {
|
|
// need to reallocate space
|
|
DWORD newdirsz = (m_bncfgsz + MAXBNCFG) * sizeof (BNDIRCFG);
|
|
DWORD newcfgsz = (m_bncfgsz + MAXBNCFG) * sizeof (BNAPICFG);
|
|
|
|
ASSERT(0 == m_bncfgsz);
|
|
ClearCfg(m_bncfgsz);
|
|
|
|
m_bncfgsz += MAXBNCFG;
|
|
}
|
|
|
|
GetDSCExtension(strRefedDSCExtension, szValue);
|
|
|
|
// No matter if we are using CHM or not -
|
|
// this path will be "..\..\network.htm".
|
|
// We are not using it directly ANYWAY
|
|
_stprintf(m_dir.file[BNOFF_HTM].szFilepath, _T("%s%s.htm"), m_szResourcePath,szValue);
|
|
|
|
if (IsUsingCHM())
|
|
{
|
|
m_dir.file[BNOFF_DSC].strFile = CString(szValue) + strRefedDSCExtension;
|
|
_stprintf(m_dir.file[BNOFF_DSC].szFilepath, _T("%s%s"), m_szResourcePath,(LPCTSTR)m_strCHM);
|
|
}
|
|
else
|
|
{
|
|
_stprintf(m_dir.file[BNOFF_DSC].szFilepath, _T("%s%s"), m_szResourcePath,szValue);
|
|
_tcscat(m_dir.file[BNOFF_DSC].szFilepath, (LPCTSTR) strRefedDSCExtension);
|
|
}
|
|
|
|
if (IsUsingCHM())
|
|
{
|
|
m_dir.file[BNOFF_HTI].strFile = CString(szValue) + HTI_DEFAULT;
|
|
_stprintf(m_dir.file[BNOFF_HTI].szFilepath, _T("%s%s"), m_szResourcePath,(LPCTSTR)m_strCHM);
|
|
}
|
|
else
|
|
{
|
|
_stprintf(m_dir.file[BNOFF_HTI].szFilepath, _T("%s%s.hti"), m_szResourcePath,szValue);
|
|
}
|
|
|
|
_stprintf(m_dir.file[BNOFF_BES].szFilepath, _T("%s%s.bes"), m_szResourcePath,szValue);
|
|
|
|
_tcscpy(m_dir.szResPath, m_szResourcePath);
|
|
|
|
_tcscpy(m_dir.type, szValue);
|
|
m_dwFilecount++;
|
|
ASSERT(1 == m_dwFilecount);
|
|
return;
|
|
}
|
|
|
|
|
|
//
|
|
//
|
|
BOOL CDBLoadConfiguration::CreatePaths(LPCTSTR szNetwork)
|
|
{
|
|
int len;
|
|
BOOL bDirChanged;
|
|
|
|
// if reg entry not present, we need to add it
|
|
bDirChanged = GetResourceDirFromReg(szNetwork);
|
|
|
|
// a this point we are guaranteed to have len > 0 for each below
|
|
|
|
// do our own validation (add backshash if not present)
|
|
len = _tcslen(m_szResourcePath);
|
|
if (len) {
|
|
if (m_szResourcePath[len - 1] == _T('/'))
|
|
m_szResourcePath[len - 1] = _T('\\');
|
|
else if (m_szResourcePath[len-1] != _T('\\')) {
|
|
m_szResourcePath[len] = _T('\\');
|
|
m_szResourcePath[len+1] = _T('\0');
|
|
}
|
|
}
|
|
|
|
return bDirChanged;
|
|
}
|
|
|
|
//
|
|
//
|
|
TCHAR *CDBLoadConfiguration::GetFullResource()
|
|
{
|
|
return (m_szResourcePath);
|
|
}
|
|
|
|
//
|
|
//
|
|
VOID CDBLoadConfiguration::GetVrootPath(TCHAR *tobuf)
|
|
{
|
|
_tcscpy(tobuf, _T(""));
|
|
}
|
|
|
|
// Find (or if it doesn't exist, create) a registry key giving path to resource directory.
|
|
// if returns true, then directory is new or changed
|
|
// if returns false, directory entry is same as before
|
|
// Yet another case of something which maybe overkill, left over from Online TS.
|
|
BOOL CDBLoadConfiguration::GetResourceDirFromReg(LPCTSTR szNetwork)
|
|
{
|
|
HKEY hknew;
|
|
DWORD dwType, dwSize, dwDisposition, len;
|
|
TCHAR buf1[MAXBUF], buf2[MAXBUF];
|
|
BOOL bDirChanged = TRUE;
|
|
LONG lErr;
|
|
CString tmp;
|
|
|
|
// search for "Path" value in SOFTWARE\Microsoft\TShoot\TroubleshooterList\Network
|
|
if (::GetNetworkRelatedResourceDirFromReg(szNetwork, &tmp))
|
|
{
|
|
if (::IsNetworkRelatedResourceDirCHM(tmp))
|
|
{
|
|
m_strCHM = ::ExtractCHM(tmp);
|
|
_tcscpy(m_szResourcePath, ::ExtractResourceDir(tmp));
|
|
}
|
|
else
|
|
{
|
|
_tcscpy(m_szResourcePath, tmp);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// create key if not present
|
|
if (RegCreateKeyEx( HKEY_LOCAL_MACHINE,
|
|
TSREGKEY_MAIN,
|
|
0,
|
|
TS_REG_CLASS,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_READ | KEY_WRITE,
|
|
NULL,
|
|
&hknew,
|
|
&dwDisposition) == ERROR_SUCCESS)
|
|
{
|
|
if (dwDisposition == REG_OPENED_EXISTING_KEY)
|
|
{
|
|
// Get the current key value.
|
|
dwSize = MAXBUF - 1;
|
|
dwType = REG_SZ;
|
|
if ((lErr = RegQueryValueEx(hknew,
|
|
FULLRESOURCE_STR,
|
|
0,
|
|
&dwType,
|
|
(LPBYTE) buf1,
|
|
&dwSize)) == ERROR_SUCCESS)
|
|
{
|
|
if (dwType == REG_EXPAND_SZ || dwType == REG_SZ)
|
|
{
|
|
if (ExpandEnvironmentStrings(buf1, buf2, MAXBUF-1))
|
|
{
|
|
len = _tcslen(buf2);
|
|
if (len)
|
|
{
|
|
if (buf2[len-1] != _T('\\'))
|
|
{
|
|
buf2[len] = _T('\\');
|
|
buf2[len+1] = _T('\0');
|
|
}
|
|
}
|
|
|
|
if (!_tcscmp(m_szResourcePath, buf2))
|
|
bDirChanged = FALSE;
|
|
else
|
|
_tcscpy(m_szResourcePath, buf2);
|
|
}
|
|
else
|
|
{
|
|
ReportWFEvent( _T("[apgtscfg]"), //Module Name
|
|
_T("[GetResourceDirFromReg]"), //event
|
|
_T(""),
|
|
_T(""),
|
|
EV_GTS_ERROR_CANT_GET_RES_PATH );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ReportWFEvent( _T("[apgtscfg]"), //Module Name
|
|
_T("[GetResourceDirFromReg]"), //event
|
|
_T(""),
|
|
_T(""),
|
|
EV_GTS_ERROR_CANT_GET_RES_PATH );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_stprintf(buf1, _T("%ld"),lErr);
|
|
ReportWFEvent( _T("[apgtscfg]"), //Module Name
|
|
_T("[GetResourceDirFromReg]"), //event
|
|
buf1,
|
|
_T(""),
|
|
EV_GTS_ERROR_CANT_OPEN_SFT_3 );
|
|
}
|
|
}
|
|
else
|
|
{ // Created new key. Don't have any resources.
|
|
_stprintf(buf1, _T("%ld"),ERROR_REGISTRY_IO_FAILED);
|
|
ReportWFEvent( _T("[apgtscfg]"), //Module Name
|
|
_T("[GetResourceDirFromReg]"), //event
|
|
buf1,
|
|
_T(""),
|
|
EV_GTS_ERROR_CANT_GET_RES_PATH);
|
|
}
|
|
RegCloseKey(hknew);
|
|
}
|
|
else
|
|
{
|
|
ReportWFEvent( _T("[apgtscfg]"), //Module Name
|
|
_T("[GetResourceDirFromReg]"), //event
|
|
_T(""),
|
|
_T(""),
|
|
EV_GTS_ERROR_CANT_OPEN_SFT_2 );
|
|
}
|
|
}
|
|
return bDirChanged;
|
|
}
|
|
|
|
//
|
|
//
|
|
VOID CDBLoadConfiguration::BackslashIt(TCHAR *str)
|
|
{
|
|
while (*str) {
|
|
if (*str==_T('/'))
|
|
*str=_T('\\');
|
|
str = _tcsinc(str);
|
|
}
|
|
}
|
|
|
|
VOID CDBLoadConfiguration::ResetNodes()
|
|
{
|
|
m_cfg.api.pAPI->ResetNodes();
|
|
return;
|
|
}
|
|
|
|
bool CDBLoadConfiguration::IsUsingCHM()
|
|
{
|
|
return 0 != m_strCHM.GetLength();
|
|
}
|