/******************************************************************************* * * (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 #include #include #include #include #include #include #include #include #include #include #include #include #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