void CfgTest::CheckCfgAndRegValueDeleted(CFGDB_HANDLE cdhDb, HKEY hk, LPCWSTR wzCfgName, LPCWSTR wzName)
{
HRESULT hr = S_OK;
LPWSTR sczValue = NULL;
hr = RegReadString(hk, wzName, &sczValue);
if (E_FILENOTFOUND == hr || HRESULT_FROM_WIN32(ERROR_KEY_DELETED) == hr)
{
hr = S_OK;
}
else if (S_OK == hr)
{
hr = E_FAIL;
}
ExitOnFailure1(hr, "Registry string should not exist:%ls", wzName);
hr = CfgGetString(cdhDb, wzCfgName, &sczValue);
if (E_NOTFOUND == hr)
{
hr = S_OK;
}
else if (S_OK == hr)
{
hr = E_FAIL;
}
ExitOnFailure1(hr, "Cfg db value should not exist:%ls", wzName);
LExit:
ReleaseStr(sczValue);
}
// 注意: 没有使用CRT.
bool SpawnDebuggerOnProcess(unsigned process_id)
{
wchar_t reg_value[1026];
int len = arraysize(reg_value);
if(RegReadString(HKEY_LOCAL_MACHINE,
L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\AeDebug",
L"Debugger", reg_value, &len))
{
wchar_t command_line[1026];
if(StringReplace(reg_value, process_id, command_line,
arraysize(command_line)))
{
// 调试器存在也没关系, 只是附加到该进程会失败.
STARTUPINFO startup_info = { 0 };
startup_info.cb = sizeof(startup_info);
PROCESS_INFORMATION process_info = { 0 };
if(CreateProcess(NULL, command_line, NULL, NULL, FALSE, 0, NULL, NULL,
&startup_info, &process_info))
{
CloseHandle(process_info.hThread);
WaitForInputIdle(process_info.hProcess, 10000);
CloseHandle(process_info.hProcess);
return true;
}
}
}
return false;
}
void CfgTest::CheckCfgAndRegValueString(CFGDB_HANDLE cdhDb, HKEY hk, LPCWSTR wzCfgName, LPCWSTR wzName, LPCWSTR wzExpectedValue)
{
HRESULT hr = S_OK;
LPWSTR sczValue = NULL;
hr = RegReadString(hk, wzName, &sczValue);
ExitOnFailure1(hr, "Failed to read registry string:%ls", wzName);
if (0 != lstrcmpW(sczValue, wzExpectedValue))
{
hr = E_FAIL;
ExitOnFailure2(hr, "Wrong value in registry! Expected value '%ls', found value '%ls'", wzExpectedValue, sczValue);
}
hr = CfgGetString(cdhDb, wzCfgName, &sczValue);
ExitOnFailure1(hr, "Failed to read cfg db string:%ls", wzCfgName);
if (0 != lstrcmpW(sczValue, wzExpectedValue))
{
hr = E_FAIL;
ExitOnFailure2(hr, "Wrong value in cfg db! Expected value '%ls', found value '%ls'", wzExpectedValue, sczValue);
}
LExit:
ReleaseStr(sczValue);
}
static HRESULT RegDefaultReadValueString(
__in CFGDB_STRUCT *pcdb,
__in HKEY hkKey,
__in_z LPCWSTR wzValueName,
__in_z LPCWSTR wzCfgValueName
)
{
HRESULT hr = S_OK;
LPWSTR sczStringValue = NULL;
CONFIG_VALUE cvNewValue = { };
hr = RegReadString(hkKey, wzValueName, &sczStringValue);
ExitOnFailure(hr, "Failed to read string value from registry: %ls", wzValueName);
hr = ValueSetString(sczStringValue, FALSE, NULL, pcdb->sczGuid, &cvNewValue);
ExitOnFailure(hr, "Failed to set string value %ls in memory", wzCfgValueName);
hr = ValueWrite(pcdb, pcdb->dwAppID, wzCfgValueName, &cvNewValue, TRUE, NULL);
ExitOnFailure(hr, "Failed to set value in db: %ls", wzCfgValueName);
LExit:
ReleaseStr(sczStringValue);
ReleaseCfgValue(cvNewValue);
return hr;
}
static void CheckLoggingPolicy(
__out DWORD *pdwAttributes
)
{
HRESULT hr = S_OK;
HKEY hk = NULL;
LPWSTR sczLoggingPolicy = NULL;
hr = RegOpen(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Policies\\Microsoft\\Windows\\Installer", KEY_READ, &hk);
if (SUCCEEDED(hr))
{
hr = RegReadString(hk, L"Logging", &sczLoggingPolicy);
if (SUCCEEDED(hr))
{
LPCWSTR wz = sczLoggingPolicy;
while (*wz)
{
if (L'v' == *wz || L'V' == *wz)
{
*pdwAttributes |= BURN_LOGGING_ATTRIBUTE_VERBOSE;
}
else if (L'x' == *wz || L'X' == *wz)
{
*pdwAttributes |= BURN_LOGGING_ATTRIBUTE_EXTRADEBUG;
}
++wz;
}
}
}
ReleaseStr(sczLoggingPolicy);
ReleaseRegKey(hk);
}
bool LoadStringList(const char *section, ccollect< carray<char> > &list)
{
char name[64];
list.clear();
for (int i=1; ; i++)
{
snprintf(name, sizeof(name), "v%i", i);
carray<char> s = RegReadString(section, name, "");
if (!s.ptr() || !s[0]) break;
list.append(s);
}
return true;
}
static void
windowsOSVersionString(char stringbuf[], size_t stringbuflen)
{
/* copy OS version to string buffer in 'uname -a' format */
static const char wcv[] = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion";
char windowsVersion[256] = "?";
DWORD windowsVersionSz = sizeof(windowsVersion);
char build[256] = "?";
DWORD buildSz = sizeof(256);
DWORD dwMajorVersion;
DWORD dwMinorVersion;
char hostname[256] = "?";
char identifier[256] = "?";
DWORD identifierSz = sizeof(identifier);
dwMajorVersion = RegReadDword(HKEY_LOCAL_MACHINE, wcv,
"CurrentMajorVersionNumber");
dwMinorVersion = RegReadDword(HKEY_LOCAL_MACHINE, wcv,
"CurrentMinorVersionNumber");
if (!RegReadString(HKEY_LOCAL_MACHINE, wcv, "CurrentBuildNumber",
build, &buildSz))
RegReadString(HKEY_LOCAL_MACHINE, wcv, "CurrentBuild",
build, &buildSz);
gethostname(hostname, sizeof(hostname));
RegReadString(HKEY_LOCAL_MACHINE, wcv, "ProductName", windowsVersion,
&windowsVersionSz);
RegReadString(HKEY_LOCAL_MACHINE,
"HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0",
"Identifier", identifier, &identifierSz);
/* Output is made to look like results from uname -a */
snprintf(stringbuf, stringbuflen, "Windows %s %d.%d.%s %s %s",
hostname, (int)dwMajorVersion, (int)dwMinorVersion, build,
windowsVersion, identifier);
}
HKEY FindAdapterKey( PDHCP_ADAPTER Adapter ) {
int i = 0;
PCHAR EnumKeyName =
"SYSTEM\\CurrentControlSet\\Control\\Class\\"
"{4D36E972-E325-11CE-BFC1-08002BE10318}";
PCHAR TargetKeyNameStart =
"SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces\\";
PCHAR TargetKeyName = NULL;
PCHAR *EnumKeysLinkage = GetSubkeyNames( EnumKeyName, "\\Linkage" );
PCHAR *EnumKeysTop = GetSubkeyNames( EnumKeyName, "" );
PCHAR RootDevice = NULL;
HKEY EnumKey, OutKey = NULL;
DWORD Error = ERROR_SUCCESS;
if( !EnumKeysLinkage || !EnumKeysTop ) goto cleanup;
Error = RegOpenKey( HKEY_LOCAL_MACHINE, EnumKeyName, &EnumKey );
if( Error ) goto cleanup;
for( i = 0; EnumKeysLinkage[i]; i++ ) {
RootDevice = RegReadString
( EnumKey, EnumKeysLinkage[i], "RootDevice" );
if( RootDevice &&
!strcmp( RootDevice, Adapter->DhclientInfo.name ) ) {
TargetKeyName =
(CHAR*) malloc( strlen( TargetKeyNameStart ) +
strlen( RootDevice ) + 1);
if( !TargetKeyName ) goto cleanup;
sprintf( TargetKeyName, "%s%s",
TargetKeyNameStart, RootDevice );
Error = RegCreateKeyExA( HKEY_LOCAL_MACHINE, TargetKeyName, 0, NULL, 0, KEY_READ, NULL, &OutKey, NULL );
break;
} else {
free( RootDevice ); RootDevice = 0;
}
}
cleanup:
if( RootDevice ) free( RootDevice );
if( EnumKeysLinkage ) free( EnumKeysLinkage );
if( EnumKeysTop ) free( EnumKeysTop );
if( TargetKeyName ) free( TargetKeyName );
return OutKey;
}
void WcmConfig::Load()
{
#ifdef _WIN32
for (int i = 0; i<mapList.count(); i++)
{
Node &node = mapList[i];
if (node.type == MT_BOOL && node.ptr.pBool != 0)
*node.ptr.pBool = RegReadInt(node.section, node.name, node.def.defBool)!=0;
else
if (node.type == MT_INT && node.ptr.pInt != 0)
*node.ptr.pInt = RegReadInt(node.section, node.name, node.def.defInt);
else
if (node.type == MT_STR && node.ptr.pStr != 0)
*node.ptr.pStr = RegReadString(node.section, node.name, node.def.defStr);
}
#else
IniHash hash;
FSPath path = configDirPath;
path.Push(CS_UTF8, "config");
hash.Load(DEFAULT_CONFIG_PATH);
hash.Load((sys_char_t*)path.GetString(sys_charset_id));
for (int i = 0; i<mapList.count(); i++)
{
Node &node = mapList[i];
if (node.type == MT_BOOL && node.ptr.pBool != 0)
*node.ptr.pBool = hash.GetBoolValue(node.section, node.name, node.def.defBool);
else
if (node.type == MT_INT && node.ptr.pInt != 0)
*node.ptr.pInt = hash.GetIntValue(node.section, node.name, node.def.defInt);
else
if (node.type == MT_STR && node.ptr.pStr != 0)
{
const char *s = hash.GetStrValue(node.section, node.name, node.def.defStr);
if (s) *node.ptr.pStr = new_char_str(s);
else (*node.ptr.pStr) = 0;
}
}
#endif
if (editTabSize<=0 || editTabSize >64) editTabSize = 8;
}
void RestoreCompressor()
{
HKEY hKey;
NCOMPRESSOR v = COMPRESSOR_SCRIPT;
if (OpenRegSettingsKey(hKey)) {
TCHAR compressor_name[32];
if (RegReadString(hKey, REGCOMPRESSOR, compressor_name, sizeof(compressor_name))==ERROR_SUCCESS) {
for(UINT i= (UINT)COMPRESSOR_SCRIPT; i <= (UINT)COMPRESSOR_BEST; i++) {
if(!lstrcmpi(compressor_names[i], compressor_name)) {
v = (NCOMPRESSOR)i;
break;
}
}
}
RegCloseKey(hKey);
}
g_sdata.default_compressor = v;
}
extern "C" HRESULT DAPI PolcReadString(
__in_z LPCWSTR wzPolicyPath,
__in_z LPCWSTR wzPolicyName,
__in_z_opt LPCWSTR wzDefault,
__deref_out_z LPWSTR* pscz
)
{
HRESULT hr = S_OK;
HKEY hk = NULL;
hr = OpenPolicyKey(wzPolicyPath, &hk);
if (E_FILENOTFOUND == hr || E_PATHNOTFOUND == hr)
{
ExitFunction1(hr = S_FALSE);
}
ExitOnFailure1(hr, "Failed to open policy key: %ls", wzPolicyPath);
hr = RegReadString(hk, wzPolicyName, pscz);
if (E_FILENOTFOUND == hr || E_PATHNOTFOUND == hr)
{
ExitFunction1(hr = S_FALSE);
}
ExitOnFailure2(hr, "Failed to open policy key: %ls, name: %ls", wzPolicyPath, wzPolicyName);
LExit:
ReleaseRegKey(hk);
if (S_FALSE == hr || FAILED(hr))
{
if (NULL == wzDefault)
{
ReleaseNullStr(*pscz);
}
else
{
hr = StrAllocString(pscz, wzDefault, 0);
}
}
return hr;
}
void RestoreMRUList()
{
HKEY hCfgKey, hMRUKey;
UINT n = 0, i;
if (OpenRegSettingsKey(hCfgKey)) {
if (RegOpenKeyForReading(hCfgKey, REGMRUSUBKEY, &hMRUKey) == ERROR_SUCCESS) {
for(int i=0; i<MRU_LIST_SIZE; i++) {
TCHAR bufName[8];
wsprintf(bufName, _T("%d"), i);
DWORD ec = RegReadString(hMRUKey, bufName, g_mru_list[n], sizeof(g_mru_list[n]));
if(!ec && g_mru_list[n][0] != _T('\0')) {
n++;
}
}
RegCloseKey(hMRUKey);
}
RegCloseKey(hCfgKey);
}
for(i = n; i < MRU_LIST_SIZE; i++) {
g_mru_list[i][0] = _T('\0');
}
BuildMRUMenus();
}
bool LoadViewerSettings (const char *filename, StudioModel *pModel )
{
LONG lResult; // Registry function result code
DWORD dwDisposition; // Type of key opening event
HKEY hModelKey;
if (filename == NULL || pModel == NULL)
return false;
lResult = RegViewerSettingsKey( filename, &hModelKey, &dwDisposition);
if (lResult != ERROR_SUCCESS) // Failure
return false;
// First time, just set to Valve default
if (dwDisposition == REG_CREATED_NEW_KEY)
{
return false;
}
RegReadQAngle( hModelKey, "Rot", pModel->m_angles );
RegReadVector( hModelKey, "Trans", pModel->m_origin );
RegReadColor( hModelKey, "bgColor", g_viewerSettings.bgColor );
RegReadColor( hModelKey, "gColor", g_viewerSettings.gColor );
RegReadColor( hModelKey, "lColor", g_viewerSettings.lColor );
RegReadColor( hModelKey, "aColor", g_viewerSettings.aColor );
RegReadQAngle( hModelKey, "lightrot", g_viewerSettings.lightrot );
int iTemp;
float flTemp;
char szTemp[256];
RegReadString( hModelKey, "sequence", szTemp, sizeof( szTemp ) );
iTemp = pModel->LookupSequence( szTemp );
pModel->SetSequence( iTemp );
RegReadString( hModelKey, "overlaySequence0", szTemp, sizeof( szTemp ) );
iTemp = pModel->LookupSequence( szTemp );
RegReadFloat( hModelKey, "overlayWeight0", &flTemp );
pModel->SetOverlaySequence( 0, iTemp, flTemp );
RegReadString( hModelKey, "overlaySequence1", szTemp, sizeof( szTemp ) );
iTemp = pModel->LookupSequence( szTemp );
RegReadFloat( hModelKey, "overlayWeight1", &flTemp );
pModel->SetOverlaySequence( 1, iTemp, flTemp );
RegReadString( hModelKey, "overlaySequence2", szTemp, sizeof( szTemp ) );
iTemp = pModel->LookupSequence( szTemp );
RegReadFloat( hModelKey, "overlayWeight2", &flTemp );
pModel->SetOverlaySequence( 2, iTemp, flTemp );
RegReadString( hModelKey, "overlaySequence3", szTemp, sizeof( szTemp ) );
iTemp = pModel->LookupSequence( szTemp );
RegReadFloat( hModelKey, "overlayWeight3",&flTemp );
pModel->SetOverlaySequence( 3, iTemp, flTemp );
RegReadInt( hModelKey, "renderwidth", &g_viewerSettings.width );
RegReadInt( hModelKey, "renderheight", &g_viewerSettings.height );
RegReadFloat( hModelKey, "speedscale", &g_viewerSettings.speedScale );
if (g_viewerSettings.speedScale > 1.0)
g_viewerSettings.speedScale = 1.0;
g_viewerSettings.width = MAX( 200, g_viewerSettings.width );
g_viewerSettings.height = MAX( 150, g_viewerSettings.height );
RegReadInt( hModelKey, "viewermode", &g_viewerSettings.application_mode );
RegReadInt( hModelKey, "thumbnailsize", &g_viewerSettings.thumbnailsize );
RegReadInt( hModelKey, "thumbnailsizeanim", &g_viewerSettings.thumbnailsizeanim );
if ( g_viewerSettings.thumbnailsize == 0 )
{
g_viewerSettings.thumbnailsize = 128;
}
if ( g_viewerSettings.thumbnailsizeanim == 0 )
{
g_viewerSettings.thumbnailsizeanim = 128;
}
RegReadInt( hModelKey, "speechapiindex", &g_viewerSettings.speechapiindex );
RegReadInt( hModelKey, "cclanguageid", &g_viewerSettings.cclanguageid );
RegReadBool( hModelKey, "showground", &g_viewerSettings.showGround );
RegReadBool( hModelKey, "showbackground", &g_viewerSettings.showBackground );
RegReadBool( hModelKey, "showshadow", &g_viewerSettings.showShadow );
RegReadBool( hModelKey, "showillumpos", &g_viewerSettings.showIllumPosition );
RegReadBool( hModelKey, "enablenormalmapping", &g_viewerSettings.enableNormalMapping );
RegReadString( hModelKey, "merge0", g_viewerSettings.mergeModelFile[0], sizeof( g_viewerSettings.mergeModelFile[0] ) );
RegReadString( hModelKey, "merge1", g_viewerSettings.mergeModelFile[1], sizeof( g_viewerSettings.mergeModelFile[1] ) );
RegReadString( hModelKey, "merge2", g_viewerSettings.mergeModelFile[2], sizeof( g_viewerSettings.mergeModelFile[2] ) );
RegReadString( hModelKey, "merge3", g_viewerSettings.mergeModelFile[3], sizeof( g_viewerSettings.mergeModelFile[3] ) );
return true;
}
