|
|
/*++
Copyright (c) 1996 Microsoft Corporation
Module Name:
regvalue.cpp
Abstract:
Routines to read/write/configure registry value settings
The following modules have links to registry values scejet.c <SceJetAddSection> inftojet.c <SceConvertpInfKeyValue> pfget.c <ScepGetRegistryValues> config.c <ScepConfigureRegistryValues> analyze.c <ScepAnalyzeRegistryValues>
Author:
Jin Huang (jinhuang) 07-Jan-1998
Revision History:
--*/
#include "headers.h"
#include "serverp.h"
#include "regvalue.h"
#include "pfp.h"
DWORDScepUnescapeAndAddCRLF( IN PWSTR pszSource, IN OUT PWSTR pszDest );
DWORDScepEscapeAndRemoveCRLF( IN const PWSTR pszSource, IN const DWORD dwSourceSize, IN OUT PWSTR pszDest );
SCESTATUSScepSaveRegistryValueToBuffer( IN DWORD RegType, IN PWSTR Value, IN DWORD dwBytes, IN OUT PSCE_REGISTRY_VALUE_INFO pRegValues );
SCESTATUSScepEnumAllRegValues( IN OUT PDWORD pCount, IN OUT PSCE_REGISTRY_VALUE_INFO *paRegValues );
DWORDScepAnalyzeOneRegistryValueNoValidate( IN HKEY hKey, IN PWSTR ValueName, IN PSCESECTION hSection OPTIONAL, IN DWORD dwAnalFlag, IN OUT PSCE_REGISTRY_VALUE_INFO pOneRegValue );
extern "C" {VOIDpSetupGetRealSystemTime( OUT LPSYSTEMTIME RealSystemTime );}
SCESTATUSScepGetRegistryValues( IN PSCECONTEXT hProfile, IN SCETYPE ProfileType, OUT PSCE_REGISTRY_VALUE_INFO * ppRegValues, OUT LPDWORD pValueCount, OUT PSCE_ERROR_LOG_INFO *Errlog OPTIONAL )/*++
Routine Description:
This routine retrieves registry values to secure from the Jet database and stores in the output buffer ppRegValues
Arguments:
hProfile - The profile handle context
ppRegValues - the output array of registry values.
pValueCount - the buffer to hold number of elements in the array
Errlog - A buffer to hold all error codes/text encountered when parsing the INF file. If Errlog is NULL, no further error information is returned except the return DWORD
Return value:
SCESTATUS - SCESTATUS_SUCCESS SCESTATUS_NOT_ENOUGH_RESOURCE SCESTATUS_INVALID_PARAMETER SCESTATUS_BAD_FORMAT SCESTATUS_INVALID_DATA
--*/
{ if ( !hProfile || !ppRegValues || !pValueCount ) { return(SCESTATUS_INVALID_PARAMETER); }
SCESTATUS rc; PSCESECTION hSection=NULL;
LPTSTR KeyName=NULL; DWORD KeyLen;
DWORD i,j; LPTSTR ValueStr=NULL; LPTSTR Value=NULL; DWORD ValueLen; LONG dType; DWORD Status; DWORD dCount;
rc = ScepOpenSectionForName( hProfile, (ProfileType==SCE_ENGINE_GPO) ? SCE_ENGINE_SCP : ProfileType, szRegistryValues, &hSection ); if ( SCESTATUS_SUCCESS != rc ) { ScepBuildErrorLogInfo( ERROR_INVALID_DATA, Errlog, SCEERR_OPEN, szRegistryValues ); return(rc); } //
// get total number of values in this section
//
*ppRegValues = NULL;
rc = SceJetGetLineCount( hSection, NULL, FALSE, pValueCount ); if ( SCESTATUS_SUCCESS == rc && *pValueCount > 0 ) {
//
// allocate memory for all objects
//
*ppRegValues = (PSCE_REGISTRY_VALUE_INFO)ScepAlloc( LMEM_ZEROINIT, *pValueCount*sizeof(SCE_REGISTRY_VALUE_INFO) ); if ( *ppRegValues ) {
//
// goto the first line of this section
//
rc = SceJetGetValue( hSection, SCEJET_PREFIX_MATCH, NULL, NULL, 0, &KeyLen, NULL, 0, &ValueLen ); i=0;
JET_COLUMNID ColGpoID = 0; JET_ERR JetErr; LONG GpoID=0; DWORD Actual;
if ( ProfileType == SCE_ENGINE_GPO ) { JET_COLUMNDEF ColumnGpoIDDef;
JetErr = JetGetTableColumnInfo( hSection->JetSessionID, hSection->JetTableID, "GpoID", (VOID *)&ColumnGpoIDDef, sizeof(JET_COLUMNDEF), JET_ColInfo ); if ( JET_errSuccess == JetErr ) { ColGpoID = ColumnGpoIDDef.columnid; } } //
// this count is for SCE_ENGINE_GPO type
//
dCount=0;
while ( rc == SCESTATUS_SUCCESS || rc == SCESTATUS_BUFFER_TOO_SMALL ) { //
// Get string key and a int value.
//
if ( i >= *pValueCount ) { //
// more lines than allocated
//
rc = SCESTATUS_INVALID_DATA; ScepBuildErrorLogInfo(ERROR_INVALID_DATA, Errlog, SCEERR_MORE_OBJECTS, *pValueCount ); break; }
GpoID = 1; if ( ProfileType == SCE_ENGINE_GPO ) {
GpoID = 0;
if ( ColGpoID > 0 ) {
//
// query if the setting comes from a GPO
// get GPO ID field from the current line
//
JetErr = JetRetrieveColumn( hSection->JetSessionID, hSection->JetTableID, ColGpoID, (void *)&GpoID, 4, &Actual, 0, NULL );
} }
if ( GpoID <= 0 ) { //
// read next line
//
rc = SceJetGetValue( hSection, SCEJET_NEXT_LINE, NULL, NULL, 0, &KeyLen, NULL, 0, &ValueLen ); continue; }
dCount++;
//
// allocate memory for the group name and value string
//
KeyName = (PWSTR)ScepAlloc( LMEM_ZEROINIT, KeyLen+2);
if ( KeyName ) {
Value = (PWSTR)ScepAlloc(LMEM_ZEROINIT, ValueLen+2);
if ( Value ) {
rc = SceJetGetValue( hSection, SCEJET_CURRENT, NULL, KeyName, KeyLen, &KeyLen, Value, ValueLen, &ValueLen );
if ( rc == SCESTATUS_SUCCESS || rc == SCESTATUS_BUFFER_TOO_SMALL ) {
rc = SCESTATUS_SUCCESS;
if ( ValueLen > 0 ) Value[ValueLen/2] = L'\0';
KeyName[KeyLen/2] = L'\0';
if ( ValueLen > 0 && Value[0] != L'\0' ) { //
// the first ansi character is the value type,
// second ansi character is the status (if in SAP)
// should be terminated by L'\0'
//
//dType = _wtol(Value);
dType = *((CHAR *)Value) - '0'; if ( *((CHAR *)Value+1) >= '0' ) { Status = *((CHAR *)Value+1) - '0'; } else { Status = 0; }
// if ( *(Value+2) ) { // a char and a null delimiter
if ( ValueLen > 4 ) { // a char and a null delimiter
//
// the second field and after is the registry value
// convert the multi-sz delimeter to ,
//
if ( dType == REG_MULTI_SZ && (0 == _wcsicmp( KeyName, szLegalNoticeTextKeyName) ) ) {
//
// check for commas and escape them with "," so the UI etc.
// understands this, since, at this point for lines such as
// k=7,a",",b,c
// pValueStr will be a,\0b\0c\0\0 which we should make
// a","\0b\0c\0\0
//
DWORD dwCommaCount = 0; j = 0;
for ( j=2; j< ValueLen/2 ; j++) { if ( Value[j] == L',' ) dwCommaCount++; }
if ( dwCommaCount > 0 ) {
//
// in this case we have to escape commas
//
PWSTR pszValueEscaped; DWORD dwBytes = (ValueLen/2 + 1 + dwCommaCount*2) * sizeof(WCHAR);
pszValueEscaped = (PWSTR)ScepAlloc(LMEM_ZEROINIT, dwBytes);
if (pszValueEscaped) {
memset(pszValueEscaped, '\0', dwBytes); ValueLen = 2 * ScepEscapeString(Value, ValueLen/2, L',', L'"', pszValueEscaped );
ScepFree(Value);
Value = pszValueEscaped;
} else { rc = SCESTATUS_NOT_ENOUGH_RESOURCE; } } }
ScepConvertMultiSzToDelim(Value+2, ValueLen/2-2, L'\0', L',');
ValueStr = (PWSTR)ScepAlloc(0, (ValueLen/2-1)*sizeof(WCHAR));
if ( ValueStr ) {
wcscpy(ValueStr, Value+2); ValueStr[ValueLen/2-2] = L'\0';
} else { rc = SCESTATUS_NOT_ENOUGH_RESOURCE; } } // else no value available
//
// assign name to the output buffer
//
(*ppRegValues)[i].FullValueName = KeyName; KeyName = NULL;
(*ppRegValues)[i].ValueType = dType;
(*ppRegValues)[i].Value = ValueStr; (*ppRegValues)[i].Status = Status;
ValueStr = NULL;
//
// increment the count
//
i++;
} else { // shouldn't be possible to get into this loop
// if it does, ignore this one
rc = SCESTATUS_INVALID_DATA; }
} else if ( rc != SCESTATUS_RECORD_NOT_FOUND ){ ScepBuildErrorLogInfo( ERROR_READ_FAULT, Errlog, SCEERR_QUERY_VALUE, szRegistryValues ); }
if ( Value ) { ScepFree(Value); Value = NULL; }
if ( ValueStr ) { ScepFree(ValueStr); ValueStr = NULL; }
} else { rc = SCESTATUS_NOT_ENOUGH_RESOURCE; }
//
// remember to free the KeyName
//
if ( KeyName ) { ScepFree(KeyName); KeyName = NULL; }
if ( rc != SCESTATUS_SUCCESS ) { break; } //
// read next line
//
rc = SceJetGetValue( hSection, SCEJET_NEXT_LINE, NULL, NULL, 0, &KeyLen, NULL, 0, &ValueLen ); } else { rc = SCESTATUS_NOT_ENOUGH_RESOURCE; }
}
} else {
rc = SCESTATUS_NOT_ENOUGH_RESOURCE; } }
if ( rc == SCESTATUS_RECORD_NOT_FOUND || rc == SCESTATUS_BUFFER_TOO_SMALL ) { rc = SCESTATUS_SUCCESS; }
if ( rc != SCESTATUS_SUCCESS ) { //
// free memory
//
ScepFreeRegistryValues( ppRegValues, *pValueCount ); *ppRegValues = NULL;
} else if ( ProfileType == SCE_ENGINE_GPO && *pValueCount > dCount ) { //
// reallocate the output buffer
//
if ( dCount > 0 ) {
PSCE_REGISTRY_VALUE_INFO pTempRegValues = *ppRegValues;
//
// allocate memory for all objects
//
*ppRegValues = (PSCE_REGISTRY_VALUE_INFO)ScepAlloc( LMEM_ZEROINIT, dCount*sizeof(SCE_REGISTRY_VALUE_INFO) ); if ( *ppRegValues ) {
for ( i=0,j=0; i<*pValueCount; i++ ) {
if ( pTempRegValues[i].Value ) { (*ppRegValues)[j].FullValueName = pTempRegValues[i].FullValueName; (*ppRegValues)[j].Value = pTempRegValues[i].Value; (*ppRegValues)[j].ValueType = pTempRegValues[i].ValueType; (*ppRegValues)[j].Status = pTempRegValues[i].Status; j++;
} else if ( pTempRegValues[i].FullValueName ) { ScepFree( pTempRegValues[i].FullValueName ); } }
ScepFree( pTempRegValues );
*pValueCount = dCount;
} else {
rc = SCESTATUS_NOT_ENOUGH_RESOURCE; *pValueCount = 0; }
} else {
//
// no registry value from the GPO settings are found
//
ScepFreeRegistryValues( ppRegValues, *pValueCount ); *ppRegValues = NULL; *pValueCount = 0; }
}
//
// close the section
//
SceJetCloseSection(&hSection, TRUE);
return(rc);}
DWORDScepSetDriverSigningPolicy( BYTE Policy)/* ++
Routine Description:
This routine configures driver signing policy through a private API that ensures the value is not being reset by the code signing "anti-tampering" feature.
Arguments:
bPolicy - new policy to set
Return value:
win32 error
-- */{ DWORD Err; HKEY hKey; DWORD dwData = 0, dwSize, dwType; BYTE NewPolicy; SYSTEMTIME RealSystemTime; Err = RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("System\\WPA\\PnP"), 0, KEY_READ, &hKey );
if(Err != ERROR_SUCCESS) { return Err; }
dwSize = sizeof(dwData);
Err = RegQueryValueEx(hKey, TEXT("seed"), NULL, &dwType, (PBYTE)&dwData, &dwSize );
if(Err == ERROR_SUCCESS) {
if(dwType != REG_DWORD) {
Err = ERROR_DATATYPE_MISMATCH;
} else if(dwSize != sizeof(dwData)) {
Err = ERROR_INVALID_DATA;
} else {
RealSystemTime.wDayOfWeek = LOWORD(&hKey) | 4; RealSystemTime.wMinute = LOWORD(dwData); RealSystemTime.wYear = HIWORD(dwData); RealSystemTime.wMilliseconds = (LOWORD(&dwType)&~3072)|(((WORD)(Policy&3))<<10); pSetupGetRealSystemTime(&RealSystemTime);
RealSystemTime.wDayOfWeek = LOWORD(&hKey) | 4; pSetupGetRealSystemTime(&RealSystemTime); NewPolicy = (BYTE)(((RealSystemTime.wMilliseconds+2)&15)^8)/4;
if(Policy != NewPolicy) {
Err = ERROR_FUNCTION_FAILED; } } }
RegCloseKey(hKey);
return Err;}
SCESTATUSScepConfigureRegistryValues( IN PSCECONTEXT hProfile OPTIONAL, IN PSCE_REGISTRY_VALUE_INFO pRegValues, IN DWORD ValueCount, IN PSCE_ERROR_LOG_INFO *pErrLog, IN DWORD ConfigOptions, OUT PBOOL pAnythingSet )/* ++
Routine Description:
This routine configure registry values in the area of security policy.
Arguments:
pRegValues - The array of registry values to configure
ValueCount - the number of values to configure
Return value:
SCESTATUS_SUCCESS SCESTATUS_NOT_ENOUGH_RESOURCE SCESTATUS_INVALID_PARAMETER SCESTATUS_OTHER_ERROR
-- */{ if ( !pRegValues || ValueCount == 0 ) { //
// if no info to configure
//
return SCESTATUS_SUCCESS; }
DWORD rc; SCESTATUS Saverc=SCESTATUS_SUCCESS;
PWSTR pStart, pTemp, pValue; HKEY hKey=NULL; HKEY hKeyRoot; PSCESECTION hSectionDomain=NULL; PSCESECTION hSectionTattoo=NULL; SCE_REGISTRY_VALUE_INFO OneRegValue;
if ( pAnythingSet ) *pAnythingSet = FALSE;
if ( (ConfigOptions & SCE_POLICY_TEMPLATE) && hProfile ) { ScepTattooOpenPolicySections( hProfile, szRegistryValues, &hSectionDomain, &hSectionTattoo ); }
for ( DWORD i=0; i<ValueCount; i++ ) {
if ( !pRegValues[i].FullValueName || !pRegValues[i].Value ) { //
// no value to configure
//
continue; }
ScepLogOutput3(2, 0, SCEDLL_SCP_CONFIGURE, pRegValues[i].FullValueName);
//
// look for the first \\ //
pStart = wcschr(pRegValues[i].FullValueName, L'\\') ; if ( !pStart ) { Saverc = SCESTATUS_INVALID_DATA;
if ( pErrLog ) { ScepBuildErrorLogInfo(Saverc,pErrLog, SCEDLL_SCP_ERROR_CONFIGURE, pRegValues[i].FullValueName); } else { ScepLogOutput3(1, Saverc, SCEDLL_SCP_ERROR_CONFIGURE, pRegValues[i].FullValueName); }
if ( ConfigOptions & SCE_RSOP_CALLBACK )
ScepRsopLog(SCE_RSOP_REGISTRY_VALUE_INFO, Saverc, pRegValues[i].FullValueName, 0, 0);
continue; } //
// find the root key
//
if ( (7 == pStart-pRegValues[i].FullValueName) && (0 == _wcsnicmp(L"MACHINE", pRegValues[i].FullValueName, 7)) ) {
hKeyRoot = HKEY_LOCAL_MACHINE;
} else if ( (5 == pStart-pRegValues[i].FullValueName) && (0 == _wcsnicmp(L"USERS", pRegValues[i].FullValueName, 5)) ) { hKeyRoot = HKEY_USERS;
} else if ( (12 == pStart-pRegValues[i].FullValueName) && (0 == _wcsnicmp(L"CLASSES_ROOT", pRegValues[i].FullValueName, 12)) ) { hKeyRoot = HKEY_CLASSES_ROOT;
} else { Saverc = SCESTATUS_INVALID_DATA; if ( pErrLog ) { ScepBuildErrorLogInfo(Saverc,pErrLog, SCEDLL_SCP_ERROR_CONFIGURE, pRegValues[i].FullValueName); } else { ScepLogOutput3(1, Saverc, SCEDLL_SCP_ERROR_CONFIGURE, pRegValues[i].FullValueName); }
if ( ConfigOptions & SCE_RSOP_CALLBACK )
ScepRsopLog(SCE_RSOP_REGISTRY_VALUE_INFO, Saverc, pRegValues[i].FullValueName, 0, 0);
continue; } //
// find the value name
//
pValue = pStart+1;
do { pTemp = wcschr(pValue, L'\\'); if ( pTemp ) { pValue = pTemp+1; } } while ( pTemp );
if ( pValue == pStart+1 ) { Saverc = SCESTATUS_INVALID_DATA; if ( pErrLog ) { ScepBuildErrorLogInfo(Saverc,pErrLog, SCEDLL_SCP_ERROR_CONFIGURE, pRegValues[i].FullValueName); } else { ScepLogOutput3(1, Saverc, SCEDLL_SCP_ERROR_CONFIGURE, pRegValues[i].FullValueName); }
if ( ConfigOptions & SCE_RSOP_CALLBACK )
ScepRsopLog(SCE_RSOP_REGISTRY_VALUE_INFO, Saverc, pRegValues[i].FullValueName, 0, 0);
continue; }
//
// terminate the subkey for now
//
*(pValue-1) = L'\0';
//
// set the value
// always create the key if it does not exist.
//
rc = RegCreateKeyEx(hKeyRoot, pStart+1, 0, NULL, 0, KEY_READ | KEY_SET_VALUE, NULL, &hKey, NULL );
if ( rc == ERROR_SUCCESS || rc == ERROR_ALREADY_EXISTS ) {/*
if(( rc = RegOpenKeyEx(hKeyRoot, pStart+1, 0, KEY_SET_VALUE, &hKey )) == ERROR_SUCCESS ) {*/
//
// restore the char
//
*(pValue-1) = L'\\';
OneRegValue.FullValueName = NULL; OneRegValue.Value = NULL;
BOOL bLMSetting = FALSE;
if ( (REG_DWORD == pRegValues[i].ValueType) && _wcsicmp(SCEP_LMC_SETTING, pRegValues[i].FullValueName) == 0 ) {
//
// check if dcpromo upgrade in progress
//
DWORD dwInSetup=0; DWORD dwUpgraded=0;
ScepRegQueryIntValue(HKEY_LOCAL_MACHINE, SCE_ROOT_PATH, TEXT("PromoteUpgradeInProgress"), &dwUpgraded );
if ( dwUpgraded ) {
//
// in dcpromo upgrade, we need to do special check about
// this setting
//
bLMSetting = TRUE;
} else {
//
// check if in setup upgrade
//
dwUpgraded=0;
ScepRegQueryIntValue(HKEY_LOCAL_MACHINE, TEXT("System\\Setup"), TEXT("SystemSetupInProgress"), &dwInSetup );
if ( dwInSetup ) {
//
// if system is upgraded, the state is stored in registry
// by SCE client at very beginning of GUI setup
//
ScepRegQueryIntValue( HKEY_LOCAL_MACHINE, SCE_ROOT_PATH, TEXT("SetupUpgraded"), (DWORD *)&dwUpgraded );
if ( dwUpgraded ) {
//
// in setup upgrade, we need to do special check about
// this setting
//
bLMSetting = TRUE; } } } }
//
// if in policy propagation, query the existing value
//
if ( ( (ConfigOptions & SCE_POLICY_TEMPLATE) && hProfile ) || bLMSetting ) {
OneRegValue.FullValueName = pRegValues[i].FullValueName; OneRegValue.ValueType = pRegValues[i].ValueType; OneRegValue.Status = 0;
DWORD rc2 = ScepAnalyzeOneRegistryValueNoValidate( hKey, pValue, NULL, SCEREG_VALUE_SYSTEM, &OneRegValue ); if ( ERROR_SUCCESS != rc2 ) { if ( !bLMSetting ) {
ScepLogOutput3(1, 0, SCESRV_POLICY_TATTOO_ERROR_QUERY, rc2, pRegValues[i].FullValueName);
} else if ( ERROR_FILE_NOT_FOUND != rc2 ) {
ScepLogOutput3(1, 0, SCESRV_SETUPUPD_ERROR_LMCOMPAT, rc2, pRegValues[i].FullValueName); } } }
if ( REG_DWORD == pRegValues[i].ValueType ) { //
// REG_DWORD type, value is a dword
//
LONG RegValue = _wtol(pRegValues[i].Value);
if ( !bLMSetting || OneRegValue.Value == NULL || _wtol(OneRegValue.Value) <= RegValue ) {
rc = RegSetValueEx( hKey, pValue, 0, REG_DWORD, (BYTE *)&RegValue, sizeof(DWORD) ); } else {
//
// for LMCompatibility level, if in setup, set this value only if
// current system setting is less than configuration, or not defined
//
ScepLogOutput3(2, 0, SCESRV_SETUPUPD_IGNORE_LMCOMPAT, pRegValues[i].FullValueName); }
} else if ( -1 == pRegValues[i].ValueType ) { //
// delete the registry value
//
rc = RegDeleteValue(hKey, pValue); //
// if the value doesn't exist, ignore the error
//
if ( ERROR_FILE_NOT_FOUND == rc ) rc = ERROR_SUCCESS;
} else {
PBYTE pRegBytes=NULL; DWORD nLen;
nLen = wcslen(pRegValues[i].Value);
if ( REG_MULTI_SZ == pRegValues[i].ValueType || REG_QWORD == pRegValues[i].ValueType) { //
// translate the comma delimited string to multi-sz string
//
//
// LegalNoticeText is special cased i.e. \0 should be converted to \r\n
// and commas should be unescaped before writing this value into the registry
//
BOOL bIsLegalNoticeText = FALSE;
if ( !(REG_MULTI_SZ == pRegValues[i].ValueType && (0 == _wcsicmp(szLegalNoticeTextKeyName, pRegValues[i].FullValueName ) ) ) ) {
pRegBytes = (PBYTE)ScepAlloc(0, (nLen+2)*sizeof(WCHAR));
if ( pRegBytes ) {
wcscpy((PWSTR)pRegBytes, pRegValues[i].Value); ((PWSTR)pRegBytes)[nLen] = L'\0'; ((PWSTR)pRegBytes)[nLen+1] = L'\0';
ScepConvertMultiSzToDelim((PWSTR)pRegBytes, nLen+1, L',', L'\0' ); } else {
rc = ERROR_NOT_ENOUGH_MEMORY; } }
else {
DWORD dwCommaCount = 0; DWORD dwBytes;
bIsLegalNoticeText = TRUE;
for ( DWORD dwIndex = 0; dwIndex <= nLen; dwIndex++) { if ( pRegValues[i].Value[dwIndex] == L',' ) dwCommaCount++; }
dwBytes = (nLen + dwCommaCount + 2)*sizeof(WCHAR);
pRegBytes = (PBYTE)ScepAlloc(0, dwBytes);
if ( pRegBytes ) {
memset(pRegBytes, '\0', dwBytes); //
// unescape the "," and add \r\n wherever there is a ,
//
nLen = ScepUnescapeAndAddCRLF( pRegValues[i].Value, (PWSTR) pRegBytes);
} else {
rc = ERROR_NOT_ENOUGH_MEMORY; }
}
if ( rc == NO_ERROR ) {
//
// engine/UI treat LegalNoticeText as REG_MULTI_SZ but
// we force it to be REG_SZ for compatibility sake
//
rc = RegSetValueEx( hKey, pValue, 0, bIsLegalNoticeText ? REG_SZ : pRegValues[i].ValueType, pRegBytes, (nLen+2)*sizeof(WCHAR) );
ScepFree(pRegBytes);
}
} else if ( REG_BINARY == pRegValues[i].ValueType ) {
if ( nLen > 0 ) {
//
// binary type, translate the unicode string to binary data
// 4 bytes (2 wchars) to 1 byte
//
DWORD newLen; newLen = nLen/2;
if ( nLen % 2 ) { newLen++; // pad a leading 0
}
pRegBytes = (PBYTE)ScepAlloc(0, newLen);
if ( pRegBytes ) {
BYTE dByte;
for ( INT j=newLen-1; j>=0; j-- ) {
if ( nLen % 2 ) { // odd number of chars
dByte = (pRegValues[i].Value[j*2]-L'0') % 16; if ( j*2 >= 1 ) { dByte += ((pRegValues[i].Value[j*2-1]-L'0') % 16) * 16; } } else { // even number of chars
dByte = (pRegValues[i].Value[j*2+1]-L'0') % 16; dByte += ((pRegValues[i].Value[j*2]-L'0') % 16) * 16; } pRegBytes[j] = dByte; }
// Special case for code signing policy, this value is protected from
// "tampering" so we need to set it through their API to avoid being
// overwritten.
if (_wcsicmp( SCEP_DRIVER_SIGNING_SETTING, pRegValues[i].FullValueName) == 0 ) {
rc = ScepSetDriverSigningPolicy(*pRegBytes);
} else {
rc = RegSetValueEx( hKey, pValue, 0, REG_BINARY, pRegBytes, newLen ); }
ScepFree(pRegBytes);
} else { rc = ERROR_NOT_ENOUGH_MEMORY; } }
} else { //
// sz type, expand_sz
//
rc = RegSetValueEx( hKey, pValue, 0, pRegValues[i].ValueType, (BYTE *)(pRegValues[i].Value), (nLen)*sizeof(WCHAR) ); } }
//
// manage the tattoo value
//
if ( (ConfigOptions & SCE_POLICY_TEMPLATE) && hProfile ) { //
// if can't query system setting (OneRegValue.Value == NULL)
// (may be because they are deleted e.g. demotion)
// we still need to delete the tattoo values
//
ScepTattooManageOneRegistryValue(hSectionDomain, hSectionTattoo, pRegValues[i].FullValueName, 0, &OneRegValue, rc ); }
if ( OneRegValue.Value ) ScepFree(OneRegValue.Value);
RegCloseKey( hKey );
}
if ( NO_ERROR != rc ) {
if ( pErrLog ) { ScepBuildErrorLogInfo(rc,pErrLog, SCEDLL_ERROR_SET_INFO, pRegValues[i].FullValueName);
}
if ( ERROR_FILE_NOT_FOUND != rc && ERROR_PATH_NOT_FOUND != rc ) {
ScepLogOutput3(1, rc, SCEDLL_ERROR_SET_INFO, pRegValues[i].FullValueName); Saverc = ScepDosErrorToSceStatus(rc); }
}
if ( ConfigOptions & SCE_RSOP_CALLBACK )
ScepRsopLog(SCE_RSOP_REGISTRY_VALUE_INFO, rc, pRegValues[i].FullValueName, 0, 0);
if ( pAnythingSet ) { *pAnythingSet = TRUE; } }
if ( hSectionDomain ) SceJetCloseSection(&hSectionDomain, TRUE); if ( hSectionTattoo ) SceJetCloseSection(&hSectionTattoo, TRUE);
return(Saverc);}
DWORDScepUnescapeAndAddCRLF( IN PWSTR pszSource, IN OUT PWSTR pszDest )/* ++
Routine Description:
Primarily used just before configuration
Unescapes commas i.e. a","\0b\0c\0\0 -> a,\0b\0c\0\0
Also replaces , with \r\n
Arguments:
pszSource - The source string
dwSourceChars - The number of chars in pszSource
pszDest - The destination string
Return value:
Number of characters copied to the destination
-- */{
DWORD dwCharsCopied = 0;
while (pszSource[0] != L'\0') {
if (0 == wcsncmp(pszSource, L"\",\"", 3)) {
pszDest[0] = L','; ++dwCharsCopied;
++pszDest; pszSource +=3;
} else if (pszSource[0] == L',') {
pszDest[0] = L'\r'; pszDest[1] = L'\n'; dwCharsCopied +=2;
pszDest +=2 ; ++pszSource;
} else {
pszDest[0] = pszSource[0]; ++dwCharsCopied;
++pszDest; ++pszSource; } }
pszDest = L'\0'; ++dwCharsCopied;
return dwCharsCopied;}
DWORDScepEscapeAndRemoveCRLF( IN const PWSTR pszSource, IN const DWORD dwSourceSize, IN OUT PWSTR pszDest )/* ++
Routine Description:
Primarily used before analysis
Escapes commas i.e. a,\0b\0c\0\0 -> a","\0b\0c\0\0
Also replaces \r\n with ,
This routine is the inverse of ScepUnescapeAndAddCRLF
Arguments:
pszSource - The source string
dwSourceChars - The number of chars in pszSource
pszDest - The destination string
Return value:
Number of characters copied to the destination
-- */
{
DWORD dwSourceIndex = 0; DWORD dwCopiedChars = 0;
while (dwSourceIndex < dwSourceSize) {
if (0 == wcsncmp(pszSource + dwSourceIndex, L"\r\n", 2)) {
pszDest[0] = L',';
++pszDest; ++dwCopiedChars; dwSourceIndex +=2;
} else if (pszSource[dwSourceIndex] == L',') {
pszDest[0] = L'"'; pszDest[1] = L','; pszDest[2] = L'"';
pszDest +=3 ; dwCopiedChars +=3 ; ++dwSourceIndex;
} else {
pszDest[0] = pszSource[dwSourceIndex];
++pszDest; ++dwCopiedChars; ++dwSourceIndex; } }
pszDest = L'\0';
return dwCopiedChars;}
SCESTATUSScepAnalyzeRegistryValues( IN PSCECONTEXT hProfile, IN DWORD dwAnalFlag, IN PSCE_PROFILE_INFO pSmpInfo )/* ++
Routine Description:
This routine analyze registry values in the area of security policy.
Arguments:
Return value:
SCESTATUS_SUCCESS SCESTATUS_NOT_ENOUGH_RESOURCE SCESTATUS_INVALID_PARAMETER SCESTATUS_OTHER_ERROR
-- */{ if ( !pSmpInfo ) { return SCESTATUS_INVALID_PARAMETER; }
if ( (dwAnalFlag != SCEREG_VALUE_SYSTEM) && !hProfile ) { return SCESTATUS_INVALID_PARAMETER; }
SCESTATUS Saverc=SCESTATUS_SUCCESS;
if ( dwAnalFlag != SCEREG_VALUE_ROLLBACK ) { Saverc = ScepEnumAllRegValues( &(pSmpInfo->RegValueCount), &(pSmpInfo->aRegValues) ); }
if ( Saverc != SCESTATUS_SUCCESS ) { return(Saverc); }
if ( pSmpInfo->RegValueCount == 0 || pSmpInfo->aRegValues == NULL ) { //
// if no info to configure
//
return SCESTATUS_SUCCESS; }
DWORD rc; DWORD i; PSCESECTION hSection=NULL; SCEJET_TABLE_TYPE tblType;
if ( dwAnalFlag != SCEREG_VALUE_SYSTEM ) { //
// query value from system doesn't require accessing the database
//
switch ( dwAnalFlag ) { case SCEREG_VALUE_SNAPSHOT: case SCEREG_VALUE_FILTER: case SCEREG_VALUE_ROLLBACK: tblType = SCEJET_TABLE_SMP; break; default: tblType = SCEJET_TABLE_SAP; break; } //
// Prepare a new section
// for delay filter mode, data is written to the SMP (local) table
// when the setting is different from the effective setting (changed outside GPO)
//
Saverc = ScepStartANewSection( hProfile, &hSection, tblType, szRegistryValues ); if ( Saverc != SCESTATUS_SUCCESS ) { ScepLogOutput3(1, ScepSceStatusToDosError(Saverc), SCEDLL_SAP_START_SECTION, (PWSTR)szRegistryValues); return(Saverc); } }
for ( i=0; i<pSmpInfo->RegValueCount; i++ ) {
if ( dwAnalFlag == SCEREG_VALUE_SYSTEM ) { //
// mark the status field
//
(pSmpInfo->aRegValues)[i].Status = SCE_STATUS_ERROR_NOT_AVAILABLE;
}
if ( !((pSmpInfo->aRegValues)[i].FullValueName) ) { continue; }
ScepLogOutput3(2, 0, SCEDLL_SAP_ANALYZE, (pSmpInfo->aRegValues)[i].FullValueName);
rc = ScepAnalyzeOneRegistryValue( hSection, dwAnalFlag, &((pSmpInfo->aRegValues)[i]) );
if ( SCESTATUS_INVALID_PARAMETER == rc || SCESTATUS_INVALID_DATA == rc ) { continue; }
if ( SCESTATUS_SUCCESS != rc ) { Saverc = rc;
break; } }
//
// close the section
//
SceJetCloseSection( &hSection, TRUE);
return(Saverc);
}
SCESTATUSScepAnalyzeOneRegistryValue( IN PSCESECTION hSection OPTIONAL, IN DWORD dwAnalFlag, IN OUT PSCE_REGISTRY_VALUE_INFO pOneRegValue ){ SCESTATUS Saverc=SCESTATUS_SUCCESS; PWSTR pStart, pTemp, pValue; HKEY hKey=NULL, hKeyRoot; DWORD rc=0;
if ( pOneRegValue == NULL || pOneRegValue->FullValueName == NULL ) { return(SCESTATUS_INVALID_DATA); }
if ( hSection == NULL && (SCEREG_VALUE_ANALYZE == dwAnalFlag || SCEREG_VALUE_ROLLBACK == dwAnalFlag) ) { return(SCESTATUS_INVALID_PARAMETER); }
//
// look for the first \\ //
pStart = wcschr(pOneRegValue->FullValueName, L'\\') ;
if ( !pStart ) { //
// if it's in snapshot mode, ignore bogus reg value names
//
Saverc = SCESTATUS_INVALID_DATA; if ( SCEREG_VALUE_ANALYZE == dwAnalFlag ) {
//
// error analyzing the value, save it
//
ScepSaveRegistryValue( hSection, pOneRegValue->FullValueName, pOneRegValue->ValueType, NULL, 0, SCE_STATUS_ERROR_NOT_AVAILABLE ); } return(Saverc); }
//
// find the root key
//
if ( (7 == pStart-pOneRegValue->FullValueName) && (0 == _wcsnicmp(L"MACHINE", pOneRegValue->FullValueName, 7)) ) {
hKeyRoot = HKEY_LOCAL_MACHINE;
} else if ( (5 == pStart-pOneRegValue->FullValueName) && (0 == _wcsnicmp(L"USERS", pOneRegValue->FullValueName, 5)) ) { hKeyRoot = HKEY_USERS;
} else if ( (12 == pStart-pOneRegValue->FullValueName) && (0 == _wcsnicmp(L"CLASSES_ROOT", pOneRegValue->FullValueName, 12)) ) { hKeyRoot = HKEY_CLASSES_ROOT;
} else {
//
// if it's in snapshot mode, ignore bogus reg value names
//
Saverc = SCESTATUS_INVALID_DATA; if ( SCEREG_VALUE_ANALYZE == dwAnalFlag ) { //
// error analyzing the value, save it
//
ScepSaveRegistryValue( hSection, pOneRegValue->FullValueName, pOneRegValue->ValueType, NULL, 0, SCE_STATUS_ERROR_NOT_AVAILABLE ); } return(Saverc); }
//
// find the value name
//
pValue = pStart+1;
do { pTemp = wcschr(pValue, L'\\'); if ( pTemp ) { pValue = pTemp+1; } } while ( pTemp );
if ( pValue == pStart+1 ) {
//
// if it's in snapshot mode, ignore bogus reg value names
//
Saverc = SCESTATUS_INVALID_DATA; if ( SCEREG_VALUE_ANALYZE == dwAnalFlag ) {
//
// error analyzing the value, save it
//
ScepSaveRegistryValue( hSection, pOneRegValue->FullValueName, pOneRegValue->ValueType, NULL, 0, SCE_STATUS_ERROR_NOT_AVAILABLE ); } return(Saverc); }
//
// terminate the subkey for now
//
*(pValue-1) = L'\0';
if(( rc = RegOpenKeyEx(hKeyRoot, pStart+1, 0, KEY_READ, &hKey )) == ERROR_SUCCESS ) {
//
// resotre the char
//
*(pValue-1) = L'\\';
rc = ScepAnalyzeOneRegistryValueNoValidate(hKey, pValue, hSection, dwAnalFlag, pOneRegValue ); //
// close the key
//
RegCloseKey(hKey);
} else {
//
// restore the char
//
*(pValue-1) = L'\\';
//
// error analyzing the value, or it doesn't exist, save it
//
if ( (SCEREG_VALUE_ANALYZE == dwAnalFlag) || (SCEREG_VALUE_ROLLBACK == dwAnalFlag) ) {
ScepSaveRegistryValue( hSection, pOneRegValue->FullValueName, (SCEREG_VALUE_ANALYZE == dwAnalFlag) ? pOneRegValue->ValueType : -1, NULL, 0, (SCEREG_VALUE_ANALYZE == dwAnalFlag) ? SCE_STATUS_ERROR_NOT_AVAILABLE : 0 ); }
if ( rc == ERROR_FILE_NOT_FOUND || rc == ERROR_PATH_NOT_FOUND || rc == ERROR_INVALID_HANDLE || rc == ERROR_ACCESS_DENIED ) {
rc = ERROR_SUCCESS; } }
if ( rc != NO_ERROR ) { ScepLogOutput3(1, rc, SCEDLL_SAP_ERROR_ANALYZE, pOneRegValue->FullValueName);
Saverc = ScepDosErrorToSceStatus(rc); }
return(Saverc);
}
DWORDScepAnalyzeOneRegistryValueNoValidate( IN HKEY hKey, IN PWSTR ValueName, IN PSCESECTION hSection OPTIONAL, IN DWORD dwAnalFlag, IN OUT PSCE_REGISTRY_VALUE_INFO pOneRegValue )/*
Query and/or compare one registry value without validating the value name, etc.The validation should be done outside of this routine.
This routine is primarily defined for sharing in both configuration and analysis.
*/{ if ( hKey == NULL || ValueName == NULL || pOneRegValue == NULL ) return(ERROR_INVALID_PARAMETER);
DWORD rc; DWORD dSize=0; DWORD RegType=pOneRegValue->ValueType; DWORD RegData=0; PWSTR strValue=NULL; BOOL bIsLegalNoticeText = FALSE;
if ( SCEREG_VALUE_SYSTEM == dwAnalFlag ) { //
// reset the status field, it's not error'ed
//
pOneRegValue->Status = 0; }
if(( rc = RegQueryValueEx(hKey, ValueName, 0, &RegType, NULL, &dSize )) == ERROR_SUCCESS ) {
//
// we treat REG_DWORD_BIG_ENDIAN the same as REG_DWORD
//
if ( RegType == REG_DWORD_BIG_ENDIAN ) { RegType = REG_DWORD; }
if ( 0 == _wcsicmp( pOneRegValue->FullValueName, szLegalNoticeTextKeyName)) {
bIsLegalNoticeText = TRUE;
RegType = REG_MULTI_SZ;
} else if ( RegType != pOneRegValue->ValueType ) { //
// if it's a wrong type, we assure it's not the value we found
//
rc = ERROR_FILE_NOT_FOUND;
}
if ( ERROR_SUCCESS == rc ) {
switch (RegType) { case REG_DWORD:
dSize = sizeof(DWORD); rc = RegQueryValueEx(hKey, ValueName, 0, &RegType, (BYTE *)&RegData, &dSize ); break; default:
//
// can be REG_BINARY, REG_MULTI_SZ, REG_SZ, and REG_EXPAND_SZ
// everything else is treated as REG_SZ
//
strValue = (PWSTR)ScepAlloc(0, dSize + 4); dSize += 2;
if ( strValue ) {
memset(strValue, 0, dSize + 4 - 2); rc = RegQueryValueEx(hKey, ValueName, 0, &RegType, (BYTE *)strValue, &dSize );
if (bIsLegalNoticeText) { RegType = REG_MULTI_SZ; }
} else { rc = ERROR_NOT_ENOUGH_MEMORY; }
break; } } }
if ( rc == NO_ERROR ) {
DWORD dwStatus = SCE_STATUS_NOT_CONFIGURED; if ( SCEREG_VALUE_SNAPSHOT == dwAnalFlag || SCEREG_VALUE_ROLLBACK == dwAnalFlag ) dwStatus = 0;
switch ( RegType ) { case REG_DWORD: case REG_DWORD_BIG_ENDIAN:
if ( pOneRegValue->Value == NULL || (SCEREG_VALUE_SNAPSHOT == dwAnalFlag) ) {
if ( SCEREG_VALUE_SYSTEM == dwAnalFlag ) { //
// add the value to OneRegValue buffer
//
rc = ScepSaveRegistryValueToBuffer( REG_DWORD, (PWSTR)&RegData, sizeof(DWORD), pOneRegValue );
} else if ( SCEREG_VALUE_FILTER != dwAnalFlag ) {
//
// not configured, or snapshot the current value
//
rc = ScepSaveRegistryValue( hSection, pOneRegValue->FullValueName, REG_DWORD, (PWSTR)&RegData, sizeof(DWORD), dwStatus ); } // else for the delay filter, only query the reg values configured
} else if ( (LONG)RegData != _wtol(pOneRegValue->Value) ) {
rc = ScepSaveRegistryValue( hSection, pOneRegValue->FullValueName, REG_DWORD, (PWSTR)&RegData, sizeof(DWORD), 0 ); } break;
case REG_BINARY:
DWORD nLen; if ( pOneRegValue->Value ) { nLen = wcslen(pOneRegValue->Value); } else { nLen = 0; }
if ( pOneRegValue->Value == NULL || (SCEREG_VALUE_SNAPSHOT == dwAnalFlag) || nLen == 0 ) {
if ( SCEREG_VALUE_SYSTEM == dwAnalFlag ) {
//
// add the value to OneRegValue buffer
//
rc = ScepSaveRegistryValueToBuffer( RegType, strValue, dSize, pOneRegValue );
} else if ( SCEREG_VALUE_FILTER != dwAnalFlag ) { //
// not configured, or snapshot the current value
//
rc = ScepSaveRegistryValue( hSection, pOneRegValue->FullValueName, RegType, strValue, dSize, dwStatus ); }
} else if ( strValue ) {
DWORD newLen;
newLen = nLen/2;
if ( nLen % 2 ) { newLen++; // pad a leading 0
}
PBYTE pRegBytes = (PBYTE)ScepAlloc(0, newLen);
if ( pRegBytes ) {
BYTE dByte;
for ( INT j=newLen-1; j>=0; j-- ) {
if ( nLen % 2 ) { // odd number of chars
dByte = (pOneRegValue->Value[j*2]-L'0') % 16; if ( j*2 >= 1 ) { dByte += ((pOneRegValue->Value[j*2-1]-L'0') % 16) * 16; } } else { // even number of chars
dByte = (pOneRegValue->Value[j*2+1]-L'0') % 16; dByte += ((pOneRegValue->Value[j*2]-L'0') % 16) * 16; } pRegBytes[j] = dByte; }
if ( memcmp(strValue, pRegBytes, dSize) == 0 ) {
//
// matched, do not do anything
//
} else {
//
// mismatched, save the binary data
//
rc = ScepSaveRegistryValue( hSection, pOneRegValue->FullValueName, RegType, strValue, dSize, 0 ); }
ScepFree(pRegBytes);
} else { //
// out of memory
//
rc = SCESTATUS_NOT_ENOUGH_RESOURCE; }
} else {
//
// mismatched, save the binary data
//
rc = ScepSaveRegistryValue( hSection, pOneRegValue->FullValueName, RegType, strValue, dSize, 0 ); } break;
case REG_MULTI_SZ: case REG_QWORD:
if ( strValue ) {
if ( !(RegType == REG_MULTI_SZ && (0 == _wcsicmp( pOneRegValue->FullValueName, szLegalNoticeTextKeyName) ) ) ) {
ScepConvertMultiSzToDelim(strValue, dSize/2, L'\0', L',');
} else {
DWORD dwCommaCount = 0; PWSTR strValueNew; DWORD dwBytes;
for (DWORD dwIndex=0; dwIndex < dSize/2; dwIndex++) { if ( strValue[dwIndex] == L',' ) dwCommaCount++; }
dwBytes = (dSize/2+dwCommaCount * 2 + 1) * sizeof(WCHAR); strValueNew = (PWSTR)ScepAlloc(0, dwBytes);
if (strValueNew) {
memset(strValueNew, '\0', dwBytes);
dSize = 2 + 2 * ScepEscapeAndRemoveCRLF( strValue, dSize/2, strValueNew);
ScepFree(strValue);
strValue = strValueNew; } else {
rc = SCESTATUS_NOT_ENOUGH_RESOURCE; break;
}
}
} // fall through
default:
if ( pOneRegValue->Value == NULL || (SCEREG_VALUE_SNAPSHOT == dwAnalFlag) ) {
if ( SCEREG_VALUE_SYSTEM == dwAnalFlag ) {
//
// add the value to OneRegValue buffer
//
rc = ScepSaveRegistryValueToBuffer( RegType, strValue, dSize, pOneRegValue );
} else if ( SCEREG_VALUE_FILTER != dwAnalFlag ) { rc = ScepSaveRegistryValue( hSection, pOneRegValue->FullValueName, RegType, strValue, dSize, dwStatus ); } } else if ( strValue && bIsLegalNoticeText && (pOneRegValue->ValueType != RegType)) { //
// legalnotice text special case
// must be old template is used
// each comma is escaped with two quotes
//
DWORD Len = wcslen(pOneRegValue->Value); PWSTR NewValue = (PWSTR)ScepAlloc(LPTR, Len*3*sizeof(WCHAR));
if ( NewValue ) {
ScepEscapeAndRemoveCRLF(pOneRegValue->Value, Len, NewValue);
if ( _wcsicmp(NewValue, strValue) != 0 ) { //
// mismatched, save the item to the database
//
rc = ScepSaveRegistryValue( hSection, pOneRegValue->FullValueName, RegType, strValue, dSize, 0 ); }
ScepFree(NewValue);
} else { rc = SCESTATUS_NOT_ENOUGH_RESOURCE; }
} else if ( strValue && _wcsicmp(pOneRegValue->Value, strValue) == 0 ) { //
// matched, do not do anything
//
} else { //
// mismatched, save the item to the database
//
rc = ScepSaveRegistryValue( hSection, pOneRegValue->FullValueName, RegType, strValue, dSize, 0 ); } break; }
rc = ScepSceStatusToDosError(rc);
} else {
//
// error analyzing the value, or it doesn't exist, save it
// if the registry value doesn't exist, doesn't mean it's 0
// just log an "not available" status in this case
//
if ( (SCEREG_VALUE_ANALYZE == dwAnalFlag) || (SCEREG_VALUE_ROLLBACK == dwAnalFlag) ) {
ScepSaveRegistryValue( hSection, pOneRegValue->FullValueName, (SCEREG_VALUE_ANALYZE == dwAnalFlag) ? pOneRegValue->ValueType : -1, NULL, 0, (SCEREG_VALUE_ANALYZE == dwAnalFlag) ? SCE_STATUS_ERROR_NOT_AVAILABLE : 0 ); }
if ( rc == ERROR_FILE_NOT_FOUND || rc == ERROR_PATH_NOT_FOUND || rc == ERROR_INVALID_HANDLE || rc == ERROR_ACCESS_DENIED ) {
rc = ERROR_SUCCESS; } }
//
// free buffer
//
if ( strValue ) { ScepFree(strValue); strValue = NULL; }
return(rc);
}
SCESTATUSScepSaveRegistryValue( IN PSCESECTION hSection, IN PWSTR Name, IN DWORD RegType, IN PWSTR CurrentValue, IN DWORD CurrentBytes, IN DWORD Status )/* ++
Routine Description:
This routine compares system settings in string with the baseline profile settings. If there is mismatch or unknown, the entry is saved in the SAP profile.
Arguments:
hSection - The section handle
Name - The entry name
RegType - the registry value type
CurrentValue - The current system setting
CurrentBytes - The length of the current setting
Status - the status of this registry vlue analyzed
Return Value:
SCESTATUS_SUCCESS SCESTATUS_INVALID_PARAMETER SCESTATUS returned from SceJetSetLine
-- */{ SCESTATUS rc;
if ( Name == NULL ) return(SCESTATUS_INVALID_PARAMETER);
if ( CurrentValue == NULL && REG_DWORD == RegType && Status == 0 ) { //
// only return if it's a DWORD type and saving for mismatch status
// for other types, NULL should be treated as ""
return(SCESTATUS_SUCCESS); }
//
// build a buffer containing type and value
// note MULTI_SZ must be converted to null delimited
//
if ( REG_DWORD == RegType ) {
TCHAR StrValue[20]; memset(StrValue, '\0', 40);
*((CHAR *)StrValue) = (BYTE)RegType + '0';
if ( Status == 0) { *((CHAR *)StrValue+1) = SCE_STATUS_MISMATCH + '0'; } else { *((CHAR *)StrValue+1) = (BYTE)Status + '0'; } StrValue[1] = L'\0';
if ( CurrentValue ) { swprintf(StrValue+2, L"%d", *CurrentValue); } rc = SceJetSetLine( hSection, Name, FALSE, StrValue, (2+wcslen(StrValue+2))*2, 0);
} else {
PWSTR StrValue;
if ( (CurrentBytes % 2) && REG_BINARY == RegType ) { StrValue = (PWSTR)ScepAlloc(0, CurrentBytes+9); } else { StrValue = (PWSTR)ScepAlloc(0, CurrentBytes+8); // 4 wide chars: one for type, one delim, and two NULL
}
if ( StrValue ) {
memset(StrValue, 0, sizeof(StrValue)); *((CHAR *)StrValue) = (BYTE)RegType + '0';
if ( Status == 0) { *((CHAR *)StrValue+1) = SCE_STATUS_MISMATCH + '0'; } else { *((CHAR *)StrValue+1) = (BYTE)Status + '0'; } StrValue[1] = L'\0';
if ( CurrentValue ) { if (REG_BINARY == RegType && CurrentBytes == 1) { swprintf(StrValue+2, L"%d", *CurrentValue); } else { memcpy(StrValue+2, (PBYTE)CurrentValue, CurrentBytes); } }
if ( (CurrentBytes % 2) && REG_BINARY == RegType ) { StrValue[CurrentBytes/2+3] = L'\0'; StrValue[CurrentBytes/2+4] = L'\0'; } else { StrValue[CurrentBytes/2+2] = L'\0'; StrValue[CurrentBytes/2+3] = L'\0'; }
if ( REG_MULTI_SZ == RegType || REG_QWORD == RegType ) { //
// convert the , to null
//
ScepConvertMultiSzToDelim(StrValue+2, CurrentBytes/2, L',', L'\0');
}
if ( (CurrentBytes % 2) && REG_BINARY == RegType ) { rc = SceJetSetLine( hSection, Name, FALSE, StrValue, CurrentBytes+7, 0); } else { rc = SceJetSetLine( hSection, Name, FALSE, StrValue, CurrentBytes+6, 0); }
ScepFree(StrValue);
} else { rc = SCESTATUS_NOT_ENOUGH_RESOURCE; } }
switch (Status) { case SCE_STATUS_ERROR_NOT_AVAILABLE: ScepLogOutput3(2, 0, SCEDLL_STATUS_ERROR, Name); break; case SCE_STATUS_NOT_CONFIGURED: ScepLogOutput3(2, 0, SCEDLL_STATUS_NC, Name); break; default: ScepLogOutput3(2, 0, SCEDLL_STATUS_MISMATCH, Name); break; }
return(rc);
}
SCESTATUSScepSaveRegistryValueToBuffer( IN DWORD RegType, IN PWSTR Value, IN DWORD dwBytes, IN OUT PSCE_REGISTRY_VALUE_INFO pRegValues )/* ++
Routine Description:
This routine saves the registry value to the buffer
Arguments:
RegType - the registry value type
Value - The current system setting
dwBytes - The length of the current setting
pRegValues - the buffer for this registry value to save to
-- */{ SCESTATUS rc=SCESTATUS_SUCCESS;
if ( pRegValues == NULL ) { return(SCESTATUS_INVALID_PARAMETER); }
if ( Value == NULL || dwBytes == 0 ) { // nothing to save
return(SCESTATUS_SUCCESS); }
//
// build a buffer containing type and value
// note MULTI_SZ must be converted to null delimited
//
if ( REG_DWORD == RegType ) {
TCHAR StrValue[20]; DWORD *pdwValue = (DWORD *)Value; memset(StrValue, '\0', 40);
_ultow(*pdwValue, StrValue, 10);
PWSTR pValue = (PWSTR)ScepAlloc(0, (wcslen(StrValue)+1)*2);
if ( pValue ) {
wcscpy(pValue, StrValue);
pRegValues->Value = pValue; pRegValues->ValueType = RegType;
} else { rc = SCESTATUS_NOT_ENOUGH_RESOURCE; }
} else {
PWSTR StrValue;
if ( (dwBytes % 2) && REG_BINARY == RegType ) { StrValue = (PWSTR)ScepAlloc(LPTR, dwBytes+5); } else { StrValue = (PWSTR)ScepAlloc(LPTR, dwBytes+4); // 2 wide chars: two NULL
}
if ( StrValue ) {
if (REG_BINARY == RegType && dwBytes == 1) { swprintf(StrValue, L"%d", *Value); } else { memcpy(StrValue, (PBYTE)Value, dwBytes); }
if ( (dwBytes % 2) && REG_BINARY == RegType ) { StrValue[dwBytes/2+1] = L'\0'; StrValue[dwBytes/2+2] = L'\0'; } else { StrValue[dwBytes/2+0] = L'\0'; StrValue[dwBytes/2+1] = L'\0'; }
pRegValues->Value = StrValue; pRegValues->ValueType = RegType;
} else { rc = SCESTATUS_NOT_ENOUGH_RESOURCE; } }
return(rc);
}
SCESTATUSScepEnumAllRegValues( IN OUT PDWORD pCount, IN OUT PSCE_REGISTRY_VALUE_INFO *paRegValues )/*
Routine Description:
Enumerate all registry values supported by SCE from registry.
Arguments:
pCount - the number of reg values to output
paRegValues - the array of registry values to output
Return Value:
*/{ DWORD Win32Rc; HKEY hKey=NULL; PSCE_NAME_STATUS_LIST pnsList=NULL; DWORD nAdded=0;
Win32Rc = RegOpenKeyEx( HKEY_LOCAL_MACHINE, SCE_ROOT_REGVALUE_PATH, 0, KEY_READ, &hKey );
DWORD cSubKeys = 0; DWORD nMaxLen;
if ( Win32Rc == ERROR_SUCCESS ) {
//
// enumerate all subkeys of the key
//
Win32Rc = RegQueryInfoKey ( hKey, NULL, NULL, NULL, &cSubKeys, &nMaxLen, NULL, NULL, NULL, NULL, NULL, NULL ); }
if ( Win32Rc == ERROR_SUCCESS && cSubKeys > 0 ) {
PWSTR szName = (PWSTR)ScepAlloc(0, (nMaxLen+2)*sizeof(WCHAR));
if ( !szName ) { Win32Rc = ERROR_NOT_ENOUGH_MEMORY;
} else {
DWORD BufSize; DWORD index = 0;
do {
BufSize = nMaxLen+1; Win32Rc = RegEnumKeyEx( hKey, index, szName, &BufSize, NULL, NULL, NULL, NULL);
if ( ERROR_SUCCESS == Win32Rc ) {
index++;
//
// get the full registry key name and Valuetype
//
cSubKeys = REG_SZ;
//
// query ValueType, if error, default REG_SZ
//
ScepRegQueryIntValue( hKey, szName, SCE_REG_VALUE_TYPE, &cSubKeys );
if ( cSubKeys < REG_SZ || cSubKeys > REG_MULTI_SZ ) { cSubKeys = REG_SZ; }
//
// convert the path name
//
ScepConvertMultiSzToDelim(szName, BufSize, L'/', L'\\');
//
// compare with the input array, if not exist,
// add it
//
for ( DWORD i=0; i<*pCount; i++ ) { if ( (*paRegValues)[i].FullValueName && _wcsicmp(szName, (*paRegValues)[i].FullValueName) == 0 ) { break; } }
if ( i >= *pCount ) { //
// did not find a match, add it
//
if ( SCESTATUS_SUCCESS != ScepAddToNameStatusList(&pnsList, szName, BufSize, cSubKeys) ) {
Win32Rc = ERROR_NOT_ENOUGH_MEMORY; break; } nAdded++; }
} else if ( ERROR_NO_MORE_ITEMS != Win32Rc ) { break; }
} while ( Win32Rc != ERROR_NO_MORE_ITEMS );
if ( Win32Rc == ERROR_NO_MORE_ITEMS ) { Win32Rc = ERROR_SUCCESS; }
//
// free the enumeration buffer
//
ScepFree(szName); } }
if ( hKey ) {
RegCloseKey(hKey); }
if ( ERROR_SUCCESS == Win32Rc ) { //
// add the name list to the output arrays
//
DWORD nNewCount = *pCount + nAdded; PSCE_REGISTRY_VALUE_INFO aNewArray;
if ( nNewCount ) {
aNewArray = (PSCE_REGISTRY_VALUE_INFO)ScepAlloc(0, nNewCount*sizeof(SCE_REGISTRY_VALUE_INFO));
if ( aNewArray ) {
DWORD i; for ( i=0; i<*pCount; i++ ) { aNewArray[i].FullValueName = (*paRegValues)[i].FullValueName; aNewArray[i].Value = (*paRegValues)[i].Value; aNewArray[i].ValueType = (*paRegValues)[i].ValueType; }
i=0; for ( PSCE_NAME_STATUS_LIST pns=pnsList; pns; pns=pns->Next ) {
if ( pns->Name && i < nAdded ) {
aNewArray[*pCount+i].FullValueName = pns->Name; pns->Name = NULL; aNewArray[*pCount+i].Value = NULL; aNewArray[*pCount+i].ValueType = pns->Status;
i++;
} }
//
// free the original array
// all components in the array are already transferred to the new array
//
ScepFree(*paRegValues); *pCount = nNewCount; *paRegValues = aNewArray;
} else {
Win32Rc = ERROR_NOT_ENOUGH_MEMORY; } } }
if ( ERROR_FILE_NOT_FOUND == Win32Rc || ERROR_PATH_NOT_FOUND == Win32Rc ) { //
// no value has been registered
//
Win32Rc = ERROR_SUCCESS; }
//
// free the name status list
//
SceFreeMemory(pnsList, SCE_STRUCT_NAME_STATUS_LIST);
return( ScepDosErrorToSceStatus(Win32Rc) );
}
|
