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.
995 lines
25 KiB
995 lines
25 KiB
/*++
|
|
|
|
Copyright (c) 1996 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
registry.c
|
|
|
|
Abstract:
|
|
|
|
Server side support for Cluster registry database APIs
|
|
|
|
Author:
|
|
|
|
John Vert (jvert) 8-Mar-1996
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
#include "apip.h"
|
|
|
|
|
|
PAPI_HANDLE
|
|
ApipMakeKeyHandle(
|
|
IN HDMKEY Key
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Allocates and initializes an API_HANDLE structure for the
|
|
specified HDMKEY.
|
|
|
|
Arguments:
|
|
|
|
Key - Supplies the HDMKEY.
|
|
|
|
Return Value:
|
|
|
|
A pointer to the initialized API_HANDLE structure on success.
|
|
|
|
NULL on memory allocation failure.
|
|
|
|
--*/
|
|
|
|
{
|
|
PAPI_HANDLE Handle;
|
|
|
|
Handle = LocalAlloc(LMEM_FIXED, sizeof(API_HANDLE));
|
|
if (Handle == NULL) {
|
|
return(NULL);
|
|
}
|
|
Handle->Type = API_KEY_HANDLE;
|
|
Handle->Flags = 0;
|
|
Handle->Key = Key;
|
|
InitializeListHead(&Handle->NotifyList);
|
|
return(Handle);
|
|
|
|
}
|
|
|
|
|
|
HKEY_RPC
|
|
s_ApiGetRootKey(
|
|
IN handle_t IDL_handle,
|
|
IN DWORD samDesired,
|
|
OUT error_status_t *Status
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Opens the registry key at the root of the cluster registry database
|
|
|
|
Arguments:
|
|
|
|
IDL_handle - Supplies RPC binding handle, not used.
|
|
|
|
samDesired - Supplies requested security access
|
|
|
|
Status - Returns error code, if any.
|
|
|
|
Return Value:
|
|
|
|
A handle to the opened registry key.
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD Error;
|
|
HDMKEY Key;
|
|
PAPI_HANDLE Handle=NULL;
|
|
|
|
*Status = RpcImpersonateClient(NULL);
|
|
if (*Status != RPC_S_OK)
|
|
{
|
|
goto FnExit;
|
|
}
|
|
Key = DmGetRootKey(samDesired);
|
|
RpcRevertToSelf();
|
|
if (Key == NULL) {
|
|
*Status = GetLastError();
|
|
} else {
|
|
Handle = ApipMakeKeyHandle(Key);
|
|
if (Handle == NULL) {
|
|
DmCloseKey(Key);
|
|
*Status = ERROR_NOT_ENOUGH_MEMORY;
|
|
} else {
|
|
*Status = ERROR_SUCCESS;
|
|
}
|
|
}
|
|
FnExit:
|
|
return(Handle);
|
|
}
|
|
|
|
|
|
HKEY_RPC
|
|
s_ApiCreateKey(
|
|
IN HKEY_RPC hKey,
|
|
IN LPCWSTR lpSubKey,
|
|
IN DWORD dwOptions,
|
|
IN DWORD samDesired,
|
|
IN PRPC_SECURITY_ATTRIBUTES lpSecurityAttributes,
|
|
OUT LPDWORD lpdwDisposition,
|
|
OUT error_status_t *Status
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Creates a key in the cluster registry. If the key exists, it
|
|
is opened. If it does not exist, it is created on all nodes in
|
|
the cluster.
|
|
|
|
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. The only currently
|
|
supported option is REG_OPTION_VOLATILE
|
|
|
|
samDesired - Supplies desired security access mask
|
|
|
|
lpSecurityAttributes - Supplies security for the newly created key.
|
|
|
|
Disposition - Returns whether the key was opened (REG_OPENED_EXISTING_KEY)
|
|
or created (REG_CREATED_NEW_KEY)
|
|
|
|
Status - Returns the error code if the function is unsuccessful.
|
|
|
|
Return Value:
|
|
|
|
A handle to the specified key if successful
|
|
|
|
NULL otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
HDMKEY NewKey;
|
|
PAPI_HANDLE Handle = NULL;
|
|
PAPI_HANDLE RootHandle = NULL;
|
|
|
|
if (hKey != NULL) {
|
|
RootHandle = (PAPI_HANDLE)hKey;
|
|
if (RootHandle->Type != API_KEY_HANDLE) {
|
|
*Status = ERROR_INVALID_HANDLE;
|
|
return(NULL);
|
|
}
|
|
} else {
|
|
*Status = ERROR_INVALID_HANDLE;
|
|
return(NULL);
|
|
}
|
|
|
|
if (ApiState != ApiStateOnline) {
|
|
*Status = ERROR_SHARING_PAUSED;
|
|
return(NULL);
|
|
}
|
|
|
|
*Status = RpcImpersonateClient(NULL);
|
|
if (*Status != RPC_S_OK)
|
|
{
|
|
return(NULL);
|
|
}
|
|
|
|
if ( ARGUMENT_PRESENT( lpSecurityAttributes ) &&
|
|
(lpSecurityAttributes->RpcSecurityDescriptor.lpSecurityDescriptor != NULL) &&
|
|
!RtlValidRelativeSecurityDescriptor( lpSecurityAttributes->RpcSecurityDescriptor.lpSecurityDescriptor,
|
|
lpSecurityAttributes->RpcSecurityDescriptor.cbInSecurityDescriptor,
|
|
0 ) ) {
|
|
*Status = ERROR_INVALID_SECURITY_DESCR;
|
|
goto FnExit;
|
|
}
|
|
|
|
NewKey = DmCreateKey(RootHandle->Key,
|
|
lpSubKey,
|
|
dwOptions,
|
|
samDesired,
|
|
ARGUMENT_PRESENT(lpSecurityAttributes)
|
|
? lpSecurityAttributes->RpcSecurityDescriptor.lpSecurityDescriptor
|
|
: NULL,
|
|
lpdwDisposition);
|
|
if (NewKey == NULL) {
|
|
*Status = GetLastError();
|
|
} else {
|
|
Handle = ApipMakeKeyHandle(NewKey);
|
|
if (Handle == NULL) {
|
|
DmCloseKey(NewKey);
|
|
*Status = ERROR_NOT_ENOUGH_MEMORY;
|
|
} else {
|
|
*Status = ERROR_SUCCESS;
|
|
}
|
|
}
|
|
|
|
FnExit:
|
|
RpcRevertToSelf();
|
|
return(Handle);
|
|
}
|
|
|
|
|
|
HKEY_RPC
|
|
s_ApiOpenKey(
|
|
IN HKEY_RPC hKey,
|
|
IN LPCWSTR lpSubKey,
|
|
IN DWORD samDesired,
|
|
OUT error_status_t *Status
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Opens a key in the cluster registry. If the key exists, it
|
|
is opened. If it does not exist, the call fails.
|
|
|
|
Arguments:
|
|
|
|
hKey - Supplies the key that the open is relative to.
|
|
|
|
lpSubKey - Supplies the key name relative to hKey
|
|
|
|
samDesired - Supplies desired security access mask
|
|
|
|
Status - Returns the error code if the function is unsuccessful.
|
|
|
|
Return Value:
|
|
|
|
A handle to the specified key if successful
|
|
|
|
NULL otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
HDMKEY NewKey;
|
|
PAPI_HANDLE Handle=NULL;
|
|
PAPI_HANDLE RootHandle;
|
|
|
|
if (hKey != NULL) {
|
|
RootHandle = (PAPI_HANDLE)hKey;
|
|
if (RootHandle->Type != API_KEY_HANDLE) {
|
|
*Status = ERROR_INVALID_HANDLE;
|
|
return(NULL);
|
|
}
|
|
} else {
|
|
*Status = ERROR_INVALID_HANDLE;
|
|
return(NULL);
|
|
}
|
|
|
|
*Status = RpcImpersonateClient(NULL);
|
|
if (*Status != RPC_S_OK)
|
|
{
|
|
goto FnExit;
|
|
}
|
|
|
|
NewKey = DmOpenKey(RootHandle->Key,
|
|
lpSubKey,
|
|
samDesired);
|
|
if (NewKey == NULL) {
|
|
*Status = GetLastError();
|
|
} else {
|
|
Handle = ApipMakeKeyHandle(NewKey);
|
|
if (Handle == NULL) {
|
|
DmCloseKey(NewKey);
|
|
*Status = ERROR_NOT_ENOUGH_MEMORY;
|
|
} else {
|
|
*Status = ERROR_SUCCESS;
|
|
}
|
|
}
|
|
RpcRevertToSelf();
|
|
FnExit:
|
|
return(Handle);
|
|
}
|
|
|
|
error_status_t
|
|
s_ApiEnumKey(
|
|
IN HKEY_RPC hKey,
|
|
IN DWORD dwIndex,
|
|
OUT LPWSTR *KeyName,
|
|
OUT PFILETIME lpftLastWriteTime
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Enumerates the subkeys of a cluster registry key.
|
|
|
|
Arguments:
|
|
|
|
hKey - Supplies the registry key for which the subkeys should
|
|
be enumerated.
|
|
|
|
dwIndex - Supplies the index to be enumerated.
|
|
|
|
KeyName - Returns the name of the dwIndex subkey. The memory
|
|
allocated for this buffer must be freed by the client.
|
|
|
|
lpftLastWriteTime - Returns the last write time.
|
|
|
|
Return Value:
|
|
|
|
ERROR_SUCCESS if successful
|
|
|
|
Win32 error code otherwise
|
|
|
|
--*/
|
|
|
|
{
|
|
LONG Status;
|
|
DWORD NameLength;
|
|
HDMKEY DmKey;
|
|
|
|
VALIDATE_KEY(DmKey, hKey);
|
|
|
|
Status = DmQueryInfoKey(DmKey,
|
|
NULL,
|
|
&NameLength,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL);
|
|
if (Status != ERROR_SUCCESS) {
|
|
return(Status);
|
|
}
|
|
|
|
NameLength += 1;
|
|
|
|
*KeyName = MIDL_user_allocate(NameLength*sizeof(WCHAR));
|
|
if (*KeyName == NULL) {
|
|
return(ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
Status = DmEnumKey(DmKey,
|
|
dwIndex,
|
|
*KeyName,
|
|
&NameLength,
|
|
lpftLastWriteTime);
|
|
if (Status != ERROR_SUCCESS) {
|
|
MIDL_user_free(*KeyName);
|
|
*KeyName = NULL;
|
|
}
|
|
return(Status);
|
|
}
|
|
|
|
|
|
DWORD
|
|
s_ApiSetValue(
|
|
IN HKEY_RPC hKey,
|
|
IN LPCWSTR lpValueName,
|
|
IN DWORD dwType,
|
|
IN CONST UCHAR *lpData,
|
|
IN DWORD cbData
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine sets the named value for the specified
|
|
cluster registry key.
|
|
|
|
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
|
|
|
|
--*/
|
|
|
|
{
|
|
HDMKEY DmKey;
|
|
|
|
VALIDATE_KEY(DmKey, hKey);
|
|
API_CHECK_INIT();
|
|
|
|
return(DmSetValue(DmKey,
|
|
lpValueName,
|
|
dwType,
|
|
lpData,
|
|
cbData));
|
|
}
|
|
|
|
|
|
DWORD
|
|
s_ApiDeleteValue(
|
|
IN HKEY_RPC hKey,
|
|
IN LPCWSTR lpValueName
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Removes the specified value from a given registry subkey
|
|
|
|
Arguments:
|
|
|
|
hKey - Supplies the key whose value is to be deleted.
|
|
|
|
lpValueName - Supplies the name of the value to be removed.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is ERROR_SUCCESS.
|
|
|
|
If the function fails, the return value is an error value.
|
|
|
|
--*/
|
|
|
|
{
|
|
HDMKEY DmKey;
|
|
|
|
VALIDATE_KEY(DmKey, hKey);
|
|
API_CHECK_INIT();
|
|
return(DmDeleteValue(DmKey, lpValueName));
|
|
}
|
|
|
|
|
|
error_status_t
|
|
s_ApiQueryValue(
|
|
IN HKEY_RPC hKey,
|
|
IN LPCWSTR lpValueName,
|
|
OUT LPDWORD lpValueType,
|
|
OUT PUCHAR lpData,
|
|
IN DWORD cbData,
|
|
OUT LPDWORD lpcbRequired
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Queries a named value for the specified cluster registry subkey
|
|
|
|
Arguments:
|
|
|
|
hKey - Supplies the subkey whose value should be queried
|
|
|
|
lpValueName - Supplies the named value to be queried
|
|
|
|
lpValueType - Returns the type of the value's data
|
|
|
|
lpData - Returns the value's data
|
|
|
|
cbData - Supplies the size (in bytes) of the lpData buffer
|
|
Returns the number of bytes copied into the lpData buffer
|
|
If lpData==NULL, cbData is set to the required buffer
|
|
size and the function returns ERROR_SUCCESS
|
|
|
|
Return Value:
|
|
|
|
ERROR_SUCCESS if successful
|
|
|
|
Win32 error code otherwise
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD Status;
|
|
DWORD BuffSize;
|
|
HDMKEY DmKey;
|
|
|
|
VALIDATE_KEY(DmKey, hKey);
|
|
|
|
BuffSize = cbData;
|
|
Status = DmQueryValue(DmKey,
|
|
lpValueName,
|
|
lpValueType,
|
|
lpData,
|
|
&BuffSize);
|
|
if ((Status == ERROR_SUCCESS) ||
|
|
(Status == ERROR_MORE_DATA)) {
|
|
*lpcbRequired = BuffSize;
|
|
}
|
|
|
|
return(Status);
|
|
}
|
|
|
|
|
|
DWORD
|
|
s_ApiDeleteKey(
|
|
IN HKEY hKey,
|
|
IN LPCWSTR lpSubKey
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Deletes the specified key. 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.
|
|
|
|
--*/
|
|
|
|
{
|
|
HDMKEY DmKey;
|
|
|
|
VALIDATE_KEY(DmKey, hKey);
|
|
API_CHECK_INIT();
|
|
return(DmDeleteKey(DmKey, lpSubKey));
|
|
}
|
|
|
|
|
|
error_status_t
|
|
s_ApiEnumValue(
|
|
IN HKEY_RPC hKey,
|
|
IN DWORD dwIndex,
|
|
OUT LPWSTR *lpValueName,
|
|
OUT LPDWORD lpType,
|
|
OUT UCHAR *lpData,
|
|
IN OUT LPDWORD lpcbData,
|
|
OUT LPDWORD TotalSize
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Enumerates the specified value of a registry subkey
|
|
|
|
Arguments:
|
|
|
|
hKey - Supplies the registry key handle
|
|
|
|
dwIndex - Supplies the index of the value to be enumerated
|
|
|
|
lpValueName - Returns the name of the dwIndex'th value. The
|
|
memory for this name is allocated on the server and must
|
|
be freed by the client side.
|
|
|
|
lpType - Returns the value data type
|
|
|
|
lpData - Returns the value data
|
|
|
|
lpcbData - Returns the number of bytes written to the lpData buffer.
|
|
|
|
TotalSize - Returns the size of the data
|
|
|
|
Return Value:
|
|
|
|
ERROR_SUCCESS if successful
|
|
|
|
Win32 error code otherwise
|
|
|
|
--*/
|
|
|
|
{
|
|
LONG Status;
|
|
DWORD OriginalNameLength;
|
|
DWORD NameLength;
|
|
DWORD DataLength;
|
|
HDMKEY DmKey;
|
|
|
|
VALIDATE_KEY(DmKey, hKey);
|
|
|
|
Status = DmQueryInfoKey(DmKey,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&NameLength,
|
|
NULL,
|
|
NULL,
|
|
NULL);
|
|
if (Status != ERROR_SUCCESS) {
|
|
return(Status);
|
|
}
|
|
NameLength += 1;
|
|
|
|
*lpValueName = MIDL_user_allocate(NameLength * sizeof(WCHAR));
|
|
if (*lpValueName == NULL) {
|
|
return(ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
|
|
*TotalSize = *lpcbData;
|
|
|
|
//
|
|
// Chittur Subbaraman (chitturs) - 3/13/2001
|
|
//
|
|
// First of all, at the beginning of this function, a big enough buffer for lpValueName
|
|
// is allocated. This means that ERROR_SUCCESS or ERROR_MORE_DATA will be returned by
|
|
// DmEnumValue depending ONLY on the size of the lpData buffer. This info is used by
|
|
// by the clusapi layer when it makes a decision based on the return code from this
|
|
// function.
|
|
//
|
|
// Note that *TotalSize is initialized to *lpcbData just above. The TotalSize OUT variable
|
|
// allows the required lpData size to be returned without touching lpcbData. This is
|
|
// important since lpcbData is declared as the sizeof lpData in the IDL file and that is
|
|
// what RPC will consider the lpData buffer size as. So, it is important that if the lpData
|
|
// buffer is not big enough, this function does not change the value of *lpcbData from what
|
|
// it was originally at IN time.
|
|
//
|
|
// Strange behavior of RegEnumValue: If you supply a big enough buffer for lpValueName and
|
|
// a smaller than required buffer for lpData, then RegEnumValue won't bother to fill in
|
|
// lpValueName and will return ERROR_MORE_DATA. This irregular behavior is handled by
|
|
// DmEnumValue.
|
|
//
|
|
// For reference pointers, RPC won't allow a client to pass in NULL pointers. That is why
|
|
// clusapi layer uses dummy variables in case some of the parameters passed in by the
|
|
// client caller is NULL.
|
|
//
|
|
//
|
|
// Behavior of RegEnumValue (assuming lpValueName buffer is big enough):
|
|
// (1) If lpData = NULL and lpcbData = NULL, then returns ERROR_SUCCESS.
|
|
// (2) If lpData = NULL and lpcbData != NULL, then returns ERROR_SUCCESS and sets
|
|
// *lpcbData to total buffer size required.
|
|
// (3) If lpData != NULL and lpcbData != NULL, but the data buffer size is smaller than
|
|
// required size, then returns ERROR_MORE_DATA and sets *lpcbData to the size required.
|
|
// (4) If lpData != NULL and lpcbData != NULL and the buffer is big enough, then returns
|
|
// ERROR_SUCCESS and sets *lpcbData to the size of the data copied into lpData.
|
|
//
|
|
// OUR GOAL: ClusterRegEnumValue == RegEnumValue.
|
|
//
|
|
//
|
|
// The following cases are handled by this function and the clusapi layer. Note that in this
|
|
// analysis, we assume that the client has called into clusapi with a big enough lpValueName
|
|
// buffer size. (If this is not true, then clusapi layer handles that, check ClusterRegEnumValue.)
|
|
//
|
|
// Case 1: Client passes in lpData=NULL, lpcbData=NULL to ClusterRegEnumValue.
|
|
//
|
|
// In this case, the clusapi layer will point both lpData and lpcbData to local dummy
|
|
// variables and initialize *lpcbData to 0. Thus, s_ApiEnumValue will see
|
|
// both lpData and lpcbData as valid pointers. If the data value is bigger than the size of
|
|
// *lpcbData, then DmEnumValue will return ERROR_MORE_DATA. In this case, *TotalSize will
|
|
// contain the required buffer size and *lpcbData will be untouched. The client detects this
|
|
// error code and sets the return status to ERROR_SUCCESS and *lpcbData to *TotalSize. Note
|
|
// that the 2nd action has less relevance since lpcbData is pointing to a local dummy variable.
|
|
// If the data value is of zero size, DmEnumValue will return ERROR_SUCCESS.
|
|
// In such a case, *lpcbData will be set to *TotalSize before returning by this function.
|
|
// Note that since the data size is 0, DmEnumValue would set *TotalSize to 0 and hence
|
|
// *lpcbData will also be set to 0. Thus, in this case, when ApiEnumValue returns to the
|
|
// clusapi layer, lpValueName will be filled in, *lpData will not be changed and *lpcbData
|
|
// will be set to 0.
|
|
//
|
|
// Case 2: Client passes in lpData=NULL, lpcbData!=NULL and *lpcbData=0 to ClusterRegEnumValue.
|
|
//
|
|
// In this case, lpData alone will be pointing to a dummy clusapi buffer when ApiEnumValue
|
|
// is invoked. Thus, s_ApiEnumValue will get both lpData and lpcbData as valid pointers.
|
|
// If the data size is non-zero, then DmEnumValue will return ERROR_MORE_DATA and
|
|
// *TotalSize will contain the size of the required buffer. When this function returns,
|
|
// *lpcbData will remain untouched. As in case 1, the clusapi layer will set status
|
|
// to ERROR_SUCCESS and *lpcbData to *TotalSize. Thus, the client will see the required
|
|
// buffer size in *lpcbData. If the data size is zero, then it is handled as in case 1.
|
|
//
|
|
// Case 3: Client passes in lpData!=NULL, lpcbData!=NULL, but the data buffer size is smaller than
|
|
// required.
|
|
//
|
|
// In this case, both lpData and lpcbData will be pointing to client buffers (or RPC buffers
|
|
// representing them) at the entry to s_ApiEnumValue. DmEnumValue will return ERROR_MORE_DATA
|
|
// and this function will return the size required in *TotalSize. *lpcbData will not be
|
|
// touched. At the clusapi layer, *lpcbData will be set to *TotalSize and ERROR_MORE_DATA
|
|
// will be returned to the client.
|
|
//
|
|
// Case 4: Client passes in lpData!=NULL, lpcbData!=NULL and the data buffer size is big enough.
|
|
//
|
|
// In this case, as in case 3, s_ApiEnumValue will have lpData and lpcbData pointing to
|
|
// client buffers. DmEnumValue will return ERROR_SUCCESS, data copied to lpData and
|
|
// *lpcbData will be set to *TotalSize (which is the size of the data copied into the
|
|
// lpData buffer), before returning. The clusapi layer will return these values to the client.
|
|
//
|
|
Status = DmEnumValue(DmKey,
|
|
dwIndex,
|
|
*lpValueName,
|
|
&NameLength,
|
|
lpType,
|
|
lpData,
|
|
TotalSize);
|
|
|
|
if (Status == ERROR_MORE_DATA) {
|
|
return(Status);
|
|
} else if (Status != ERROR_SUCCESS) {
|
|
MIDL_user_free(*lpValueName);
|
|
*lpValueName = NULL;
|
|
*lpcbData = 0;
|
|
} else {
|
|
// This tells RPC how big the lpData buffer
|
|
// is so it can copy the buffer to the client.
|
|
*lpcbData = *TotalSize;
|
|
}
|
|
return(Status);
|
|
}
|
|
|
|
|
|
error_status_t
|
|
s_ApiQueryInfoKey(
|
|
IN HKEY_RPC hKey,
|
|
OUT LPDWORD lpcSubKeys,
|
|
OUT LPDWORD lpcbMaxSubKeyLen,
|
|
OUT LPDWORD lpcValues,
|
|
OUT LPDWORD lpcbMaxValueNameLen,
|
|
OUT LPDWORD lpcbMaxValueLen,
|
|
OUT LPDWORD lpcbSecurityDescriptor,
|
|
OUT PFILETIME lpftLastWriteTime
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Retrieves information about a specified cluster registry key.
|
|
|
|
Arguments:
|
|
|
|
hKey - Supplies the handle of the key.
|
|
|
|
lpcSubKeys - Points to a variable that receives the number of subkeys
|
|
contained by the specified key.
|
|
|
|
lpcbMaxSubKeyLen - Points to a variable that receives the length, in
|
|
characters, of the key's subkey with the longest name.
|
|
The count returned does not include the terminating null character.
|
|
|
|
lpcValues - Points to a variable that receives the number of values
|
|
associated with the key.
|
|
|
|
lpcbMaxValueNameLen - Points to a variable that receives the length,
|
|
in characters, of the key's longest value name. The count
|
|
returned does not include the terminating null character.
|
|
|
|
lpcbMaxValueLen - Points to a variable that receives the length, in
|
|
bytes, of the longest data component among the key's values.
|
|
|
|
lpcbSecurityDescriptor - Points to a variable that receives the length,
|
|
in bytes, of the key's security descriptor.
|
|
|
|
lpftLastWriteTime - Pointer to a FILETIME structure.
|
|
|
|
Return Value:
|
|
|
|
ERROR_SUCCESS if successful
|
|
|
|
Win32 error code otherwise
|
|
|
|
--*/
|
|
|
|
{
|
|
HDMKEY DmKey;
|
|
DWORD Status;
|
|
|
|
VALIDATE_KEY(DmKey, hKey);
|
|
|
|
Status = DmQueryInfoKey(DmKey,
|
|
lpcSubKeys,
|
|
lpcbMaxSubKeyLen,
|
|
lpcValues,
|
|
lpcbMaxValueNameLen,
|
|
lpcbMaxValueLen,
|
|
lpcbSecurityDescriptor,
|
|
lpftLastWriteTime);
|
|
return(Status);
|
|
}
|
|
|
|
|
|
error_status_t
|
|
s_ApiCloseKey(
|
|
IN OUT HKEY_RPC *pKey
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Closes a cluster registry key
|
|
|
|
Arguments:
|
|
|
|
pKey - Supplies the key to be closed
|
|
Returns NULL
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
HDMKEY DmKey;
|
|
DWORD Status;
|
|
|
|
VALIDATE_KEY(DmKey, *pKey);
|
|
|
|
Status = RpcImpersonateClient(NULL);
|
|
if (Status != ERROR_SUCCESS) {
|
|
return(Status);
|
|
}
|
|
Status = DmCloseKey(DmKey);
|
|
RpcRevertToSelf();
|
|
|
|
LocalFree(*pKey);
|
|
*pKey = NULL;
|
|
|
|
return(Status);
|
|
}
|
|
|
|
|
|
void
|
|
HKEY_RPC_rundown(
|
|
IN HKEY_RPC Key
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
RPC rundown routine for cluster registry keys
|
|
|
|
Arguments:
|
|
|
|
Key - Supplies the handle to be rundown
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
HDMKEY DmKey;
|
|
|
|
//this should not call impersonate client
|
|
|
|
if ((Key != NULL) && (((PAPI_HANDLE)(Key))->Type == API_KEY_HANDLE))
|
|
{
|
|
DmKey = ((PAPI_HANDLE)(Key))->Key;
|
|
DmCloseKey(DmKey);
|
|
LocalFree(Key);
|
|
}
|
|
}
|
|
|
|
|
|
DWORD
|
|
s_ApiSetKeySecurity(
|
|
IN HKEY hKey,
|
|
IN DWORD SecurityInformation,
|
|
IN PRPC_SECURITY_DESCRIPTOR pRpcSecurityDescriptor
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Sets the security on the specified registry key.
|
|
|
|
Arguments:
|
|
|
|
hKey - Supplies a handle to a currently open key.
|
|
|
|
SecurityInformation - Supplies the type of security information to
|
|
be set.
|
|
|
|
pRpcSecurityDescriptor - Supplies the security information
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is ERROR_SUCCESS.
|
|
|
|
If the function fails, the return value is an error value.
|
|
|
|
--*/
|
|
|
|
{
|
|
HDMKEY DmKey;
|
|
DWORD Status;
|
|
PSECURITY_DESCRIPTOR pSecurityDescriptor;
|
|
|
|
VALIDATE_KEY(DmKey, hKey);
|
|
API_CHECK_INIT();
|
|
|
|
pSecurityDescriptor = pRpcSecurityDescriptor->lpSecurityDescriptor;
|
|
if (!RtlValidRelativeSecurityDescriptor( pSecurityDescriptor,
|
|
pRpcSecurityDescriptor->cbInSecurityDescriptor,0)){
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
Status = RpcImpersonateClient(NULL);
|
|
if (Status != ERROR_SUCCESS) {
|
|
return(Status);
|
|
}
|
|
Status = DmSetKeySecurity(DmKey, SecurityInformation, pSecurityDescriptor);
|
|
RpcRevertToSelf();
|
|
return(Status);
|
|
}
|
|
|
|
|
|
DWORD
|
|
s_ApiGetKeySecurity(
|
|
IN HKEY hKey,
|
|
IN DWORD SecurityInformation,
|
|
IN OUT PRPC_SECURITY_DESCRIPTOR pRpcSecurityDescriptor
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Gets the security from the specified registry key.
|
|
|
|
Arguments:
|
|
|
|
hKey - Supplies a handle to a currently open key.
|
|
|
|
SecurityInformation - Supplies the type of security information to
|
|
be retrieved.
|
|
|
|
pRpcSecurityDescriptor - Returns the security information
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is ERROR_SUCCESS.
|
|
|
|
If the function fails, the return value is an error value.
|
|
|
|
--*/
|
|
|
|
{
|
|
HDMKEY DmKey;
|
|
DWORD cbLength;
|
|
DWORD Status;
|
|
PSECURITY_DESCRIPTOR lpSD;
|
|
|
|
VALIDATE_KEY(DmKey, hKey);
|
|
API_CHECK_INIT();
|
|
|
|
cbLength = pRpcSecurityDescriptor->cbInSecurityDescriptor;
|
|
lpSD = LocalAlloc(LMEM_FIXED, cbLength);
|
|
if (lpSD == NULL) {
|
|
return(ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
|
|
Status = RpcImpersonateClient(NULL);
|
|
if (Status != ERROR_SUCCESS) {
|
|
LocalFree(lpSD);
|
|
return(Status);
|
|
}
|
|
Status = DmGetKeySecurity(DmKey, SecurityInformation, lpSD, &cbLength);
|
|
RpcRevertToSelf();
|
|
if (Status == ERROR_SUCCESS) {
|
|
Status = MapSDToRpcSD(lpSD, pRpcSecurityDescriptor);
|
|
}
|
|
if (Status != ERROR_SUCCESS) {
|
|
pRpcSecurityDescriptor->cbInSecurityDescriptor = cbLength;
|
|
pRpcSecurityDescriptor->cbOutSecurityDescriptor = 0;
|
|
}
|
|
|
|
LocalFree(lpSD);
|
|
return(Status);
|
|
}
|
|
|