1095 lines
34 KiB
C
1095 lines
34 KiB
C
//*********************************************************************
|
|
//* Microsoft Windows **
|
|
//* Copyright(c) Microsoft Corp., 1993 **
|
|
//*********************************************************************
|
|
|
|
#include "admincfg.h"
|
|
UINT SaveUserData(USERDATA * pUserData,TABLEENTRY * pTableEntry,HKEY hkeyRoot,
|
|
CHAR * pszCurrentKeyName);
|
|
UINT SaveOneEntry(USERDATA * pUserData,TABLEENTRY * pTableEntry,HKEY hkeyRoot,
|
|
CHAR * pszCurrentKeyName,BOOL fErase);
|
|
UINT SavePolicy(USERDATA * pUserData,TABLEENTRY * pTableEntry,HKEY hkeyRoot,
|
|
CHAR * pszCurrentKeyName);
|
|
UINT SaveSettings(USERDATA * pUserData,TABLEENTRY * pTableEntry,HKEY hkeyRoot,
|
|
CHAR * pszCurrentKeyName,BOOL fErase);
|
|
UINT SaveListboxData(USERDATA * pUserData,TABLEENTRY * pTableEntry,HKEY hkeyRoot,
|
|
CHAR * pszCurrentKeyName,BOOL fErase,BOOL fMarkDeleted);
|
|
UINT WriteStandardValue(HKEY hkeyRoot,CHAR * pszKeyName,CHAR * pszValueName,
|
|
TABLEENTRY * pTableEntry,DWORD dwData,BOOL fErase,BOOL fWriteZero);
|
|
UINT WriteCustomValue(HKEY hkeyRoot,CHAR * pszKeyName,CHAR * pszValueName,
|
|
STATEVALUE * pStateValue,BOOL fErase);
|
|
UINT WriteCustomValue_W(HKEY hkeyRoot,CHAR * pszKeyName,CHAR * pszValueName,
|
|
CHAR * pszValue,DWORD dwValue,DWORD dwFlags,BOOL fErase);
|
|
UINT WriteActionList(HKEY hkeyRoot,ACTIONLIST * pActionList,
|
|
CHAR *pszCurrentKeyName,BOOL fErase);
|
|
UINT WriteDropdownValue(TABLEENTRY * pTableEntry,HKEY hkeyRoot,
|
|
CHAR * pszCurrentKeyName,CHAR * pszValueName,UINT nValue,BOOL fErase);
|
|
UINT ProcessPolicyActionLists(HKEY hkeyRoot,POLICY * pPolicy,
|
|
CHAR * pszCurrentKeyName,UINT uState,BOOL fErase);
|
|
UINT ProcessCheckboxActionLists(HKEY hkeyRoot,TABLEENTRY * pTableEntry,
|
|
CHAR * pszCurrentKeyName,DWORD dwVal,BOOL fErase);
|
|
BOOL GetCloneData(HGLOBAL hClone,UINT uDataIndex,DWORD *pdwData);
|
|
UINT DeleteSettings(USERDATA * pUserData,TABLEENTRY * pTableEntry,HKEY hkeyRoot,
|
|
CHAR * pszCurrentKeyName);
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: SaveFile
|
|
|
|
SYNOPSIS: Saves the active policy file
|
|
|
|
NOTES: Save is non-destructive; e.g. we don't wipe out the file
|
|
and write it from scratch, because there may be stuff
|
|
in the file that we're not aware of. If this is a previously
|
|
saved file, we look at the clones of users that contain
|
|
their initial states and tip-toe through writing out
|
|
the data.
|
|
|
|
********************************************************************/
|
|
BOOL SaveFile(CHAR * pszFilename,HWND hwndApp,HWND hwndList)
|
|
{
|
|
HKEY hkeyMain=NULL,hkeyUser=NULL,hkeyWorkstation=NULL,hkeyRoot,hkeyInstance;
|
|
HKEY hkeyGroup=NULL,hkeyGroupPriority=NULL;
|
|
UINT uRet=ERROR_SUCCESS,nIndex;
|
|
HGLOBAL hUser;
|
|
USERDATA * pUserData;
|
|
TABLEENTRY * pTableEntry;
|
|
USERHDR * pUserHdrDeleted;
|
|
CHAR szMappedName[MAXNAMELEN+1];
|
|
HCURSOR hOldCursor;
|
|
OFSTRUCT of;
|
|
HFILE hFile;
|
|
|
|
// RegLoadKey returns totally coarse error codes, and will not
|
|
// return any error if the file is on a read-only share on the network,
|
|
// so open the file normally first to try to catch errors
|
|
if ((hFile=OpenFile(pszFilename,&of,OF_READWRITE)) == HFILE_ERROR) {
|
|
DisplayStandardError(hwndApp,pszFilename,IDS_ErrREGERR_SAVEKEY1,
|
|
of.nErrCode);
|
|
return FALSE;
|
|
}
|
|
_lclose(hFile);
|
|
|
|
if ((uRet = MyRegLoadKey(HKEY_LOCAL_MACHINE,szTMPDATA,pszFilename))
|
|
!= ERROR_SUCCESS) {
|
|
CHAR szFmt[REGBUFLEN],szMsg[REGBUFLEN+MAX_PATH+1];
|
|
LoadSz(IDS_ErrREGERR_LOADKEY,szFmt,sizeof(szFmt));
|
|
wsprintf(szMsg,szFmt,pszFilename,uRet);
|
|
MsgBoxSz(hwndApp,szMsg,MB_ICONEXCLAMATION,MB_OK);
|
|
return FALSE;
|
|
}
|
|
|
|
// write the information to the local registry, then use RegSaveKey to
|
|
// make it into a hive file.
|
|
if ( (RegCreateKey(HKEY_LOCAL_MACHINE,szTMPDATA,&hkeyMain) !=
|
|
ERROR_SUCCESS) ||
|
|
(RegCreateKey(hkeyMain,szUSERS,&hkeyUser) != ERROR_SUCCESS) ||
|
|
(RegCreateKey(hkeyMain,szWORKSTATIONS,&hkeyWorkstation)
|
|
!= ERROR_SUCCESS) ||
|
|
(RegCreateKey(hkeyMain,szUSERGROUPS,&hkeyGroup) != ERROR_SUCCESS) ||
|
|
(RegCreateKey(hkeyMain,szUSERGROUPDATA,&hkeyGroupPriority) != ERROR_SUCCESS)) {
|
|
|
|
if (hkeyWorkstation) RegCloseKey(hkeyWorkstation);
|
|
if (hkeyUser) RegCloseKey(hkeyUser);
|
|
if (hkeyMain) RegCloseKey(hkeyMain);
|
|
if (hkeyGroup) RegCloseKey(hkeyGroup);
|
|
if (hkeyGroupPriority) RegCloseKey(hkeyGroupPriority);
|
|
|
|
MsgBox(hwndApp,IDS_ErrREGERR_CANTSAVE,MB_ICONEXCLAMATION,MB_OK);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
hOldCursor=SetCursor(LoadCursor(NULL,IDC_WAIT));
|
|
|
|
for (nIndex = 0;nIndex < (UINT) ListView_GetItemCount(hwndList) &&
|
|
(uRet == ERROR_SUCCESS);nIndex++) {
|
|
if (hUser = (HGLOBAL) LongToHandle(ListView_GetItemParm(hwndList,nIndex))) {
|
|
|
|
if (!(pUserData = (USERDATA *) GlobalLock(hUser))) {
|
|
SetCursor(hOldCursor);
|
|
MsgBox(hwndApp,IDS_ErrOUTOFMEMORY,MB_ICONEXCLAMATION,MB_OK);
|
|
uRet = ERROR_NOT_ENOUGH_MEMORY;
|
|
break;
|
|
}
|
|
|
|
if (pUserData->hdr.dwType & UT_USER) {
|
|
pTableEntry = gClassList.pUserCategoryList;
|
|
hkeyRoot = (pUserData->hdr.dwType & UF_GROUP ? hkeyGroup :
|
|
hkeyUser);
|
|
} else {
|
|
pTableEntry = gClassList.pMachineCategoryList;
|
|
hkeyRoot = hkeyWorkstation;
|
|
}
|
|
|
|
// create a key with user/machine name
|
|
MapUserName(pUserData->hdr.szName,szMappedName);
|
|
if ((uRet=RegCreateKey(hkeyRoot,szMappedName,
|
|
&hkeyInstance)) != ERROR_SUCCESS)
|
|
break;
|
|
|
|
// build a tree of information to be merged under user/machine
|
|
// name
|
|
uRet=SaveUserData(pUserData,pTableEntry,hkeyInstance,NULL);
|
|
GlobalUnlock(hUser);
|
|
|
|
// create a clone for this user with last saved state
|
|
CloneUser(hUser);
|
|
|
|
RegCloseKey(hkeyInstance);
|
|
}
|
|
}
|
|
|
|
#ifdef INCL_GROUP_SUPPORT
|
|
SaveGroupPriorityList(hkeyGroupPriority);
|
|
#endif
|
|
|
|
// delete any users that have been marked as deleted
|
|
nIndex=0;
|
|
while (pUserHdrDeleted = GetDeletedUser(nIndex)) {
|
|
HKEY hkeyDelRoot=NULL;
|
|
|
|
switch (pUserHdrDeleted->dwType) {
|
|
case UT_USER:
|
|
hkeyDelRoot = hkeyUser;
|
|
break;
|
|
|
|
case UT_MACHINE:
|
|
hkeyDelRoot = hkeyWorkstation;
|
|
break;
|
|
#ifdef INCL_GROUP_SUPPORT
|
|
case UT_USER | UF_GROUP:
|
|
hkeyDelRoot = hkeyGroup;
|
|
break;
|
|
#endif
|
|
default:
|
|
continue; // shouldn't happen, but just in case
|
|
}
|
|
|
|
// map the user name to map "default user" to ".default", etc.
|
|
MapUserName(pUserHdrDeleted->szName,szMappedName);
|
|
|
|
MyRegDeleteKey(hkeyDelRoot,szMappedName);
|
|
nIndex++;
|
|
}
|
|
ClearDeletedUserList();
|
|
|
|
RegCloseKey(hkeyUser);
|
|
RegCloseKey(hkeyWorkstation);
|
|
RegCloseKey(hkeyMain);
|
|
RegCloseKey(hkeyGroup);
|
|
RegCloseKey(hkeyGroupPriority);
|
|
MyRegUnLoadKey(HKEY_LOCAL_MACHINE,szTMPDATA);
|
|
RegFlushKey(HKEY_LOCAL_MACHINE);
|
|
SetCursor(hOldCursor);
|
|
SetFileAttributes(pszFilename,FILE_ATTRIBUTE_ARCHIVE);
|
|
|
|
if (uRet != ERROR_SUCCESS) {
|
|
if (uRet == ERROR_NOT_ENOUGH_MEMORY) {
|
|
MsgBox(hwndApp,IDS_ErrOUTOFMEMORY,MB_ICONEXCLAMATION,MB_OK);
|
|
} else {
|
|
CHAR szFmt[REGBUFLEN],szMsg[REGBUFLEN+MAX_PATH+1];
|
|
LoadSz(IDS_ErrREGERR_SAVEKEY,szFmt,sizeof(szFmt));
|
|
wsprintf(szMsg,szFmt,pszFilename,uRet);
|
|
MsgBoxSz(hwndApp,szMsg,MB_ICONEXCLAMATION,MB_OK);
|
|
}
|
|
}
|
|
|
|
return (uRet == ERROR_SUCCESS);
|
|
}
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: SaveToRegistry
|
|
|
|
SYNOPSIS: Writes loaded information to the registry
|
|
|
|
********************************************************************/
|
|
BOOL SaveToRegistry(HWND hwndApp,HWND hwndList)
|
|
{
|
|
HKEY hkeyUser=NULL,hkeyWorkstation=NULL,hkeyRoot;
|
|
UINT uRet = ERROR_SUCCESS,nIndex;
|
|
HGLOBAL hUser;
|
|
USERDATA * pUserData=NULL;
|
|
TABLEENTRY * pTableEntry;
|
|
HCURSOR hOldCursor;
|
|
|
|
if ((RegOpenKeyEx(hkeyVirtHCU,NULL,0,KEY_ALL_ACCESS,&hkeyUser) != ERROR_SUCCESS) ||
|
|
(RegOpenKeyEx(hkeyVirtHLM,NULL,0,KEY_ALL_ACCESS,&hkeyWorkstation) != ERROR_SUCCESS)) {
|
|
MsgBox(hwndApp,IDS_ErrCANTOPENREGISTRY,MB_ICONEXCLAMATION,MB_OK);
|
|
if (hkeyUser) RegCloseKey(hkeyUser);
|
|
if (hkeyWorkstation) RegCloseKey(hkeyWorkstation);
|
|
return FALSE;
|
|
}
|
|
|
|
hOldCursor=SetCursor(LoadCursor(NULL,IDC_WAIT));
|
|
for (nIndex = 0;nIndex < (UINT) ListView_GetItemCount(hwndList)
|
|
&& (uRet == ERROR_SUCCESS);nIndex++) {
|
|
if (hUser = (HGLOBAL) LongToHandle(ListView_GetItemParm(hwndList,nIndex))) {
|
|
|
|
if (!(pUserData = (USERDATA *) GlobalLock(hUser))) {
|
|
SetCursor(hOldCursor);
|
|
MsgBox(hwndApp,IDS_ErrOUTOFMEMORY,MB_ICONEXCLAMATION,MB_OK);
|
|
uRet = ERROR_NOT_ENOUGH_MEMORY;
|
|
break;
|
|
}
|
|
|
|
if (pUserData->hdr.dwType & UT_USER) {
|
|
pTableEntry = gClassList.pUserCategoryList;
|
|
hkeyRoot = hkeyUser;
|
|
} else {
|
|
pTableEntry = gClassList.pMachineCategoryList;
|
|
hkeyRoot = hkeyWorkstation;
|
|
}
|
|
|
|
// build a tree of information to be merged under user/machine
|
|
// name
|
|
uRet=SaveUserData(pUserData,pTableEntry,hkeyRoot,NULL);
|
|
GlobalUnlock(hUser);
|
|
}
|
|
}
|
|
|
|
RegCloseKey(hkeyUser);
|
|
RegCloseKey(hkeyWorkstation);
|
|
SetCursor(hOldCursor);
|
|
|
|
if (uRet != ERROR_SUCCESS) {
|
|
if (uRet == ERROR_NOT_ENOUGH_MEMORY) {
|
|
MsgBox(hwndApp,IDS_ErrOUTOFMEMORY,MB_ICONEXCLAMATION,MB_OK);
|
|
} else {
|
|
CHAR szMsg[REGBUFLEN+1];
|
|
wsprintf(szMsg,"%d",uRet);
|
|
MsgBoxParam(hwndApp,IDS_ErrREGERR_SAVE,szMsg,MB_ICONEXCLAMATION,MB_OK);
|
|
}
|
|
}
|
|
|
|
return (uRet == ERROR_SUCCESS);
|
|
}
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: SaveUserData
|
|
|
|
SYNOPSIS: Saves one user to file
|
|
|
|
********************************************************************/
|
|
UINT SaveUserData(USERDATA * pUserData,TABLEENTRY * pTableEntry,HKEY hkeyRoot,
|
|
CHAR * pszCurrentKeyName)
|
|
{
|
|
UINT uRet=ERROR_SUCCESS;
|
|
|
|
while (pTableEntry && (uRet == ERROR_SUCCESS)) {
|
|
|
|
uRet = SaveOneEntry(pUserData,pTableEntry,hkeyRoot,
|
|
pszCurrentKeyName,FALSE);
|
|
|
|
pTableEntry = pTableEntry->pNext;
|
|
}
|
|
|
|
return uRet;
|
|
}
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: SaveOneEntry
|
|
|
|
SYNOPSIS: Saves one entry (category, policy, or part) to
|
|
file, calls SaveUserData for child entries
|
|
|
|
********************************************************************/
|
|
UINT SaveOneEntry(USERDATA * pUserData,TABLEENTRY * pTableEntry,HKEY hkeyRoot,
|
|
CHAR * pszCurrentKeyName,BOOL fErase)
|
|
{
|
|
UINT uRet;
|
|
|
|
#if 0
|
|
wsprintf(szDebugOut,"Saving... %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=SaveUserData(pUserData,pTableEntry->pChild,
|
|
hkeyRoot,pszCurrentKeyName)) != ERROR_SUCCESS) {
|
|
return uRet;
|
|
}
|
|
} else if (pTableEntry->dwType == ETYPE_POLICY) {
|
|
|
|
if ((uRet = SavePolicy(pUserData,pTableEntry,hkeyRoot,
|
|
pszCurrentKeyName)) != ERROR_SUCCESS) {
|
|
return uRet;
|
|
}
|
|
|
|
} else if ( (pTableEntry->dwType & ETYPE_MASK) == ETYPE_SETTING
|
|
&& !(pTableEntry->dwType & STYPE_TEXT)) {
|
|
|
|
if ((uRet = SaveSettings(pUserData,pTableEntry,hkeyRoot,
|
|
pszCurrentKeyName,fErase)) != ERROR_SUCCESS) {
|
|
return uRet;
|
|
}
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: SavePolicy
|
|
|
|
SYNOPSIS: Saves policy to file
|
|
|
|
********************************************************************/
|
|
UINT SavePolicy(USERDATA * pUserData,TABLEENTRY * pTableEntry,HKEY hkeyRoot,
|
|
CHAR * pszCurrentKeyName)
|
|
{
|
|
UINT uState = pUserData->SettingData[((POLICY *)
|
|
pTableEntry)->uDataIndex].uData;
|
|
DWORD dwData;
|
|
UINT uRet=ERROR_SUCCESS;
|
|
CHAR * pszValueName = NULL;
|
|
UINT uCloneState;
|
|
|
|
// get the name of the value to write, if any
|
|
if (((POLICY *) pTableEntry)->uOffsetValueName)
|
|
pszValueName = GETVALUENAMEPTR(((POLICY *) pTableEntry));
|
|
// if this policy is "on" or "off" write it to registry
|
|
// (not if it's "indeterminate")
|
|
if (uState == IMG_CHECKED || uState == IMG_UNCHECKED) {
|
|
|
|
// write the value associated with the policy, if it has one
|
|
if (pszValueName) {
|
|
|
|
dwData = (uState == IMG_CHECKED ? 1 : 0);
|
|
|
|
// write this key & value
|
|
if (dwData && ((POLICY *) pTableEntry)->uOffsetValue_On) {
|
|
|
|
uRet= WriteCustomValue(hkeyRoot,pszCurrentKeyName,pszValueName,
|
|
(STATEVALUE *) ((CHAR *) pTableEntry + ((POLICY *)
|
|
pTableEntry)->uOffsetValue_On),FALSE);
|
|
} else if (!dwData && ((POLICY *) pTableEntry)->uOffsetValue_Off) {
|
|
uRet= WriteCustomValue(hkeyRoot,pszCurrentKeyName,pszValueName,
|
|
(STATEVALUE *) ((CHAR *) pTableEntry + ((POLICY *)
|
|
pTableEntry)->uOffsetValue_Off),FALSE);
|
|
}
|
|
else uRet=WriteStandardValue(hkeyRoot,pszCurrentKeyName,pszValueName,
|
|
pTableEntry,dwData,FALSE,FALSE);
|
|
if (uRet != ERROR_SUCCESS)
|
|
return uRet;
|
|
}
|
|
|
|
// process settings underneath this policy (if any) if
|
|
// policy is turned on.
|
|
if (pTableEntry->pChild) {
|
|
if (uState == IMG_CHECKED) {
|
|
if ((uRet=SaveUserData(pUserData,pTableEntry->pChild,
|
|
hkeyRoot,pszCurrentKeyName))
|
|
!=ERROR_SUCCESS)
|
|
return uRet;
|
|
} else {
|
|
DeleteSettings(pUserData,pTableEntry->pChild,hkeyRoot,
|
|
pszCurrentKeyName);
|
|
}
|
|
}
|
|
|
|
// write out each key & value in the action list, if an action
|
|
// list is specified
|
|
if (GetCloneData(pUserData->hClone,((POLICY *)pTableEntry)->uDataIndex,
|
|
&uCloneState)) {
|
|
// if the clone state (initial state) is different from the
|
|
// current state, erase action list for the clone's state
|
|
if (uCloneState != uState) {
|
|
uRet=ProcessPolicyActionLists(hkeyRoot,(POLICY *) pTableEntry,
|
|
pszCurrentKeyName,uCloneState,TRUE);
|
|
if (uRet != ERROR_SUCCESS)
|
|
return uRet;
|
|
}
|
|
}
|
|
uRet=ProcessPolicyActionLists(hkeyRoot,(POLICY *) pTableEntry,
|
|
pszCurrentKeyName,uState,FALSE);
|
|
if (uRet != ERROR_SUCCESS)
|
|
return uRet;
|
|
|
|
} else {
|
|
// policy is "indeterminate"... which means do no delta.
|
|
// However, since we save non-destructively, we need to delete
|
|
// the value for this key if it is currently written in the file.
|
|
// See if we have a clone for this user (clone will exist if there
|
|
// is already a saved file that contains this user, clone will
|
|
// reflect initial state). If the initial state was "checked"
|
|
// or "unchecked", then erase the value from the file so that
|
|
// the saved state is "nothing".
|
|
TABLEENTRY * pTableEntryChild = pTableEntry->pChild;
|
|
|
|
if (pszValueName) {
|
|
CHAR szNewValueName[MAX_PATH+1];
|
|
DeleteRegistryValue(hkeyRoot,pszCurrentKeyName,pszValueName);
|
|
// delete the "delete" mark for this value, if there is one
|
|
PrependValueName(pszValueName,VF_DELETE,szNewValueName,
|
|
sizeof(szNewValueName));
|
|
DeleteRegistryValue(hkeyRoot,pszCurrentKeyName,szNewValueName);
|
|
}
|
|
|
|
if (GetCloneData(pUserData->hClone,((POLICY *)pTableEntry)->uDataIndex,
|
|
&uCloneState)) {
|
|
// if the clone state (initial state) is different from the
|
|
// current state, erase action list for the clone's state
|
|
if (uCloneState != uState) {
|
|
uRet=ProcessPolicyActionLists(hkeyRoot,(POLICY *) pTableEntry,
|
|
pszCurrentKeyName,uCloneState,TRUE);
|
|
if (uRet != ERROR_SUCCESS)
|
|
return uRet;
|
|
}
|
|
}
|
|
|
|
// erase values for any settings contained in this policy
|
|
while (pTableEntryChild && (uRet == ERROR_SUCCESS)) {
|
|
uRet = SaveOneEntry(pUserData,pTableEntryChild,hkeyRoot,
|
|
pszCurrentKeyName,TRUE);
|
|
|
|
pTableEntryChild = pTableEntryChild->pNext;
|
|
}
|
|
}
|
|
|
|
return uRet;
|
|
}
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: SaveSettings
|
|
|
|
SYNOPSIS: Saves settings entry to a file
|
|
|
|
NOTES: if fErase is TRUE, settings and action lists are deleted from file
|
|
********************************************************************/
|
|
UINT SaveSettings(USERDATA * pUserData,TABLEENTRY * pTableEntry,HKEY hkeyRoot,
|
|
CHAR * pszCurrentKeyName,BOOL fErase)
|
|
{
|
|
UINT uRet = ERROR_SUCCESS,uOffset;
|
|
CHAR * pszValueName = NULL,* pszValue;
|
|
DWORD dwData,dwCloneData;
|
|
CHAR * pObjectData = GETOBJECTDATAPTR(((SETTINGS *)pTableEntry));
|
|
CHAR szNewValueName[MAX_PATH+1];
|
|
|
|
// nothing to save for static text items
|
|
if ((((SETTINGS *) pTableEntry)->dwType & STYPE_MASK) == STYPE_TEXT)
|
|
return ERROR_SUCCESS;
|
|
|
|
if (((SETTINGS *) pTableEntry)->uOffsetValueName) {
|
|
pszValueName = GETVALUENAMEPTR(((SETTINGS *) pTableEntry));
|
|
} else {
|
|
return ERROR_NOT_ENOUGH_MEMORY; // should never happen, but bag out just in case
|
|
}
|
|
switch (pTableEntry->dwType & STYPE_MASK) {
|
|
|
|
case STYPE_EDITTEXT:
|
|
case STYPE_COMBOBOX:
|
|
|
|
uOffset = pUserData->SettingData[((SETTINGS *)
|
|
pTableEntry)->uDataIndex].uOffsetData;
|
|
|
|
// add prefixes if appropriate
|
|
PrependValueName(pszValueName,((SETTINGS *) pTableEntry)->dwFlags,
|
|
szNewValueName,sizeof(szNewValueName));
|
|
if (!fErase) {
|
|
if (uOffset) {
|
|
pszValue = ((STRDATA *) ((CHAR *) pUserData + uOffset))
|
|
->szData;
|
|
} else {
|
|
pszValue = (CHAR *) szNull;
|
|
}
|
|
|
|
uRet=WriteRegistryStringValue(hkeyRoot,pszCurrentKeyName,
|
|
szNewValueName,pszValue,
|
|
(((SETTINGS *) pTableEntry)->dwFlags & DF_EXPANDABLETEXT) ?
|
|
TRUE : FALSE);
|
|
|
|
if ((dwAppState & AS_POLICYFILE) && !(dwCmdLineFlags & CLF_DIALOGMODE)
|
|
&& !(((SETTINGS *) pTableEntry)->dwFlags & VF_DELETE)) {
|
|
// delete the "delete" mark for this value, if there is one
|
|
PrependValueName(pszValueName,VF_DELETE,szNewValueName,
|
|
sizeof(szNewValueName));
|
|
DeleteRegistryValue(hkeyRoot,pszCurrentKeyName,szNewValueName);
|
|
}
|
|
|
|
} else {
|
|
DeleteRegistryValue(hkeyRoot,pszCurrentKeyName,szNewValueName);
|
|
uRet = ERROR_SUCCESS;
|
|
if (dwAppState & AS_POLICYFILE &&
|
|
!(((SETTINGS *) pTableEntry)->dwFlags & VF_DELETE)) {
|
|
// delete the "delete" mark for this value, if there is one
|
|
PrependValueName(pszValueName,VF_DELETE,szNewValueName,
|
|
sizeof(szNewValueName));
|
|
DeleteRegistryValue(hkeyRoot,pszCurrentKeyName,szNewValueName);
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case STYPE_CHECKBOX:
|
|
|
|
dwData = pUserData->SettingData[((SETTINGS *)
|
|
pTableEntry)->uDataIndex].uData;
|
|
|
|
if (dwData && ((CHECKBOXINFO *) pObjectData)->uOffsetValue_On) {
|
|
uRet= WriteCustomValue(hkeyRoot,pszCurrentKeyName,pszValueName,
|
|
(STATEVALUE *) ((CHAR *) pTableEntry + ((CHECKBOXINFO *)
|
|
pObjectData)->uOffsetValue_On),fErase);
|
|
} else if (!dwData && ((CHECKBOXINFO *) pObjectData)->uOffsetValue_Off) {
|
|
uRet= WriteCustomValue(hkeyRoot,pszCurrentKeyName,pszValueName,
|
|
(STATEVALUE *) ((CHAR *) pTableEntry + ((CHECKBOXINFO *)
|
|
pObjectData)->uOffsetValue_Off),fErase);
|
|
}
|
|
else uRet=WriteStandardValue(hkeyRoot,pszCurrentKeyName,pszValueName,
|
|
pTableEntry,dwData,fErase,FALSE);
|
|
|
|
if (uRet == ERROR_SUCCESS) {
|
|
|
|
// erase old actionlists if changed
|
|
if (GetCloneData(pUserData->hClone,((SETTINGS *)pTableEntry)->uDataIndex,
|
|
&dwCloneData)) {
|
|
ProcessCheckboxActionLists(hkeyRoot,pTableEntry,
|
|
pszCurrentKeyName,dwCloneData,TRUE);
|
|
|
|
}
|
|
|
|
ProcessCheckboxActionLists(hkeyRoot,pTableEntry,
|
|
pszCurrentKeyName,dwData,fErase);
|
|
}
|
|
|
|
break;
|
|
|
|
case STYPE_NUMERIC:
|
|
|
|
dwData = pUserData->SettingData[((SETTINGS *)
|
|
pTableEntry)->uDataIndex].uData;
|
|
|
|
uRet=WriteStandardValue(hkeyRoot,pszCurrentKeyName,pszValueName,
|
|
pTableEntry,dwData,fErase,TRUE);
|
|
break;
|
|
|
|
case STYPE_DROPDOWNLIST:
|
|
|
|
dwData = pUserData->SettingData[((SETTINGS *)
|
|
pTableEntry)->uDataIndex].uData;
|
|
|
|
if (GetCloneData(pUserData->hClone,((SETTINGS *)pTableEntry)->uDataIndex,
|
|
&dwCloneData)) {
|
|
// erase old value if changed
|
|
if (dwData != dwCloneData && dwCloneData != NO_DATA_INDEX)
|
|
uRet=WriteDropdownValue(pTableEntry,hkeyRoot,pszCurrentKeyName,
|
|
pszValueName,dwCloneData,TRUE);
|
|
if (uRet != ERROR_SUCCESS)
|
|
return uRet;
|
|
}
|
|
|
|
// write new value
|
|
if (dwData == NO_DATA_INDEX) {
|
|
if (dwAppState & AS_POLICYFILE &&
|
|
!(((SETTINGS *) pTableEntry)->dwFlags & VF_DELETE)) {
|
|
// delete the "delete" mark for this value, if there is one
|
|
PrependValueName(pszValueName,VF_DELETE,szNewValueName,
|
|
sizeof(szNewValueName));
|
|
DeleteRegistryValue(hkeyRoot,pszCurrentKeyName,szNewValueName);
|
|
}
|
|
uRet = ERROR_SUCCESS;
|
|
}
|
|
else
|
|
uRet=WriteDropdownValue(pTableEntry,hkeyRoot,pszCurrentKeyName,
|
|
pszValueName,dwData,fErase);
|
|
|
|
break;
|
|
|
|
case STYPE_LISTBOX:
|
|
|
|
uRet=SaveListboxData(pUserData,pTableEntry,hkeyRoot,pszCurrentKeyName,
|
|
fErase,FALSE);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
if (uRet != ERROR_SUCCESS) {
|
|
wsprintf(szDebugOut,"ADMINCFG: registry write returned %d\r\n",uRet);
|
|
OutputDebugString(szDebugOut);
|
|
}
|
|
#endif
|
|
|
|
return uRet;
|
|
}
|
|
|
|
UINT ProcessPolicyActionLists(HKEY hkeyRoot,POLICY * pPolicy,
|
|
CHAR * pszCurrentKeyName,UINT uState,BOOL fErase)
|
|
{
|
|
if ((uState == IMG_CHECKED) && (pPolicy->uOffsetActionList_On)) {
|
|
return WriteActionList(hkeyRoot,(ACTIONLIST *)
|
|
( (CHAR *) pPolicy + pPolicy->uOffsetActionList_On),pszCurrentKeyName,
|
|
fErase);
|
|
} else if ((uState == IMG_UNCHECKED) && pPolicy->uOffsetActionList_Off) {
|
|
return WriteActionList(hkeyRoot,(ACTIONLIST *)
|
|
( (CHAR *) pPolicy + pPolicy->uOffsetActionList_Off),
|
|
pszCurrentKeyName,fErase);
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
UINT ProcessCheckboxActionLists(HKEY hkeyRoot,TABLEENTRY * pTableEntry,
|
|
CHAR * pszCurrentKeyName,DWORD dwData,BOOL fErase)
|
|
{
|
|
CHAR * pObjectData = GETOBJECTDATAPTR(((SETTINGS *)pTableEntry));
|
|
UINT uOffsetActionList_On,uOffsetActionList_Off,uRet=ERROR_SUCCESS;
|
|
|
|
uOffsetActionList_On = ((CHECKBOXINFO *) pObjectData)
|
|
->uOffsetActionList_On;
|
|
uOffsetActionList_Off = ((CHECKBOXINFO *) pObjectData)
|
|
->uOffsetActionList_Off;
|
|
|
|
if (dwData && uOffsetActionList_On) {
|
|
uRet = WriteActionList(hkeyRoot,(ACTIONLIST *)
|
|
((CHAR *) pTableEntry + uOffsetActionList_On),
|
|
pszCurrentKeyName,fErase);
|
|
} else if (!dwData && uOffsetActionList_Off) {
|
|
uRet = WriteActionList(hkeyRoot,(ACTIONLIST *)
|
|
((CHAR *) pTableEntry + uOffsetActionList_Off),
|
|
pszCurrentKeyName,fErase);
|
|
}
|
|
|
|
return uRet;
|
|
}
|
|
|
|
UINT WriteCustomValue_W(HKEY hkeyRoot,CHAR * pszKeyName,CHAR * pszValueName,
|
|
CHAR * pszValue,DWORD dwValue,DWORD dwFlags,BOOL fErase)
|
|
{
|
|
UINT uRet=ERROR_SUCCESS;
|
|
CHAR szNewValueName[MAX_PATH+1];
|
|
|
|
// first: "clean house" by deleting both the specified value name,
|
|
// and the value name with the delete (**del.) prefix (if writing to policy
|
|
// file). Then write the appropriate version back out if need be
|
|
if (dwAppState & AS_POLICYFILE) {
|
|
// delete the "delete" mark for this value, if there is one
|
|
PrependValueName(pszValueName,VF_DELETE,szNewValueName,
|
|
sizeof(szNewValueName));
|
|
DeleteRegistryValue(hkeyRoot,pszKeyName,szNewValueName);
|
|
}
|
|
|
|
// add prefixes if appropriate
|
|
PrependValueName(pszValueName,(dwFlags & ~VF_DELETE),szNewValueName,
|
|
sizeof(szNewValueName));
|
|
DeleteRegistryValue(hkeyRoot,pszKeyName,szNewValueName);
|
|
|
|
if (fErase) {
|
|
// just need to delete value, done above
|
|
|
|
uRet = ERROR_SUCCESS;
|
|
} else if (dwFlags & VF_ISNUMERIC) {
|
|
uRet=WriteRegistryDWordValue(hkeyRoot,pszKeyName,
|
|
szNewValueName,dwValue);
|
|
} else if (dwFlags & VF_DELETE) {
|
|
// need to delete value (done above) and mark as deleted if writing
|
|
// to policy file
|
|
|
|
uRet = ERROR_SUCCESS;
|
|
if ((dwAppState & AS_POLICYFILE) && !(dwCmdLineFlags & CLF_DIALOGMODE)) {
|
|
PrependValueName(pszValueName,VF_DELETE,szNewValueName,
|
|
sizeof(szNewValueName));
|
|
uRet=WriteRegistryStringValue(hkeyRoot,pszKeyName,
|
|
szNewValueName,(CHAR *) szNOVALUE, FALSE);
|
|
}
|
|
|
|
} else {
|
|
uRet = WriteRegistryStringValue(hkeyRoot,pszKeyName,
|
|
szNewValueName,pszValue,
|
|
(dwFlags & DF_EXPANDABLETEXT) ? TRUE : FALSE);
|
|
}
|
|
|
|
return uRet;
|
|
}
|
|
|
|
UINT WriteCustomValue(HKEY hkeyRoot,CHAR * pszKeyName,CHAR * pszValueName,
|
|
STATEVALUE * pStateValue,BOOL fErase)
|
|
{
|
|
// pull info out of STATEVALUE struct and call worker function
|
|
return WriteCustomValue_W(hkeyRoot,pszKeyName,pszValueName,
|
|
pStateValue->szValue,pStateValue->dwValue,pStateValue->dwFlags,
|
|
fErase);
|
|
}
|
|
|
|
// writes a numeric value given root key, key name and value name. The specified
|
|
// value is removed if fErase is TRUE. Normally if the data (dwData) is zero
|
|
// the value will be deleted, but if fWriteZero is TRUE then the value will
|
|
// be written as zero if the data is zero.
|
|
UINT WriteStandardValue(HKEY hkeyRoot,CHAR * pszKeyName,CHAR * pszValueName,
|
|
TABLEENTRY * pTableEntry,DWORD dwData,BOOL fErase,BOOL fWriteZero)
|
|
{
|
|
UINT uRet=ERROR_SUCCESS;
|
|
CHAR szNewValueName[MAX_PATH+1];
|
|
|
|
// first: "clean house" by deleting both the specified value name,
|
|
// and the value name with the delete (**del.) prefix (if writing to policy
|
|
// file). Then write the appropriate version back out if need be
|
|
if (dwAppState & AS_POLICYFILE) {
|
|
// delete the "delete" mark for this value, if there is one
|
|
PrependValueName(pszValueName,VF_DELETE,szNewValueName,
|
|
sizeof(szNewValueName));
|
|
DeleteRegistryValue(hkeyRoot,pszKeyName,szNewValueName);
|
|
}
|
|
|
|
DeleteRegistryValue(hkeyRoot,pszKeyName,pszValueName);
|
|
|
|
if (fErase) {
|
|
// just need to delete value, done above
|
|
uRet = ERROR_SUCCESS;
|
|
} else if ( ((SETTINGS *) pTableEntry)->dwFlags & DF_TXTCONVERT) {
|
|
// if specified, save value as text
|
|
CHAR szNum[11];
|
|
wsprintf(szNum,"%lu",dwData);
|
|
PrependValueName(pszValueName,((SETTINGS *)pTableEntry)->dwFlags,
|
|
szNewValueName,sizeof(szNewValueName));
|
|
uRet = WriteRegistryStringValue(hkeyRoot,pszKeyName,
|
|
szNewValueName,szNum, FALSE);
|
|
} else {
|
|
if (!dwData && !fWriteZero) {
|
|
// if value is 0, delete the value (done above), and mark
|
|
// it as deleted if writing to policy file
|
|
uRet = ERROR_SUCCESS;
|
|
|
|
if ((dwAppState & AS_POLICYFILE) && !(dwCmdLineFlags & CLF_DIALOGMODE)) {
|
|
PrependValueName(pszValueName,VF_DELETE,szNewValueName,
|
|
sizeof(szNewValueName));
|
|
uRet=WriteRegistryStringValue(hkeyRoot,pszKeyName,
|
|
szNewValueName,(CHAR *) szNOVALUE, FALSE);
|
|
}
|
|
|
|
} else {
|
|
// save value as binary
|
|
PrependValueName(pszValueName,((SETTINGS *)pTableEntry)->dwFlags,
|
|
szNewValueName,sizeof(szNewValueName));
|
|
uRet=WriteRegistryDWordValue(hkeyRoot,pszKeyName,
|
|
szNewValueName,dwData);
|
|
}
|
|
}
|
|
|
|
return uRet;
|
|
}
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: WriteDropdownValue
|
|
|
|
SYNOPSIS: Writes (or deletes) the value corresponding to the
|
|
nValue selection from a drop-down list, and writes
|
|
(or deletes) the items in associated action list
|
|
if there is one.
|
|
|
|
NOTES: if fErase is TRUE, deletes value & action list.
|
|
|
|
********************************************************************/
|
|
UINT WriteDropdownValue(TABLEENTRY * pTableEntry,HKEY hkeyRoot,
|
|
CHAR * pszCurrentKeyName,CHAR * pszValueName,UINT nValue,BOOL fErase)
|
|
{
|
|
DROPDOWNINFO * pddi = (DROPDOWNINFO *)
|
|
GETOBJECTDATAPTR( ((SETTINGS *) pTableEntry));
|
|
UINT nIndex = 0,uRet=ERROR_SUCCESS;
|
|
|
|
// walk the chain of DROPDOWNINFO structs to find the entry that
|
|
// we want to write. (for value n, find the nth struct)
|
|
while (nIndex < nValue) {
|
|
// selected val is higher than # of structs in chain,
|
|
// should never happen but check just in case...
|
|
if (!pddi->uOffsetNextDropdowninfo) {
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
pddi = (DROPDOWNINFO *)
|
|
((CHAR *) pTableEntry + pddi->uOffsetNextDropdowninfo);
|
|
nIndex++;
|
|
}
|
|
|
|
uRet=WriteCustomValue_W(hkeyRoot,pszCurrentKeyName,pszValueName,
|
|
(CHAR *) pTableEntry+pddi->uOffsetValue,pddi->dwValue,pddi->dwFlags,
|
|
fErase);
|
|
|
|
if (uRet == ERROR_SUCCESS && pddi->uOffsetActionList) {
|
|
uRet=WriteActionList(hkeyRoot,(ACTIONLIST *) ( (CHAR *)
|
|
pTableEntry + pddi->uOffsetActionList),pszCurrentKeyName,
|
|
fErase);
|
|
}
|
|
|
|
return uRet;
|
|
}
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: WriteActionList
|
|
|
|
SYNOPSIS: Writes (or deletes) a list of key name\value name\value
|
|
triplets as specified in an ACTIONLIST struct
|
|
|
|
NOTES: if fErase is TRUE, deletes every value in list
|
|
|
|
********************************************************************/
|
|
UINT WriteActionList(HKEY hkeyRoot,ACTIONLIST * pActionList,
|
|
CHAR *pszCurrentKeyName,BOOL fErase)
|
|
{
|
|
UINT nCount;
|
|
CHAR * pszValueName;
|
|
CHAR * pszValue=NULL;
|
|
UINT uRet;
|
|
|
|
ACTION * pAction = pActionList->Action;
|
|
|
|
for (nCount=0;nCount < pActionList->nActionItems; nCount++) {
|
|
// not every action in the list has to have a key name. But if one
|
|
// is specified, use it and it becomes the current key name for the
|
|
// list until we encounter another one.
|
|
if (pAction->uOffsetKeyName) {
|
|
pszCurrentKeyName = (CHAR *) pActionList + pAction->uOffsetKeyName;
|
|
}
|
|
|
|
// every action must have a value name, enforced at parse time
|
|
pszValueName = (CHAR *) pActionList + pAction->uOffsetValueName;
|
|
|
|
// string values have a string elsewhere in buffer
|
|
if (!pAction->dwFlags && pAction->uOffsetValue) {
|
|
pszValue = (CHAR *) pActionList + pAction->uOffsetValue;
|
|
}
|
|
|
|
// write the value in list
|
|
uRet=WriteCustomValue_W(hkeyRoot,pszCurrentKeyName,pszValueName,
|
|
pszValue,pAction->dwValue,pAction->dwFlags,fErase);
|
|
|
|
if (uRet != ERROR_SUCCESS) return uRet;
|
|
|
|
pAction = (ACTION*) ((CHAR *) pActionList + pAction->uOffsetNextAction);
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: GetCloneData
|
|
|
|
SYNOPSIS: Retrieves the data for a specified setting index
|
|
from a user's clone (initial state) if one exists.
|
|
|
|
NOTES: returns TRUE if successful, FALSE if no clone exists
|
|
|
|
********************************************************************/
|
|
BOOL GetCloneData(HGLOBAL hClone,UINT uDataIndex,DWORD *pdwData)
|
|
{
|
|
USERDATA * pUserDataClone;
|
|
if (!hClone) return FALSE;
|
|
|
|
pUserDataClone = (USERDATA *) GlobalLock(hClone);
|
|
if (!pUserDataClone) return FALSE;
|
|
|
|
*pdwData = pUserDataClone->SettingData[uDataIndex].uData;
|
|
|
|
GlobalUnlock(hClone);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: DeleteSettings
|
|
|
|
SYNOPSIS: Deletes all settings for a policy; called if the policy
|
|
is turned off
|
|
|
|
NOTES: In direct-registry mode, deletes the value(s). When
|
|
operating on a policy file, marks the values to be deleted.
|
|
|
|
DeleteSettings calls worker function DeleteSetting so
|
|
that hierarchy of key names works correctly (pszCurrentKeyName
|
|
is preserved in DeleteSettings, but individual settings
|
|
may override it in DeleteSetting)
|
|
|
|
********************************************************************/
|
|
UINT DeleteSettings(USERDATA * pUserData,TABLEENTRY * pTableEntry,HKEY hkeyRoot,
|
|
CHAR * pszCurrentKeyName)
|
|
{
|
|
UINT uRet=ERROR_SUCCESS;
|
|
UINT DeleteSetting(USERDATA * pUserData,TABLEENTRY * pTableEntry,HKEY hkeyRoot,
|
|
CHAR * pszCurrentKeyName);
|
|
|
|
while (pTableEntry && (uRet == ERROR_SUCCESS)) {
|
|
|
|
uRet = DeleteSetting(pUserData,pTableEntry,hkeyRoot,pszCurrentKeyName);
|
|
pTableEntry = pTableEntry->pNext;
|
|
}
|
|
|
|
return uRet;
|
|
}
|
|
|
|
UINT DeleteSetting(USERDATA * pUserData,TABLEENTRY * pTableEntry,HKEY hkeyRoot,
|
|
CHAR * pszCurrentKeyName)
|
|
{
|
|
CHAR * pszValueName=NULL;
|
|
DWORD dwSettingType;
|
|
UINT uRet;
|
|
|
|
// if this setting has its own key name, use it to override parent's key name
|
|
if (pTableEntry->uOffsetKeyName) {
|
|
pszCurrentKeyName = GETKEYNAMEPTR(pTableEntry);
|
|
}
|
|
|
|
dwSettingType = pTableEntry->dwType & STYPE_MASK;
|
|
|
|
// special handling for listboxes, drop-down listboxes and static text
|
|
// controls
|
|
|
|
switch (dwSettingType) {
|
|
case STYPE_LISTBOX:
|
|
// for listboxes, call SaveListboxData to delete (fErase param set to TRUE)
|
|
return SaveListboxData(pUserData,pTableEntry,hkeyRoot,pszCurrentKeyName,
|
|
TRUE,TRUE);
|
|
break;
|
|
|
|
case STYPE_DROPDOWNLIST:
|
|
|
|
{
|
|
DWORD dwData;
|
|
|
|
dwData = pUserData->SettingData[((SETTINGS *)
|
|
pTableEntry)->uDataIndex].uData;
|
|
|
|
// no data set, nothing to do
|
|
if (dwData == NO_DATA_INDEX)
|
|
break;
|
|
|
|
if (((SETTINGS *) pTableEntry)->uOffsetValueName) {
|
|
pszValueName = GETVALUENAMEPTR(((SETTINGS *) pTableEntry));
|
|
} else {
|
|
return ERROR_NOT_ENOUGH_MEMORY; // should never happen, but bag out just in case
|
|
}
|
|
|
|
// erase the dropdown value (and any associated action lists)
|
|
uRet = WriteDropdownValue(pTableEntry,hkeyRoot,pszCurrentKeyName,
|
|
pszValueName,dwData,TRUE);
|
|
if (uRet != ERROR_SUCCESS)
|
|
return uRet;
|
|
// fall through and do processing below
|
|
}
|
|
break;
|
|
|
|
case STYPE_TEXT:
|
|
|
|
return ERROR_SUCCESS; // static text w/no reg value, nothing to do
|
|
break;
|
|
|
|
}
|
|
|
|
// otherwise delete the value
|
|
|
|
if (((SETTINGS *) pTableEntry)->uOffsetValueName) {
|
|
pszValueName = GETVALUENAMEPTR(((SETTINGS *) pTableEntry));
|
|
} else {
|
|
return ERROR_NOT_ENOUGH_MEMORY; // should never happen, but bag out just in case
|
|
}
|
|
|
|
// delete the value
|
|
DeleteRegistryValue(hkeyRoot,pszCurrentKeyName,pszValueName);
|
|
|
|
if ((dwAppState & AS_POLICYFILE) && !(dwCmdLineFlags & CLF_DIALOGMODE)) {
|
|
// if writing to a policy file, also mark it as deleted.
|
|
// WriteCustomValue_W will prepend "**del." to the value name
|
|
WriteCustomValue_W(hkeyRoot,pszCurrentKeyName,pszValueName,NULL,0,
|
|
VF_DELETE | ((SETTINGS *) pTableEntry)->dwFlags,FALSE);
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
UINT SaveListboxData(USERDATA * pUserData,TABLEENTRY * pTableEntry,HKEY hkeyRoot,
|
|
CHAR * pszCurrentKeyName,BOOL fErase,BOOL fMarkDeleted)
|
|
{
|
|
UINT uOffset,uRet,nItem=1;
|
|
HKEY hKey;
|
|
CHAR * pszData,* pszName;
|
|
CHAR szValueName[MAX_PATH+1];
|
|
DWORD cbValueName;
|
|
LISTBOXINFO * pListboxInfo = (LISTBOXINFO *)
|
|
GETOBJECTDATAPTR(((SETTINGS *) pTableEntry));
|
|
|
|
if ((uRet=RegCreateKey(hkeyRoot,pszCurrentKeyName,&hKey)) != ERROR_SUCCESS)
|
|
return uRet;
|
|
uOffset = pUserData->SettingData[((SETTINGS *)
|
|
pTableEntry)->uDataIndex].uOffsetData;
|
|
|
|
// erase all values for this key, first off
|
|
while (TRUE) {
|
|
cbValueName=sizeof(szValueName);
|
|
uRet=RegEnumValue(hKey,0,szValueName,&cbValueName,NULL,
|
|
NULL,NULL,NULL);
|
|
// stop if we're out of items
|
|
if (uRet != ERROR_SUCCESS && uRet != ERROR_MORE_DATA)
|
|
break;
|
|
RegDeleteValue(hKey,szValueName);
|
|
}
|
|
uRet=ERROR_SUCCESS;
|
|
|
|
if (!fErase || fMarkDeleted) {
|
|
// if in policy file mode, write a control code that will cause
|
|
// all values under that key to be deleted when client downloads from the file.
|
|
// Don't do this if listbox is additive (DF_ADDITIVE), in that case whatever
|
|
// we write here will be dumped in along with existing values
|
|
if ((dwAppState & AS_POLICYFILE) && !(dwCmdLineFlags & CLF_DIALOGMODE) &&
|
|
!(((SETTINGS *) pTableEntry)->dwFlags & DF_ADDITIVE))
|
|
uRet=WriteRegistryStringValue(hkeyRoot,pszCurrentKeyName,(CHAR *) szDELVALS,
|
|
(CHAR *) szNOVALUE, FALSE);
|
|
}
|
|
|
|
if (!fErase) {
|
|
if (uOffset) {
|
|
pszData = ((STRDATA *) ((CHAR *) pUserData + uOffset))->szData;
|
|
|
|
while (*pszData && (uRet == ERROR_SUCCESS)) {
|
|
UINT nLen = lstrlen(pszData)+1;
|
|
|
|
if (((SETTINGS *)pTableEntry)->dwFlags & DF_EXPLICITVALNAME) {
|
|
// value name specified for each item
|
|
pszName = pszData; // value name
|
|
pszData += nLen; // now pszData points to value data
|
|
nLen = lstrlen(pszData)+1;
|
|
} else {
|
|
// value name is either same as the data, or a prefix
|
|
// with a number
|
|
|
|
if (!pListboxInfo->uOffsetPrefix) {
|
|
// if no prefix set, then name = data
|
|
pszName = pszData;
|
|
} else {
|
|
// value name is "<prefix><n>" where n=1,2,etc.
|
|
wsprintf(szValueName,"%s%lu",(CHAR *) pTableEntry +
|
|
pListboxInfo->uOffsetPrefix,nItem);
|
|
pszName = szValueName;
|
|
nItem++;
|
|
}
|
|
}
|
|
|
|
uRet=RegSetValueEx(hKey,pszName,0,REG_SZ,pszData,
|
|
nLen);
|
|
pszData += nLen;
|
|
}
|
|
}
|
|
}
|
|
|
|
RegCloseKey(hKey);
|
|
|
|
return uRet;
|
|
}
|