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.
1585 lines
41 KiB
1585 lines
41 KiB
/*++
|
|
|
|
Copyright (c) 1996 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
registry.c
|
|
|
|
Abstract:
|
|
|
|
Provides interface for managing cluster registry
|
|
|
|
Author:
|
|
|
|
John Vert (jvert) 19-Jan-1996
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
#include "clusapip.h"
|
|
|
|
|
|
//
|
|
// Function prototypes for routines local to this module
|
|
//
|
|
VOID
|
|
FreeKey(
|
|
IN PCKEY Key
|
|
);
|
|
|
|
HKEY
|
|
OpenClusterRelative(
|
|
IN HCLUSTER hCluster,
|
|
IN LPCWSTR RelativeName,
|
|
IN LPCWSTR SpecificName,
|
|
IN DWORD samDesired
|
|
);
|
|
|
|
|
|
HKEY
|
|
WINAPI
|
|
GetClusterKey(
|
|
IN HCLUSTER hCluster,
|
|
IN REGSAM samDesired
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Opens the the root of the cluster registry subtree
|
|
for the given cluster.
|
|
|
|
Arguments:
|
|
|
|
hCluster - Supplies a handle to the cluster
|
|
|
|
samDesired - Specifies an access mask that describes the desired
|
|
security access for the new key.
|
|
|
|
Return Value:
|
|
|
|
A cluster registry key handle to the root of the registry subtree
|
|
for the given cluster
|
|
|
|
If unsuccessful, NULL is returned and GetLastError() provides the
|
|
specific error code.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCLUSTER Cluster = (PCLUSTER)hCluster;
|
|
PCKEY Key;
|
|
error_status_t Status = ERROR_SUCCESS;
|
|
|
|
//
|
|
// Allocate new CKEY structure and connect to cluster registry.
|
|
//
|
|
Key = LocalAlloc(LMEM_FIXED, sizeof(CKEY));
|
|
if (Key == NULL) {
|
|
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
|
|
return(NULL);
|
|
}
|
|
|
|
Key->Parent = NULL;
|
|
Key->RelativeName = NULL;
|
|
Key->SamDesired = samDesired;
|
|
Key->Cluster = Cluster;
|
|
InitializeListHead(&Key->ChildList);
|
|
InitializeListHead(&Key->NotifyList);
|
|
WRAP_NULL(Key->RemoteKey,
|
|
(ApiGetRootKey(Cluster->RpcBinding,
|
|
samDesired,
|
|
&Status)),
|
|
&Status,
|
|
Cluster);
|
|
if ((Key->RemoteKey == NULL) ||
|
|
(Status != ERROR_SUCCESS)) {
|
|
|
|
LocalFree(Key);
|
|
SetLastError(Status);
|
|
return(NULL);
|
|
}
|
|
|
|
EnterCriticalSection(&Cluster->Lock);
|
|
|
|
InsertHeadList(&Cluster->KeyList, &Key->ParentList);
|
|
|
|
LeaveCriticalSection(&Cluster->Lock);
|
|
|
|
return((HKEY)Key);
|
|
}
|
|
|
|
|
|
HKEY
|
|
WINAPI
|
|
GetClusterNodeKey(
|
|
IN HNODE hNode,
|
|
IN REGSAM samDesired
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Opens the the root of the cluster registry subtree
|
|
for the given node
|
|
|
|
Arguments:
|
|
|
|
hNode - Supplies a handle to the node
|
|
|
|
samDesired - Specifies an access mask that describes the desired
|
|
security access for the new key.
|
|
|
|
Return Value:
|
|
|
|
A cluster registry key handle to the root of the registry subtree
|
|
for the given node
|
|
|
|
If unsuccessful, NULL is returned and GetLastError() provides the
|
|
specific error code.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCNODE Node = (PCNODE)hNode;
|
|
HCLUSTER Cluster = (HCLUSTER)Node->Cluster;
|
|
DWORD Status;
|
|
LPWSTR Guid=NULL;
|
|
HKEY NodeKey;
|
|
|
|
WRAP(Status,
|
|
(ApiGetNodeId(Node->hNode, &Guid)),
|
|
Node->Cluster);
|
|
if (Status != ERROR_SUCCESS) {
|
|
SetLastError(Status);
|
|
return(NULL);
|
|
}
|
|
NodeKey = OpenClusterRelative(Cluster,
|
|
CLUSREG_KEYNAME_NODES,
|
|
Guid,
|
|
samDesired);
|
|
if (NodeKey == NULL) {
|
|
Status = GetLastError();
|
|
}
|
|
MIDL_user_free(Guid);
|
|
if (NodeKey == NULL) {
|
|
SetLastError(Status);
|
|
}
|
|
return(NodeKey);
|
|
}
|
|
|
|
|
|
HKEY
|
|
WINAPI
|
|
GetClusterGroupKey(
|
|
IN HGROUP hGroup,
|
|
IN REGSAM samDesired
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Opens the the root of the cluster registry subtree
|
|
for the given group
|
|
|
|
Arguments:
|
|
|
|
hResource - Supplies a handle to the group
|
|
|
|
samDesired - Specifies an access mask that describes the desired
|
|
security access for the new key.
|
|
|
|
Return Value:
|
|
|
|
A cluster registry key handle to the root of the registry subtree
|
|
for the given group
|
|
|
|
If unsuccessful, NULL is returned and GetLastError() provides the
|
|
specific error code.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCGROUP Group = (PCGROUP)hGroup;
|
|
HCLUSTER Cluster = (HCLUSTER)Group->Cluster;
|
|
DWORD Status;
|
|
LPWSTR Guid=NULL;
|
|
HKEY GroupKey;
|
|
|
|
WRAP(Status,
|
|
(ApiGetGroupId(Group->hGroup, &Guid)),
|
|
Group->Cluster);
|
|
if (Status != ERROR_SUCCESS) {
|
|
SetLastError(Status);
|
|
return(NULL);
|
|
}
|
|
GroupKey = OpenClusterRelative(Cluster,
|
|
CLUSREG_KEYNAME_GROUPS,
|
|
Guid,
|
|
samDesired);
|
|
if (GroupKey == NULL) {
|
|
Status = GetLastError();
|
|
}
|
|
MIDL_user_free(Guid);
|
|
if (GroupKey == NULL) {
|
|
SetLastError(Status);
|
|
}
|
|
return(GroupKey);
|
|
|
|
}
|
|
|
|
|
|
HKEY
|
|
WINAPI
|
|
GetClusterResourceKey(
|
|
IN HRESOURCE hResource,
|
|
IN REGSAM samDesired
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Opens the the root of the cluster registry subtree
|
|
for the given resource.
|
|
|
|
Arguments:
|
|
|
|
hResource - Supplies a handle to the resource
|
|
|
|
samDesired - Specifies an access mask that describes the desired
|
|
security access for the new key.
|
|
|
|
Return Value:
|
|
|
|
A cluster registry key handle to the root of the registry subtree
|
|
for the given resource
|
|
|
|
If unsuccessful, NULL is returned and GetLastError() provides the
|
|
specific error code.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCRESOURCE Resource = (PCRESOURCE)hResource;
|
|
HCLUSTER Cluster = (HCLUSTER)Resource->Cluster;
|
|
DWORD Status;
|
|
LPWSTR Guid=NULL;
|
|
HKEY ResKey;
|
|
|
|
WRAP(Status,
|
|
(ApiGetResourceId(Resource->hResource, &Guid)),
|
|
Resource->Cluster);
|
|
if (Status != ERROR_SUCCESS) {
|
|
SetLastError(Status);
|
|
return(NULL);
|
|
}
|
|
ResKey = OpenClusterRelative(Cluster,
|
|
CLUSREG_KEYNAME_RESOURCES,
|
|
Guid,
|
|
samDesired);
|
|
if (ResKey == NULL) {
|
|
Status = GetLastError();
|
|
}
|
|
MIDL_user_free(Guid);
|
|
if (ResKey == NULL) {
|
|
SetLastError(Status);
|
|
}
|
|
return(ResKey);
|
|
}
|
|
|
|
|
|
HKEY
|
|
WINAPI
|
|
GetClusterResourceTypeKey(
|
|
IN HCLUSTER hCluster,
|
|
IN LPCWSTR lpszTypeName,
|
|
IN REGSAM samDesired
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Opens the the root of the cluster registry subtree
|
|
for the given resource type.
|
|
|
|
Arguments:
|
|
|
|
hCluster - Supplies the cluster the open is relative to.
|
|
|
|
lpszTypeName - Supplies the resource type name.
|
|
|
|
samDesired - Specifies an access mask that describes the desired
|
|
security access for the new key.
|
|
|
|
Return Value:
|
|
|
|
A cluster registry key handle to the root of the registry subtree
|
|
for the given resource type.
|
|
|
|
If unsuccessful, NULL is returned and GetLastError() provides the
|
|
specific error code.
|
|
|
|
--*/
|
|
|
|
{
|
|
return(OpenClusterRelative(hCluster,
|
|
CLUSREG_KEYNAME_RESOURCE_TYPES,
|
|
lpszTypeName,
|
|
samDesired));
|
|
}
|
|
|
|
|
|
HKEY
|
|
WINAPI
|
|
GetClusterNetworkKey(
|
|
IN HNETWORK hNetwork,
|
|
IN REGSAM samDesired
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Opens the the root of the cluster registry subtree
|
|
for the given network.
|
|
|
|
Arguments:
|
|
|
|
hNetwork - Supplies a handle to the network.
|
|
|
|
samDesired - Specifies an access mask that describes the desired
|
|
security access for the new key.
|
|
|
|
Return Value:
|
|
|
|
A cluster registry key handle to the root of the registry subtree
|
|
for the given network.
|
|
|
|
If unsuccessful, NULL is returned and GetLastError() provides the
|
|
specific error code.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCNETWORK Network = (PCNETWORK)hNetwork;
|
|
HCLUSTER Cluster = (HCLUSTER)Network->Cluster;
|
|
DWORD Status;
|
|
LPWSTR Guid=NULL;
|
|
HKEY NetworkKey;
|
|
|
|
WRAP(Status,
|
|
(ApiGetNetworkId(Network->hNetwork, &Guid)),
|
|
Network->Cluster);
|
|
if (Status != ERROR_SUCCESS) {
|
|
SetLastError(Status);
|
|
return(NULL);
|
|
}
|
|
NetworkKey = OpenClusterRelative(Cluster,
|
|
CLUSREG_KEYNAME_NETWORKS,
|
|
Guid,
|
|
samDesired);
|
|
if (NetworkKey == NULL) {
|
|
Status = GetLastError();
|
|
}
|
|
MIDL_user_free(Guid);
|
|
if (NetworkKey == NULL) {
|
|
SetLastError(Status);
|
|
}
|
|
return(NetworkKey);
|
|
}
|
|
|
|
|
|
HKEY
|
|
WINAPI
|
|
GetClusterNetInterfaceKey(
|
|
IN HNETINTERFACE hNetInterface,
|
|
IN REGSAM samDesired
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Opens the the root of the cluster registry subtree
|
|
for the given network interface.
|
|
|
|
Arguments:
|
|
|
|
hNetInterface - Supplies a handle to the network interface.
|
|
|
|
samDesired - Specifies an access mask that describes the desired
|
|
security access for the new key.
|
|
|
|
Return Value:
|
|
|
|
A cluster registry key handle to the root of the registry subtree
|
|
for the given network interface.
|
|
|
|
If unsuccessful, NULL is returned and GetLastError() provides the
|
|
specific error code.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCNETINTERFACE NetInterface = (PCNETINTERFACE)hNetInterface;
|
|
HCLUSTER Cluster = (HCLUSTER)NetInterface->Cluster;
|
|
DWORD Status;
|
|
LPWSTR Guid=NULL;
|
|
HKEY NetInterfaceKey;
|
|
|
|
WRAP(Status,
|
|
(ApiGetNetInterfaceId(NetInterface->hNetInterface, &Guid)),
|
|
NetInterface->Cluster);
|
|
if (Status != ERROR_SUCCESS) {
|
|
SetLastError(Status);
|
|
return(NULL);
|
|
}
|
|
NetInterfaceKey = OpenClusterRelative(Cluster,
|
|
CLUSREG_KEYNAME_NETINTERFACES,
|
|
Guid,
|
|
samDesired);
|
|
if (NetInterfaceKey == NULL) {
|
|
Status = GetLastError();
|
|
}
|
|
MIDL_user_free(Guid);
|
|
if (NetInterfaceKey == NULL) {
|
|
SetLastError(Status);
|
|
}
|
|
return(NetInterfaceKey);
|
|
}
|
|
|
|
|
|
HKEY
|
|
OpenClusterRelative(
|
|
IN HCLUSTER Cluster,
|
|
IN LPCWSTR RelativeName,
|
|
IN LPCWSTR SpecificName,
|
|
IN DWORD samDesired
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Helper routine for the functions that open cluster object keys.
|
|
(GetCluster*Key)
|
|
|
|
Arguments:
|
|
|
|
Cluster - Supplies the cluster the key should be opened in.
|
|
|
|
RelativeName - Supplies the first part of the relative name
|
|
(i.e. L"Resources")
|
|
|
|
SpecificName - Supplies the name of the object.
|
|
|
|
Return Value:
|
|
|
|
An open registry key if successful
|
|
|
|
NULL if unsuccessful. LastError will be set to a Win32 error code
|
|
|
|
--*/
|
|
|
|
{
|
|
LPWSTR Buff;
|
|
HKEY ClusterKey;
|
|
HKEY Key;
|
|
LONG Status;
|
|
|
|
Buff = LocalAlloc(LMEM_FIXED, (lstrlenW(RelativeName)+lstrlenW(SpecificName)+2)*sizeof(WCHAR));
|
|
if ( Buff == NULL ) {
|
|
return(NULL);
|
|
}
|
|
lstrcpyW(Buff, RelativeName);
|
|
lstrcatW(Buff, L"\\");
|
|
lstrcatW(Buff, SpecificName);
|
|
|
|
ClusterKey = GetClusterKey(Cluster, KEY_READ);
|
|
if (ClusterKey == NULL) {
|
|
Status = GetLastError();
|
|
LocalFree(Buff);
|
|
SetLastError(Status);
|
|
return(NULL);
|
|
}
|
|
Status = ClusterRegOpenKey(ClusterKey,
|
|
Buff,
|
|
samDesired,
|
|
&Key);
|
|
LocalFree(Buff);
|
|
ClusterRegCloseKey(ClusterKey);
|
|
if (Status == ERROR_SUCCESS) {
|
|
return(Key);
|
|
} else {
|
|
SetLastError(Status);
|
|
return(NULL);
|
|
}
|
|
}
|
|
|
|
|
|
LONG
|
|
WINAPI
|
|
ClusterRegCreateKey(
|
|
IN HKEY hKey,
|
|
IN LPCWSTR lpSubKey,
|
|
IN DWORD dwOptions,
|
|
IN REGSAM samDesired,
|
|
IN LPSECURITY_ATTRIBUTES lpSecurityAttributes,
|
|
OUT PHKEY phkResult,
|
|
OUT OPTIONAL LPDWORD lpdwDisposition
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Creates the specified key in the cluster registry. If the
|
|
key already exists in the registry, the function opens it.
|
|
|
|
Arguments:
|
|
|
|
hKey - Supplies a currently open key.
|
|
|
|
lpSubKey - Points to a null-terminated string specifying the name
|
|
of a subkey that this function opens or creates. The subkey
|
|
specified must be a subkey of the key identified by the hKey
|
|
parameter. This subkey must not begin with the backslash
|
|
character ('\'). This parameter cannot be NULL.
|
|
|
|
dwOptions - Specifies special options for this key. Valid options are:
|
|
|
|
REG_OPTION_VOLATILE - This key is volatile; the information is
|
|
stored in memory and is not preserved when
|
|
the system is restarted.
|
|
|
|
samDesired - Specifies an access mask that specifies the desired security
|
|
access for the new key
|
|
|
|
lpSecurityAttributes - The lpSecurityDescriptor member of the structure
|
|
specifies a security descriptor for the new key. If
|
|
lpSecurityAttributes is NULL, the key gets a default security
|
|
descriptor. Since cluster registry handles are not inheritable,
|
|
the bInheritHandle field of the SECURITY_ATTRIBUTES structure
|
|
must be FALSE.
|
|
|
|
phkResult - Points to a variable that receives the handle of the opened
|
|
or created key
|
|
|
|
lpdwDisposition - Points to a variable that receives one of the following
|
|
disposition values:
|
|
Value Meaning
|
|
REG_CREATED_NEW_KEY The key did not exist and was created.
|
|
REG_OPENED_EXISTING_KEY The key existed and was simply opened
|
|
without being changed.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is ERROR_SUCCESS.
|
|
|
|
If the function fails, the return value is an error value.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCKEY Key;
|
|
PCKEY ParentKey = (PCKEY)hKey;
|
|
PCLUSTER Cluster = ParentKey->Cluster;
|
|
PRPC_SECURITY_ATTRIBUTES pRpcSA;
|
|
RPC_SECURITY_ATTRIBUTES RpcSA;
|
|
error_status_t Status = ERROR_SUCCESS;
|
|
DWORD Disposition;
|
|
|
|
if (lpdwDisposition == NULL) {
|
|
lpdwDisposition = &Disposition;
|
|
}
|
|
//
|
|
// Allocate new CKEY structure and create cluster registry key
|
|
//
|
|
Key = LocalAlloc(LMEM_FIXED, sizeof(CKEY));
|
|
if (Key == NULL) {
|
|
return(ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
|
|
Key->Parent = ParentKey;
|
|
Key->RelativeName = LocalAlloc(LMEM_FIXED, (lstrlenW(lpSubKey)+1)*sizeof(WCHAR));
|
|
if (Key->RelativeName == NULL) {
|
|
LocalFree(Key);
|
|
return(ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
lstrcpyW(Key->RelativeName, lpSubKey);
|
|
Key->SamDesired = samDesired;
|
|
Key->Cluster = Cluster;
|
|
InitializeListHead(&Key->ChildList);
|
|
InitializeListHead(&Key->NotifyList);
|
|
if( ARGUMENT_PRESENT( lpSecurityAttributes )) {
|
|
DWORD Error;
|
|
|
|
pRpcSA = &RpcSA;
|
|
|
|
Error = MapSAToRpcSA( lpSecurityAttributes, pRpcSA );
|
|
|
|
if( Error != ERROR_SUCCESS ) {
|
|
LocalFree(Key->RelativeName);
|
|
LocalFree(Key);
|
|
return Error;
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// No PSECURITY_ATTRIBUTES argument, therefore no mapping was done.
|
|
//
|
|
|
|
pRpcSA = NULL;
|
|
}
|
|
WRAP_NULL(Key->RemoteKey,
|
|
(ApiCreateKey(ParentKey->RemoteKey,
|
|
lpSubKey,
|
|
dwOptions,
|
|
samDesired,
|
|
pRpcSA,
|
|
lpdwDisposition,
|
|
&Status)),
|
|
&Status,
|
|
ParentKey->Cluster);
|
|
|
|
//
|
|
// Free the RPC_SECURITY_DESCRIPTOR buffer allocated by MapSAToRpcSA.
|
|
//
|
|
if ( pRpcSA ) {
|
|
//
|
|
// RtlFreeHeap accepts a NULL base address
|
|
//
|
|
RtlFreeHeap( RtlProcessHeap(),
|
|
0,
|
|
pRpcSA->RpcSecurityDescriptor.lpSecurityDescriptor );
|
|
}
|
|
|
|
if ((Key->RemoteKey == NULL) ||
|
|
(Status != ERROR_SUCCESS)) {
|
|
*phkResult = NULL;
|
|
LocalFree(Key->RelativeName);
|
|
LocalFree(Key);
|
|
return(Status);
|
|
}
|
|
|
|
EnterCriticalSection(&Cluster->Lock);
|
|
|
|
InsertHeadList(&ParentKey->ChildList, &Key->ParentList);
|
|
|
|
LeaveCriticalSection(&Cluster->Lock);
|
|
|
|
*phkResult = (HKEY)Key;
|
|
return(ERROR_SUCCESS);
|
|
|
|
}
|
|
|
|
|
|
LONG
|
|
WINAPI
|
|
ClusterRegOpenKey(
|
|
IN HKEY hKey,
|
|
IN LPCWSTR lpSubKey,
|
|
IN REGSAM samDesired,
|
|
OUT PHKEY phkResult
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Opens the specified key in the cluster registry.
|
|
|
|
Arguments:
|
|
|
|
hKey - Supplies a currently open key.
|
|
|
|
lpSubKey - Points to a null-terminated string specifying the name
|
|
of a subkey that this function opens or creates. The subkey
|
|
specified must be a subkey of the key identified by the hKey
|
|
parameter. This subkey must not begin with the backslash
|
|
character ('\'). This parameter cannot be NULL.
|
|
|
|
samDesired - Specifies an access mask that specifies the desired security
|
|
access for the new key
|
|
|
|
phkResult - Points to a variable that receives the handle of the opened
|
|
or created key. Initialized to NULL on failure.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is ERROR_SUCCESS.
|
|
|
|
If the function fails, the return value is an error value.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCKEY Key;
|
|
PCKEY ParentKey = (PCKEY)hKey;
|
|
PCLUSTER Cluster = ParentKey->Cluster;
|
|
error_status_t Status = ERROR_SUCCESS;
|
|
|
|
//
|
|
// Allocate new CKEY structure and create cluster registry key
|
|
//
|
|
Key = LocalAlloc(LMEM_FIXED, sizeof(CKEY));
|
|
if (Key == NULL) {
|
|
return(ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
|
|
*phkResult = NULL;
|
|
Key->Parent = ParentKey;
|
|
Key->RelativeName = LocalAlloc(LMEM_FIXED, (lstrlenW(lpSubKey)+1)*sizeof(WCHAR));
|
|
if (Key->RelativeName == NULL) {
|
|
LocalFree(Key);
|
|
return(ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
lstrcpyW(Key->RelativeName, lpSubKey);
|
|
Key->SamDesired = samDesired;
|
|
Key->Cluster = Cluster;
|
|
InitializeListHead(&Key->ChildList);
|
|
InitializeListHead(&Key->NotifyList);
|
|
WRAP_NULL(Key->RemoteKey,
|
|
(ApiOpenKey(ParentKey->RemoteKey,
|
|
lpSubKey,
|
|
samDesired,
|
|
&Status)),
|
|
&Status,
|
|
ParentKey->Cluster);
|
|
|
|
if (Status != ERROR_SUCCESS) {
|
|
LocalFree(Key->RelativeName);
|
|
LocalFree(Key);
|
|
return(Status);
|
|
}
|
|
|
|
EnterCriticalSection(&Cluster->Lock);
|
|
|
|
InsertHeadList(&ParentKey->ChildList, &Key->ParentList);
|
|
|
|
LeaveCriticalSection(&Cluster->Lock);
|
|
|
|
*phkResult = (HKEY)Key;
|
|
return(ERROR_SUCCESS);
|
|
|
|
}
|
|
|
|
|
|
LONG
|
|
WINAPI
|
|
ClusterRegDeleteKey(
|
|
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.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCKEY Key = (PCKEY)hKey;
|
|
DWORD Status;
|
|
|
|
WRAP(Status,
|
|
(ApiDeleteKey(Key->RemoteKey, lpSubKey)),
|
|
Key->Cluster);
|
|
return(Status);
|
|
}
|
|
|
|
|
|
LONG
|
|
WINAPI
|
|
ClusterRegCloseKey(
|
|
IN HKEY hKey
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Closes the handle of the specified cluster registry key
|
|
|
|
Arguments:
|
|
|
|
hKey - Supplies the open key to close
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is ERROR_SUCCESS.
|
|
|
|
If the function fails, the return value is an error value.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCKEY Key = (PCKEY)hKey;
|
|
PCLUSTER Cluster = Key->Cluster;
|
|
|
|
//
|
|
// If any keys have been opened relative to this key, we need to
|
|
// keep this CKEY around so that we can reconstruct the key names
|
|
// if we need to reopen the handles.
|
|
//
|
|
// If there are no children of this key, all the storage can be
|
|
// freed. Note that freeing this key may also require us to free
|
|
// up its parent if the parent has been closed but not freed because
|
|
// it has children.
|
|
//
|
|
|
|
EnterCriticalSection(&Cluster->Lock);
|
|
if (Cluster->Flags & CLUS_DEAD)
|
|
{
|
|
if (Key->RemoteKey)
|
|
RpcSmDestroyClientContext(&Key->RemoteKey);
|
|
}
|
|
else
|
|
{
|
|
ApiCloseKey(&Key->RemoteKey);
|
|
}
|
|
|
|
//
|
|
// Remove any notifications posted against this key.
|
|
//
|
|
RundownNotifyEvents(&Key->NotifyList, L"");
|
|
|
|
if (IsListEmpty(&Key->ChildList)) {
|
|
FreeKey(Key);
|
|
}
|
|
|
|
LeaveCriticalSection(&Cluster->Lock);
|
|
|
|
//
|
|
// If this key was the last thing keeping the cluster structure
|
|
// around, we can clean it up now.
|
|
//
|
|
CleanupCluster(Cluster);
|
|
return(ERROR_SUCCESS);
|
|
}
|
|
|
|
VOID
|
|
FreeKey(
|
|
IN PCKEY Key
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Frees up the storage for a key and removes it from its
|
|
parent's ChildList. If this is the last key in its parent's
|
|
ChildList, this routine calls itself recursively to free
|
|
the parent storage.
|
|
|
|
Arguments:
|
|
|
|
Key - Supplies the CKEY to be freed.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
RemoveEntryList(&Key->ParentList);
|
|
if (Key->Parent != NULL) {
|
|
//
|
|
// This is not a root key, so see if we need to free the
|
|
// parent.
|
|
//
|
|
if ((Key->Parent->RemoteKey == NULL) &&
|
|
(IsListEmpty(&Key->Parent->ChildList))) {
|
|
FreeKey(Key->Parent);
|
|
}
|
|
LocalFree(Key->RelativeName);
|
|
}
|
|
LocalFree(Key);
|
|
}
|
|
|
|
|
|
LONG
|
|
WINAPI
|
|
ClusterRegEnumKey(
|
|
IN HKEY hKey,
|
|
IN DWORD dwIndex,
|
|
OUT LPWSTR lpszName,
|
|
IN OUT LPDWORD lpcchName,
|
|
OUT PFILETIME lpftLastWriteTime
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Enumerates subkeys of the specified open cluster registry key.
|
|
The function retrieves information about one subkey each time it is called.
|
|
|
|
Arguments:
|
|
|
|
hKey - Supplies a currently open key or NULL. If NULL is specified,
|
|
the root of the cluster registry is enumerated.
|
|
|
|
dwIndex - Supplies the index of the subkey to retrieve. This parameter
|
|
should be zero for the first call to the RegEnumKeyEx function
|
|
and then incremented for subsequent calls. Because subkeys are
|
|
not ordered, any new subkey will have an arbitrary index. This
|
|
means that the function may return subkeys in any order.
|
|
|
|
lpszName - Points to a buffer that receives the name of the subkey,
|
|
including the terminating null character. The function copies
|
|
only the name of the subkey, not the full key hierarchy, to
|
|
the buffer.
|
|
|
|
lpcchName - Points to a variable that specifies the size, in characters,
|
|
of the buffer specified by the lpszName parameter. This size should
|
|
include the terminating null character. When the function returns,
|
|
the variable pointed to by lpcchName contains the number of characters
|
|
stored in the buffer. The count returned does not include the
|
|
terminating null character.
|
|
|
|
lpftLastWriteTime - Points to a variable that receives the time the
|
|
enumerated subkey was last written to.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is ERROR_SUCCESS.
|
|
|
|
If the function fails, the return value is an error value.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCKEY Key = (PCKEY)hKey;
|
|
LONG Status;
|
|
FILETIME LastWriteTime;
|
|
LPWSTR KeyName=NULL;
|
|
DWORD dwNameLen;
|
|
|
|
WRAP(Status,
|
|
(ApiEnumKey(Key->RemoteKey,
|
|
dwIndex,
|
|
&KeyName,
|
|
&LastWriteTime)),
|
|
Key->Cluster);
|
|
if (Status != ERROR_SUCCESS) {
|
|
return(Status);
|
|
}
|
|
|
|
MylstrcpynW(lpszName, KeyName, *lpcchName);
|
|
dwNameLen = lstrlenW(KeyName);
|
|
if (*lpcchName < (dwNameLen + 1)) {
|
|
if (lpszName != NULL) {
|
|
Status = ERROR_MORE_DATA;
|
|
}
|
|
}
|
|
*lpcchName = dwNameLen;
|
|
MIDL_user_free(KeyName);
|
|
return(Status);
|
|
}
|
|
|
|
|
|
DWORD
|
|
WINAPI
|
|
ClusterRegSetValue(
|
|
IN HKEY hKey,
|
|
IN LPCWSTR lpszValueName,
|
|
IN DWORD dwType,
|
|
IN CONST BYTE* lpData,
|
|
IN DWORD cbData
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Sets the named value for the given resource.
|
|
|
|
Arguments:
|
|
|
|
hKey - Supplies the handle of the cluster registry key.
|
|
|
|
lpszValueName - Supplies a pointer to a string containing
|
|
the name of the value to set. If a value with this
|
|
name is not already present in the resource, the function
|
|
adds it to the resource.
|
|
|
|
dwType - Supplies the type of information to be stored as the
|
|
value's data. This parameter can be one of the following values:
|
|
Value Meaning
|
|
REG_BINARY Binary data in any form.
|
|
REG_DWORD A 32-bit number.
|
|
REG_EXPAND_SZ A null-terminated Unicode string that contains unexpanded
|
|
references to environment variables (for example, "%PATH%").
|
|
REG_MULTI_SZ An array of null-terminated Unicode strings, terminated
|
|
by two null characters.
|
|
REG_NONE No defined value type.
|
|
REG_SZ A null-terminated Unicode string.
|
|
|
|
lpData - Supplies a pointer to a buffer containing the data
|
|
to be stored with the specified value name.
|
|
|
|
cbData - Supplies the size, in bytes, of the information
|
|
pointed to by the lpData parameter. If the data
|
|
is of type REG_SZ, REG_EXPAND_SZ, or REG_MULTI_SZ,
|
|
cbData must include the size of the terminating null character.
|
|
|
|
Return value:
|
|
|
|
If the function succeeds, the return value is ERROR_SUCCESS.
|
|
|
|
If the function fails, the return value is an error value.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCKEY Key = (PCKEY)hKey;
|
|
DWORD Status;
|
|
|
|
WRAP(Status,
|
|
(ApiSetValue(Key->RemoteKey,
|
|
lpszValueName,
|
|
dwType,
|
|
lpData,
|
|
cbData)),
|
|
Key->Cluster);
|
|
|
|
return(Status);
|
|
}
|
|
|
|
|
|
DWORD
|
|
WINAPI
|
|
ClusterRegDeleteValue(
|
|
IN HKEY hKey,
|
|
IN LPCWSTR lpszValueName
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Removes the specified value from a given registry subkey
|
|
|
|
Arguments:
|
|
|
|
hKey - Supplies the key whose value is to be deleted.
|
|
|
|
lpszValueName - 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.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCKEY Key = (PCKEY)hKey;
|
|
DWORD Status;
|
|
|
|
WRAP(Status,
|
|
(ApiDeleteValue(Key->RemoteKey, lpszValueName)),
|
|
Key->Cluster);
|
|
|
|
return(Status);
|
|
}
|
|
|
|
|
|
LONG
|
|
WINAPI
|
|
ClusterRegQueryValue(
|
|
IN HKEY hKey,
|
|
IN LPCWSTR lpszValueName,
|
|
OUT LPDWORD lpdwValueType,
|
|
OUT LPBYTE lpData,
|
|
IN OUT LPDWORD lpcbData
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Retrieves the type and data for a specified value name associated with
|
|
an open cluster registry key.
|
|
|
|
Arguments:
|
|
|
|
hKey - Supplies the handle of the cluster registry key.
|
|
|
|
lpszValueName - Supplies a pointer to a string containing the
|
|
name of the value to be queried.
|
|
|
|
lpdwValueType - Points to a variable that receives the key's value
|
|
type. The value returned through this parameter will
|
|
be one of the following:
|
|
|
|
Value Meaning
|
|
REG_BINARY Binary data in any form.
|
|
REG_DWORD A 32-bit number.
|
|
REG_EXPAND_SZ A null-terminated Unicode string that contains unexpanded
|
|
references to environment variables (for example, "%PATH%").
|
|
REG_MULTI_SZ An array of null-terminated Unicode strings, terminated
|
|
by two null characters.
|
|
REG_NONE No defined value type.
|
|
REG_SZ A null-terminated Unicode string.
|
|
|
|
The lpdwValueType parameter can be NULL if the type is not required
|
|
|
|
lpData - Points to a buffer that receives the value's data. This parameter
|
|
can be NULL if the data is not required.
|
|
|
|
lpcbData - Points to a variable that specifies the size, in bytes, of the buffer
|
|
pointed to by the lpData parameter. When the function returns, this
|
|
variable contains the size of the data copied to lpData.
|
|
|
|
If the buffer specified by lpData parameter is not large enough to hold
|
|
the data, the function returns the value ERROR_MORE_DATA, and stores the
|
|
required buffer size, in bytes, into the variable pointed to by
|
|
lpcbData.
|
|
|
|
If lpData is NULL, and lpcbData is non-NULL, the function returns
|
|
ERROR_SUCCESS, and stores the size of the data, in bytes, in the variable
|
|
pointed to by lpcbData. This lets an application determine the best way
|
|
to allocate a buffer for the value key's data.
|
|
|
|
If the data has the REG_SZ, REG_MULTI_SZ or REG_EXPAND_SZ type, then
|
|
lpData will also include the size of the terminating null character.
|
|
|
|
The lpcbData parameter can be NULL only if lpData is NULL.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is ERROR_SUCCESS.
|
|
|
|
If the function fails, the return value is an error value.
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD Dummy1;
|
|
DWORD Dummy2;
|
|
DWORD Required;
|
|
PCKEY Key = (PCKEY)hKey;
|
|
DWORD Status;
|
|
LPBYTE TempData;
|
|
DWORD BufferSize;
|
|
|
|
if (lpdwValueType == NULL) {
|
|
lpdwValueType = &Dummy1;
|
|
}
|
|
if (lpData == NULL) {
|
|
TempData = (LPBYTE)&Dummy2;
|
|
BufferSize = 0;
|
|
} else {
|
|
TempData = lpData;
|
|
BufferSize = *lpcbData;
|
|
}
|
|
WRAP(Status,
|
|
(ApiQueryValue(Key->RemoteKey,
|
|
lpszValueName,
|
|
lpdwValueType,
|
|
TempData,
|
|
BufferSize,
|
|
&Required)),
|
|
Key->Cluster);
|
|
if ((Status == ERROR_SUCCESS) ||
|
|
(Status == ERROR_MORE_DATA)) {
|
|
if ((Status == ERROR_MORE_DATA) &&
|
|
(lpData == NULL)) {
|
|
//
|
|
// Map this error to success to match the spec.
|
|
//
|
|
Status = ERROR_SUCCESS;
|
|
}
|
|
*lpcbData = Required;
|
|
}
|
|
return(Status);
|
|
|
|
}
|
|
|
|
|
|
|
|
DWORD
|
|
WINAPI
|
|
ClusterRegEnumValue(
|
|
IN HKEY hKey,
|
|
IN DWORD dwIndex,
|
|
OUT LPWSTR lpszValueName,
|
|
IN OUT LPDWORD lpcchValueName,
|
|
IN LPDWORD lpdwType,
|
|
OUT LPBYTE lpData,
|
|
IN OUT LPDWORD lpcbData
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Enumerates the properties of the given resource.
|
|
|
|
Arguments:
|
|
|
|
hKey - Supplies the handle of the key
|
|
|
|
dwIndex - Specifies the index of the value to retrieve. This parameter
|
|
should be zero for the first call to the EnumClusterResourceValue
|
|
function and then be incremented for subsequent calls. Because
|
|
properties are not ordered, any new value will have an arbitrary
|
|
index. This means that the function may return properties in any
|
|
order.
|
|
|
|
lpszValueName - Points to a buffer that receives the name of the value,
|
|
including the terminating null character.
|
|
|
|
lpcchValueName - Points to a variable that specifies the size, in characters,
|
|
of the buffer pointed to by the lpszValueName parameter. This size
|
|
should include the terminating null character. When the function returns,
|
|
the variable pointed to by lpcchValueName contains the number of
|
|
characters stored in the buffer. The count returned does not include
|
|
the terminating null character.
|
|
|
|
lpdwType - Points to a variable that receives the type code for the value entry.
|
|
The type code can be one of the following values:
|
|
|
|
Value Meaning
|
|
REG_BINARY Binary data in any form.
|
|
REG_DWORD A 32-bit number.
|
|
REG_EXPAND_SZ A null-terminated Unicode string that contains unexpanded
|
|
references to environment variables (for example, "%PATH%").
|
|
REG_MULTI_SZ An array of null-terminated Unicode strings, terminated
|
|
by two null characters.
|
|
REG_NONE No defined value type.
|
|
REG_SZ A null-terminated Unicode string.
|
|
|
|
The lpdwType parameter can be NULL if the type code is not required.
|
|
|
|
lpData - Points to a buffer that receives the data for the value entry.
|
|
This parameter can be NULL if the data is not required.
|
|
|
|
lpcbData - Points to a variable that specifies the size, in bytes, of the
|
|
buffer pointed to by the lpData parameter. When the function
|
|
returns, the variable pointed to by the lpcbData parameter contains
|
|
the number of bytes stored in the buffer. This parameter can be NULL
|
|
only if lpData is NULL.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is ERROR_SUCCESS.
|
|
|
|
If the function fails, the return value is an error value.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCKEY Key = (PCKEY)hKey;
|
|
LONG Status;
|
|
LPWSTR ValueName=NULL;
|
|
DWORD TotalSize;
|
|
DWORD DummyType;
|
|
BYTE DummyData;
|
|
DWORD DummycbData;
|
|
DWORD dwNameLen;
|
|
|
|
if (lpdwType == NULL) {
|
|
lpdwType = &DummyType;
|
|
}
|
|
if (lpcbData == NULL) {
|
|
if (lpData != NULL) {
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
DummycbData = 0;
|
|
lpcbData = &DummycbData;
|
|
}
|
|
if (lpData == NULL) {
|
|
lpData = &DummyData;
|
|
}
|
|
|
|
WRAP(Status,
|
|
(ApiEnumValue(Key->RemoteKey,
|
|
dwIndex,
|
|
&ValueName,
|
|
lpdwType,
|
|
lpData,
|
|
lpcbData,
|
|
&TotalSize)),
|
|
Key->Cluster);
|
|
if ((Status != ERROR_SUCCESS) &&
|
|
(Status != ERROR_MORE_DATA)) {
|
|
return(Status);
|
|
}
|
|
if (Status == ERROR_MORE_DATA) {
|
|
*lpcbData = TotalSize;
|
|
if (lpData == &DummyData) {
|
|
Status = ERROR_SUCCESS;
|
|
}
|
|
}
|
|
|
|
MylstrcpynW(lpszValueName, ValueName, *lpcchValueName);
|
|
dwNameLen = lstrlenW(ValueName);
|
|
if (*lpcchValueName < (dwNameLen + 1)) {
|
|
if (lpszValueName != NULL) {
|
|
Status = ERROR_MORE_DATA;
|
|
}
|
|
}
|
|
*lpcchValueName = dwNameLen;
|
|
MIDL_user_free(ValueName);
|
|
return(Status);
|
|
}
|
|
|
|
|
|
LONG
|
|
WINAPI
|
|
ClusterRegQueryInfoKey(
|
|
HKEY hKey,
|
|
LPDWORD lpcSubKeys,
|
|
LPDWORD lpcchMaxSubKeyLen,
|
|
LPDWORD lpcValues,
|
|
LPDWORD lpcchMaxValueNameLen,
|
|
LPDWORD lpcbMaxValueLen,
|
|
LPDWORD lpcbSecurityDescriptor,
|
|
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. This parameter can be NULL.
|
|
|
|
lpcchMaxSubKeyLen - 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. This parameter can be NULL.
|
|
|
|
lpcValues - Points to a variable that receives the number of values
|
|
associated with the key. This parameter can be NULL.
|
|
|
|
lpcchMaxValueNameLen - 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. This parameter can be NULL.
|
|
|
|
lpcbMaxValueLen - Points to a variable that receives the length, in
|
|
bytes, of the longest data component among the key's values. This parameter can be NULL.
|
|
|
|
lpcbSecurityDescriptor - Points to a variable that receives the length,
|
|
in bytes, of the key's security descriptor. This parameter can be NULL.
|
|
|
|
lpftLastWriteTime - Pointer to a FILETIME structure. This parameter can be NULL.
|
|
|
|
Return Value:
|
|
|
|
ERROR_SUCCESS if successful
|
|
|
|
Win32 error code otherwise
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD SubKeys;
|
|
DWORD MaxSubKeyLen;
|
|
DWORD Values;
|
|
DWORD MaxValueNameLen;
|
|
DWORD MaxValueLen;
|
|
DWORD SecurityDescriptor;
|
|
DWORD Status;
|
|
FILETIME LastWriteTime;
|
|
PCKEY Key = (PCKEY)hKey;
|
|
|
|
WRAP(Status,
|
|
ApiQueryInfoKey(Key->RemoteKey,
|
|
&SubKeys,
|
|
&MaxSubKeyLen,
|
|
&Values,
|
|
&MaxValueNameLen,
|
|
&MaxValueLen,
|
|
&SecurityDescriptor,
|
|
&LastWriteTime),
|
|
Key->Cluster);
|
|
if (Status == ERROR_SUCCESS) {
|
|
if (ARGUMENT_PRESENT(lpcSubKeys)) {
|
|
*lpcSubKeys = SubKeys;
|
|
}
|
|
if (ARGUMENT_PRESENT(lpcchMaxSubKeyLen)) {
|
|
*lpcchMaxSubKeyLen = MaxSubKeyLen;
|
|
}
|
|
if (ARGUMENT_PRESENT(lpcValues)) {
|
|
*lpcValues = Values;
|
|
}
|
|
if (ARGUMENT_PRESENT(lpcchMaxValueNameLen)) {
|
|
*lpcchMaxValueNameLen = MaxValueNameLen;
|
|
}
|
|
if (ARGUMENT_PRESENT(lpcbMaxValueLen)) {
|
|
*lpcbMaxValueLen = MaxValueLen;
|
|
}
|
|
if (ARGUMENT_PRESENT(lpcbSecurityDescriptor)) {
|
|
*lpcbSecurityDescriptor = SecurityDescriptor;
|
|
}
|
|
if (ARGUMENT_PRESENT(lpftLastWriteTime)) {
|
|
*lpftLastWriteTime = LastWriteTime;
|
|
}
|
|
}
|
|
|
|
return(Status);
|
|
}
|
|
|
|
|
|
LONG
|
|
WINAPI
|
|
ClusterRegGetKeySecurity(
|
|
HKEY hKey,
|
|
SECURITY_INFORMATION RequestedInformation,
|
|
PSECURITY_DESCRIPTOR pSecurityDescriptor,
|
|
LPDWORD lpcbSecurityDescriptor
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Retrieves a copy of the security descriptor protecting
|
|
the specified cluster registry key.
|
|
|
|
Arguments:
|
|
|
|
hKey - Supplies the handle of the key
|
|
|
|
RequestedInformation - Specifies a SECURITY_INFORMATION structure that
|
|
indicates the requested security information.
|
|
|
|
pSecurityDescriptor - Points to a buffer that receives a copy of the
|
|
requested security descriptor.
|
|
|
|
lpcbSecurityDescriptor - Points to a variable that specifies the size,
|
|
in bytes, of the buffer pointed to by the pSecurityDescriptor parameter.
|
|
When the function returns, the variable contains the number of bytes
|
|
written to the buffer.
|
|
|
|
Return Value:
|
|
|
|
ERROR_SUCCESS if successful
|
|
|
|
Win32 error code otherwise
|
|
|
|
--*/
|
|
|
|
{
|
|
PCKEY Key = (PCKEY)hKey;
|
|
RPC_SECURITY_DESCRIPTOR RpcSD;
|
|
DWORD Status;
|
|
|
|
//
|
|
// Convert the supplied SECURITY_DESCRIPTOR to a RPCable version.
|
|
//
|
|
RpcSD.lpSecurityDescriptor = pSecurityDescriptor;
|
|
RpcSD.cbInSecurityDescriptor = *lpcbSecurityDescriptor;
|
|
RpcSD.cbOutSecurityDescriptor = 0;
|
|
|
|
WRAP(Status,
|
|
(ApiGetKeySecurity(Key->RemoteKey,
|
|
RequestedInformation,
|
|
&RpcSD)),
|
|
Key->Cluster);
|
|
|
|
//
|
|
// Extract the size of the SECURITY_DESCRIPTOR from the RPCable version.
|
|
//
|
|
|
|
*lpcbSecurityDescriptor = RpcSD.cbOutSecurityDescriptor;
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
LONG
|
|
WINAPI
|
|
ClusterRegSetKeySecurity(
|
|
HKEY hKey,
|
|
SECURITY_INFORMATION SecurityInformation,
|
|
PSECURITY_DESCRIPTOR pSecurityDescriptor
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Sets the security of an open cluster registry key.
|
|
|
|
|
|
Arguments:
|
|
|
|
hKey - Supplies the cluster registry key
|
|
|
|
SecurityInformation - Specifies a SECURITY_INFORMATION structure that
|
|
indicates the contents of the supplied security descriptor.
|
|
|
|
pSecurityDescriptor - Points to a SECURITY_DESCRIPTOR structure that
|
|
specifies the security attributes to set for the specified key.
|
|
|
|
Return Value:
|
|
|
|
ERROR_SUCCESS if successful
|
|
|
|
Win32 error code otherwise
|
|
|
|
--*/
|
|
|
|
{
|
|
PCKEY Key = (PCKEY)hKey;
|
|
RPC_SECURITY_DESCRIPTOR RpcSD;
|
|
DWORD Status;
|
|
|
|
//
|
|
// Convert the supplied SECURITY_DESCRIPTOR to a RPCable version.
|
|
//
|
|
RpcSD.lpSecurityDescriptor = NULL;
|
|
|
|
Status = MapSDToRpcSD(pSecurityDescriptor,&RpcSD);
|
|
if (Status != ERROR_SUCCESS) {
|
|
return(Status);
|
|
}
|
|
|
|
WRAP(Status,
|
|
(ApiSetKeySecurity(Key->RemoteKey,
|
|
SecurityInformation,
|
|
&RpcSD)),
|
|
Key->Cluster);
|
|
|
|
//
|
|
// Free the buffer allocated by MapSDToRpcSD.
|
|
//
|
|
LocalFree(RpcSD.lpSecurityDescriptor);
|
|
return(Status);
|
|
|
|
}
|
|
|