/*******************************************************************************
*
*  (C) COPYRIGHT MICROSOFT CORP., 1996
*
*  TITLE:       REGHELP.C
*
*  VERSION:     2.0
*
*  AUTHOR:      ReedB
*
*  DATE:        17 Oct, 1996
*
*  DESCRIPTION:
*
*******************************************************************************/

#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>

#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <regstr.h>
#include <commctrl.h>

#include <ntpoapi.h>

#include "powrprofp.h"
#include "reghelp.h"

/*******************************************************************************
*
*                     G L O B A L    D A T A
*
*******************************************************************************/

extern HINSTANCE   g_hInstance;        // Global instance handle of this DLL.
extern HANDLE      g_hSemRegistry;     // Registry semaphore.
extern UINT        g_uiLastID;         // The last ID value used, per machine.

extern TCHAR c_szREGSTR_PATH_MACHINE_POWERCFG[];
extern TCHAR c_szREGSTR_VAL_LASTID[];

// Global semaphore name.
const TCHAR c_szSemRegistry[] = TEXT("PowerProfileRegistrySemaphore");


/*******************************************************************************
*
*  OpenCurrentUser
*
*  DESCRIPTION:
*   
*  PARAMETERS:
*
*******************************************************************************/

DWORD OpenCurrentUser2(PHKEY phKey,REGSAM samDesired)
{
#ifdef WINNT

    // Since powerprof can be called in the Winlogon context when
    // a user is being impersonated, use RegOpenCurrentUser to get HKCU.
    LONG lRet = RegOpenCurrentUser(samDesired, phKey);
    if (lRet != ERROR_SUCCESS) {
        MYDBGPRINT(("RegOpenCurrentUser, failed, LastError: 0x%08X", lRet));
    }

    return lRet;

#else
    *phKey = HKEY_CURRENT_USER;
    return ERROR_SUCCESS; 
#endif
}


#if 0
BOOLEAN OpenCurrentUser(
                       PHKEY phKey,
                       REGSAM samDesired
                       )
{
    DWORD dwError = OpenCurrentUser2(phKey, samDesired);
    BOOLEAN fSucceeded = TRUE;

    if (ERROR_SUCCESS != dwError) {
        fSucceeded = FALSE;
        SetLastError(dwError);
    }

    return fSucceeded;
}
#endif


/*******************************************************************************
*
*  CloseCurrentUser
*
*  DESCRIPTION:
*   
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN CloseCurrentUser(HKEY hKey)
{
#ifdef WINNT
    RegCloseKey(hKey);
#endif
    return TRUE;
}

/*******************************************************************************
*
*  OpenMachineUserKeys
*
*  DESCRIPTION:
*   
*  PARAMETERS:
*
*******************************************************************************/

DWORD OpenMachineUserKeys2(
                          LPTSTR  lpszUserKeyName,
                          REGSAM samDesiredUser,
                          LPTSTR  lpszMachineKeyName,
                          REGSAM samDesiredMachine,
                          PHKEY   phKeyUser,
                          PHKEY   phKeyMachine
                          )
{
    HKEY hKeyCurrentUser;
    DWORD dwError = OpenCurrentUser2(&hKeyCurrentUser,samDesiredUser);

    if (ERROR_SUCCESS == dwError) { // Sets Last Error

        dwError = RegOpenKeyEx(
                              hKeyCurrentUser,
                              lpszUserKeyName,
                              0,
                              samDesiredUser,
                              phKeyUser);

        CloseCurrentUser(hKeyCurrentUser);

        if (ERROR_SUCCESS == dwError) {
            dwError = RegOpenKeyEx(
                                  HKEY_LOCAL_MACHINE,
                                  lpszMachineKeyName,
                                  0,
                                  samDesiredMachine,
                                  phKeyMachine);
            if (ERROR_SUCCESS == dwError) {
                goto exit;
            } else {
                MYDBGPRINT(("OpenMachineUserKeys, failure opening  HKEY_LOCAL_MACHINE\\%s", lpszMachineKeyName));
            }

            RegCloseKey(*phKeyUser);
        } else {
            MYDBGPRINT(("OpenMachineUserKeys, failure opening HKEY_CURRENT_USER\\%s", lpszUserKeyName));
        }
    } else {
        dwError = ERROR_FILE_NOT_FOUND;
    }

    MYDBGPRINT(("OpenMachineUserKeys, failed, LastError: 0x%08X", dwError));
exit:
    return dwError;
}

#if 0
BOOLEAN OpenMachineUserKeys(
                           LPTSTR  lpszUserKeyName,
                           LPTSTR  lpszMachineKeyName,
                           PHKEY   phKeyUser,
                           PHKEY   phKeyMachine,
                           REGSAM  samDesired)
{
    DWORD dwError = OpenMachineUserKeys2(lpszUserKeyName, lpszMachineKeyName, phKeyUser, phKeyMachine, samDesired);
    BOOLEAN fSucceeded = TRUE;

    if (ERROR_SUCCESS != dwError) {
        fSucceeded = FALSE;
        SetLastError(dwError);
    }

    return fSucceeded;
}
#endif

/*******************************************************************************
*
*  OpenPathKeys
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

DWORD OpenPathKeys(
                  LPTSTR  lpszUserKeyName,
                  REGSAM  samDesiredUser,
                  LPTSTR  lpszMachineKeyName,
                  REGSAM  samDesiredMachine,
                  LPTSTR  lpszSchemeName,
                  PHKEY   phKeyUser,
                  PHKEY   phKeyMachine,
                  BOOLEAN bMustExist
                  )
{
    HKEY     hKeyUser, hKeyMachine;

    DWORD dwError = OpenMachineUserKeys2(
                                        lpszUserKeyName, 
                                        samDesiredUser,
                                        lpszMachineKeyName,
                                        samDesiredMachine, 
                                        &hKeyUser, 
                                        &hKeyMachine);

    if (ERROR_SUCCESS == dwError) {
        DWORD dwDisposition;

        dwError = RegCreateKeyEx(hKeyUser, lpszSchemeName, 0, TEXT(""), REG_OPTION_NON_VOLATILE, samDesiredUser, NULL, phKeyUser, &dwDisposition);
        if (dwError == ERROR_SUCCESS) {
            if (!bMustExist || (dwDisposition == REG_OPENED_EXISTING_KEY)) {
                dwError = RegCreateKeyEx(hKeyMachine,
                                         lpszSchemeName,
                                         0,
                                         TEXT(""),
                                         REG_OPTION_NON_VOLATILE,
                                         samDesiredMachine,
                                         NULL,
                                         phKeyMachine,
                                         &dwDisposition);
                if (dwError == ERROR_SUCCESS) {
                    if (!bMustExist ||
                        (dwDisposition == REG_OPENED_EXISTING_KEY)) {
                        // This is the success case.
                    } else {
                        dwError = ERROR_ACCESS_DENIED;
                    }
                } else {
                    RegCloseKey(*phKeyUser);
                    MYDBGPRINT(("OpenPathKeys, unable to create machine key %s\\%s", lpszMachineKeyName, lpszSchemeName));
                }
            } else {
                dwError = ERROR_ACCESS_DENIED;
            }
        } else {
            MYDBGPRINT(("OpenPathKeys, unable to create user key %s\\%s", lpszUserKeyName, lpszSchemeName));
        }

        RegCloseKey(hKeyUser);
        RegCloseKey(hKeyMachine);

        if (ERROR_SUCCESS != dwError) {
            MYDBGPRINT(("OpenPathKeys, failed, LastError: 0x%08X", dwError));
        }
    }

    return dwError;
}

PACL    BuildSemaphoreACL (void)

//  2000-06-22 vtan:
//
//  This function builds an ACL which allows authenticated users access to the named
//  semaphore for SYNCHRONIZE | READ_CONTROL | SEMAPHORE_QUERY_STATE | SEMAPHORE_MODIFY_STATE.
//  It gives full access for the local SYSTEM or members of the local administrators
//  group. If something goes wrong the return result is NULL and no security descriptor
//  is built then.

{
    static  SID_IDENTIFIER_AUTHORITY    securityNTAuthority     =   SECURITY_NT_AUTHORITY;

    PSID        pSIDAuthenticatedUsers;
    PACL        pACL;

    pACL = NULL;
    if (AllocateAndInitializeSid(&securityNTAuthority,
                                 1,
                                 SECURITY_AUTHENTICATED_USER_RID,
                                 0, 0, 0, 0, 0, 0, 0,
                                 &pSIDAuthenticatedUsers) != FALSE) {
        PSID    pSIDLocalSystem;

        if (AllocateAndInitializeSid(&securityNTAuthority,
                                     1,
                                     SECURITY_LOCAL_SYSTEM_RID,
                                     0, 0, 0, 0, 0, 0, 0,
                                     &pSIDLocalSystem) != FALSE) {
            PSID    pSIDLocalAdministrators;

            if (AllocateAndInitializeSid(&securityNTAuthority,
                                         2,
                                         SECURITY_BUILTIN_DOMAIN_RID,
                                         DOMAIN_ALIAS_RID_ADMINS,
                                         0, 0, 0, 0, 0, 0,
                                         &pSIDLocalAdministrators) != FALSE) {
                DWORD       dwACLSize;

                dwACLSize = sizeof(ACL) +
                            ((sizeof(ACCESS_ALLOWED_ACE) - sizeof(ULONG)) * 3) +
                            GetLengthSid(pSIDAuthenticatedUsers) +
                            GetLengthSid(pSIDLocalSystem) +
                            GetLengthSid(pSIDLocalAdministrators);
                pACL = (PACL)LocalAlloc(LMEM_FIXED, dwACLSize);
                if (pACL != NULL) {
                    if ((InitializeAcl(pACL, dwACLSize, ACL_REVISION) == FALSE) ||
                        (AddAccessAllowedAce(pACL,
                                             ACL_REVISION,
                                             SYNCHRONIZE | READ_CONTROL | SEMAPHORE_QUERY_STATE | SEMAPHORE_MODIFY_STATE,
                                             pSIDAuthenticatedUsers) == FALSE) ||
                        (AddAccessAllowedAce(pACL,
                                             ACL_REVISION,
                                             SEMAPHORE_ALL_ACCESS,
                                             pSIDLocalSystem) == FALSE) ||
                        (AddAccessAllowedAce(pACL,
                                             ACL_REVISION,
                                             SEMAPHORE_ALL_ACCESS,
                                             pSIDLocalAdministrators) == FALSE)) {
                        (HLOCAL)LocalFree(pACL);
                        pACL = NULL;
                    }
                }
                (PVOID)FreeSid(pSIDLocalAdministrators);
            }
            (PVOID)FreeSid(pSIDLocalSystem);
        }
        (PVOID)FreeSid(pSIDAuthenticatedUsers);
    }
    return(pACL);
}


/*******************************************************************************
*
*  CreateRegSemaphore
*
*  DESCRIPTION: Attempts to open/create the registry semaphore. g_hSemRegistry
*               is initialized on success.
*
*  PARAMETERS:  None
*
*******************************************************************************/

BOOLEAN CreateRegSemaphore(VOID)
{
    HANDLE Semaphore=NULL;

    // First try to open the named semaphore with only required access.

    // NOTE: the named object is per terminal server session. Therefore
    // this semaphore is really bogus because it protects HKEY_LOCAL_MACHINE
    // as well as HKEY_CURRENT_USER. Making it "Global\" is very dangerous
    // and you don't know the side effects without complete retesting.
    // Not worth it.

    Semaphore = OpenSemaphore(SYNCHRONIZE | SEMAPHORE_QUERY_STATE | SEMAPHORE_MODIFY_STATE,
                              FALSE,
                              c_szSemRegistry);
    if ((Semaphore == NULL) && (GetLastError() != ERROR_ACCESS_DENIED)) {
        SECURITY_ATTRIBUTES     securityAttributes, *pSA;
        SECURITY_DESCRIPTOR     securityDescriptor;
        PACL                    pACL;

        // If this fails then create the semaphore and ACL it so that everybody
        // can get SYNCHRONIZE | SEMAPHORE_QUERY_STATE | SEMAPHORE_MODIFY_STATE
        // access. This allows a service (such as UPS) running in the SYSTEM context
        // to grant limited access to anybody who needs it to synchronize against
        // this semaphore. It also prevents C2 violation by NOT putting a NULL
        // DACL on the named semaphore. If an ACL for the semaphore cannot be
        // built then no security descriptor is given and the default ACL is used.

        pSA = NULL;
        pACL = BuildSemaphoreACL();
        if (pACL != NULL) {
            if ((InitializeSecurityDescriptor(&securityDescriptor, SECURITY_DESCRIPTOR_REVISION) != FALSE) &&
                (SetSecurityDescriptorDacl(&securityDescriptor, TRUE, pACL, FALSE) != FALSE)) {
                securityAttributes.nLength = sizeof(securityAttributes);
                securityAttributes.bInheritHandle = FALSE;
                securityAttributes.lpSecurityDescriptor = &securityDescriptor;
                pSA = &securityAttributes;
            }
        }

        // Create the registry semaphore.
        Semaphore = CreateSemaphore(pSA, 1, 1, c_szSemRegistry);

        if (pACL != NULL) {
            (HLOCAL)LocalFree(pACL);
        }
    }

    //
    // If we successfully opened a handle, update the global g_hSemRegistry now
    //
    if (Semaphore) {
        if (InterlockedCompareExchangePointer(&g_hSemRegistry, Semaphore, NULL) != NULL) {
            CloseHandle(Semaphore);
        }
        return(TRUE);
    } else {
        return(FALSE);
    }

}

/*******************************************************************************
*
*  TakeRegSemaphore
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN TakeRegSemaphore(VOID)
{
    if (g_hSemRegistry == NULL) {
        if (!CreateRegSemaphore()) {
            return FALSE;
        }
    }
    if (WaitForSingleObject(g_hSemRegistry, SEMAPHORE_TIMEOUT) != WAIT_OBJECT_0) {
        ReleaseSemaphore(g_hSemRegistry, 1, NULL);
        MYDBGPRINT(("WaitForSingleObject, failed"));
        SetLastError(ERROR_INVALID_ACCESS);
        return FALSE;
    }
    return TRUE;
}

/*******************************************************************************
*
*  ReadPowerValueOptional
*
*  DESCRIPTION:
*   Value may not exist.
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN ReadPowerValueOptional(
                              HKEY    hKey,
                              LPTSTR  lpszPath,
                              LPTSTR  lpszValueName,
                              LPTSTR  lpszValue,
                              LPDWORD lpdwSize
                              )
{
    HKEY     hKeyPath;
    BOOLEAN  bRet = FALSE;
    DWORD    dwSize;
    LONG     lRet;

    if ((lRet = RegOpenKeyEx(
                            hKey,
                            lpszPath,
                            0,
                            KEY_READ,
                            &hKeyPath)) != ERROR_SUCCESS) {
        goto RPVO_exit;
    }

    if ((lRet = RegQueryValueEx(hKeyPath,
                                lpszValueName,
                                NULL,
                                NULL,
                                (PBYTE) lpszValue,
                                lpdwSize)) == ERROR_SUCCESS) {
        bRet = TRUE;
    }

    RegCloseKey(hKeyPath);

    RPVO_exit:
    return bRet;
}

/*******************************************************************************
*
*  ReadPowerIntOptional
*
*  DESCRIPTION:
*   Integer value may not exist.
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN ReadPowerIntOptional(
                            HKEY    hKey,
                            LPTSTR  lpszPath,
                            LPTSTR  lpszValueName,
                            PINT    piVal
                            )
{
    HKEY     hKeyPath;
    BOOLEAN  bRet = FALSE;
    DWORD    dwSize;
    TCHAR    szNum[NUM_DEC_DIGITS];
    LONG     lRet;

    if ((lRet = RegOpenKeyEx(hKey,
                             lpszPath,
                             0,
                             KEY_READ,
                             &hKeyPath)) != ERROR_SUCCESS) {
        goto RPVO_exit;
    }

    dwSize = sizeof(szNum);
    if ((lRet = RegQueryValueEx(hKeyPath,
                                lpszValueName,
                                NULL,
                                NULL,
                                (PBYTE) szNum,
                                &dwSize)) == ERROR_SUCCESS) {
        if (MyStrToInt(szNum, piVal)) {
            bRet = TRUE;
        }
    }

    RegCloseKey(hKeyPath);

    RPVO_exit:
    return bRet;
}

/*******************************************************************************
*
*  CreatePowerValue
*
*  DESCRIPTION:
*   Value may not exist.
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN CreatePowerValue(
                        HKEY    hKey,
                        LPCTSTR  lpszPath,
                        LPCTSTR  lpszValueName,
                        LPCTSTR  lpszValue
                        )
{
    DWORD    dwDisposition, dwDescSize;
    HKEY     hKeyPath;
    BOOLEAN  bRet = FALSE;
    DWORD    dwSize;
    LONG     lRet;

    // Wait on/take the registry semaphore.
    if (!TakeRegSemaphore()) {        // Will SetLastError
        return FALSE;
    }

    if ((lRet = RegCreateKeyEx(hKey,
                               lpszPath,
                               0,
                               TEXT(""),
                               REG_OPTION_NON_VOLATILE,
                               KEY_WRITE,
                               NULL,
                               &hKeyPath,
                               &dwDisposition)) == ERROR_SUCCESS) {
        if (lpszValue) {
            dwSize = (lstrlen(lpszValue) + 1) * sizeof(TCHAR);
            if ((lRet = RegSetValueEx(hKeyPath,
                                      lpszValueName,
                                      0,
                                      REG_SZ,
                                      (PBYTE) lpszValue,
                                      dwSize)) == ERROR_SUCCESS) {
                bRet = TRUE;
            }
        } else {
            lRet = ERROR_INVALID_PARAMETER;
        }

        RegCloseKey(hKeyPath);
    }

    if (!bRet) {
        SetLastError(lRet);
    }

    ReleaseSemaphore(g_hSemRegistry, 1, NULL);
    return bRet;
}


/*******************************************************************************
*
*  ReadWritePowerValue
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN ReadWritePowerValue(
                           HKEY    hKey,
                           LPTSTR  lpszPath,
                           LPTSTR  lpszValueName,
                           LPTSTR  lpszValue,
                           LPDWORD lpdwSize,
                           BOOLEAN bWrite,
                           BOOLEAN bTakeSemaphore
                           )
{
    // This function will set the Last Error correctly on failure
    HKEY     hKeyPath = NULL;
    BOOLEAN  bRet = FALSE;
    DWORD    dwSize;
    DWORD    dwDisposition;
    LONG     lRet;

    if ((lRet = RegCreateKeyEx(
                            hKey,
                            lpszPath,
                            0,
                            TEXT(""),
                            REG_OPTION_NON_VOLATILE,
                            bWrite 
                             ? KEY_WRITE 
                             : KEY_READ,
                            NULL,
                            &hKeyPath,
                            &dwDisposition)) != ERROR_SUCCESS) {
        goto RWPV_exit;
    }

    // Wait on/take the registry semaphore.
    if (bTakeSemaphore) {
        if (!TakeRegSemaphore()) {        // Will Set last error
            goto RWPV_exit;            
        }
    }

    if (bWrite) {
        // Write current case.
        if (lpszValue) {
            dwSize = (lstrlen(lpszValue) + 1) * sizeof(TCHAR);
            if ((lRet = RegSetValueEx(hKeyPath,
                                      lpszValueName,
                                      0,
                                      REG_SZ,
                                      (PBYTE) lpszValue,
                                      dwSize)) == ERROR_SUCCESS) {
                bRet = TRUE;
            }
        } else {
            lRet = ERROR_INVALID_PARAMETER;
        }
    } else {
        // Read current case.
        if ((lRet = RegQueryValueEx(hKeyPath,
                                    lpszValueName,
                                    NULL,
                                    NULL,
                                    (PBYTE) lpszValue,
                                    lpdwSize)) == ERROR_SUCCESS) {
            bRet = TRUE;
        }
    }

    if (bTakeSemaphore) {
        ReleaseSemaphore(g_hSemRegistry, 1, NULL);
    }
    
RWPV_exit:
    if (hKeyPath != NULL) {
        RegCloseKey(hKeyPath);
    }

    if (!bRet) {
        if (lRet == ERROR_SUCCESS) {
            lRet = GetLastError();
        }

        SetLastError(lRet);

        // Access denied is a valid result. 
        if (lRet != ERROR_ACCESS_DENIED) {
            MYDBGPRINT(("ReadWritePowerValue, failed, lpszValueName: %s, LastError: 0x%08X", lpszValueName, lRet));
        }
    }
    return bRet;
}

/*******************************************************************************
*
*  ReadPwrPolicyEx
*
*  DESCRIPTION:
*   Supports ReadPwrScheme and ReadGlobalPwrPolicy
*
*  PARAMETERS:
*   lpdwDescSize - Pointer to size of optional description buffer.
*   lpszDesc     - Optional description buffer.
*
*******************************************************************************/

DWORD ReadPwrPolicyEx2(
                      LPTSTR  lpszUserKeyName,
                      LPTSTR  lpszMachineKeyName,
                      LPTSTR  lpszSchemeName,
                      LPTSTR  lpszDesc,
                      LPDWORD lpdwDescSize,
                      LPVOID  lpvUser,
                      DWORD   dwcbUserSize,
                      LPVOID  lpvMachine,
                      DWORD   dwcbMachineSize
                      )
{
    HKEY     hKeyUser, hKeyMachine;
    DWORD    dwType, dwSize;
    DWORD dwError = ERROR_SUCCESS;
    BOOLEAN  bRet = FALSE;

    if ((!lpszUserKeyName || !lpszMachineKeyName) ||
        (!lpszSchemeName  || !lpvUser || !lpvMachine) ||
        (!lpdwDescSize    && lpszDesc) ||
        (lpdwDescSize     && !lpszDesc)) {
        dwError = ERROR_INVALID_PARAMETER;
    } else {
        // Wait on/take the registry semaphore.
        if (!TakeRegSemaphore()) {        // Will Set Last Error 
            return GetLastError();
        }

        dwError = OpenPathKeys(
                              lpszUserKeyName, 
                              KEY_READ, 
                              lpszMachineKeyName, 
                              KEY_READ, 
                              lpszSchemeName, 
                              &hKeyUser, 
                              &hKeyMachine, 
                              TRUE);

        if (ERROR_SUCCESS != dwError) {
            ReleaseSemaphore(g_hSemRegistry, 1, NULL);
            return dwError;
        }

        dwSize = dwcbUserSize;
        dwError = RegQueryValueEx(hKeyUser,
                                  TEXT("Policies"),
                                  NULL,
                                  &dwType,
                                  (PBYTE) lpvUser,
                                  &dwSize);

        if (dwError == ERROR_SUCCESS) {
            if (dwType == REG_BINARY) {
                dwSize = dwcbMachineSize;
                dwError = RegQueryValueEx(hKeyMachine,
                                          TEXT("Policies"),
                                          NULL,
                                          &dwType,
                                          (PBYTE) lpvMachine,
                                          &dwSize);
            } else {
                dwError = ERROR_INVALID_DATATYPE;
            }
        }

        if (dwError == ERROR_SUCCESS) {
            if (dwType == REG_BINARY) {
                if (lpdwDescSize) {
                    dwError = RegQueryValueEx(hKeyUser, TEXT("Description"), NULL, &dwType, (PBYTE) lpszDesc, lpdwDescSize);
                }
            } else {
                dwError = ERROR_INVALID_DATATYPE;
            }
        }

        RegCloseKey(hKeyUser);
        RegCloseKey(hKeyMachine);
        ReleaseSemaphore(g_hSemRegistry, 1, NULL);
    }

    if (ERROR_SUCCESS != dwError) {
        MYDBGPRINT(("ReadPwrPolicyEx, failed, LastError: 0x%08X", dwError));
        MYDBGPRINT(("  lpszUserKeyName: %s, lpszSchemeName: %s", lpszUserKeyName, lpszSchemeName));
        SetLastError(dwError);
    }

    return dwError;
}

DWORD 
ReadProcessorPwrPolicy(
                      LPTSTR lpszMachineKeyName, 
                      LPTSTR lpszSchemeName, 
                      LPVOID lpvMachineProcessor, 
                      DWORD dwcbMachineProcessorSize
                      )
{
    HKEY    hKeyMachine = NULL;
    HKEY    hKeyPolicy = NULL;
    DWORD   dwError = ERROR_SUCCESS;
    DWORD   dwDisposition, dwSize, dwType;

    if (!lpszMachineKeyName || !lpvMachineProcessor) {
        dwError = ERROR_INVALID_PARAMETER;
        goto ReadProcessorPwrPolicyEnd;
    }

    // Wait on/take the registry semaphore.
    if (!TakeRegSemaphore()) {        // Will Set Last Error 
        return GetLastError();
    }

    dwError = RegOpenKeyEx(HKEY_LOCAL_MACHINE, lpszMachineKeyName, 0, KEY_READ, &hKeyMachine);
    if (ERROR_SUCCESS != dwError) goto ReadProcessorPwrPolicyExit;

    dwError = RegCreateKeyEx(hKeyMachine, lpszSchemeName, 0, TEXT(""), REG_OPTION_NON_VOLATILE, KEY_READ, NULL, &hKeyPolicy, &dwDisposition);
    if (ERROR_SUCCESS != dwError) goto ReadProcessorPwrPolicyExit;

    dwSize = dwcbMachineProcessorSize;
    dwError = RegQueryValueEx(hKeyPolicy,
                              TEXT("Policies"),
                              NULL,
                              &dwType,
                              (PBYTE) lpvMachineProcessor,
                              &dwSize);

    if (REG_BINARY != dwType) {
        dwError = ERROR_INVALID_DATATYPE;
    }

    ReadProcessorPwrPolicyExit:

    if (hKeyPolicy) RegCloseKey(hKeyPolicy);
    if (hKeyMachine) RegCloseKey(hKeyMachine);
    ReleaseSemaphore(g_hSemRegistry, 1, NULL);

    ReadProcessorPwrPolicyEnd:

    if (ERROR_SUCCESS != dwError) {
        MYDBGPRINT(("ReadProcessorPwrPolicy, failed, LastError: 0x%08X", dwError));
        MYDBGPRINT(("  lpszMachineKeyName: %s, lpszSchemeName: %s", lpszMachineKeyName, lpszSchemeName));
        SetLastError(dwError);
    }

    return dwError;
}

DWORD 
WriteProcessorPwrPolicy(
                       LPTSTR lpszMachineKeyName, 
                       LPTSTR lpszSchemeName, 
                       LPVOID lpvMachineProcessor, 
                       DWORD dwcbMachineProcessorSize
                       )
{
    HKEY    hKeyMachine = NULL;
    HKEY    hKeyPolicy = NULL;
    DWORD   dwError = ERROR_SUCCESS;
    DWORD   dwDisposition;

    if (!lpszMachineKeyName || !lpvMachineProcessor) {
        dwError = ERROR_INVALID_PARAMETER;
        goto WriteProcessorPwrPolicyEnd;
    }

    // Wait on/take the registry semaphore.
    if (!TakeRegSemaphore()) {        // Will Set Last Error 
        return GetLastError();
    }

    
    dwError = RegCreateKeyEx(
                            HKEY_LOCAL_MACHINE,
                            lpszMachineKeyName,
                            0,
                            TEXT(""),
                            REG_OPTION_NON_VOLATILE,
                            KEY_WRITE,
                            NULL,
                            &hKeyMachine,
                            &dwDisposition);
    if (ERROR_SUCCESS != dwError) goto WriteProcessorPwrPolicyExit;

    dwError = RegCreateKeyEx(hKeyMachine, lpszSchemeName, 0, TEXT(""), REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKeyPolicy, &dwDisposition);
    if (ERROR_SUCCESS != dwError) goto WriteProcessorPwrPolicyExit;

    dwError = RegSetValueEx(hKeyPolicy,
                            TEXT("Policies"),
                            0,
                            REG_BINARY,
                            (PBYTE) lpvMachineProcessor,
                            dwcbMachineProcessorSize);

    WriteProcessorPwrPolicyExit:

    if (hKeyPolicy) RegCloseKey(hKeyPolicy);
    if (hKeyMachine) RegCloseKey(hKeyMachine);
    ReleaseSemaphore(g_hSemRegistry, 1, NULL);

    WriteProcessorPwrPolicyEnd:

    if (ERROR_SUCCESS != dwError) {
        MYDBGPRINT(("WriteProcessorPwrPolicy, failed, LastError: 0x%08X", dwError));
        MYDBGPRINT(("  lpszMachineKeyName: %s, lpszSchemeName: %s", lpszMachineKeyName, lpszSchemeName));
        SetLastError(dwError);
    }

    return dwError;
}

/*******************************************************************************
*
*  WritePwrPolicyEx
*
*  DESCRIPTION:
*   Supports WritePwrScheme and
*   WriteGlobalPwrPolicy
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN WritePwrPolicyEx(
                        LPTSTR  lpszUserKeyName,
                        LPTSTR  lpszMachineKeyName,
                        PUINT   puiID,
                        LPTSTR  lpszName,
                        LPTSTR  lpszDescription,
                        LPVOID  lpvUser,
                        DWORD   dwcbUserSize,
                        LPVOID  lpvMachine,
                        DWORD   dwcbMachineSize
                        )
{
    // The function will set the last error if it fails.
    HKEY     hKeyUser, hKeyMachine;
    LONG     lRet = ERROR_SUCCESS;
    DWORD    dwDisposition, dwSize;
    TCHAR    szNum[NUM_DEC_DIGITS];
    LPTSTR   lpszKeyName;

    //
    // Check Params.
    //
    if( !lpszUserKeyName    || 
        !lpszMachineKeyName || 
        !lpvUser            || 
        !lpvMachine         ||
        (!puiID && !lpszName)   // They need to send us at least an index or a name.
      ) {

        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }

    
    //
    // If a scheme ID was passed
    //
    if (puiID) {
        if (*puiID == NEWSCHEME) {
            *puiID = ++g_uiLastID;
            _itot(*puiID, szNum, 10 );

            // This ReadWritePowerValue will SetLastError
            if (!ReadWritePowerValue(HKEY_LOCAL_MACHINE,
                                     c_szREGSTR_PATH_MACHINE_POWERCFG,
                                     c_szREGSTR_VAL_LASTID,
                                     szNum, &dwSize, TRUE, TRUE)) {
                return FALSE;
            }
        } else {
            _itot(*puiID, szNum, 10 );            
        }
        lpszKeyName = szNum;
    } else {
        lpszKeyName = lpszName;
    }

    // Wait on/take the registry semaphore.
    if (!TakeRegSemaphore()) {    // Will set last error
        return FALSE;
    }

    lRet = OpenPathKeys(
                       lpszUserKeyName, 
                       KEY_WRITE,
                       lpszMachineKeyName,
                       KEY_WRITE,
                       lpszKeyName, 
                       &hKeyUser,
                       &hKeyMachine, 
                       FALSE);
    if (ERROR_SUCCESS != lRet) {
        ReleaseSemaphore(g_hSemRegistry, 1, FALSE);
        SetLastError(lRet);
        return FALSE;
    }

    // Write the binary policies data
    if ((lRet = RegSetValueEx(hKeyUser,
                              TEXT("Policies"),
                              0,
                              REG_BINARY,
                              (PBYTE) lpvUser,
                              dwcbUserSize)) == ERROR_SUCCESS) {
        // Write the binary policies data
        if ((lRet = RegSetValueEx(hKeyMachine,
                                  TEXT("Policies"),
                                  0,
                                  REG_BINARY,
                                  (PBYTE) lpvMachine,
                                  dwcbMachineSize)) == ERROR_SUCCESS) {
            // Write the name text if an ID was provided.
            if (lpszName && puiID) {
                dwSize = (lstrlen(lpszName) + 1) * sizeof(TCHAR);
                lRet = RegSetValueEx(hKeyUser, TEXT("Name"), 0, REG_SZ, (PBYTE) lpszName, dwSize);
            }

            // Write the description text.
            if (lpszDescription && (lRet == ERROR_SUCCESS)) {
                dwSize = (lstrlen(lpszDescription) + 1) * sizeof(TCHAR);
                lRet = RegSetValueEx(hKeyUser, TEXT("Description"), 0, REG_SZ, (PBYTE) lpszDescription, dwSize);
            }
        }
    }
    RegCloseKey(hKeyUser);
    RegCloseKey(hKeyMachine);
    ReleaseSemaphore(g_hSemRegistry, 1, NULL);

    if (lRet != ERROR_SUCCESS) {
        MYDBGPRINT(("WritePwrPolicyEx, failed, LastError: 0x%08X", lRet));
        MYDBGPRINT(("  lpszUserKeyName: %s, lpszKeyName: %s", lpszUserKeyName, lpszKeyName));

        SetLastError(lRet);
        return FALSE;
    }
    return TRUE;
}