1167 lines
31 KiB
C
1167 lines
31 KiB
C
/*++
|
|
|
|
Copyright (c) 1996 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
dmlocal.c
|
|
|
|
Abstract:
|
|
|
|
Contains the routines for local transactions that can be called within
|
|
gum handlers.
|
|
|
|
Author:
|
|
|
|
Sunita Shrivastava (sunitas) 24-Apr-1996
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
#include "dmp.h"
|
|
#include "clusudef.h"
|
|
|
|
extern BOOL gbIsQuoLoggingOn;
|
|
extern PFM_RESOURCE gpQuoResource;
|
|
extern DWORD gbIsQuoResOnline;
|
|
extern HLOG ghQuoLog;
|
|
#if NO_SHARED_LOCKS
|
|
extern CRITICAL_SECTION gLockDmpRoot;
|
|
#else
|
|
extern RTL_RESOURCE gLockDmpRoot;
|
|
#endif
|
|
/****
|
|
@doc EXTERNAL INTERFACES CLUSSVC DM
|
|
****/
|
|
|
|
/****
|
|
@func HXSACTION | DmBeginLocalUpdate| Called by gum handlers to make consistent
|
|
changes to the local registry. The log is reset and a start transaction
|
|
record is written to the log, if the log is active.
|
|
|
|
@comm When GumHandlers need to update the registry consitently they must use the
|
|
LocalApis provided by DM.
|
|
|
|
@rdesc Returns a transaction handle. NULL on failure. Call GetLastError()
|
|
for error code.
|
|
|
|
@xref <f DmAbortLocalUpdate> <f DmCommitLocalUpdate>
|
|
****/
|
|
HLOCALXSACTION DmBeginLocalUpdate()
|
|
{
|
|
DWORD dwError=ERROR_SUCCESS;
|
|
LSN StartXsactionLsn;
|
|
DWORD dwSequence;
|
|
HXSACTION hXsaction = NULL;
|
|
PLOCALXSACTION pLocalXsaction;
|
|
|
|
ClRtlLogPrint(LOG_NOISE,
|
|
"[DM] DmBeginLocalUpdate Entry\r\n");
|
|
|
|
//lock the data base, so that a check point is not taken in this duration
|
|
//this lock is released in DmCommitLocalUpdate() or DmAbortLocalUpdate()
|
|
//this lock also prevents the the registry from being flushed.
|
|
ACQUIRE_EXCLUSIVE_LOCK(gLockDmpRoot);
|
|
|
|
|
|
//Commit the registry so that it can be restored on abort
|
|
if ((dwError = DmCommitRegistry()) != ERROR_SUCCESS)
|
|
{
|
|
goto FnExit;
|
|
}
|
|
//allocate memory for local transaction
|
|
pLocalXsaction = LocalAlloc(LMEM_FIXED, sizeof(LOCALXSACTION));
|
|
if (!pLocalXsaction)
|
|
{
|
|
dwError = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto FnExit;
|
|
}
|
|
pLocalXsaction->dwSig = LOCALXSAC_SIG;
|
|
dwSequence = GumGetCurrentSequence(GumUpdateRegistry);
|
|
pLocalXsaction->dwSequence = dwSequence;
|
|
pLocalXsaction->hLogXsaction = NULL;
|
|
InitializeListHead(&pLocalXsaction->PendingNotifyListHead);
|
|
|
|
//log the start checkpoint record
|
|
if (gbIsQuoLoggingOn && gbIsQuoResOnline && AMIOWNEROFQUORES(gpQuoResource) && ghQuoLog)
|
|
{
|
|
|
|
hXsaction = LogStartXsaction(ghQuoLog, dwSequence ,RMRegistryMgr, 0);
|
|
if (!hXsaction)
|
|
{
|
|
dwError = GetLastError();
|
|
}
|
|
pLocalXsaction->hLogXsaction = hXsaction;
|
|
}
|
|
FnExit:
|
|
if (dwError != ERROR_SUCCESS)
|
|
{
|
|
if (pLocalXsaction) LocalFree(pLocalXsaction);
|
|
pLocalXsaction = NULL;
|
|
RELEASE_LOCK(gLockDmpRoot);
|
|
|
|
ClRtlLogPrint(LOG_NOISE,
|
|
"[DM] DmBeginLocalUpdate Exit, pLocalXsaction=0x%1!08lx! Error=0x%2!08lx!\r\n",
|
|
pLocalXsaction, dwError);
|
|
} else {
|
|
ClRtlLogPrint(LOG_NOISE,
|
|
"[DM] DmBeginLocalUpdate Exit, pLocalXsaction=0x%1!08lx!\r\n",
|
|
pLocalXsaction);
|
|
}
|
|
|
|
return((HLOCALXSACTION)pLocalXsaction);
|
|
}
|
|
|
|
|
|
|
|
/****
|
|
@func DWORD | DmCommitLocalUpdate| This api must be called to commit
|
|
the changes to the local registry.
|
|
|
|
@parm IN HXSACTION | hXsaction | The handle to the transaction to be committed.
|
|
|
|
@comm A commit record is written the quorum log if logging is active.
|
|
|
|
@rdesc Returns a result code. ERROR_SUCCESS on success.
|
|
|
|
@xref <f DmBeginLocalUpdate> <f DmAbortLocalUpdate>
|
|
****/
|
|
DWORD DmCommitLocalUpdate(IN HLOCALXSACTION hLocalXsaction)
|
|
{
|
|
DWORD dwError=ERROR_SUCCESS;
|
|
PLOCALXSACTION pLocalXsaction;
|
|
|
|
ClRtlLogPrint(LOG_NOISE,
|
|
"[DM] DmCommitLocalUpdate Entry\r\n");
|
|
|
|
GETLOCALXSACTION(pLocalXsaction, hLocalXsaction);
|
|
|
|
|
|
//update the gum sequence
|
|
DmpUpdateSequence();
|
|
|
|
DmpReportPendingNotifications(pLocalXsaction, TRUE );
|
|
|
|
//write a commit record to the quorum log
|
|
if (gbIsQuoLoggingOn && gbIsQuoResOnline && AMIOWNEROFQUORES(gpQuoResource)
|
|
&& ghQuoLog && pLocalXsaction->hLogXsaction)
|
|
{
|
|
CL_ASSERT(pLocalXsaction->hLogXsaction);
|
|
dwError = LogCommitXsaction(ghQuoLog, pLocalXsaction->hLogXsaction, 0);
|
|
//
|
|
// Chittur Subbaraman (chitturs) - 1/19/99
|
|
//
|
|
pLocalXsaction->hLogXsaction = NULL;
|
|
}
|
|
|
|
//
|
|
// Chittur Subbaraman (chitturs) - 1/19/99
|
|
//
|
|
// Make sure that the hLogXsaction memory is freed (even in the case
|
|
// in which you started a local xsaction and didn't get a chance to
|
|
// commit it or abort it to the log because quorum logging got turned
|
|
// off in the middle, for example. This turning off of the logging
|
|
// in the middle of a transaction could be considered as a bug ?)
|
|
//
|
|
LocalFree( pLocalXsaction->hLogXsaction );
|
|
|
|
//invalidate the signature and free the transaction structure
|
|
pLocalXsaction->dwSig = 0;
|
|
LocalFree(pLocalXsaction);
|
|
//release the database
|
|
RELEASE_LOCK(gLockDmpRoot);
|
|
|
|
ClRtlLogPrint(LOG_NOISE,
|
|
"[DM] DmCommitLocalUpdate Exit, returning 0x%1!08lx!\r\n",
|
|
dwError);
|
|
|
|
return(dwError);
|
|
}
|
|
|
|
|
|
/****
|
|
@func DWORD | DmAbortLocalUpdate| DmAbortLocalUpdate aborts all the changes
|
|
to the local registry associated with this transaction.
|
|
|
|
@parm IN HXSACTION | hXsaction | The handle to the transaction to be committed.
|
|
|
|
@rdesc Returns a result code. ERROR_SUCCESS on success.
|
|
|
|
@xref <f DmBeginLocalUpdate> <f DmCommitLocalUpdate>
|
|
****/
|
|
DWORD DmAbortLocalUpdate(IN HLOCALXSACTION hLocalXsaction)
|
|
{
|
|
DWORD dwError=ERROR_SUCCESS;
|
|
PLOCALXSACTION pLocalXsaction;
|
|
|
|
ClRtlLogPrint(LOG_NOISE,
|
|
"[DM] DmAbortLocalUpdate Entry\r\n");
|
|
|
|
GETLOCALXSACTION(pLocalXsaction, hLocalXsaction);
|
|
|
|
//write the abort chkpoint record
|
|
//if the locker node is logging this is valid,
|
|
//if the nonlocker node is logging, and it aborts
|
|
// some other node will inherit the quorum log and
|
|
//checkpoint and hence commit this update.
|
|
if (gbIsQuoLoggingOn && gbIsQuoResOnline && AMIOWNEROFQUORES(gpQuoResource)
|
|
&& ghQuoLog && pLocalXsaction->hLogXsaction)
|
|
{
|
|
CL_ASSERT(pLocalXsaction->hLogXsaction);
|
|
LogAbortXsaction(ghQuoLog, pLocalXsaction->hLogXsaction, 0);
|
|
//
|
|
// Chittur Subbaraman (chitturs) - 1/19/99
|
|
//
|
|
pLocalXsaction->hLogXsaction = NULL;
|
|
}
|
|
|
|
//SS: if the rollback fails, then we kill ourselves??
|
|
//restore the old registry
|
|
if ((dwError = DmRollbackRegistry()) != ERROR_SUCCESS)
|
|
{
|
|
CL_UNEXPECTED_ERROR(dwError);
|
|
}
|
|
|
|
//free any pending notifications that were built up for
|
|
//this transaction
|
|
DmpReportPendingNotifications(pLocalXsaction, FALSE );
|
|
|
|
//
|
|
// Chittur Subbaraman (chitturs) - 1/19/99
|
|
//
|
|
// Make sure that the hLogXsaction memory is freed (even in the case
|
|
// in which you started a local xsaction and didn't get a chance to
|
|
// commit it or abort it to the log because quorum logging got turned
|
|
// off in the middle, for example. This turning off of the logging
|
|
// in the middle of a transaction could be considered as a bug ?)
|
|
//
|
|
LocalFree( pLocalXsaction->hLogXsaction );
|
|
|
|
//free the transaction structure, it cannot be used any more
|
|
pLocalXsaction->dwSig = 0;
|
|
LocalFree(pLocalXsaction);
|
|
|
|
//release the database
|
|
RELEASE_LOCK(gLockDmpRoot);
|
|
|
|
ClRtlLogPrint(LOG_NOISE,
|
|
"[DM] DmAbortLocalUpdate Exit, returning 0x%1!08lx!\r\n",
|
|
dwError);
|
|
|
|
return(dwError);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
DWORD
|
|
DmLocalSetValue(
|
|
IN HLOCALXSACTION hLocalXsaction,
|
|
IN HDMKEY hKey,
|
|
IN LPCWSTR lpValueName,
|
|
IN DWORD dwType,
|
|
IN CONST BYTE *lpData,
|
|
IN DWORD cbData
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine sets the named value for the specified
|
|
cluster registry key on the local machine
|
|
|
|
Arguments:
|
|
|
|
hKey - Supplies the cluster registry subkey whose value is to be set
|
|
|
|
lpValueName - Supplies the name of the value to be set.
|
|
|
|
dwType - Supplies the value data type
|
|
|
|
lpData - Supplies a pointer to the value data
|
|
|
|
cbData - Supplies the length of the value data.
|
|
|
|
Return Value:
|
|
|
|
ERROR_SUCCESS if successful
|
|
|
|
Win32 error code otherwise
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
DWORD Status = ERROR_SUCCESS;
|
|
PDMKEY Key;
|
|
PUCHAR Dest;
|
|
DWORD NameLength;
|
|
DWORD ValueNameLength;
|
|
DWORD UpdateLength;
|
|
PDM_SET_VALUE_UPDATE Update = NULL;
|
|
PLOCALXSACTION pLocalXsaction;
|
|
|
|
Key = (PDMKEY)hKey;
|
|
|
|
GETLOCALXSACTION(pLocalXsaction, hLocalXsaction);
|
|
|
|
Status = RegSetValueExW(Key->hKey,
|
|
lpValueName,
|
|
0,
|
|
dwType,
|
|
lpData,
|
|
cbData);
|
|
|
|
if (Status != ERROR_SUCCESS)
|
|
{
|
|
goto FnExit;
|
|
}
|
|
|
|
DmpAddToPendingNotifications(pLocalXsaction, Key->Name, CLUSTER_CHANGE_REGISTRY_VALUE);
|
|
|
|
//write it to the quorum log
|
|
if (gbIsQuoLoggingOn && gbIsQuoResOnline && AMIOWNEROFQUORES(gpQuoResource)
|
|
&& ghQuoLog && pLocalXsaction->hLogXsaction)
|
|
{
|
|
Key = (PDMKEY)hKey;
|
|
NameLength = (lstrlenW(Key->Name)+1)*sizeof(WCHAR);
|
|
ValueNameLength = (lstrlenW(lpValueName)+1)*sizeof(WCHAR);
|
|
UpdateLength = sizeof(DM_SET_VALUE_UPDATE) +
|
|
NameLength +
|
|
ValueNameLength +
|
|
cbData;
|
|
|
|
|
|
Update = (PDM_SET_VALUE_UPDATE)LocalAlloc(LMEM_FIXED, UpdateLength);
|
|
if (Update == NULL)
|
|
{
|
|
Status = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto FnExit;
|
|
}
|
|
|
|
|
|
Update->lpStatus = NULL;
|
|
Update->NameOffset = FIELD_OFFSET(DM_SET_VALUE_UPDATE, KeyName)+NameLength;
|
|
Update->DataOffset = Update->NameOffset + ValueNameLength;
|
|
Update->DataLength = cbData;
|
|
Update->Type = dwType;
|
|
CopyMemory(Update->KeyName, Key->Name, NameLength);
|
|
|
|
Dest = (PUCHAR)Update + Update->NameOffset;
|
|
CopyMemory(Dest, lpValueName, ValueNameLength);
|
|
|
|
Dest = (PUCHAR)Update + Update->DataOffset;
|
|
CopyMemory(Dest, lpData, cbData);
|
|
|
|
|
|
if (LogWriteXsaction(ghQuoLog, pLocalXsaction->hLogXsaction,
|
|
DmUpdateSetValue, Update, UpdateLength) == NULL_LSN)
|
|
{
|
|
Status = GetLastError();
|
|
}
|
|
}
|
|
|
|
FnExit:
|
|
if (Update) LocalFree(Update);
|
|
return(Status);
|
|
|
|
}
|
|
|
|
|
|
HDMKEY
|
|
DmLocalCreateKey(
|
|
IN HLOCALXSACTION hLocalXsaction,
|
|
IN HDMKEY hKey,
|
|
IN LPCWSTR lpSubKey,
|
|
IN DWORD dwOptions,
|
|
IN DWORD samDesired,
|
|
IN OPTIONAL LPVOID lpSecurityDescriptor,
|
|
OUT LPDWORD lpDisposition
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Creates a key in the local registry. If the key exists, it
|
|
is opened. If it does not exist, it is created.
|
|
|
|
Arguments:
|
|
|
|
hKey - Supplies the key that the create is relative to.
|
|
|
|
lpSubKey - Supplies the key name relative to hKey
|
|
|
|
dwOptions - Supplies any registry option flags.
|
|
|
|
samDesired - Supplies desired security access mask
|
|
|
|
lpSecurityDescriptor - Supplies security for the newly created key.
|
|
|
|
Disposition - Returns whether the key was opened (REG_OPENED_EXISTING_KEY)
|
|
or created (REG_CREATED_NEW_KEY)
|
|
|
|
Return Value:
|
|
|
|
A handle to the specified key if successful
|
|
|
|
NULL otherwise. LastError will be set to the specific error code.
|
|
|
|
--*/
|
|
|
|
{
|
|
PDMKEY Parent;
|
|
PDMKEY Key = NULL;
|
|
DWORD NameLength;
|
|
DWORD Status;
|
|
PDM_CREATE_KEY_UPDATE CreateUpdate = NULL;
|
|
PVOID pBuffer = NULL;
|
|
DWORD dwBufLength;
|
|
DWORD dwSecurityLength;
|
|
PLOCALXSACTION pLocalXsaction;
|
|
|
|
|
|
GETLOCALXSACTION(pLocalXsaction, hLocalXsaction);
|
|
|
|
if (dwOptions == REG_OPTION_VOLATILE)
|
|
{
|
|
Status = ERROR_INVALID_PARAMETER;
|
|
goto FnExit;
|
|
}
|
|
|
|
Parent = (PDMKEY)hKey;
|
|
|
|
//
|
|
// Allocate the DMKEY structure.
|
|
//
|
|
NameLength = (lstrlenW(Parent->Name) + 1 + lstrlenW(lpSubKey) + 1)*sizeof(WCHAR);
|
|
Key = LocalAlloc(LMEM_FIXED, sizeof(DMKEY)+NameLength);
|
|
if (Key == NULL) {
|
|
CL_UNEXPECTED_ERROR(ERROR_NOT_ENOUGH_MEMORY);
|
|
Status = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto FnExit;
|
|
}
|
|
|
|
//
|
|
// Create the key on the local machine.
|
|
//
|
|
Status = RegCreateKeyExW(Parent->hKey,
|
|
lpSubKey,
|
|
0,
|
|
NULL,
|
|
0,
|
|
samDesired,
|
|
lpSecurityDescriptor,
|
|
&Key->hKey,
|
|
lpDisposition);
|
|
if (Status != ERROR_SUCCESS) {
|
|
goto FnExit;
|
|
}
|
|
|
|
//
|
|
// Create the key name
|
|
//
|
|
lstrcpyW(Key->Name, Parent->Name);
|
|
if (Key->Name[0] != UNICODE_NULL) {
|
|
lstrcatW(Key->Name, L"\\");
|
|
}
|
|
lstrcatW(Key->Name, lpSubKey);
|
|
Key->GrantedAccess = samDesired;
|
|
|
|
EnterCriticalSection(&KeyLock);
|
|
InsertHeadList(&KeyList, &Key->ListEntry);
|
|
InitializeListHead(&Key->NotifyList);
|
|
LeaveCriticalSection(&KeyLock);
|
|
|
|
//add the pending notification to be delivered on commit
|
|
DmpAddToPendingNotifications(pLocalXsaction, Key->Name, CLUSTER_CHANGE_REGISTRY_NAME);
|
|
|
|
//successfully created key, write to the log
|
|
if (gbIsQuoLoggingOn && gbIsQuoResOnline && AMIOWNEROFQUORES(gpQuoResource)
|
|
&& ghQuoLog && pLocalXsaction->hLogXsaction)
|
|
{
|
|
|
|
//get the length of the security structure
|
|
if (ARGUMENT_PRESENT(lpSecurityDescriptor))
|
|
{
|
|
dwSecurityLength = GetSecurityDescriptorLength(lpSecurityDescriptor);
|
|
}
|
|
else
|
|
{
|
|
dwSecurityLength = 0;
|
|
}
|
|
|
|
CreateUpdate = (PDM_CREATE_KEY_UPDATE)LocalAlloc(LMEM_FIXED, sizeof(DM_CREATE_KEY_UPDATE));
|
|
if (CreateUpdate == NULL) {
|
|
CL_UNEXPECTED_ERROR(ERROR_NOT_ENOUGH_MEMORY);
|
|
Status = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto FnExit;
|
|
}
|
|
|
|
//
|
|
// Issue the update.
|
|
//
|
|
CreateUpdate->lpDisposition = lpDisposition;
|
|
CreateUpdate->phKey = &Key->hKey;
|
|
CreateUpdate->samDesired = samDesired;
|
|
CreateUpdate->dwOptions = dwOptions;
|
|
|
|
if (ARGUMENT_PRESENT(lpSecurityDescriptor)) {
|
|
CreateUpdate->SecurityPresent = TRUE;
|
|
} else {
|
|
CreateUpdate->SecurityPresent = FALSE;
|
|
}
|
|
|
|
//marshall the data,
|
|
pBuffer = GumMarshallArgs(&dwBufLength,
|
|
3,
|
|
sizeof(DM_CREATE_KEY_UPDATE),
|
|
CreateUpdate,
|
|
(lstrlenW(Key->Name)+1)*sizeof(WCHAR),
|
|
Key->Name,
|
|
dwSecurityLength,
|
|
lpSecurityDescriptor);
|
|
if (pBuffer)
|
|
{
|
|
CL_ASSERT(pLocalXsaction->hLogXsaction);
|
|
//write it to the logger
|
|
if (LogWriteXsaction(ghQuoLog, pLocalXsaction->hLogXsaction,
|
|
DmUpdateCreateKey, pBuffer, dwBufLength) == NULL_LSN)
|
|
{
|
|
Status = GetLastError();
|
|
goto FnExit;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
FnExit:
|
|
if (Status != ERROR_SUCCESS)
|
|
{
|
|
if (Key) LocalFree(Key);
|
|
Key = NULL;
|
|
SetLastError(Status);
|
|
}
|
|
if (CreateUpdate) LocalFree(CreateUpdate);
|
|
if (pBuffer) LocalFree(pBuffer);
|
|
return((HDMKEY)Key);
|
|
|
|
}
|
|
|
|
|
|
DWORD
|
|
DmLocalRemoveFromMultiSz(
|
|
IN HLOCALXSACTION hLocalXsaction,
|
|
IN HDMKEY hKey,
|
|
IN LPCWSTR lpValueName,
|
|
IN LPCWSTR lpString
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Removes a string from a REG_MULTI_SZ value.
|
|
|
|
Arguments:
|
|
|
|
hKey - Supplies the key where the value exists. This key must
|
|
have been opened with READ | KEY_SET_VALUE access
|
|
|
|
lpValueName - Supplies the name of the value.
|
|
|
|
lpString - Supplies the string to be removed from the REG_MULTI_SZ value
|
|
|
|
Return Value:
|
|
|
|
ERROR_SUCCESS if successful
|
|
|
|
Win32 error code otherwise
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD Status;
|
|
LPWSTR Buffer=NULL;
|
|
DWORD BufferSize;
|
|
DWORD DataSize;
|
|
LPWSTR Current;
|
|
DWORD CurrentLength;
|
|
DWORD i;
|
|
LPWSTR Next;
|
|
PCHAR Src, Dest;
|
|
DWORD NextLength;
|
|
DWORD MultiLength;
|
|
|
|
|
|
|
|
BufferSize = 0;
|
|
Status = DmQueryString(hKey,
|
|
lpValueName,
|
|
REG_MULTI_SZ,
|
|
&Buffer,
|
|
&BufferSize,
|
|
&DataSize);
|
|
if (Status != ERROR_SUCCESS) {
|
|
return(Status);
|
|
}
|
|
|
|
MultiLength = DataSize/sizeof(WCHAR);
|
|
Status = ClRtlMultiSzRemove(Buffer,
|
|
&MultiLength,
|
|
lpString);
|
|
if (Status == ERROR_SUCCESS) {
|
|
//
|
|
// Set the new value back.
|
|
//
|
|
Status = DmLocalSetValue(hLocalXsaction,
|
|
hKey,
|
|
lpValueName,
|
|
REG_MULTI_SZ,
|
|
(CONST BYTE *)Buffer,
|
|
MultiLength * sizeof(WCHAR));
|
|
|
|
} else if (Status == ERROR_FILE_NOT_FOUND) {
|
|
Status = ERROR_SUCCESS;
|
|
}
|
|
if (Buffer) LocalFree(Buffer);
|
|
return(Status);
|
|
}
|
|
|
|
DWORD
|
|
DmLocalAppendToMultiSz(
|
|
IN HLOCALXSACTION hLocalXsaction,
|
|
IN HDMKEY hKey,
|
|
IN LPCWSTR lpValueName,
|
|
IN LPCWSTR lpString
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Adds another string to a REG_MULTI_SZ value. If the value does
|
|
not exist, it will be created.
|
|
|
|
Arguments:
|
|
|
|
hLocalXsaction - A handle to a local transaction.
|
|
|
|
hKey - Supplies the key where the value exists. This key must
|
|
have been opened with KEY_READ | KEY_SET_VALUE access
|
|
|
|
lpValueName - Supplies the name of the value.
|
|
|
|
lpString - Supplies the string to be appended to the REG_MULTI_SZ value
|
|
|
|
Return Value:
|
|
|
|
ERROR_SUCCESS if successful
|
|
|
|
Win32 error code otherwise
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD ValueLength = 512;
|
|
DWORD ReturnedLength;
|
|
LPWSTR ValueData;
|
|
DWORD StringLength;
|
|
DWORD Status;
|
|
DWORD cbValueData;
|
|
PWSTR s;
|
|
DWORD Type;
|
|
|
|
StringLength = (lstrlenW(lpString)+1)*sizeof(WCHAR);
|
|
retry:
|
|
ValueData = LocalAlloc(LMEM_FIXED, ValueLength + StringLength);
|
|
if (ValueData == NULL) {
|
|
return(ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
|
|
cbValueData = ValueLength;
|
|
Status = DmQueryValue(hKey,
|
|
lpValueName,
|
|
&Type,
|
|
(LPBYTE)ValueData,
|
|
&cbValueData);
|
|
if (Status == ERROR_MORE_DATA) {
|
|
//
|
|
// The existing value is too large for our buffer.
|
|
// Retry with a larger buffer.
|
|
//
|
|
ValueLength = cbValueData;
|
|
LocalFree(ValueData);
|
|
goto retry;
|
|
}
|
|
if (Status == ERROR_FILE_NOT_FOUND) {
|
|
//
|
|
// The value does not currently exist. Create the
|
|
// value with our data.
|
|
//
|
|
s = ValueData;
|
|
|
|
} else if (Status == ERROR_SUCCESS) {
|
|
//
|
|
// A value already exists. Append our string to the
|
|
// MULTI_SZ.
|
|
//
|
|
s = (PWSTR)((PCHAR)ValueData + cbValueData) - 1;
|
|
} else {
|
|
LocalFree(ValueData);
|
|
return(Status);
|
|
}
|
|
|
|
CopyMemory(s, lpString, StringLength);
|
|
s += (StringLength / sizeof(WCHAR));
|
|
*s++ = L'\0';
|
|
|
|
Status = DmLocalSetValue(
|
|
hLocalXsaction,
|
|
hKey,
|
|
lpValueName,
|
|
REG_MULTI_SZ,
|
|
(CONST BYTE *)ValueData,
|
|
(DWORD)((s-ValueData)*sizeof(WCHAR)));
|
|
LocalFree(ValueData);
|
|
|
|
return(Status);
|
|
}
|
|
|
|
DWORD
|
|
DmLocalDeleteKey(
|
|
IN HLOCALXSACTION hLocalXsaction,
|
|
IN HDMKEY hKey,
|
|
IN LPCWSTR lpSubKey
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Deletes the specified key from the local registry. A key that has subkeys cannot
|
|
be deleted.
|
|
|
|
Arguments:
|
|
|
|
hKey - Supplies a handle to a currently open key.
|
|
|
|
lpSubKey - Points to a null-terminated string specifying the
|
|
name of the key to delete. This parameter cannot be NULL,
|
|
and the specified key must not have subkeys.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is ERROR_SUCCESS.
|
|
|
|
If the function fails, the return value is an error value.
|
|
|
|
--*/
|
|
|
|
{
|
|
PDMKEY Key;
|
|
DWORD NameLength;
|
|
DWORD UpdateLength;
|
|
PDM_DELETE_KEY_UPDATE Update=NULL;
|
|
DWORD Status;
|
|
PLOCALXSACTION pLocalXsaction;
|
|
|
|
GETLOCALXSACTION(pLocalXsaction, hLocalXsaction);
|
|
|
|
Key = (PDMKEY)hKey;
|
|
NameLength = (lstrlenW(Key->Name) + 1 + lstrlenW(lpSubKey) + 1)*sizeof(WCHAR);
|
|
UpdateLength = NameLength + sizeof(DM_DELETE_KEY_UPDATE);
|
|
|
|
Update = (PDM_DELETE_KEY_UPDATE)LocalAlloc(LMEM_FIXED, UpdateLength);
|
|
|
|
if (Update == NULL)
|
|
{
|
|
Status = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto FnExit;
|
|
}
|
|
|
|
|
|
//dont need an update on status thru marshalled data
|
|
Update->lpStatus = NULL;
|
|
CopyMemory(Update->Name, Key->Name, (lstrlenW(Key->Name) + 1) * sizeof(WCHAR));
|
|
if (Update->Name[0] != L'\0')
|
|
{
|
|
lstrcatW(Update->Name, L"\\");
|
|
}
|
|
lstrcatW(Update->Name, lpSubKey);
|
|
|
|
Status = RegDeleteKeyW(DmpRoot, Update->Name);
|
|
|
|
if (Status != ERROR_SUCCESS)
|
|
goto FnExit;
|
|
|
|
//add the pending notification to be delivered on commit
|
|
DmpAddToPendingNotifications(pLocalXsaction, Update->Name, CLUSTER_CHANGE_REGISTRY_NAME);
|
|
|
|
//successfully deleted key, write to the log
|
|
if (gbIsQuoLoggingOn && gbIsQuoResOnline && AMIOWNEROFQUORES(gpQuoResource)
|
|
&& ghQuoLog && pLocalXsaction->hLogXsaction)
|
|
{
|
|
|
|
if (LogWriteXsaction(ghQuoLog, pLocalXsaction->hLogXsaction,
|
|
DmUpdateDeleteKey, Update, UpdateLength) == NULL_LSN)
|
|
{
|
|
Status = GetLastError();
|
|
goto FnExit;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
FnExit:
|
|
if (Update) LocalFree(Update);
|
|
return(Status);
|
|
}
|
|
|
|
DWORD
|
|
DmLocalDeleteTree(
|
|
IN HLOCALXSACTION hLocalXsaction,
|
|
IN HDMKEY hKey,
|
|
IN LPCWSTR lpSubKey
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Deletes the specified registry subtree in the local registry.
|
|
All subkeys are deleted.
|
|
|
|
Arguments:
|
|
|
|
hKey - Supplies a handle to a currently open key.
|
|
|
|
lpSubKey - Points to a null-terminated string specifying the
|
|
name of the key to delete. This parameter cannot be NULL.
|
|
Any subkeys of the specified key will also be deleted.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is ERROR_SUCCESS.
|
|
|
|
If the function fails, the return value is an error value.
|
|
|
|
--*/
|
|
|
|
{
|
|
HDMKEY Subkey;
|
|
DWORD i;
|
|
DWORD Status;
|
|
LPWSTR KeyBuffer=NULL;
|
|
DWORD MaxKeyLen;
|
|
DWORD NeededSize;
|
|
|
|
Subkey = DmOpenKey(hKey,
|
|
lpSubKey,
|
|
MAXIMUM_ALLOWED);
|
|
if (Subkey == NULL) {
|
|
Status = GetLastError();
|
|
return(Status);
|
|
}
|
|
|
|
//
|
|
// Get the size of name buffer we will need.
|
|
//
|
|
Status = DmQueryInfoKey(Subkey,
|
|
NULL,
|
|
&MaxKeyLen,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL);
|
|
if (Status != ERROR_SUCCESS) {
|
|
CL_UNEXPECTED_ERROR( Status );
|
|
DmCloseKey(Subkey);
|
|
return(Status);
|
|
}
|
|
KeyBuffer = LocalAlloc(LMEM_FIXED, (MaxKeyLen+1)*sizeof(WCHAR));
|
|
if (KeyBuffer == NULL) {
|
|
CL_UNEXPECTED_ERROR( ERROR_NOT_ENOUGH_MEMORY );
|
|
DmCloseKey(Subkey);
|
|
return(ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
|
|
//
|
|
// Enumerate the subkeys and apply ourselves recursively to each one.
|
|
//
|
|
i=0;
|
|
do {
|
|
NeededSize = MaxKeyLen+1;
|
|
Status = DmEnumKey(Subkey,
|
|
i,
|
|
KeyBuffer,
|
|
&NeededSize,
|
|
NULL);
|
|
if (Status == ERROR_SUCCESS) {
|
|
//
|
|
// Call ourselves recursively on this keyname.
|
|
//
|
|
DmLocalDeleteTree(hLocalXsaction, Subkey, KeyBuffer);
|
|
|
|
} else {
|
|
//
|
|
// Some odd error, keep going with the next key.
|
|
//
|
|
++i;
|
|
}
|
|
|
|
} while ( Status != ERROR_NO_MORE_ITEMS );
|
|
|
|
DmCloseKey(Subkey);
|
|
|
|
Status = DmLocalDeleteKey(hLocalXsaction, hKey, lpSubKey);
|
|
|
|
if (KeyBuffer != NULL) {
|
|
LocalFree(KeyBuffer);
|
|
}
|
|
return(Status);
|
|
}
|
|
|
|
|
|
DWORD
|
|
DmLocalDeleteValue(
|
|
IN HLOCALXSACTION hLocalXsaction,
|
|
IN HDMKEY hKey,
|
|
IN LPCWSTR lpValueName
|
|
)
|
|
{
|
|
PDMKEY Key;
|
|
DWORD NameLength;
|
|
DWORD ValueNameLength;
|
|
DWORD UpdateLength;
|
|
PDM_DELETE_VALUE_UPDATE Update=NULL;
|
|
PUCHAR Dest;
|
|
DWORD Status;
|
|
HKEY hRegKey;
|
|
PLOCALXSACTION pLocalXsaction;
|
|
|
|
GETLOCALXSACTION(pLocalXsaction, hLocalXsaction);
|
|
|
|
Key = (PDMKEY)hKey;
|
|
|
|
Status = RegOpenKeyExW(DmpRoot,
|
|
Key->Name,
|
|
0,
|
|
KEY_SET_VALUE,
|
|
&hRegKey);
|
|
if (Status != ERROR_SUCCESS) {
|
|
goto FnExit;
|
|
}
|
|
|
|
|
|
Status = RegDeleteValueW(hRegKey, lpValueName);
|
|
RegCloseKey(hRegKey);
|
|
|
|
if (Status!=ERROR_SUCCESS)
|
|
goto FnExit;
|
|
|
|
//add the pending notification to be delivered on commit
|
|
DmpAddToPendingNotifications(pLocalXsaction, Key->Name, CLUSTER_CHANGE_REGISTRY_VALUE);
|
|
|
|
//successfully created key, write to the log
|
|
if (gbIsQuoLoggingOn && gbIsQuoResOnline && AMIOWNEROFQUORES(gpQuoResource)
|
|
&& ghQuoLog && pLocalXsaction->hLogXsaction)
|
|
{
|
|
|
|
//if successful and this is the logging node, then log
|
|
// the transaction
|
|
NameLength = (lstrlenW(Key->Name)+1)*sizeof(WCHAR);
|
|
ValueNameLength = (lstrlenW(lpValueName)+1)*sizeof(WCHAR);
|
|
UpdateLength = sizeof(DM_DELETE_VALUE_UPDATE) +
|
|
NameLength +
|
|
ValueNameLength;
|
|
|
|
Update = (PDM_DELETE_VALUE_UPDATE)LocalAlloc(LMEM_FIXED, UpdateLength);
|
|
if (Update == NULL) {
|
|
Status = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto FnExit;
|
|
}
|
|
|
|
|
|
Update->lpStatus = NULL;
|
|
Update->NameOffset = FIELD_OFFSET(DM_DELETE_VALUE_UPDATE, KeyName)+NameLength;
|
|
|
|
CopyMemory(Update->KeyName, Key->Name, NameLength);
|
|
|
|
Dest = (PUCHAR)Update + Update->NameOffset;
|
|
CopyMemory(Dest, lpValueName, ValueNameLength);
|
|
|
|
if (LogWriteXsaction(ghQuoLog, pLocalXsaction->hLogXsaction,
|
|
DmUpdateDeleteValue, Update, UpdateLength) == NULL_LSN)
|
|
{
|
|
Status = GetLastError();
|
|
goto FnExit;
|
|
}
|
|
}
|
|
|
|
FnExit:
|
|
if (Update) LocalFree(Update);
|
|
return(Status);
|
|
}
|
|
|
|
|
|
/****
|
|
@func VOID | DmpReportPendingNotifications| This is called
|
|
on commit or abort of a local transactions. On a commit,
|
|
notifications related to changes within a transaction
|
|
are delivered.
|
|
|
|
@parm IN PLOCALXSACTION | pLocalXsaction| A pointer to the local
|
|
transation context.
|
|
|
|
@parm IN BOOL | bCommit| Set to TRUE when the transaction is
|
|
commited.
|
|
|
|
@comm The pending notification structure associated with the
|
|
transaction is cleaned up.
|
|
|
|
@xref <f DmAbortLocalUpdate> <f DmCommitLocalUpdate>
|
|
****/
|
|
VOID
|
|
DmpReportPendingNotifications(
|
|
IN PLOCALXSACTION pLocalXsaction,
|
|
IN BOOL bCommit
|
|
)
|
|
{
|
|
PLIST_ENTRY pListEntry;
|
|
PDM_PENDING_NOTIFY pDmPendingNotify;
|
|
|
|
pListEntry = pLocalXsaction->PendingNotifyListHead.Flink;
|
|
|
|
//remove the entries and proces them one by one
|
|
//free them when done
|
|
while (pListEntry != &pLocalXsaction->PendingNotifyListHead)
|
|
{
|
|
pDmPendingNotify = CONTAINING_RECORD(pListEntry, DM_PENDING_NOTIFY, ListEntry);
|
|
// if transaction is commited
|
|
if (bCommit)
|
|
DmpReportNotify(pDmPendingNotify->pszKeyName, pDmPendingNotify->dwFilter);
|
|
pListEntry = pListEntry->Flink;
|
|
RemoveEntryList( &pDmPendingNotify->ListEntry );
|
|
LocalFree(pDmPendingNotify->pszKeyName);
|
|
LocalFree(pDmPendingNotify);
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
/****
|
|
@func DWORD | DmpAddToPendingNotifications| This is called
|
|
by the DmLocal Api's to queue registry notifications
|
|
on success. The notifications are delivered or
|
|
thrown away depending on whether the transaction commits
|
|
or aborts.
|
|
|
|
@parm IN PLOCALXSACTION | pLocalXsaction| A pointer to the local
|
|
transation context.
|
|
|
|
@parm IN LPCWSTR | pszName| A pointer to the registry key name.
|
|
|
|
@parm IN DWORD | dwFilter | The filters associated with the notification.
|
|
|
|
@comm A new pending notification structure is created and associated
|
|
with the transaction.
|
|
|
|
@xref <f DmAbortLocalUpdate> <f DmCommitLocalUpdate>
|
|
****/
|
|
DWORD
|
|
DmpAddToPendingNotifications(
|
|
IN PLOCALXSACTION pLocalXsaction,
|
|
IN LPCWSTR pszName,
|
|
IN DWORD dwFilter
|
|
)
|
|
{
|
|
DWORD dwError = ERROR_SUCCESS;
|
|
PDM_PENDING_NOTIFY pDmPendingNotify;
|
|
|
|
pDmPendingNotify = LocalAlloc(LPTR, sizeof(DM_PENDING_NOTIFY));
|
|
if (!pDmPendingNotify)
|
|
{
|
|
dwError = ERROR_NOT_ENOUGH_MEMORY;
|
|
CL_LOGFAILURE(dwError);
|
|
goto FnExit;
|
|
}
|
|
|
|
pDmPendingNotify->pszKeyName = LocalAlloc(LMEM_FIXED,
|
|
((lstrlenW(pszName) + 1 ) * sizeof(WCHAR)));
|
|
if (!pDmPendingNotify->pszKeyName)
|
|
{
|
|
dwError = ERROR_NOT_ENOUGH_MEMORY;
|
|
CL_LOGFAILURE(dwError);
|
|
goto FnExit;
|
|
}
|
|
|
|
//initialize the structure
|
|
lstrcpyW(pDmPendingNotify->pszKeyName, pszName);
|
|
pDmPendingNotify->dwFilter = dwFilter;
|
|
InitializeListHead(&pDmPendingNotify->ListEntry);
|
|
|
|
//add to the list
|
|
InsertTailList(&pLocalXsaction->PendingNotifyListHead,
|
|
&pDmPendingNotify->ListEntry);
|
|
|
|
|
|
FnExit:
|
|
return(dwError);
|
|
}
|
|
|
|
/****
|
|
@func DWORD | DmAmITheOwnerOfTheQuorumResource| This harmless
|
|
function is used by regroup module to determine whether
|
|
a node thinks that it is the owner of the quorum resource or not.
|
|
****/
|
|
DWORD DmAmITheOwnerOfTheQuorumResource() {
|
|
return gpQuoResource
|
|
&& gpQuoResource->Group
|
|
&& gbIsQuoResOnline
|
|
&& AMIOWNEROFQUORES(gpQuoResource);
|
|
}
|
|
|
|
|
|
|
|
DWORD
|
|
DmRtlLocalCreateKey(
|
|
IN HLOCALXSACTION hLocalXsaction,
|
|
IN HDMKEY hKey,
|
|
IN LPCWSTR lpSubKey,
|
|
IN DWORD dwOptions,
|
|
IN DWORD samDesired,
|
|
IN OPTIONAL LPVOID lpSecurityDescriptor,
|
|
OUT HDMKEY * phkResult,
|
|
OUT LPDWORD lpDisposition
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Wrapper function for DmLocalCreateKey to be used with CLRtl* functions.
|
|
|
|
--*/
|
|
{
|
|
DWORD status;
|
|
|
|
*phkResult= DmLocalCreateKey(
|
|
hLocalXsaction,
|
|
hKey,
|
|
lpSubKey,
|
|
dwOptions,
|
|
samDesired,
|
|
lpSecurityDescriptor,
|
|
lpDisposition
|
|
);
|
|
if(* phkResult == NULL)
|
|
status=GetLastError();
|
|
else
|
|
status=ERROR_SUCCESS;
|
|
return status;
|
|
}
|