windows-xp/Source/XPSP1/NT/shell/osshell/cpls/powrprof/powrprof.c

/*******************************************************************************
*
*  (C) COPYRIGHT MICROSOFT CORP., 1996
*
*  TITLE:       POWRPROF.C
*
*  VERSION:     2.0
*
*  AUTHOR:      ReedB
*
*  DATE:        17 Oct, 1996
*
*  DESCRIPTION:
*   User power management profile maintenance library. Implements persistent
*   power mamagement data storage. To minimize registry storage and simplify
*   user power profile management, power scheme's are divided into two parts,
*   GLOBAL_POWER_POLICY and POWER_POLICY:
*
*   User Level              Registry Storage
*   GLOBAL_POWER_POLICY =                               - Common scheme data.
*                           GLOBAL_MACHINE_POWER_POLICY - Per machine data.
*                        +  GLOBAL_USER_POWER_POLICY    - Per user data.
*
*   POWER_POLICY        =                              - Unique scheme data.
*                           MACHINE_POWER_POLICY       - Per machine data.
*                         + USER_POWER_POLICY          - Per user data.
*
*   The interface to the power policy manager is by AC and DC
*   SYSTEM_POWER_POLICY which is formed by merging the above structures.
*
*******************************************************************************/

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

#include <windows.h>
#include <initguid.h>
#include <devguid.h>
#include <string.h>
#include <regstr.h>
#include <commctrl.h>

#include <ntpoapi.h>

#include <setupapi.h>
#include <syssetup.h>
#include <setupbat.h>

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


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

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

// Variables and definitions to manage dynamic link to  NtPowerInformation.
typedef NTSTATUS (NTAPI *PFNNTPOWERINFORMATION)(POWER_INFORMATION_LEVEL, PVOID, ULONG, PVOID, ULONG);

#ifdef WINNT
// Global administrator power policy variables. Initialize to allow everything.
BOOLEAN g_bAdminOverrideActive = FALSE;
ADMINISTRATOR_POWER_POLICY g_app =
{
    // Meaning of power action "sleep" Min, Max.
    PowerSystemSleeping1, PowerSystemHibernate,

    // Video policies Min, Max.
    0, -1,

    // Disk spindown policies Min, Max.
    0, -1
};
#endif

// Debug strings for Power Policy Manager POWER_INFORMATION_LEVEL:
#ifdef DEBUG
LPTSTR lpszInfoLevel[] =
{
    TEXT("SystemPowerPolicyAc"),
    TEXT("SystemPowerPolicyDc"),
    TEXT("VerifySystemPolicyAc"),
    TEXT("VerifySystemPolicyDc"),
    TEXT("SystemPowerCapabilities"),
    TEXT("SystemBatteryState"),
    TEXT("SystemPowerStateHandler"),
    TEXT("ProcessorStateHandler"),
    TEXT("SystemPowerPolicyCurrent"),
    TEXT("AdministratorPowerPolicy"),
    TEXT("SystemReserveHiberFile"),
    TEXT("ProcessorInformation"),
    TEXT("SystemPowerInformation"),
    TEXT("ProcessorStateHandler2"),
    TEXT("LastWakeTime"),
    TEXT("LastSleepTime"),
    TEXT("SystemExecutionState"),
    TEXT("SystemPowerStateNotifyHandler"),
    TEXT("ProcessorPowerPolicyAc"),
    TEXT("ProcessorPowerPolicyDc"),
    TEXT("VerifyProcessorPowerPolicyAc"),
    TEXT("VerifyProcessorPowerPolicyDc"),
    TEXT("ProcessorPowerPolicyCurrent")
};

int g_iShowValidationChanges;
int g_iShowCapabilities;
int g_iShowSetPPM;
#endif

// Global value for storing a single registry value name/path. Multithread
// protection is provided by the Registry semaphore.
TCHAR g_szRegValue[REGSTR_MAX_VALUE_LENGTH];


// Strings used to access the registry. REGSTR_* string constants can be
// found in sdk\inc\regstr.h, USER strings are under HKEY_CURRENT_USER,
// MACHINE strings are under HKEY_LOCAL_MACHINE.

TCHAR c_szREGSTR_PATH_MACHINE_POWERCFG[]  = REGSTR_PATH_CONTROLSFOLDER TEXT("\\PowerCfg");
TCHAR c_szREGSTR_PATH_USER_POWERCFG[]     = REGSTR_PATH_CONTROLPANEL TEXT("\\PowerCfg");

TCHAR c_szREGSTR_PATH_MACHINE_POWERCFG_POLICIES[]  = REGSTR_PATH_CONTROLSFOLDER TEXT("\\PowerCfg\\PowerPolicies");
TCHAR c_szREGSTR_PATH_MACHINE_PROCESSOR_POLICIES[]  = REGSTR_PATH_CONTROLSFOLDER TEXT("\\PowerCfg\\ProcessorPolicies");
TCHAR c_szREGSTR_PATH_USER_POWERCFG_POLICIES[]     = REGSTR_PATH_CONTROLPANEL   TEXT("\\PowerCfg\\PowerPolicies");

TCHAR c_szREGSTR_VAL_GLOBALPOWERPOLICY[]  = TEXT("GlobalPowerPolicy");
TCHAR c_szREGSTR_VAL_CURRENTPOWERPOLICY[] = TEXT("CurrentPowerPolicy");

// These values are provided to help OEM's meet disk drive warranty requirements.
TCHAR c_szREGSTR_VAL_SPINDOWNMAX[]        = TEXT("DiskSpinDownMax");
TCHAR c_szREGSTR_VAL_SPINDOWNMIN[]        = TEXT("DiskSpinDownMin");

// These values are provided to support administrator power policies.
TCHAR c_szREGSTR_VAL_ADMINMAXVIDEOTIMEOUT[]       = TEXT("AdminMaxVideoTimeout");
TCHAR c_szREGSTR_VAL_ADMINMAXSLEEP[]              = TEXT("AdminMaxSleep");

// This value manages the policy ID's.
TCHAR c_szREGSTR_VAL_LASTID[] = TEXT("LastID");

// This value turns on debug logging of PPM Validation Changes
#ifdef DEBUG
TCHAR c_szREGSTR_VAL_SHOWVALCHANGES[] = TEXT("ShowValidationChanges");
TCHAR c_szREGSTR_VAL_SHOWCAPABILITIES[] = TEXT("ShowCapabilities");
TCHAR c_szREGSTR_VAL_SHOWSETPPM[] = TEXT("ShowSetPPM");
#endif


/*******************************************************************************
*
*               P U B L I C   E N T R Y   P O I N T S
*
*******************************************************************************/


/*******************************************************************************
*
*  DllInitialize
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN DllInitialize(IN PVOID hmod, IN ULONG ulReason, IN PCONTEXT pctx OPTIONAL)
{

    UNREFERENCED_PARAMETER(pctx);

    switch (ulReason) {

        case DLL_PROCESS_ATTACH:
        {
            DisableThreadLibraryCalls(hmod);
            g_hInstance = hmod;

#ifdef DEBUG
            // Get the debug optional settings from HKCU.
            ReadOptionalDebugSettings();
#endif

#ifdef WINNT
            // Initialize an administrator power policy.
            InitAdmin(&g_app);
#endif
            // One time registry related initialization.
            if (!RegistryInit(&g_uiLastID)) {
                return FALSE;
            }
            break;
        }
        case DLL_PROCESS_DETACH:
            CloseHandle(g_hSemRegistry);
            g_hSemRegistry = NULL;
            break;
    }
    return TRUE;
}

/*******************************************************************************
*
*  IsAdminOverrideActive
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN IsAdminOverrideActive(PADMINISTRATOR_POWER_POLICY papp)
{
#ifdef WINNT
    if ((g_bAdminOverrideActive) && (papp)) {
        memcpy(papp, &g_app, sizeof(g_app));
    }
    return g_bAdminOverrideActive;
#else
    return FALSE;
#endif
}

/*******************************************************************************
*
*  IsPwrSuspendAllowed
*
*  DESCRIPTION:
*   Called by Explorer to determine whether suspend is supported.
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN IsPwrSuspendAllowed(VOID)
{
    SYSTEM_POWER_CAPABILITIES   spc;

    if (GetPwrCapabilities(&spc)) {
        if (spc.SystemS1 || spc.SystemS2 || spc.SystemS3) {
            return TRUE;
        }
    }
    return FALSE;
}

/*******************************************************************************
*
*  IsPwrHibernateAllowed
*
*  DESCRIPTION:
*   Called by Explorer to determine whether hibernate is supported.
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN IsPwrHibernateAllowed(VOID)
{
    SYSTEM_POWER_CAPABILITIES   spc;

    if (GetPwrCapabilities(&spc)) {
        if (spc.SystemS4 && spc.HiberFilePresent) {
            return TRUE;
        }
    }
    return FALSE;
}

/*******************************************************************************
*
*  IsPwrShutdownAllowed
*
*  DESCRIPTION:
*   Called by Explorer to determine whether shutdown is supported.
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN IsPwrShutdownAllowed(VOID)
{
    SYSTEM_POWER_CAPABILITIES   spc;

    if (GetPwrCapabilities(&spc)) {
        if (spc.SystemS5) {
            return TRUE;
        }
    }
    return FALSE;
}

/*******************************************************************************
*
*  CanUserWritePwrScheme
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN CanUserWritePwrScheme(VOID)
{
    DWORD   dwSize;
    TCHAR   szNum[NUM_DEC_DIGITS];
    LONG    lErr;

    // Read in the last ID this value must be present.
    dwSize = sizeof(szNum);

    // ReadWritePowerValue will set last error
    if (ReadWritePowerValue(HKEY_LOCAL_MACHINE,
                            c_szREGSTR_PATH_MACHINE_POWERCFG,
                            c_szREGSTR_VAL_LASTID,
                            szNum, &dwSize, FALSE, TRUE))
    {
        // Write the value back out, this may fail if user doesn't have write access.
        if (ReadWritePowerValue(HKEY_LOCAL_MACHINE,
                                c_szREGSTR_PATH_MACHINE_POWERCFG,
                                c_szREGSTR_VAL_LASTID,
                                szNum, &dwSize, TRUE, TRUE))
        {
            return TRUE;
        }
        else
        {
            lErr = GetLastError();
            if (lErr != ERROR_ACCESS_DENIED)
            {
                DebugPrint( "CanUserWritePwrScheme, Unable to write last ID, Error: %d", lErr);
            }
        }
    }
    else
    {
        lErr = GetLastError();
        DebugPrint( "CanUserWritePwrScheme, Unable to fetch last ID, Error: %d", lErr);
    }

    return FALSE;
}

/*******************************************************************************
*
*  GetPwrDiskSpindownRange
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN GetPwrDiskSpindownRange(PUINT puiMax, PUINT puiMin)
{
    if (!puiMax || !puiMin) {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }

    if (ReadPowerIntOptional(HKEY_LOCAL_MACHINE,
                             c_szREGSTR_PATH_MACHINE_POWERCFG,
                             c_szREGSTR_VAL_SPINDOWNMAX,
                             puiMax) &&
        ReadPowerIntOptional(HKEY_LOCAL_MACHINE,
                             c_szREGSTR_PATH_MACHINE_POWERCFG,
                             c_szREGSTR_VAL_SPINDOWNMIN,
                             puiMin)) {
            return TRUE;
    }
    return FALSE;
}

/*******************************************************************************
*
*  EnumPwrSchemes
*
*  DESCRIPTION:
*   Calls back the PWRSCHEMESENUMPROC with the ID, a pointer to the name,
*   the size in bytes of the name, a pointer to the description, the size in
*   bytes of the description, a pointer to the power policies and a user
*   defined value. Returns ERROR_SUCCESS on success, else error code. Callback
*   data is not allocated and is only valid during the scope of the callback.
*
*   Note: No calls to any other API's in this library should be made during
*   the call back to PWRSCHEMESENUMPROC. The registry semaphore is held at
*   this time and a deadlock will result.
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN EnumPwrSchemes(
    PWRSCHEMESENUMPROC  lpfn,
    LPARAM              lParam
)
{
    HKEY            hKeyPolicyUser, hKeyPolicyMachine;
    HKEY            hKeyUser    = INVALID_HANDLE_VALUE;
    HKEY            hKeyMachine = INVALID_HANDLE_VALUE;
    DWORD           dwDescSize;
    DWORD           dwSize, dwNameSize, dwIndex = 0;
    BOOLEAN         bOneCallBackOk = FALSE;
    LONG            lRet = ERROR_SUCCESS;
    LPTSTR          lpszDescBuf, lpszDesc;
    TCHAR           szNameBuf[MAX_NAME_LEN+1];
    FILETIME        ft;
    UINT            uiID;

    MACHINE_POWER_POLICY    mpp;
    USER_POWER_POLICY       upp;
    POWER_POLICY            pp;

    if (!lpfn) {
        SetLastError(ERROR_INVALID_PARAMETER);
        goto WESPSP_exit;
    }

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

    // Allocate a description buffer.
    lpszDescBuf = LocalAlloc(0, (MAX_DESC_LEN + 1) * sizeof(TCHAR));
    if (!lpszDescBuf) {
        goto WESPSP_exit;
    }

    if (ERROR_SUCCESS != OpenMachineUserKeys2(c_szREGSTR_PATH_USER_POWERCFG_POLICIES,
                             c_szREGSTR_PATH_MACHINE_POWERCFG_POLICIES,
                             &hKeyUser, &hKeyMachine))
    {
        ReleaseSemaphore(g_hSemRegistry, 1, NULL);
        return FALSE;
    }

    // Enumerate the schemes
    while (lRet == ERROR_SUCCESS) {
        dwSize = REGSTR_MAX_VALUE_LENGTH - 1;
        if ((lRet = RegEnumKeyEx(hKeyUser,
                                 dwIndex,
                                 g_szRegValue,
                                 &dwSize,
                                 NULL,
                                 NULL,
                                 NULL,
                                 &ft)) == ERROR_SUCCESS) {

            // Open the Policies Key. The key name is the policies ID.
            lpszDesc = NULL;
            if (MyStrToInt(g_szRegValue, &uiID)) {
                if ((lRet = RegOpenKeyEx(hKeyUser,
                                         g_szRegValue,
                                         0,
                                         KEY_READ,
                                         &hKeyPolicyUser)) == ERROR_SUCCESS) {

                    if ((lRet = RegOpenKeyEx(hKeyMachine,
                                             g_szRegValue,
                                             0,
                                             KEY_READ,
                                             &hKeyPolicyMachine)) == ERROR_SUCCESS) {

                        // Get the friendly name..
                        dwNameSize = MAX_NAME_SIZE;
                        if ((lRet = RegQueryValueEx(hKeyPolicyUser,
                                                    TEXT("Name"),
                                                    NULL,
                                                    NULL,
                                                    (PBYTE) szNameBuf,
                                                    &dwNameSize)) == ERROR_SUCCESS) {

                            // Descriptions are optional.
                            dwDescSize = MAX_DESC_SIZE;
                            if ((lRet = RegQueryValueEx(hKeyPolicyUser,
                                                        TEXT("Description"),
                                                        NULL,
                                                        NULL,
                                                        (PBYTE) lpszDescBuf,
                                                        &dwDescSize)) == ERROR_SUCCESS) {
                                lpszDesc = lpszDescBuf;
                            }

                            // Read the user and machine policies.
                            dwSize = sizeof(upp);
                            if ((lRet = RegQueryValueEx(hKeyPolicyUser,
                                                        TEXT("Policies"),
                                                        NULL,
                                                        NULL,
                                                        (PBYTE) &upp,
                                                        &dwSize)) == ERROR_SUCCESS) {

                                dwSize = sizeof(mpp);
                                if ((lRet = RegQueryValueEx(hKeyPolicyMachine,
                                                            TEXT("Policies"),
                                                            NULL,
                                                            NULL,
                                                            (PBYTE) &mpp,
                                                            &dwSize)) == ERROR_SUCCESS) {


                                    // Merge the user and machine policies.
                                    if (MergePolicies(&upp, &mpp, &pp)) {

                                        // Call the enumerate proc.
                                        if (!lpfn(uiID,
                                                  dwNameSize, szNameBuf,
                                                  dwDescSize, lpszDesc,
                                                  &pp, lParam)) {
                                            RegCloseKey(hKeyPolicyMachine);
                                            RegCloseKey(hKeyPolicyUser);
                                            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
                                            break;
                                        }
                                        else {
                                            bOneCallBackOk = TRUE;
                                        }
                                    }
                                }
                            }
                        }
                        RegCloseKey(hKeyPolicyMachine);
                    }
                    RegCloseKey(hKeyPolicyUser);
                }
            }
        }
        dwIndex++;
    }

    RegCloseKey(hKeyUser);
    RegCloseKey(hKeyMachine);
    ReleaseSemaphore(g_hSemRegistry, 1, NULL);
    if (lpszDescBuf) {
        LocalFree(lpszDescBuf);
    }

WESPSP_exit:
    if (lRet != ERROR_NO_MORE_ITEMS) {
        DebugPrint( "EnumPwrSchemes, failed, LastError: 0x%08X",
                 (lRet == ERROR_SUCCESS) ? GetLastError():lRet);
    }
    return bOneCallBackOk;
}

/*******************************************************************************
*
*  ReadGlobalPwrPolicy
*
*  DESCRIPTION:
*   Function reads the users global power policy profile and returns it.
*   If there is no such profile FALSE is returned. A global power policy
*   profile is per user, and contains values which apply to all of a users
*   power policies.
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN ReadGlobalPwrPolicy(
    PGLOBAL_POWER_POLICY  pgpp
)
{
    GLOBAL_MACHINE_POWER_POLICY gmpp;
    GLOBAL_USER_POWER_POLICY    gupp;
    DWORD dwError = ReadPwrPolicyEx2(c_szREGSTR_PATH_USER_POWERCFG, c_szREGSTR_PATH_MACHINE_POWERCFG, c_szREGSTR_VAL_GLOBALPOWERPOLICY,
                        NULL, NULL, &gupp, sizeof(gupp), &gmpp, sizeof(gmpp));

    if (ERROR_SUCCESS == dwError)
    {
        return MergeGlobalPolicies(&gupp, &gmpp, pgpp); // Sets Last Error
    }
    else
    {
        SetLastError(dwError);
    }

    return FALSE;
}

/*******************************************************************************
*
*  WritePwrScheme
*
*  DESCRIPTION:
*   Function to write a users power policy profile.  If the profile already
*   exists it is replaced.  Otherwise a new profile is created.
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN WritePwrScheme(
    PUINT           puiID,
    LPTSTR          lpszSchemeName,
    LPTSTR          lpszDescription,
    PPOWER_POLICY   lpScheme
)
{
    MACHINE_POWER_POLICY    mpp;
    USER_POWER_POLICY       upp;

    if (SplitPolicies(lpScheme, &upp, &mpp))
    {
        // WritePwrPolicyEx will set the last error on failure.
        return WritePwrPolicyEx(c_szREGSTR_PATH_USER_POWERCFG_POLICIES,
                                c_szREGSTR_PATH_MACHINE_POWERCFG_POLICIES,
                                puiID,
                                lpszSchemeName,
                                lpszDescription,
                                &upp,
                                sizeof(upp),
                                &mpp,
                                sizeof(mpp));
    }
    return FALSE;
}

/*******************************************************************************
*
*  WriteGlobalPwrPolicy
*
*  DESCRIPTION:
*   Function to write a users global power policy profile.  If the profile
*   already exists it is replaced.  Otherwise a new profile is created.
*   A global power policy profile is per user, and contains values which
*   apply to all of a users power policies. Otherwise a new profile is created.
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN WriteGlobalPwrPolicy (
    PGLOBAL_POWER_POLICY   pgpp
)
{
    GLOBAL_MACHINE_POWER_POLICY gmpp;
    GLOBAL_USER_POWER_POLICY    gupp;

    if (SplitGlobalPolicies(pgpp, &gupp, &gmpp))     // Will set last error
    {
        // WritePwrPolicyEx will set the last error on failure.
        return WritePwrPolicyEx(c_szREGSTR_PATH_USER_POWERCFG,
                                c_szREGSTR_PATH_MACHINE_POWERCFG,
                                NULL,
                                c_szREGSTR_VAL_GLOBALPOWERPOLICY,
                                NULL,
                                &gupp,
                                sizeof(gupp),
                                &gmpp,
                                sizeof(gmpp));
    }
    return FALSE;
}

/*******************************************************************************
*
*  DeletePwrScheme
*
*  DESCRIPTION:
*   Function to delete a users power policy profile. An attempt to delete the
*   currently active power policy profile will fail with last error set to
*   ERROR_ACCESS_DENIED.
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN DeletePwrScheme(UINT uiID)
{
    HKEY    hKeyUser;
    DWORD   dwSize = REGSTR_MAX_VALUE_LENGTH * sizeof(TCHAR);
    BOOLEAN bRet = FALSE;
    LONG    lRet = ERROR_SUCCESS;
    TCHAR   szNum[NUM_DEC_DIGITS];
    int     iCurrent;
    HKEY     hKeyCurrentUser;

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

    if (ERROR_SUCCESS == OpenCurrentUser2(&hKeyCurrentUser))
    {
        // Don't allow the currently active power policy profile to be deleted.
        // ReadWritePowerValue will set last error
        if (ReadWritePowerValue(hKeyCurrentUser,
                                c_szREGSTR_PATH_USER_POWERCFG,
                                c_szREGSTR_VAL_CURRENTPOWERPOLICY,
                                g_szRegValue, &dwSize, FALSE, FALSE) &&
            MyStrToInt(g_szRegValue, &iCurrent))
        {
            if (uiID != (UINT) iCurrent)
            {
                // For now we only delete the user portion of a policy. We may
                // want a ref count on the machine portion which allows deletion
                // of the machine portion when no user portion references it.
                lRet = RegOpenKey(hKeyCurrentUser, c_szREGSTR_PATH_USER_POWERCFG_POLICIES, &hKeyUser);
                if (lRet == ERROR_SUCCESS)
                {
                    wsprintf(szNum, TEXT("%d"), uiID);

                    lRet = RegDeleteKey(hKeyUser, szNum);
                    if (lRet == ERROR_SUCCESS)
                    {
                       bRet = TRUE;
                    }
                    RegCloseKey(hKeyUser);
                }
            }
            else
            {
                SetLastError(ERROR_ACCESS_DENIED);
            }
        }
        CloseCurrentUser(hKeyCurrentUser);
    }

    ReleaseSemaphore(g_hSemRegistry, 1, NULL);
    if (!bRet)
    {
        DebugPrint( "DeletePwrScheme, failed, LastError: 0x%08X", (lRet == ERROR_SUCCESS) ? GetLastError():lRet);
    }
    return bRet;
}

/*******************************************************************************
*
*  GetActivePwrScheme
*
*  DESCRIPTION:
*   Retrieves the ID of the currently active power policy profile. This value
*   is set by SetActivePwrScheme.
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN
GetActivePwrScheme(PUINT puiID)
{
    BOOLEAN bRet = FALSE;
    TCHAR   szNum[NUM_DEC_DIGITS];
    DWORD   dwSize = SIZE_DEC_DIGITS;
    HKEY    hKey;

    if (ERROR_SUCCESS == OpenCurrentUser2(&hKey))
    {
        // ReadWritePowerValue will set last error
        if (ReadWritePowerValue(hKey,
                                c_szREGSTR_PATH_USER_POWERCFG,
                                c_szREGSTR_VAL_CURRENTPOWERPOLICY,
                                szNum, &dwSize, FALSE, TRUE) &&
            MyStrToInt(szNum, puiID))
        {
            bRet = TRUE;
        }
        CloseCurrentUser(hKey);
    }
    return bRet;
}

/*******************************************************************************
*
*  SetActivePwrScheme
*
*  DESCRIPTION:
*   Set the currently active power policy profile.
*
*  PARAMETERS:
*   uiID           - ID of the new active power scheme.
*   lpGlobalPolicy - Optional global policies to merge with active power scheme.
*   lpPowerPolicy  - Optional power policies to merge with active power scheme.
*
*******************************************************************************/

BOOLEAN
SetActivePwrScheme(
    UINT                    uiID,
    PGLOBAL_POWER_POLICY    pgpp,
    PPOWER_POLICY           ppp
)
{
    DWORD                       dwSize;
    NTSTATUS                    ntsRetVal, status;
    TCHAR                       szNum[NUM_DEC_DIGITS];
    POWER_POLICY                pp;
    GLOBAL_POWER_POLICY         gpp;
    MACHINE_POWER_POLICY        mpp;
    USER_POWER_POLICY           upp;
    GLOBAL_MACHINE_POWER_POLICY gmpp;
    GLOBAL_USER_POWER_POLICY    gupp;
    SYSTEM_POWER_POLICY         sppAc, sppDc;
    MACHINE_PROCESSOR_POWER_POLICY mppp;


    HKEY     hKeyCurrentUser;
    DWORD dwError;
    BOOLEAN  bRet = FALSE;

    // If a new scheme is not passed, fetch the target scheme.
    if (!ppp)
    {
        if (!ReadPwrScheme(uiID, &pp))  //  Will SetLastError
        {
            return FALSE;
        }
        ppp = &pp;
    }

    // If a new global policy is not passed, fetch the target global policy.
    if (!pgpp)
    {
        if (!ReadGlobalPwrPolicy(&gpp)) // Sets last error
        {
            return FALSE;
        }
        pgpp = &gpp;
    }

    if (!ReadProcessorPwrScheme(uiID, &mppp)) {
        return FALSE;
    }

    // Merge global policy and user scheme if a global policy was passed.
    if (!MergeToSystemPowerPolicies(pgpp, ppp, &sppAc, &sppDc))     // Sets last error
    {
        return FALSE;
    }

    // Write out what was requested to the registry.
    SplitPolicies(ppp, &upp, &mpp);     // Will set last error

    if (!WritePwrPolicyEx(c_szREGSTR_PATH_USER_POWERCFG_POLICIES, c_szREGSTR_PATH_MACHINE_POWERCFG_POLICIES,
                          &uiID, NULL, NULL, &upp, sizeof(upp), &mpp, sizeof(mpp)))
    {
        // WritePwrPolicyEx will set the last error on failure.
        return FALSE;
    }

    SplitGlobalPolicies(pgpp, &gupp, &gmpp);     // Will set last error
    if (!WritePwrPolicyEx(c_szREGSTR_PATH_USER_POWERCFG,
                          c_szREGSTR_PATH_MACHINE_POWERCFG,
                          NULL,
                          c_szREGSTR_VAL_GLOBALPOWERPOLICY,
                          NULL,
                          &gupp,
                          sizeof(gupp),
                          &gmpp,
                          sizeof(gmpp)))
    {
        // WritePwrPolicyEx will set the last error on failure.
        return FALSE;
    }

    // Call down to the power policy manager to set the scheme.
    // I'm working under the assumption that CallNtSetValidateAcDc will call SetLastError() with any
    // error values.
    status = CallNtSetValidateAcDc(FALSE, FALSE, &(mppp.ProcessorPolicyAc), &(mppp.ProcessorPolicyAc), &(mppp.ProcessorPolicyDc), &(mppp.ProcessorPolicyDc));
    ntsRetVal = CallNtSetValidateAcDc(FALSE, TRUE, &sppAc, &sppAc, &sppDc, &sppDc);
    //if ((ntsRetVal == STATUS_SUCCESS) && (status = STATUS_SUCCESS))
    if ((ntsRetVal == STATUS_SUCCESS))
    {
        dwError = OpenCurrentUser2(&hKeyCurrentUser);
        if (ERROR_SUCCESS == dwError)
        {
            // On success, set the current active power scheme in the registry.
            wsprintf(szNum, TEXT("%d"), uiID);

            // ReadWritePowerValue will set last error
            bRet =  ReadWritePowerValue(hKeyCurrentUser,
                                       c_szREGSTR_PATH_USER_POWERCFG,
                                       c_szREGSTR_VAL_CURRENTPOWERPOLICY,
                                       szNum, NULL, TRUE, TRUE);

            dwError = GetLastError();
            CloseCurrentUser(hKeyCurrentUser);
            SetLastError(dwError);
        }
        else
        {
            SetLastError(dwError);
        }
    }

    return bRet;
}

/*******************************************************************************
*
*  LoadCurrentPwrScheme
*
*  DESCRIPTION:
*   A Memphis only cover to call SetActivePwrScheme using RunDLL32 calling
*   convention. Do not change parameter list.
*
*  PARAMETERS:
*
*******************************************************************************/

void WINAPI LoadCurrentPwrScheme(
    HWND hwnd,
    HINSTANCE hAppInstance,
    LPSTR lpszCmdLine,
    int nCmdShow)
{
    UINT uiID;

    if (GetActivePwrScheme(&uiID)) {
        SetActivePwrScheme(uiID, NULL, NULL);
    }
}

/*******************************************************************************
*
*  MergeLegacyPwrScheme
*
*  DESCRIPTION:
*   A Memphis only call to merge legacy power management registry info into the
*   currently active power scheme.
*   Called using the RunDLL32 calling convention. Do not change parameter list.
*
*  PARAMETERS:
*
*******************************************************************************/

void WINAPI MergeLegacyPwrScheme(
    HWND hwnd,
    HINSTANCE hAppInstance,
    LPSTR lpszCmdLine,
    int nCmdShow)
{
    DWORD                       dwSize, dwLegacy;
    POWER_POLICY                pp;
    GLOBAL_POWER_POLICY         gpp;
    UINT                        uiID;
    HKEY                        hKeyCurrentUser;

    // Get the active power scheme from the registry.
    if (!GetActivePwrScheme(&uiID)) 
    {
        return;
    }
    if (!ReadPwrScheme(uiID, &pp))
    {
        return;
    }
    if (!ReadGlobalPwrPolicy(&gpp))
    {
        return;
    }

    if (ERROR_SUCCESS == OpenCurrentUser2(&hKeyCurrentUser))
    {
        // Get the legacy video monitor power down information.
        if (ReadPowerIntOptional(hKeyCurrentUser,
                                 REGSTR_PATH_SCREENSAVE,
                                 REGSTR_VALUE_POWEROFFACTIVE,
                                 &pp.user.VideoTimeoutAc))
        {
            DebugPrint( "MergeLegacyPwrScheme, found legacy %s: %d", REGSTR_VALUE_POWEROFFACTIVE, pp.user.VideoTimeoutAc);
            pp.user.VideoTimeoutDc = pp.user.VideoTimeoutAc;
        }
        CloseCurrentUser(hKeyCurrentUser);
    }


    // Get the legacy disk spin down information.
    if (ReadPowerIntOptional(HKEY_LOCAL_MACHINE,
                             REGSTR_PATH_FILESYSTEM,
                             REGSTR_VAL_ACDRIVESPINDOWN,
                             &pp.user.SpindownTimeoutAc)) {
        DebugPrint( "MergeLegacyPwrScheme, found legacy %s: %d", REGSTR_VAL_ACDRIVESPINDOWN, pp.user.SpindownTimeoutAc);
    }

    if (ReadPowerIntOptional(HKEY_LOCAL_MACHINE,
                               REGSTR_PATH_FILESYSTEM,
                               REGSTR_VAL_BATDRIVESPINDOWN,
                               &pp.user.SpindownTimeoutDc)) {
        DebugPrint( "MergeLegacyPwrScheme, found legacy %s: %d", REGSTR_VAL_BATDRIVESPINDOWN, pp.user.SpindownTimeoutDc);
    }

    // Get the legacy battery meter information.
    dwSize = sizeof(dwLegacy);
    if (ReadPowerValueOptional(HKEY_LOCAL_MACHINE,
                               REGSTR_PATH_VPOWERD,
                               REGSTR_VAL_VPOWERDFLAGS,
                               (LPTSTR)&dwLegacy, &dwSize)) {
        if (dwLegacy & VPDF_SHOWMULTIBATT) {
            gpp.user.GlobalFlags |= EnableSysTrayBatteryMeter;
        }
        else {
            gpp.user.GlobalFlags &= ~EnableSysTrayBatteryMeter;
        }
        DebugPrint( "MergeLegacyPwrScheme, found legacy %s: %X", REGSTR_VAL_VPOWERDFLAGS, dwLegacy);
    }

    // Write out the modified active power scheme.
    if (!WriteGlobalPwrPolicy(&gpp)) {
        return;
    }

    WritePwrScheme(&uiID, NULL, NULL, &pp);
}

/*******************************************************************************
*
*  GetPwrCapabilities
*
*  DESCRIPTION:
*   Get the system power capabilities from the Power Policy Manager.
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN GetPwrCapabilities(PSYSTEM_POWER_CAPABILITIES lpspc)
{
    NTSTATUS ntsRetVal = STATUS_SUCCESS;

    if (!lpspc) {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }

    ntsRetVal = CallNtPowerInformation(SystemPowerCapabilities, NULL, 0, lpspc,
                                       sizeof(SYSTEM_POWER_CAPABILITIES));

    if (ntsRetVal == STATUS_SUCCESS) {
#ifdef DEBUG
        if (g_iShowCapabilities) {
            DumpSystemPowerCapabilities("GetPwrCapabilities, returned:", lpspc);
        }
#ifdef SIM_BATTERY
        lpspc->SystemBatteriesPresent = TRUE;
#endif
#endif
        return TRUE;
    }
    else {
        return FALSE;
    }
}

/*******************************************************************************
*
*  CallNtPowerInformation
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

NTSTATUS CallNtPowerInformation(
    POWER_INFORMATION_LEVEL InformationLevel,
    PVOID InputBuffer OPTIONAL,
    ULONG InputBufferLength,
    PVOID OutputBuffer OPTIONAL,
    ULONG OutputBufferLength
)
{
    NTSTATUS ntsRetVal;
    DWORD dwOldState, dwStatus;
    DWORD dwErrorSave;
    LPCTSTR PrivilegeName;

    if (InformationLevel == SystemReserveHiberFile) {
        PrivilegeName = SE_CREATE_PAGEFILE_NAME;
    } else {
        PrivilegeName = SE_SHUTDOWN_NAME;
    }

    SetLastError(0);
    dwStatus = SetPrivilegeAttribute(PrivilegeName, SE_PRIVILEGE_ENABLED,
                                     &dwOldState);
    dwErrorSave = GetLastError();

    ntsRetVal = NtPowerInformation(InformationLevel,
                                        InputBuffer, InputBufferLength,
                                        OutputBuffer, OutputBufferLength);

    //
    // If we were able to set the privilege, then reset it.
    //
    if (NT_SUCCESS(dwStatus) && dwErrorSave == 0) {
        SetPrivilegeAttribute(PrivilegeName, dwOldState, NULL);
    }
    else {
        DebugPrint( "CallNtPowerInformation, SetPrivilegeAttribute failed: 0x%08X", GetLastError());
    }

#ifdef DEBUG
    if ((ntsRetVal != STATUS_SUCCESS) && (InformationLevel <= ProcessorPowerPolicyCurrent)) {
        DebugPrint( "NtPowerInformation, %s, failed: 0x%08X", lpszInfoLevel[InformationLevel], ntsRetVal);
    }
    else {
        if (g_iShowSetPPM && InputBuffer) {
            if ((InformationLevel == SystemPowerPolicyAc) ||
                (InformationLevel == SystemPowerPolicyDc)) {
                DumpSystemPowerPolicy("NtPowerInformation, Set to PPM, InputBuffer", InputBuffer);
            }
        }
    }
#endif

    return ntsRetVal;
}

/*******************************************************************************
*
*  SetSuspendState
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN SetSuspendState(
    BOOLEAN bHibernate,
    BOOLEAN bForce,
    BOOLEAN bWakeupEventsDisabled)
{
    NTSTATUS ntsRetVal;
    POWER_ACTION pa;
    ULONG Flags;
    DWORD dwOldState, dwStatus;
    DWORD dwErrorSave;

    SetLastError(0);
    dwStatus = SetPrivilegeAttribute(SE_SHUTDOWN_NAME, SE_PRIVILEGE_ENABLED,
                                     &dwOldState);
    dwErrorSave = GetLastError();

    if (bHibernate) {
        pa = PowerActionHibernate;
    }
    else {
        pa = PowerActionSleep;
    }

    Flags = POWER_ACTION_QUERY_ALLOWED | POWER_ACTION_UI_ALLOWED;

    if (bForce) {
        Flags |= POWER_ACTION_CRITICAL;
    }

    if (bWakeupEventsDisabled) {
        Flags |= POWER_ACTION_DISABLE_WAKES;
    }

    ntsRetVal = NtInitiatePowerAction(pa, PowerSystemSleeping1, Flags, FALSE);

    //
    // If we were able to set the privilege, then reset it.
    //
    if (NT_SUCCESS(dwStatus) && dwErrorSave == 0) {
        SetPrivilegeAttribute(SE_SHUTDOWN_NAME, dwOldState, NULL);
    }
    else {
        DebugPrint( "SetSuspendState, SetPrivilegeAttribute failed: 0x%08X", GetLastError());
    }

    if (ntsRetVal == STATUS_SUCCESS) {
        return TRUE;
    }
    else {
        DebugPrint( "NtInitiatePowerAction, failed: 0x%08X", ntsRetVal);
        return FALSE;
    }
}

/*******************************************************************************
*
*                 P R I V A T E   F U N C T I O N S
*
*******************************************************************************/

/*******************************************************************************
*
*  ValidatePowerPolicies
*
*  DESCRIPTION:
*   Call down to the power policy manager to validate power policies.
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN ValidatePowerPolicies(
    PGLOBAL_POWER_POLICY    pgpp,
    PPOWER_POLICY           ppp
)
{
    POWER_POLICY        ppValid;
    GLOBAL_POWER_POLICY gppValid;
    SYSTEM_POWER_POLICY sppAc, sppDc;

    // Get current power policy data from the PPM.
    if (!GetCurrentPowerPolicies(&gppValid, &ppValid)) {
        return FALSE;
    }

    if (!pgpp) {
        pgpp = &gppValid;
    }

    if (!ppp) {
        ppp = &ppValid;
    }

    // Merge policy and global policy data.
    if (!MergeToSystemPowerPolicies(pgpp, ppp, &sppAc, &sppDc)) {
        return FALSE;
    }

    if (!ValidateSystemPolicies(&sppAc, &sppDc)) {
        return FALSE;
    }

    return SplitFromSystemPowerPolicies(&sppAc, &sppDc, pgpp, ppp);
}

/*******************************************************************************
*
*  ValidateSystemPolicies
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN ValidateSystemPolicies(
    PSYSTEM_POWER_POLICY psppAc,
    PSYSTEM_POWER_POLICY psppDc
)
{
    DWORD               dwLastErr;
    NTSTATUS            ntsRetVal;

    // Call down to the power policy manager to validate the scheme.
    ntsRetVal = CallNtSetValidateAcDc(TRUE, TRUE, psppAc, psppAc, psppDc, psppDc);

    // Map any PPM errors to winerror.h values
    switch (ntsRetVal) {
        case STATUS_SUCCESS:
            return TRUE;

        case STATUS_PRIVILEGE_NOT_HELD:
            dwLastErr = ERROR_ACCESS_DENIED;
            break;

        case STATUS_INVALID_PARAMETER:
            dwLastErr = ERROR_INVALID_DATA;
            break;

        default:
            dwLastErr = ERROR_GEN_FAILURE;
            break;
    }
    SetLastError(dwLastErr);
    return FALSE;
}


/*******************************************************************************
*
*  GetCurrentPowerPolicies
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN GetCurrentPowerPolicies(PGLOBAL_POWER_POLICY pgpp, PPOWER_POLICY ppp)
{
    SYSTEM_POWER_POLICY sppAc, sppDc;

    if (!GetCurrentSystemPowerPolicies(&sppAc, &sppDc)) {
        return FALSE;
    }

    return SplitFromSystemPowerPolicies(&sppAc, &sppDc, pgpp, ppp);
}

/*******************************************************************************
*
*  GetCurrentSystemPowerPolicies
*
*  DESCRIPTION:
*   Call down to the power policy manager to get the current system power
*   policies.
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN GetCurrentSystemPowerPolicies(
    PSYSTEM_POWER_POLICY psppAc,
    PSYSTEM_POWER_POLICY psppDc
)
{
    NTSTATUS            ntsRetVal;

    // Call down to the power policy manager to get system power policies.
    ntsRetVal = CallNtSetValidateAcDc(FALSE, TRUE, NULL, psppAc, NULL, psppDc);

    if (ntsRetVal == STATUS_SUCCESS) {
        return TRUE;
    }
    else {
        return FALSE;
    }
}

#ifdef WINNT
/*******************************************************************************
*
*  SetPrivilegeAttribute
*
*  DESCRIPTION:
*   This routine sets the security attributes for a given privilege.
*
*  PARAMETERS:
*   PrivilegeName - Name of the privilege we are manipulating.
*   NewPrivilegeAttribute - The new attribute value to use.
*   OldPrivilegeAttribute - Pointer to receive the old privilege value.
*                           OPTIONAL.
*
*******************************************************************************/

DWORD SetPrivilegeAttribute(
    LPCTSTR PrivilegeName,
    DWORD   NewPrivilegeAttribute,
    DWORD   *OldPrivilegeAttribute
)
{
    LUID             PrivilegeValue;
    TOKEN_PRIVILEGES TokenPrivileges, OldTokenPrivileges;
    DWORD            ReturnLength;
    HANDLE           TokenHandle;

    // First, find out the LUID Value of the privilege

    if(!LookupPrivilegeValue(NULL, PrivilegeName, &PrivilegeValue)) {
        return GetLastError();
    }

    // Get the token handle
    if (!OpenThreadToken (GetCurrentThread(),
                          TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
                          FALSE, &TokenHandle)) {
        if (!OpenProcessToken (GetCurrentProcess(),
                               TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
                               &TokenHandle)) {
            return GetLastError();
        }
    }

    // Set up the privilege set we will need
    TokenPrivileges.PrivilegeCount = 1;
    TokenPrivileges.Privileges[0].Luid = PrivilegeValue;
    TokenPrivileges.Privileges[0].Attributes = NewPrivilegeAttribute;

    ReturnLength = sizeof(TOKEN_PRIVILEGES);
    if (!AdjustTokenPrivileges(TokenHandle, FALSE,
                               &TokenPrivileges, sizeof(TOKEN_PRIVILEGES),
                               &OldTokenPrivileges, &ReturnLength)) {
        CloseHandle(TokenHandle);
        return GetLastError();
    }
    else {
        if (OldPrivilegeAttribute != NULL) {

            //
            //  If the privilege changed, store the old value.  If it did
            //  not change, store the value passed in.
            //

            if( OldTokenPrivileges.PrivilegeCount != 0 ) {

                *OldPrivilegeAttribute = OldTokenPrivileges.Privileges[0].Attributes;

            } else {

                *OldPrivilegeAttribute = NewPrivilegeAttribute;
            }
        }
        CloseHandle(TokenHandle);
        return NO_ERROR;
    }
}
#endif


/*******************************************************************************
*
*  CallNtSetValidateAcDc
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

NTSTATUS CallNtSetValidateAcDc(
    BOOLEAN bValidate,
    BOOLEAN bSystem,
    PVOID InputBufferAc OPTIONAL,
    PVOID OutputBufferAc OPTIONAL,
    PVOID InputBufferDc OPTIONAL,
    PVOID OutputBufferDc OPTIONAL
)
{
    NTSTATUS                ntsRetVal;
    POWER_INFORMATION_LEVEL pil, pilAc, pilDc;
    ULONG                   policyLength;

#ifdef DEBUG
    SYSTEM_POWER_POLICY sppOrgAc, sppOrgDc;
#endif

#ifdef WINNT
    DWORD dwOldState, dwStatus;
    DWORD dwErrorSave;

    SetLastError(0);
    dwStatus = SetPrivilegeAttribute(SE_SHUTDOWN_NAME, SE_PRIVILEGE_ENABLED, &dwOldState);
    dwErrorSave = GetLastError();
#endif

    if (bSystem) {

        if (bValidate) {
            pil = pilAc = VerifySystemPolicyAc;
            pilDc = VerifySystemPolicyDc;
        } else {
            pil = pilAc = SystemPowerPolicyAc;
            pilDc = SystemPowerPolicyDc;
        }
    
        policyLength = sizeof(SYSTEM_POWER_POLICY);

    } else {
        if (bValidate) {
            pil = pilAc = VerifyProcessorPowerPolicyAc;
            pilDc = VerifyProcessorPowerPolicyDc;
        } else {
            pil = pilAc = ProcessorPowerPolicyAc;
            pilDc = ProcessorPowerPolicyDc;
        }
        
        policyLength = sizeof(PROCESSOR_POWER_POLICY);
    }
    
#ifdef DEBUG
    if (InputBufferAc)
    {
        memcpy(&sppOrgAc, InputBufferAc, policyLength);
    }
    if (InputBufferDc)
    {
        memcpy(&sppOrgDc, InputBufferDc, policyLength);
    }
#endif

    ntsRetVal = NtPowerInformation(pilAc,
                                   InputBufferAc,
                                   policyLength,
                                   OutputBufferAc,
                                   policyLength);

    if (ntsRetVal == STATUS_SUCCESS)
    {
        pil = pilDc;
        ntsRetVal = NtPowerInformation(pilDc,
                                       InputBufferDc,
                                       policyLength,
                                       OutputBufferDc,
                                       policyLength);
    }

#ifdef WINNT
    // If we were able to set the privilege, then reset it.
    if (NT_SUCCESS(dwStatus) && (dwErrorSave == ERROR_SUCCESS))
    {
        SetPrivilegeAttribute(SE_SHUTDOWN_NAME, dwOldState, NULL);

#ifdef DEBUG
        if (InputBufferAc && OutputBufferAc)
        {
            DifSystemPowerPolicies("PPM modified AC policies", &sppOrgAc, OutputBufferAc);
        }
        if (InputBufferDc && OutputBufferDc)
        {
            DifSystemPowerPolicies("PPM modified DC policies", &sppOrgDc, OutputBufferDc);
        }
#endif

    }
    else
    {
        DebugPrint( "SetSuspendState, SetPrivilegeAttribute failed: 0x%08X", GetLastError());
    }
#endif

#ifdef DEBUG
    if (ntsRetVal != STATUS_SUCCESS)
    {
        DebugPrint( "NtPowerInformation, %s, failed: 0x%08X", lpszInfoLevel[pil], ntsRetVal);
        switch (pil)
        {
            case SystemPowerPolicyAc:
            case VerifySystemPolicyAc:
                DumpSystemPowerPolicy("InputBufferAc", InputBufferAc);
                break;

            case SystemPowerPolicyDc:
            case VerifySystemPolicyDc:
                DumpSystemPowerPolicy("InputBufferDc", InputBufferDc);
                break;
        }
    }
    else
    {
        if (g_iShowSetPPM && InputBufferAc && InputBufferDc && !bValidate)
        {
            DumpSystemPowerPolicy("CallNtSetValidateAcDc, Set AC to PPM", InputBufferAc);
            DumpSystemPowerPolicy("CallNtSetValidateAcDc, Set DC to PPM", InputBufferDc);
        }
    }
#endif
    return ntsRetVal;
}

/*******************************************************************************
*
*  ReadPwrScheme
*
*  DESCRIPTION:
*   Function reads the specified user power policy profile and returns
*   it.  If there is no such profile FALSE is returned.
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN ReadPwrScheme(
    UINT            uiID,
    PPOWER_POLICY   ppp
)
{
    MACHINE_POWER_POLICY    mpp;
    USER_POWER_POLICY       upp;
    TCHAR                   szNum[NUM_DEC_DIGITS];
    DWORD dwError;

    wsprintf(szNum, TEXT("%d"), uiID);

    dwError = ReadPwrPolicyEx2(c_szREGSTR_PATH_USER_POWERCFG_POLICIES, c_szREGSTR_PATH_MACHINE_POWERCFG_POLICIES,
                  szNum, NULL, 0, &upp, sizeof(upp), &mpp, sizeof(mpp));

    if (ERROR_SUCCESS == dwError)
    {
        return MergePolicies(&upp, &mpp, ppp);
    }
    else
    {
        SetLastError(dwError);
    }

    return FALSE;
}

/*******************************************************************************
*
*  ReadProcessorPwrScheme
*
*  DESCRIPTION:
*   Function reads the specified processor power policy profile and returns
*   it.  If there is no such profile FALSE is returned.
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN
ReadProcessorPwrScheme(
    UINT                            uiID,
    PMACHINE_PROCESSOR_POWER_POLICY pmppp
    )
{
    TCHAR                   szNum[NUM_DEC_DIGITS];
    DWORD dwError;

    wsprintf(szNum, TEXT("%d"), uiID);

    dwError = ReadProcessorPwrPolicy(c_szREGSTR_PATH_MACHINE_PROCESSOR_POLICIES,
                                     szNum,
                                     pmppp,
                                     sizeof(MACHINE_PROCESSOR_POWER_POLICY));

    //
    // It's legal for there to be no Processor Power Scheme that corresponds with
    // uiID, as long as uiID is non-zero.  If this is the case, just use a 
    // default scheme.  (We use '1' as a default because this will be the 
    // default laptop scheme.  Non-laptops probably won't have power controls 
    // on the processor, so it won't matter if we get a scheme that is too aggressive.)
    //

    if ((ERROR_SUCCESS != dwError) &&
        (uiID != 0)) {

        wsprintf(szNum, TEXT("%d"), 1);

        dwError = ReadProcessorPwrPolicy(c_szREGSTR_PATH_MACHINE_PROCESSOR_POLICIES,
                                         szNum,
                                         pmppp,
                                         sizeof(MACHINE_PROCESSOR_POWER_POLICY));
    }
    
    if (ERROR_SUCCESS == dwError) {
        return TRUE;
    } else {
        SetLastError(dwError);
        return FALSE;
    }
}

/*******************************************************************************
*
*  WriteProcessorPwrScheme
*
*  DESCRIPTION:
*   Function writes the specified processor power policy profile
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN
WriteProcessorPwrScheme(
    UINT                            uiID,
    PMACHINE_PROCESSOR_POWER_POLICY pmppp
    )
{
    TCHAR                   szNum[NUM_DEC_DIGITS];
    DWORD dwError;

    wsprintf(szNum, TEXT("%d"), uiID);

    dwError = WriteProcessorPwrPolicy(c_szREGSTR_PATH_MACHINE_PROCESSOR_POLICIES,
                                     szNum,
                                     pmppp,
                                     sizeof(MACHINE_PROCESSOR_POWER_POLICY));
    
    if (ERROR_SUCCESS == dwError) {
        return TRUE;
    } else {
        SetLastError(dwError);
        return FALSE;
    }
}

/*******************************************************************************
*
*  MyStrToInt
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN MyStrToInt(LPCTSTR lpSrc, PINT pi)
{

#define ISDIGIT(c)  ((c) >= TEXT('0') && (c) <= TEXT('9'))

    int n = 0;
    BOOL bNeg = FALSE;

    if (*lpSrc == TEXT('-')) {
        bNeg = TRUE;
        lpSrc++;
    }

    if (!ISDIGIT(*lpSrc))  {
        DebugPrint( "MyStrToInt, non-integer string: %s", lpSrc);
        return FALSE;
    }

    while (ISDIGIT(*lpSrc)) {
        n *= 10;
        n += *lpSrc - TEXT('0');
        lpSrc++;
    }

    if (bNeg) {
        *pi = -n;
    }
    else {
        *pi = n;
    }
    return TRUE;
}

#ifndef WINNT
/*******************************************************************************
*
*  DM32IsPCMCIAPresent
*
*  DESCRIPTION:
*   Memphis only test for existence of PCMCIA slots. From Jason Cobb.
*
*  PARAMETERS:
*
*******************************************************************************/

DEFINE_GUID(GUID_DEVICEINTERFACE_PCMCIA,0x4d36e977L, 0xe325, 0x11ce, 0xbf, 0xc1, 0x08, 0x00, 0x2b, 0xe1, 0x03, 0x18);

BOOLEAN DM32IsPCMCIAPresent(VOID)
{
    HDEVINFO        hDevInfo;
    SP_DEVINFO_DATA DeviceInfoData;
    BOOLEAN         bRet = FALSE;

    hDevInfo = SetupDiGetClassDevs((LPGUID)&GUID_DEVICEINTERFACE_PCMCIA,
                                   NULL, NULL, 0);

    if (hDevInfo != INVALID_HANDLE_VALUE) {
        DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
        if (SetupDiEnumDeviceInfo(hDevInfo, 0, &DeviceInfoData)) {
            bRet = TRUE;
        }
        else {
            DebugPrint( "DM32IsPCMCIAPresent, SetupDiEnumDeviceInfo on PCMCIA failed");
        }
        SetupDiDestroyDeviceInfoList(hDevInfo);
    }
    else {
        DebugPrint( "DM32IsPCMCIAPresent, SetupDiGetClassDevs on PCMCIA failed");
    }
    return bRet;
}
#endif

/*******************************************************************************
*
*  RegistryInit
*
*  DESCRIPTION:
*   Do DLL load time registry related initialization.
*
*  PARAMETERS:
*
*******************************************************************************/

BOOLEAN RegistryInit(PUINT puiLastId)
{
    DWORD               dwSize;
    TCHAR               szNum[NUM_DEC_DIGITS];
    UINT                uiCurPwrScheme;

    // Read in the last ID this value must be present.
    dwSize = sizeof(szNum);

    // ReadWritePowerValue will set last error
    if (!ReadWritePowerValue(HKEY_LOCAL_MACHINE,
                             c_szREGSTR_PATH_MACHINE_POWERCFG,
                             c_szREGSTR_VAL_LASTID,
                             szNum, &dwSize, FALSE, TRUE) ||
        !MyStrToInt(szNum, &g_uiLastID)) {
        DebugPrint( "RegistryInit, Unable to fetch last ID, registry is corrupt");
        return FALSE;
    }

#ifndef WINNT
    // For Memphis only we check the HKCU current scheme entry. If it's not
    // valid a new entry is written. If the machine has a PCMCIA slot we set
    // Portable as the current scheme, otherwise it's Home/Office. Per RobMCK.

    if (!GetActivePwrScheme(&uiCurPwrScheme)) {
        DebugPrint( "RegistryInit, unable to validate currrent scheme");
        if (DM32IsPCMCIAPresent()) {
            uiCurPwrScheme = 1;
        }
        else {
            uiCurPwrScheme = 0;
        }
        wsprintf(szNum, TEXT("%d"), uiCurPwrScheme);
        DebugPrint( "RegistryInit, attempting to write new current ID: %s", szNum);

        // ReadWritePowerValue will set last error
        return ReadWritePowerValue(HKEY_CURRENT_USER,
                                   c_szREGSTR_PATH_USER_POWERCFG,
                                   c_szREGSTR_VAL_CURRENTPOWERPOLICY,
                                   szNum, NULL, TRUE, TRUE);
    }
#endif
    return TRUE;
}

#ifdef DEBUG
/*******************************************************************************
*
*  ReadOptionalDebugSettings
*
*  DESCRIPTION:
*   Debug only. Get the debug settings from HKCU registry entries into globals.
*
*  PARAMETERS:
*
*******************************************************************************/

VOID ReadOptionalDebugSettings(VOID)
{
    HKEY     hKeyCurrentUser;

    if (ERROR_SUCCESS == OpenCurrentUser2(&hKeyCurrentUser))
    {
        // Optional debug logging of PPM policy validation changes.
        ReadPowerIntOptional(hKeyCurrentUser,
                             c_szREGSTR_PATH_USER_POWERCFG,
                             c_szREGSTR_VAL_SHOWVALCHANGES,
                             &g_iShowValidationChanges);

        // Optional debug logging of PPM capabilities.
        ReadPowerIntOptional(hKeyCurrentUser,
                             c_szREGSTR_PATH_USER_POWERCFG,
                             c_szREGSTR_VAL_SHOWCAPABILITIES,
                             &g_iShowCapabilities);

        // Optional debug logging of setting new policy to PPM.
        ReadPowerIntOptional(hKeyCurrentUser,
                             c_szREGSTR_PATH_USER_POWERCFG,
                             c_szREGSTR_VAL_SHOWSETPPM,
                             &g_iShowSetPPM);

        CloseCurrentUser(hKeyCurrentUser);
    }
}
#endif

#ifdef WINNT
/*******************************************************************************
*
*  InitAdmin
*
*  DESCRIPTION:
*   For NT only, initialize an administrator power policy which
*   supports an optional administrative override of certain
*   power policy settings. The PowerCfg.Cpl and PPM will use these
*   override values during validation.
*
*  PARAMETERS:
*
*******************************************************************************/

VOID InitAdmin(PADMINISTRATOR_POWER_POLICY papp)
{
    INT         i;
    NTSTATUS    ntsRetVal;
    HKEY        hKeyCurrentUser;

    if (ERROR_SUCCESS == OpenCurrentUser2(&hKeyCurrentUser))
    {
        if (ReadPowerIntOptional(hKeyCurrentUser, c_szREGSTR_PATH_USER_POWERCFG, c_szREGSTR_VAL_ADMINMAXSLEEP, &i))
        {
            g_app.MaxSleep = (SYSTEM_POWER_STATE) i;
            g_bAdminOverrideActive = TRUE;
        }

        if (ReadPowerIntOptional(hKeyCurrentUser, c_szREGSTR_PATH_USER_POWERCFG, c_szREGSTR_VAL_ADMINMAXVIDEOTIMEOUT, &i))
        {
            g_app.MaxVideoTimeout = i;
            g_bAdminOverrideActive = TRUE;
        }

        CloseCurrentUser(hKeyCurrentUser);
    }

    // If an administration override was set, call down to the power
    // policy manager to set the administrator policy.
    if (g_bAdminOverrideActive)
    {
        ntsRetVal = CallNtPowerInformation(AdministratorPowerPolicy, &g_app, sizeof(ADMINISTRATOR_POWER_POLICY),
                                                &g_app, sizeof(ADMINISTRATOR_POWER_POLICY));
        if (ntsRetVal != STATUS_SUCCESS)
        {
            DebugPrint( "DllInitialize, Set AdministratorPowerPolicy failed: 0x%08X", ntsRetVal);
        }
    }
}
#endif