windows-server-2003/base/cluster/service/api/registry.c

/*++

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);
}