mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
896 lines
27 KiB
896 lines
27 KiB
//*********************************************************************
|
|
//* Microsoft Windows **
|
|
//* Copyright(c) Microsoft Corp., 1993 **
|
|
//*********************************************************************
|
|
|
|
#include "admincfg.h"
|
|
UINT LoadUsersFromKey(HWND hwndList,HKEY hkeyRoot,TABLEENTRY * pTableEntry,
|
|
DWORD dwType);
|
|
UINT LoadOneEntry(USERDATA ** ppUserData,TABLEENTRY * pTableEntry,HKEY hkeyRoot,
|
|
TCHAR * pszCurrentKeyName,HGLOBAL hUser,DWORD *pdwFoundSettings);
|
|
UINT LoadUserData(USERDATA ** ppUserData,HGLOBAL hTable,HKEY hkeyRoot,
|
|
TCHAR * pszCurrentKeyName,HGLOBAL hUser,DWORD *pdwFoundSettings);
|
|
UINT LoadPolicy(USERDATA ** ppUserData,TABLEENTRY * pTableEntry,HKEY hkeyRoot,
|
|
TCHAR * pszCurrentKeyName,HGLOBAL hUser);
|
|
UINT LoadSettings(USERDATA ** ppUserData,TABLEENTRY * pTableEntry,HKEY hkeyRoot,
|
|
TCHAR * pszCurrentKeyName,HGLOBAL hUser,DWORD *pdwFoundSettings);
|
|
UINT LoadListboxData(USERDATA ** ppUserData,TABLEENTRY * pTableEntry,HKEY hkeyRoot,
|
|
TCHAR * pszCurrentKeyName,HGLOBAL hUser,DWORD * pdwFound);
|
|
BOOL ReadStandardValue(HKEY hkeyRoot,TCHAR * pszKeyName,TCHAR * pszValueName,
|
|
TABLEENTRY * pTableEntry,DWORD * pdwData,DWORD * pdwFound);
|
|
BOOL ReadCustomValue(HKEY hkeyRoot,TCHAR * pszKeyName,TCHAR * pszValueName,
|
|
TCHAR * pszValue,UINT cbValue,DWORD * pdwValue,DWORD * pdwFlags);
|
|
BOOL CompareCustomValue(HKEY hkeyRoot,TCHAR * pszKeyName,TCHAR * pszValueName,
|
|
STATEVALUE * pStateValue,DWORD * pdwFound);
|
|
|
|
// flags for detected settings
|
|
#define FS_PRESENT 0x0001
|
|
#define FS_DELETED 0x0002
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: LoadFile
|
|
|
|
SYNOPSIS: Loads the specified policy file
|
|
|
|
********************************************************************/
|
|
BOOL LoadFile(TCHAR * pszFilename,HWND hwndApp,HWND hwndList,BOOL fDisplayErrors)
|
|
{
|
|
HKEY hkeyMain=NULL,hkeyUser=NULL,hkeyWorkstation=NULL,hkeyGroup=NULL,hkeyGroupPriority=NULL;
|
|
UINT uRet;
|
|
OFSTRUCT of;
|
|
HCURSOR hOldCursor;
|
|
HFILE hFile;
|
|
of.cBytes = sizeof(of);
|
|
|
|
hOldCursor=SetCursor(LoadCursor(NULL,IDC_WAIT));
|
|
|
|
// RegLoadKey returns totally coarse error codes, so first do
|
|
// an open file on the file to get a sane error message if there's
|
|
// a problem
|
|
|
|
hFile = OpenFile(pszFilename,&of,OF_EXIST);
|
|
|
|
if (hFile == HFILE_ERROR) {
|
|
SetCursor(hOldCursor);
|
|
if (fDisplayErrors)
|
|
DisplayStandardError(hwndApp,pszFilename,IDS_ErrREGERR_LOADKEY1,
|
|
of.nErrCode);
|
|
return FALSE;
|
|
}
|
|
|
|
// Not needed. This will raise an exception.
|
|
// _lclose (hFile);
|
|
|
|
// load the hive file
|
|
if ((uRet = MyRegLoadKey(HKEY_LOCAL_MACHINE,szTMPDATA,pszFilename))
|
|
!= ERROR_SUCCESS) {
|
|
SetCursor(hOldCursor);
|
|
if (fDisplayErrors)
|
|
DisplayStandardError(hwndApp,pszFilename,IDS_ErrREGERR_LOADKEY1,uRet);
|
|
return FALSE;
|
|
}
|
|
|
|
// read information from local registry
|
|
if ( (RegOpenKey(HKEY_LOCAL_MACHINE,szTMPDATA,&hkeyMain) !=
|
|
ERROR_SUCCESS) ||
|
|
(RegOpenKey(hkeyMain,szUSERS,&hkeyUser) != ERROR_SUCCESS) ||
|
|
(RegOpenKey(hkeyMain,szWORKSTATIONS,&hkeyWorkstation)
|
|
!= ERROR_SUCCESS)) {
|
|
SetCursor(hOldCursor);
|
|
|
|
if (fDisplayErrors)
|
|
MsgBoxParam(hwndApp,IDS_ErrINVALIDPOLICYFILE,pszFilename,
|
|
MB_ICONEXCLAMATION,MB_OK);
|
|
|
|
if (hkeyWorkstation) RegCloseKey(hkeyWorkstation);
|
|
if (hkeyUser) RegCloseKey(hkeyUser);
|
|
if (hkeyMain) RegCloseKey(hkeyMain);
|
|
MyRegUnLoadKey(HKEY_LOCAL_MACHINE,szTMPDATA);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
// if we fail to open these two keys no big deal, these are optional keys.
|
|
// HKEYs are checked below before we use them
|
|
RegOpenKey(hkeyMain,szUSERGROUPS,&hkeyGroup);
|
|
RegOpenKey(hkeyMain,szUSERGROUPDATA,&hkeyGroupPriority);
|
|
|
|
// load users
|
|
if ((uRet = LoadUsersFromKey(hwndList,hkeyUser,gClassList.pUserCategoryList,
|
|
UT_USER)) != ERROR_SUCCESS)
|
|
goto cleanup;
|
|
// load workstations
|
|
if ((uRet = LoadUsersFromKey(hwndList,hkeyWorkstation,gClassList.pMachineCategoryList,
|
|
UT_MACHINE))
|
|
!= ERROR_SUCCESS)
|
|
goto cleanup;
|
|
|
|
#ifdef INCL_GROUP_SUPPORT
|
|
// load groups
|
|
if (hkeyGroupPriority && hkeyGroup) {
|
|
if ((uRet = LoadGroupPriorityList(hkeyGroupPriority,hkeyGroup)) != ERROR_SUCCESS)
|
|
goto cleanup;
|
|
|
|
if (uRet = LoadUsersFromKey(hwndList,hkeyGroup,gClassList.pUserCategoryList,
|
|
UT_USER | UF_GROUP)
|
|
!= ERROR_SUCCESS)
|
|
goto cleanup;
|
|
}
|
|
#endif
|
|
|
|
uRet = ERROR_SUCCESS;
|
|
cleanup:
|
|
RegCloseKey(hkeyUser);
|
|
RegCloseKey(hkeyWorkstation);
|
|
RegCloseKey(hkeyMain);
|
|
if (hkeyGroup)
|
|
RegCloseKey(hkeyGroup);
|
|
if (hkeyGroupPriority)
|
|
RegCloseKey(hkeyGroupPriority);
|
|
MyRegUnLoadKey(HKEY_LOCAL_MACHINE,szTMPDATA);
|
|
SetFileAttributes(pszFilename,FILE_ATTRIBUTE_ARCHIVE);
|
|
ClearDeletedUserList();
|
|
SetCursor(hOldCursor);
|
|
|
|
if (uRet != ERROR_SUCCESS && fDisplayErrors) {
|
|
if (uRet == ERROR_NOT_ENOUGH_MEMORY) {
|
|
MsgBox(hwndApp,IDS_ErrOUTOFMEMORY,MB_ICONEXCLAMATION,MB_OK);
|
|
} else {
|
|
TCHAR szFmt[REGBUFLEN],szMsg[REGBUFLEN+MAX_PATH+1];
|
|
LoadSz(IDS_ErrREGERR_LOADKEY,szFmt,ARRAYSIZE(szFmt));
|
|
wsprintf(szMsg,szFmt,pszFilename,uRet);
|
|
MsgBoxSz(hwndApp,szMsg,MB_ICONEXCLAMATION,MB_OK);
|
|
}
|
|
// remove any users that might have gotten loaded
|
|
RemoveAllUsers(hwndList);
|
|
}
|
|
|
|
return (uRet == ERROR_SUCCESS);
|
|
}
|
|
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: LoadFromRegistry
|
|
|
|
SYNOPSIS: Loads policies from the registry
|
|
|
|
NOTES: Errors will be displayed if fDisplayErrors is TRUE.
|
|
|
|
********************************************************************/
|
|
BOOL LoadFromRegistry(HWND hwndApp,HWND hwndList,BOOL fDisplayErrors)
|
|
{
|
|
HKEY hkeyUser=NULL,hkeyWorkstation=NULL;
|
|
UINT uRet = ERROR_SUCCESS;
|
|
HGLOBAL hUser,hWorkstation;
|
|
USERDATA * pUserData=NULL,* pWorkstationData=NULL;
|
|
HCURSOR hOldCursor;
|
|
|
|
if ((RegOpenKeyEx(hkeyVirtHCU,NULL,0,KEY_ALL_ACCESS,&hkeyUser) != ERROR_SUCCESS) ||
|
|
(RegOpenKeyEx(hkeyVirtHLM,NULL,0,KEY_ALL_ACCESS,&hkeyWorkstation) != ERROR_SUCCESS)) {
|
|
if (fDisplayErrors)
|
|
MsgBox(hwndApp,IDS_ErrCANTOPENREGISTRY,MB_ICONEXCLAMATION,MB_OK);
|
|
if (hkeyUser) RegCloseKey(hkeyUser);
|
|
if (hkeyWorkstation) RegCloseKey(hkeyWorkstation);
|
|
return FALSE;
|
|
}
|
|
|
|
hUser = AddUser(hwndList,LoadSz(IDS_LOCALUSER,szSmallBuf,ARRAYSIZE(szSmallBuf))
|
|
,UT_USER);
|
|
hWorkstation = AddUser(hwndList,LoadSz(IDS_LOCALCOMPUTER,szSmallBuf,
|
|
ARRAYSIZE(szSmallBuf)),UT_MACHINE);
|
|
|
|
if (!hUser || !hWorkstation || !(pUserData = (USERDATA *) GlobalLock(hUser)) ||
|
|
!(pWorkstationData = (USERDATA *) GlobalLock(hWorkstation)) ) {
|
|
uRet = ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
hOldCursor=SetCursor(LoadCursor(NULL,IDC_WAIT));
|
|
|
|
if (uRet == ERROR_SUCCESS)
|
|
uRet = LoadUserData(&pUserData,gClassList.pUserCategoryList,hkeyUser,NULL,
|
|
hUser,NULL);
|
|
if (uRet == ERROR_SUCCESS)
|
|
uRet = LoadUserData(&pWorkstationData,gClassList.pMachineCategoryList,
|
|
hkeyWorkstation,NULL,hWorkstation,NULL);
|
|
|
|
RegCloseKey(hkeyUser);
|
|
RegCloseKey(hkeyWorkstation);
|
|
GlobalUnlock(hUser);
|
|
GlobalUnlock(hWorkstation);
|
|
|
|
SetCursor(hOldCursor);
|
|
|
|
if (uRet != ERROR_SUCCESS) {
|
|
if (uRet == ERROR_NOT_ENOUGH_MEMORY) {
|
|
if (fDisplayErrors)
|
|
MsgBox(hwndApp,IDS_ErrOUTOFMEMORY,MB_ICONEXCLAMATION,MB_OK);
|
|
} else {
|
|
TCHAR szMsg[REGBUFLEN+1];
|
|
wsprintf(szMsg,TEXT("%lu"),uRet);
|
|
if (fDisplayErrors)
|
|
MsgBoxParam(hwndApp,IDS_ErrREGERR_LOAD,szMsg,MB_ICONEXCLAMATION,MB_OK);
|
|
}
|
|
|
|
RemoveAllUsers(hwndList);
|
|
return FALSE;
|
|
}
|
|
ClearDeletedUserList();
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
UINT LoadUsersFromKey(HWND hwndList,HKEY hkeyRoot,TABLEENTRY * pTableEntry,
|
|
DWORD dwType)
|
|
{
|
|
TCHAR szKeyName[MAX_PATH+1];
|
|
UINT uRet,nIndex=0;
|
|
HGLOBAL hUser;
|
|
USERDATA * pUserData;
|
|
HKEY hKey;
|
|
TCHAR szUnmappedName[MAXNAMELEN+1];
|
|
|
|
do {
|
|
// enumerate the subkeys, which will be user/workstation names
|
|
if ((uRet=RegEnumKey(hkeyRoot,nIndex,szKeyName,ARRAYSIZE(szKeyName)))
|
|
== ERROR_SUCCESS) {
|
|
|
|
// open the subkey
|
|
if ((uRet = RegOpenKey(hkeyRoot,szKeyName,&hKey)) != ERROR_SUCCESS)
|
|
return uRet;
|
|
|
|
// allocate this user and add to list control
|
|
UnmapUserName(szKeyName,szUnmappedName,(BOOL) (dwType & UT_USER));
|
|
hUser = AddUser(hwndList,szUnmappedName,dwType);
|
|
if ( !hUser || !(pUserData = (USERDATA *) GlobalLock(hUser))) {
|
|
RegCloseKey(hKey);
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
// load user data into user's buffer
|
|
uRet=LoadUserData(&pUserData,pTableEntry,hKey,NULL,hUser,NULL);
|
|
|
|
#ifdef INCL_GROUP_SUPPORT
|
|
// add group name to bottom of priority list. The group name
|
|
// should already be somewhere on priority list because we loaded
|
|
// the list earlier, but this will add the group name to the bottom
|
|
// of the list if it's not on the list already. Adds extra robustness
|
|
// in the face of god-knows-whose-app creating flaky policy files.
|
|
if (dwType == (UT_USER | UF_GROUP))
|
|
AddGroupPriEntry(szUnmappedName);
|
|
#endif
|
|
|
|
RegCloseKey(hKey);
|
|
GlobalUnlock(hUser);
|
|
|
|
// make a copy of the initial state of each user, so on
|
|
// a save we only have to save the deltas. We need to only
|
|
// save the deltas, because saves have to be non-destructive--
|
|
// we can't clean the user's tree out and start over because
|
|
// there might be stuff in there we don't know about.
|
|
CloneUser(hUser);
|
|
|
|
if (uRet != ERROR_SUCCESS) return uRet;
|
|
}
|
|
|
|
nIndex++;
|
|
} while (uRet == ERROR_SUCCESS);
|
|
|
|
// end of enum will report ERROR_NO_MORE_ITEMS, don't report this as error
|
|
if (uRet == ERROR_NO_MORE_ITEMS) uRet = ERROR_SUCCESS;
|
|
|
|
return uRet;
|
|
}
|
|
|
|
UINT LoadUserData(USERDATA ** ppUserData,TABLEENTRY * pTableEntry,HKEY hkeyRoot,
|
|
TCHAR * pszCurrentKeyName,HGLOBAL hUser,DWORD *pdwFoundSettings)
|
|
{
|
|
UINT uRet=ERROR_SUCCESS;
|
|
|
|
while (pTableEntry && (uRet == ERROR_SUCCESS)) {
|
|
|
|
uRet = LoadOneEntry(ppUserData,pTableEntry,hkeyRoot,
|
|
pszCurrentKeyName,hUser,pdwFoundSettings);
|
|
|
|
pTableEntry = pTableEntry->pNext;
|
|
}
|
|
|
|
return uRet;
|
|
}
|
|
|
|
UINT LoadOneEntry(USERDATA ** ppUserData,TABLEENTRY * pTableEntry,HKEY hkeyRoot,
|
|
TCHAR * pszCurrentKeyName,HGLOBAL hUser,DWORD *pdwFoundSettings)
|
|
{
|
|
UINT uRet;
|
|
|
|
#if 0
|
|
wsprintf(szDebugOut,TEXT("LoadOneEntry: %s\r\n"),GETNAMEPTR(pTableEntry));
|
|
OutputDebugString(szDebugOut);
|
|
#endif
|
|
|
|
// if there is a key name for this entry, it becomes the "current"
|
|
// key name-- it will be overridden if child entries specify their
|
|
// own keys, otherwise it's the default key for children to use
|
|
if (pTableEntry->uOffsetKeyName) {
|
|
pszCurrentKeyName = GETKEYNAMEPTR(pTableEntry);
|
|
}
|
|
|
|
if ((pTableEntry->dwType == ETYPE_CATEGORY || pTableEntry->dwType
|
|
== ETYPE_ROOT) &&
|
|
(pTableEntry->pChild)) {
|
|
|
|
// if entry is a category, recusively process sub-categories and policies
|
|
|
|
if ((uRet=LoadUserData(ppUserData,pTableEntry->pChild,
|
|
hkeyRoot,pszCurrentKeyName,hUser,pdwFoundSettings)) != ERROR_SUCCESS) {
|
|
return uRet;
|
|
}
|
|
} else if (pTableEntry->dwType == ETYPE_POLICY) {
|
|
|
|
if ((uRet = LoadPolicy(ppUserData,pTableEntry,hkeyRoot,
|
|
pszCurrentKeyName,hUser)) != ERROR_SUCCESS) {
|
|
return uRet;
|
|
}
|
|
|
|
} else if ( (pTableEntry->dwType & ETYPE_MASK) == ETYPE_SETTING
|
|
&& !(pTableEntry->dwType & STYPE_TEXT)) {
|
|
|
|
if ((uRet = LoadSettings(ppUserData,pTableEntry,hkeyRoot,
|
|
pszCurrentKeyName,hUser,pdwFoundSettings)) != ERROR_SUCCESS) {
|
|
return uRet;
|
|
}
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
UINT LoadPolicy(USERDATA ** ppUserData,TABLEENTRY * pTableEntry,HKEY hkeyRoot,
|
|
TCHAR * pszCurrentKeyName,HGLOBAL hUser)
|
|
{
|
|
DWORD dwData=0;
|
|
UINT uRet;
|
|
TCHAR * pszValueName;
|
|
DWORD dwFoundSettings=0;
|
|
BOOL fHasPolicySwitch=FALSE;
|
|
BOOL fFound=FALSE,fCustomOn=FALSE,fCustomOff=FALSE;
|
|
|
|
// get the name of the value to read, if any
|
|
if (((POLICY *) pTableEntry)->uOffsetValueName) {
|
|
fHasPolicySwitch = TRUE;
|
|
|
|
pszValueName = GETVALUENAMEPTR(((POLICY *) pTableEntry));
|
|
|
|
// first look for custom on/off values
|
|
if (((POLICY *) pTableEntry)->uOffsetValue_On) {
|
|
fCustomOn = TRUE;
|
|
if (CompareCustomValue(hkeyRoot,pszCurrentKeyName,pszValueName,
|
|
(STATEVALUE *) ((TCHAR *) pTableEntry + ((POLICY *)
|
|
pTableEntry)->uOffsetValue_On),&dwFoundSettings)) {
|
|
dwData = 1;
|
|
fFound = TRUE;
|
|
}
|
|
}
|
|
|
|
if (!fFound && ((POLICY *) pTableEntry)->uOffsetValue_Off) {
|
|
fCustomOff = TRUE;
|
|
if (CompareCustomValue(hkeyRoot,pszCurrentKeyName,pszValueName,
|
|
(STATEVALUE *) ((TCHAR *) pTableEntry + ((POLICY *)
|
|
pTableEntry)->uOffsetValue_Off),&dwFoundSettings)) {
|
|
dwData = 0;
|
|
fFound = TRUE;
|
|
}
|
|
}
|
|
|
|
// look for standard values if custom values have not been specified
|
|
if (!fCustomOn && !fCustomOff &&
|
|
ReadStandardValue(hkeyRoot,pszCurrentKeyName,pszValueName,
|
|
pTableEntry,&dwData,&dwFoundSettings)) {
|
|
fFound = TRUE;
|
|
}
|
|
|
|
if (fFound) {
|
|
// store data in user's buffer
|
|
(*ppUserData)->SettingData[((POLICY *) pTableEntry)->uDataIndex].uData =
|
|
(dwData ? IMG_CHECKED : IMG_UNCHECKED);
|
|
}
|
|
}
|
|
|
|
dwFoundSettings = 0;
|
|
// process settings underneath this policy (if any)
|
|
if (pTableEntry->pChild && (dwData || !fHasPolicySwitch)) {
|
|
if ((uRet=LoadUserData(ppUserData,pTableEntry->pChild,hkeyRoot,
|
|
pszCurrentKeyName,hUser,&dwFoundSettings)) !=ERROR_SUCCESS) {
|
|
return uRet;
|
|
}
|
|
}
|
|
|
|
if (!fHasPolicySwitch) {
|
|
// store data in user's buffer
|
|
if (dwFoundSettings) {
|
|
(*ppUserData)->SettingData[((POLICY *) pTableEntry)->uDataIndex].uData =
|
|
(dwFoundSettings & FS_PRESENT ? IMG_CHECKED : IMG_UNCHECKED);
|
|
}
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
UINT LoadSettings(USERDATA ** ppUserData,TABLEENTRY * pTableEntry,HKEY hkeyRoot,
|
|
TCHAR * pszCurrentKeyName,HGLOBAL hUser,DWORD * pdwFound)
|
|
{
|
|
UINT uRet = ERROR_SUCCESS;
|
|
TCHAR * pszValueName = NULL;
|
|
DWORD dwData,dwFlags,dwFoundSettings=0;
|
|
TCHAR szData[MAXSTRLEN];
|
|
BOOL fCustomOn=FALSE,fCustomOff=FALSE,fFound=FALSE;
|
|
TCHAR * pObjectData = GETOBJECTDATAPTR(((SETTINGS *)pTableEntry));
|
|
TCHAR szNewValueName[MAX_PATH+1];
|
|
|
|
// get the name of the value to read
|
|
if (((SETTINGS *) pTableEntry)->uOffsetValueName) {
|
|
pszValueName = GETVALUENAMEPTR(((SETTINGS *) pTableEntry));
|
|
}
|
|
else return ERROR_NOT_ENOUGH_MEMORY;
|
|
|
|
switch (pTableEntry->dwType & STYPE_MASK) {
|
|
|
|
case STYPE_EDITTEXT:
|
|
case STYPE_COMBOBOX:
|
|
|
|
dwFlags = ( (SETTINGS *) pTableEntry)->dwFlags;
|
|
|
|
// add prefixes if appropriate
|
|
PrependValueName(pszValueName,dwFlags,
|
|
szNewValueName,ARRAYSIZE(szNewValueName));
|
|
|
|
if ((uRet = ReadRegistryStringValue(hkeyRoot,pszCurrentKeyName,
|
|
szNewValueName,szData,ARRAYSIZE(szData) * sizeof(TCHAR))) == ERROR_SUCCESS) {
|
|
|
|
GlobalUnlock(hUser);
|
|
if (!SetVariableLengthData(hUser,((SETTINGS *)
|
|
pTableEntry)->uDataIndex,szData,lstrlen(szData)+1)) {
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
if (!((*ppUserData) = (USERDATA *) GlobalLock(hUser)))
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
|
|
// set flag that we found setting in registry/policy file
|
|
if (pdwFound)
|
|
*pdwFound |= FS_PRESENT;
|
|
} else if ((dwAppState & AS_POLICYFILE) && !(dwFlags & VF_DELETE)) {
|
|
|
|
// see if this key is marked as deleted
|
|
PrependValueName(pszValueName,VF_DELETE,
|
|
szNewValueName,ARRAYSIZE(szNewValueName));
|
|
if ((uRet = ReadRegistryStringValue(hkeyRoot,pszCurrentKeyName,
|
|
szNewValueName,szData,ARRAYSIZE(szData) * sizeof(TCHAR))) == ERROR_SUCCESS) {
|
|
|
|
// set flag that we found setting marked as deleted in
|
|
// policy file
|
|
if (pdwFound)
|
|
*pdwFound |= FS_DELETED;
|
|
}
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
break;
|
|
|
|
case STYPE_CHECKBOX:
|
|
|
|
// first look for custom on/off values
|
|
if (((CHECKBOXINFO *) pObjectData)->uOffsetValue_On) {
|
|
fCustomOn = TRUE;
|
|
if (CompareCustomValue(hkeyRoot,pszCurrentKeyName,pszValueName,
|
|
(STATEVALUE *) ((TCHAR *) pTableEntry + ((CHECKBOXINFO *)
|
|
pObjectData)->uOffsetValue_On),&dwFoundSettings)) {
|
|
dwData = 1;
|
|
fFound = TRUE;
|
|
}
|
|
}
|
|
|
|
if (!fFound && ((CHECKBOXINFO *) pObjectData)->uOffsetValue_Off) {
|
|
fCustomOff = TRUE;
|
|
if (CompareCustomValue(hkeyRoot,pszCurrentKeyName,pszValueName,
|
|
(STATEVALUE *) ((TCHAR *) pTableEntry + ((CHECKBOXINFO *)
|
|
pObjectData)->uOffsetValue_Off),&dwFoundSettings)) {
|
|
dwData = 0;
|
|
fFound = TRUE;
|
|
}
|
|
}
|
|
|
|
// look for standard values if custom values have not been specified
|
|
if (!fFound &&
|
|
ReadStandardValue(hkeyRoot,pszCurrentKeyName,pszValueName,
|
|
pTableEntry,&dwData,&dwFoundSettings)) {
|
|
fFound = TRUE;
|
|
}
|
|
|
|
if (fFound) {
|
|
(*ppUserData)->SettingData[((SETTINGS *)
|
|
pTableEntry)->uDataIndex].uData = dwData;
|
|
|
|
// set flag that we found setting in registry
|
|
if (pdwFound)
|
|
*pdwFound |= dwFoundSettings;
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
break;
|
|
|
|
case STYPE_NUMERIC:
|
|
|
|
if (ReadStandardValue(hkeyRoot,pszCurrentKeyName,pszValueName,
|
|
pTableEntry,&dwData,&dwFoundSettings)) {
|
|
|
|
(*ppUserData)->SettingData[((SETTINGS *)
|
|
pTableEntry)->uDataIndex].uData = dwData;
|
|
|
|
// set flag that we found setting in registry
|
|
if (pdwFound)
|
|
*pdwFound |= dwFoundSettings;
|
|
}
|
|
break;
|
|
|
|
case STYPE_DROPDOWNLIST:
|
|
|
|
if (ReadCustomValue(hkeyRoot,pszCurrentKeyName,pszValueName,
|
|
szData,ARRAYSIZE(szData) * sizeof(TCHAR),&dwData,&dwFlags)) {
|
|
BOOL fMatch = FALSE;
|
|
|
|
if ((dwAppState & AS_POLICYFILE) &&
|
|
(dwFlags & VF_DELETE)) {
|
|
// set flag that we found setting marked as deleted
|
|
// in policy file
|
|
if (pdwFound)
|
|
*pdwFound |= FS_DELETED;
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
// walk the list of DROPDOWNINFO structs (one for each state),
|
|
// and see if the value we found matches the value for the state
|
|
|
|
if ( ((SETTINGS *) pTableEntry)->uOffsetObjectData) {
|
|
DROPDOWNINFO * pddi = (DROPDOWNINFO *)
|
|
GETOBJECTDATAPTR( ((SETTINGS *) pTableEntry));
|
|
UINT nIndex = 0;
|
|
|
|
do {
|
|
if (dwFlags == pddi->dwFlags) {
|
|
|
|
if (pddi->dwFlags & VF_ISNUMERIC) {
|
|
if (dwData == pddi->dwValue)
|
|
fMatch = TRUE;
|
|
} else if (!pddi->dwFlags) {
|
|
if (!lstrcmpi(szData,(TCHAR *) pTableEntry +
|
|
pddi->uOffsetValue))
|
|
fMatch = TRUE;
|
|
}
|
|
}
|
|
|
|
if (!pddi->uOffsetNextDropdowninfo || fMatch)
|
|
break;
|
|
|
|
pddi = (DROPDOWNINFO *) ( (TCHAR *) pTableEntry +
|
|
pddi->uOffsetNextDropdowninfo);
|
|
nIndex++;
|
|
|
|
} while (!fMatch);
|
|
|
|
if (fMatch) {
|
|
(*ppUserData)->SettingData[((SETTINGS *)
|
|
pTableEntry)->uDataIndex].uData = nIndex;
|
|
|
|
// set flag that we found setting in registry
|
|
if (pdwFound)
|
|
*pdwFound |= FS_PRESENT;
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case STYPE_LISTBOX:
|
|
|
|
return LoadListboxData(ppUserData,pTableEntry,hkeyRoot,
|
|
pszCurrentKeyName,hUser,pdwFound);
|
|
|
|
break;
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: ReadCustomValue
|
|
|
|
SYNOPSIS: For specified keyname and value name, retrieve the
|
|
value (if there is one).
|
|
|
|
NOTES: fills in pszValue if value is REG_SZ, fills in *pdwValue
|
|
if value is REG_DWORD (and sets VF_ISNUMERIC). Sets
|
|
VF_DELETE if value is marked for deletion.
|
|
|
|
********************************************************************/
|
|
BOOL ReadCustomValue(HKEY hkeyRoot,TCHAR * pszKeyName,TCHAR * pszValueName,
|
|
TCHAR * pszValue,UINT cbValue,DWORD * pdwValue,DWORD * pdwFlags)
|
|
{
|
|
HKEY hKey;
|
|
DWORD dwType,dwSize=cbValue * sizeof(TCHAR);
|
|
BOOL fSuccess = FALSE;
|
|
TCHAR szNewValueName[MAX_PATH+1];
|
|
|
|
*( (DWORD *)pszValue) = *pdwValue=0;
|
|
|
|
if (RegOpenKey(hkeyRoot,pszKeyName,&hKey) == ERROR_SUCCESS) {
|
|
if (RegQueryValueEx(hKey,pszValueName,NULL,&dwType,(LPBYTE) pszValue,
|
|
&dwSize) == ERROR_SUCCESS) {
|
|
|
|
if (dwType == REG_SZ) {
|
|
// value returned in pszValueName
|
|
*pdwFlags = 0;
|
|
fSuccess = TRUE;
|
|
} else if (dwType == REG_DWORD || dwType == REG_BINARY) {
|
|
// copy value to *pdwValue
|
|
memcpy(pdwValue,pszValue,sizeof(DWORD));
|
|
*pdwFlags = VF_ISNUMERIC;
|
|
fSuccess = TRUE;
|
|
}
|
|
|
|
} else {
|
|
// see if this is a value that's marked for deletion
|
|
// (valuename is prepended with "**del."
|
|
PrependValueName(pszValueName,VF_DELETE,
|
|
szNewValueName,ARRAYSIZE(szNewValueName));
|
|
|
|
if (RegQueryValueEx(hKey,szNewValueName,NULL,&dwType,(LPBYTE) pszValue,
|
|
&dwSize) == ERROR_SUCCESS) {
|
|
fSuccess=TRUE;
|
|
*pdwFlags = VF_DELETE;
|
|
} else {
|
|
// see if this is a soft value
|
|
// (valuename is prepended with "**soft."
|
|
PrependValueName(pszValueName,VF_SOFT,
|
|
szNewValueName,ARRAYSIZE(szNewValueName));
|
|
|
|
if (RegQueryValueEx(hKey,szNewValueName,NULL,&dwType,(LPBYTE) pszValue,
|
|
&dwSize) == ERROR_SUCCESS) {
|
|
fSuccess=TRUE;
|
|
*pdwFlags = VF_SOFT;
|
|
}
|
|
}
|
|
}
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
return fSuccess;
|
|
}
|
|
|
|
BOOL CompareCustomValue(HKEY hkeyRoot,TCHAR * pszKeyName,TCHAR * pszValueName,
|
|
STATEVALUE * pStateValue,DWORD * pdwFound)
|
|
{
|
|
TCHAR szValue[MAXSTRLEN];
|
|
DWORD dwValue;
|
|
TCHAR szNewValueName[MAX_PATH+1];
|
|
|
|
// add prefixes if appropriate
|
|
PrependValueName(pszValueName,pStateValue->dwFlags,
|
|
szNewValueName,ARRAYSIZE(szNewValueName));
|
|
|
|
if (pStateValue->dwFlags & VF_ISNUMERIC) {
|
|
if ((ReadRegistryDWordValue(hkeyRoot,pszKeyName,
|
|
szNewValueName,&dwValue) == ERROR_SUCCESS) &&
|
|
dwValue == pStateValue->dwValue) {
|
|
*pdwFound = FS_PRESENT;
|
|
return TRUE;
|
|
}
|
|
} else if (pStateValue->dwFlags & VF_DELETE) {
|
|
|
|
if (dwAppState & AS_POLICYFILE) {
|
|
// see if this is a value that's marked for deletion
|
|
// (valuename is prepended with "**del."
|
|
|
|
if ((ReadRegistryStringValue(hkeyRoot,pszKeyName,
|
|
szNewValueName,szValue,ARRAYSIZE(szValue) * sizeof(TCHAR))) == ERROR_SUCCESS) {
|
|
*pdwFound = FS_DELETED;
|
|
return TRUE;
|
|
}
|
|
} else {
|
|
// return TRUE if value ISN't there...
|
|
if (ReadRegistryDWordValue(hkeyRoot,pszKeyName,
|
|
szNewValueName,&dwValue) != ERROR_SUCCESS) {
|
|
*pdwFound = FS_DELETED;
|
|
return TRUE;
|
|
}
|
|
}
|
|
} else {
|
|
if ((ReadRegistryStringValue(hkeyRoot,pszKeyName,
|
|
szNewValueName,szValue,ARRAYSIZE(szValue) * sizeof(TCHAR))) == ERROR_SUCCESS &&
|
|
!lstrcmpi(szValue,pStateValue->szValue)) {
|
|
*pdwFound = FS_PRESENT;
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL ReadStandardValue(HKEY hkeyRoot,TCHAR * pszKeyName,TCHAR * pszValueName,
|
|
TABLEENTRY * pTableEntry,DWORD * pdwData,DWORD * pdwFound)
|
|
{
|
|
UINT uRet;
|
|
TCHAR szNewValueName[MAX_PATH+1];
|
|
|
|
// add prefixes if appropriate
|
|
PrependValueName(pszValueName,((SETTINGS *) pTableEntry)->dwFlags,
|
|
szNewValueName,ARRAYSIZE(szNewValueName));
|
|
|
|
if ( ((SETTINGS *) pTableEntry)->dwFlags & DF_TXTCONVERT) {
|
|
// read numeric value as text if specified
|
|
TCHAR szNum[11];
|
|
uRet = ReadRegistryStringValue(hkeyRoot,pszKeyName,
|
|
szNewValueName,szNum,ARRAYSIZE(szNum) * sizeof(TCHAR));
|
|
if (uRet == ERROR_SUCCESS) {
|
|
StringToNum(szNum,pdwData);
|
|
*pdwFound = FS_PRESENT;
|
|
return TRUE;
|
|
}
|
|
} else {
|
|
// read numeric value as binary
|
|
uRet = ReadRegistryDWordValue(hkeyRoot,pszKeyName,
|
|
szNewValueName,pdwData);
|
|
if (uRet == ERROR_SUCCESS) {
|
|
*pdwFound = FS_PRESENT;
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
// see if this settings has been marked as 'deleted'
|
|
if ((dwAppState & AS_POLICYFILE) && !(dwCmdLineFlags & CLF_DIALOGMODE)) {
|
|
TCHAR szVal[MAX_PATH+1];
|
|
*pdwData = 0;
|
|
PrependValueName(pszValueName,VF_DELETE,szNewValueName,
|
|
ARRAYSIZE(szNewValueName));
|
|
uRet=ReadRegistryStringValue(hkeyRoot,pszKeyName,
|
|
szNewValueName,szVal,ARRAYSIZE(szVal) * sizeof(TCHAR));
|
|
if (uRet == ERROR_SUCCESS) {
|
|
*pdwFound = FS_DELETED;
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
UINT LoadListboxData(USERDATA ** ppUserData,TABLEENTRY * pTableEntry,HKEY hkeyRoot,
|
|
TCHAR * pszCurrentKeyName,HGLOBAL hUser,DWORD * pdwFound)
|
|
{
|
|
HKEY hKey;
|
|
UINT nIndex=0,nLen;
|
|
TCHAR szValueName[MAX_PATH+1],szValueData[MAX_PATH+1];
|
|
DWORD cbValueName,cbValueData;
|
|
DWORD dwType,dwAlloc=1024,dwUsed=0;
|
|
HGLOBAL hBuf;
|
|
TCHAR * pBuf;
|
|
SETTINGS * pSettings = (SETTINGS *) pTableEntry;
|
|
LISTBOXINFO * pListboxInfo = (LISTBOXINFO *)
|
|
GETOBJECTDATAPTR(pSettings);
|
|
BOOL fFoundValues=FALSE,fFoundDelvals=FALSE;
|
|
UINT uRet=ERROR_SUCCESS;
|
|
|
|
if (RegOpenKey(hkeyRoot,pszCurrentKeyName,&hKey) != ERROR_SUCCESS)
|
|
return ERROR_SUCCESS; // nothing to do
|
|
|
|
// allocate a temp buffer to read entries into
|
|
if (!(hBuf = GlobalAlloc(GHND,dwAlloc * sizeof(TCHAR))) ||
|
|
!(pBuf = (TCHAR *) GlobalLock(hBuf))) {
|
|
if (hBuf)
|
|
GlobalFree(hBuf);
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
while (TRUE) {
|
|
cbValueName=ARRAYSIZE(szValueName);
|
|
cbValueData=ARRAYSIZE(szValueData) * sizeof(TCHAR);
|
|
uRet=RegEnumValue(hKey,nIndex,szValueName,&cbValueName,NULL,
|
|
&dwType,szValueData,&cbValueData);
|
|
// stop if we're out of items
|
|
if (uRet != ERROR_SUCCESS && uRet != ERROR_MORE_DATA)
|
|
break;
|
|
nIndex++;
|
|
|
|
// if valuename prefixed with '**', it's a control code, ignore it
|
|
if (szValueName[0] == TEXT('*') && szValueName[1] == TEXT('*')) {
|
|
// if we found **delvals., then some sort of listbox stuff
|
|
// is going on, remember that we found this code
|
|
if (!lstrcmpi(szValueName,szDELVALS))
|
|
fFoundDelvals = TRUE;
|
|
continue;
|
|
}
|
|
|
|
// only process this item if enum was successful
|
|
// (so we'll skip items with weird errors like ERROR_MORE_DATA and
|
|
// but keep going with the enum)
|
|
if (uRet == ERROR_SUCCESS) {
|
|
TCHAR * pszData;
|
|
|
|
// if there's no value name prefix scheme specified (e.g.
|
|
// value names are "foo1", "foo2", etc), and the explicit valuename
|
|
// flag isn't set where we remember the value name as well as
|
|
// the data for every value, then we need the value name to
|
|
// be the same as the value data ("thing.exe=thing.exe").
|
|
if (!(pSettings->dwFlags & DF_EXPLICITVALNAME) &&
|
|
!(pListboxInfo->uOffsetPrefix) && !(pListboxInfo->uOffsetValue)) {
|
|
if (dwType != REG_SZ || lstrcmpi(szValueName,szValueData))
|
|
continue; // skip this value if val name != val data
|
|
}
|
|
|
|
// if explicit valuenames used, then copy the value name into
|
|
// buffer
|
|
if (pSettings->dwFlags & DF_EXPLICITVALNAME) {
|
|
nLen = lstrlen(szValueName) + 1;
|
|
if (!(pBuf=ResizeBuffer(pBuf,hBuf,dwUsed+nLen+4,&dwAlloc)))
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
lstrcpy(pBuf+dwUsed,szValueName);
|
|
dwUsed += nLen;
|
|
}
|
|
|
|
|
|
// for default listbox type, value data is the actual "data"
|
|
// and value name either will be the same as the data or
|
|
// some prefix + "1", "2", etc. If there's a data value to
|
|
// write for each entry, then the "data" is the value name
|
|
// (e.g. "Larry = foo", "Dave = foo"), etc. If explicit value names
|
|
// are turned on, then both the value name and data are stored
|
|
// and editable
|
|
|
|
// copy value data into buffer
|
|
if (pListboxInfo->uOffsetValue) {
|
|
// data value set, use value name for data
|
|
pszData = szValueName;
|
|
} else pszData = szValueData;
|
|
|
|
nLen = lstrlen(pszData) + 1;
|
|
if (!(pBuf=ResizeBuffer(pBuf,hBuf,dwUsed+nLen+4,&dwAlloc)))
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
lstrcpy(pBuf+dwUsed,pszData);
|
|
dwUsed += nLen;
|
|
fFoundValues=TRUE;
|
|
}
|
|
}
|
|
|
|
// doubly null-terminate the buffer... safe to do this because we
|
|
// tacked on the extra "+4" in the ResizeBuffer calls above
|
|
*(pBuf+dwUsed) = TEXT('\0');
|
|
dwUsed++;
|
|
|
|
uRet = ERROR_SUCCESS;
|
|
|
|
if (fFoundValues) {
|
|
// add the value data to user's buffer
|
|
GlobalUnlock(hUser);
|
|
if (!SetVariableLengthData(hUser,((SETTINGS *)
|
|
pTableEntry)->uDataIndex,pBuf,dwUsed)) {
|
|
uRet = ERROR_NOT_ENOUGH_MEMORY;
|
|
} else if (!((*ppUserData) = (USERDATA *) GlobalLock(hUser)))
|
|
uRet = ERROR_NOT_ENOUGH_MEMORY;
|
|
// set flag that we found setting in registry/policy file
|
|
if (pdwFound)
|
|
*pdwFound |= FS_PRESENT;
|
|
} else {
|
|
if (fFoundDelvals && pdwFound) {
|
|
*pdwFound |= FS_DELETED;
|
|
}
|
|
}
|
|
|
|
GlobalUnlock(hBuf);
|
|
GlobalFree(hBuf);
|
|
|
|
RegCloseKey(hKey);
|
|
|
|
return uRet;
|
|
}
|