ReactOS 0.4.15-dev-7942-gd23573b
powrprof.c
Go to the documentation of this file.
1/*
2 * Copyright (C) 2005 Benjamin Cutler
3 * Copyright (C) 2008 Dmitry Chapyshev
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19
20
21#include <stdarg.h>
22
23#define WIN32_NO_STATUS
24#include <windef.h>
25#include <winbase.h>
26#include <winreg.h>
27#define NTOS_MODE_USER
28#include <ndk/pofuncs.h>
29#include <ndk/rtlfuncs.h>
30#include <ndk/setypes.h>
31#include <powrprof.h>
32#include <wine/debug.h>
33#include <wine/unicode.h>
34
36
37
38static const WCHAR szPowerCfgSubKey[] =
39 L"Software\\Microsoft\\Windows\\CurrentVersion\\Controls Folder\\PowerCfg";
41 L"Control Panel\\PowerCfg";
43 L"CurrentPowerPolicy";
44static const WCHAR szPolicies[] = L"Policies";
45static const WCHAR szName[] = L"Name";
46static const WCHAR szDescription[] = L"Description";
47static const WCHAR szSemaphoreName[] = L"PowerProfileRegistrySemaphore";
48static const WCHAR szDiskMax[] = L"DiskSpindownMax";
49static const WCHAR szDiskMin[] = L"DiskSpindownMin";
50static const WCHAR szLastID[] = L"LastID";
51
53
55
57
60 PVOID lpInputBuffer,
61 ULONG nInputBufferSize,
62 PVOID lpOutputBuffer,
63 ULONG nOutputBufferSize)
64{
65 BOOLEAN old;
66
67 //Lohnegrim: In order to get the right results, we have to adjust our Privileges
70
71 return NtPowerInformation(InformationLevel,
72 lpInputBuffer,
73 nInputBufferSize,
74 lpOutputBuffer,
75 nOutputBufferSize);
76}
77
80{
81 HKEY hKey = NULL;
82 LONG Ret;
83
84 TRACE("()\n");
85
87 if (Ret != ERROR_SUCCESS)
88 {
89 TRACE("RegOpenKeyEx failed: %d\n", Ret);
90 SetLastError(Ret);
91 return FALSE;
92 }
93
95 return TRUE;
96}
97
100{
101 WCHAR Buf[MAX_PATH];
102 UINT Current;
103 LONG Err;
104
105 swprintf(Buf, L"Control Panel\\PowerCfg\\PowerPolicies\\%d", uiIndex);
106
107 if (!GetActivePwrScheme(&Current))
108 return FALSE;
109
110 if (Current == uiIndex)
111 {
113 return FALSE;
114 }
115
117 if (Err != ERROR_SUCCESS)
118 {
119 TRACE("RegDeleteKey failed: %d\n", Err);
120 SetLastError(Err);
121 return FALSE;
122 }
123
124 return TRUE;
125}
126
127static BOOLEAN
129 PUSER_POWER_POLICY puserPwrPolicy,
131 DWORD cchDesc, LPWSTR szDesc)
132{
133 HKEY hSubKey = NULL;
135 LONG Err;
137 BOOL bRet = FALSE;
138
139 swprintf(szPath, L"Control Panel\\PowerCfg\\PowerPolicies\\%s", szNum);
140
141 Err = RegOpenKeyExW(HKEY_CURRENT_USER, szPath, 0, KEY_READ, &hSubKey);
142 if (Err != ERROR_SUCCESS)
143 {
144 ERR("RegOpenKeyExW failed: %d\n", Err);
145 SetLastError(Err);
146 return FALSE;
147 }
148
149 dwSize = cchName * sizeof(WCHAR);
150 Err = RegQueryValueExW(hSubKey, L"Name", NULL, NULL, (LPBYTE)szName, &dwSize);
151 if (Err != ERROR_SUCCESS)
152 {
153 ERR("RegQueryValueExW failed: %d\n", Err);
154 SetLastError(Err);
155 goto cleanup;
156 }
157
158 dwSize = cchDesc * sizeof(WCHAR);
159 Err = RegQueryValueExW(hSubKey, L"Description", NULL, NULL, (LPBYTE)szDesc, &dwSize);
160 if (Err != ERROR_SUCCESS)
161 {
162 ERR("RegQueryValueExW failed: %d\n", Err);
163 SetLastError(Err);
164 goto cleanup;
165 }
166
167 dwSize = sizeof(USER_POWER_POLICY);
168 Err = RegQueryValueExW(hSubKey, L"Policies", NULL, NULL, (LPBYTE)puserPwrPolicy, &dwSize);
169 if (Err != ERROR_SUCCESS)
170 {
171 ERR("RegQueryValueExW failed: %d\n", Err);
172 SetLastError(Err);
173 goto cleanup;
174 }
175
176 bRet = TRUE;
177
178cleanup:
179 RegCloseKey(hSubKey);
180
181 return bRet;
182}
183
184static BOOLEAN
186{
187 HKEY hKey;
188 LONG Err;
191
192 swprintf(szPath, L"Software\\Microsoft\\Windows\\CurrentVersion\\Controls Folder\\PowerCfg\\PowerPolicies\\%s", szNum);
193
195 if (Err != ERROR_SUCCESS)
196 {
197 ERR("RegOpenKeyExW failed: %d\n", Err);
198 SetLastError(Err);
199 return FALSE;
200 }
201
203 Err = RegQueryValueExW(hKey, L"Policies", NULL, NULL, (LPBYTE)pmachinePwrPolicy, &dwSize);
204
205 if (Err != ERROR_SUCCESS)
206 {
207 ERR("RegQueryValueExW failed: %d\n", Err);
208 SetLastError(Err);
210 return FALSE;
211 }
212
214
215 return TRUE;
216}
217
219EnumPwrSchemes(PWRSCHEMESENUMPROC lpfnPwrSchemesEnumProc,
221{
222 HKEY hKey;
223 LONG Err;
224 DWORD dwSize, dwNameSize = MAX_PATH, dwDescSize = MAX_PATH, dwIndex = 0;
225 WCHAR szNum[3 + 1], szName[MAX_PATH], szDesc[MAX_PATH];
226 POWER_POLICY PwrPolicy;
227 USER_POWER_POLICY userPwrPolicy;
228 MACHINE_POWER_POLICY machinePwrPolicy;
229 BOOLEAN bRet = FALSE;
230
231 if (!lpfnPwrSchemesEnumProc)
232 {
234 return FALSE;
235 }
236
237 Err = RegOpenKeyExW(HKEY_CURRENT_USER, L"Control Panel\\PowerCfg\\PowerPolicies", 0, KEY_READ, &hKey);
238 if (Err != ERROR_SUCCESS)
239 {
240 ERR("RegOpenKeyW failed: %d\n", Err);
241 SetLastError(Err);
242 return FALSE;
243 }
244
246
247 dwSize = sizeof(szNum) / sizeof(WCHAR);
248
249 while (RegEnumKeyExW(hKey, dwIndex, szNum, &dwSize, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
250 {
251 if (!POWRPROF_GetUserPowerPolicy(szNum, &userPwrPolicy,
252 dwNameSize, szName,
253 dwDescSize, szDesc))
254 {
255 WARN("POWRPROF_GetUserPowerPolicy failed\n");
256 goto cleanup;
257 }
258
259 if (!POWRPROF_GetMachinePowerPolicy(szNum, &machinePwrPolicy))
260 {
261 WARN("POWRPROF_GetMachinePowerPolicy failed\n");
262 goto cleanup;
263 }
264
265 memcpy(&PwrPolicy.user, &userPwrPolicy, sizeof(USER_POWER_POLICY));
266 memcpy(&PwrPolicy.mach, &machinePwrPolicy, sizeof(MACHINE_POWER_POLICY));
267
268 if (!lpfnPwrSchemesEnumProc(_wtoi(szNum), (wcslen(szName) + 1) * sizeof(WCHAR), szName, (wcslen(szDesc) + 1) * sizeof(WCHAR), szDesc, &PwrPolicy, lParam))
269 goto cleanup;
270 else
271 bRet = TRUE;
272
273 dwSize = sizeof(szNum) / sizeof(WCHAR);
274 dwIndex++;
275 }
276
277cleanup:
280
281 return bRet;
282}
283
286{
287 HKEY hKey;
288 WCHAR szBuf[MAX_PATH];
290 LONG Err;
291
292 TRACE("GetActivePwrScheme(%u)", puiID);
293
294 Err = RegOpenKeyExW(HKEY_CURRENT_USER, L"Control Panel\\PowerCfg", 0, KEY_READ, &hKey);
295 if (Err != ERROR_SUCCESS)
296 {
297 ERR("RegOpenKey failed: %d\n", Err);
298 SetLastError(Err);
299 return FALSE;
300 }
301
302 dwSize = sizeof(szBuf);
303 Err = RegQueryValueExW(hKey, L"CurrentPowerPolicy",
304 NULL, NULL,
305 (LPBYTE)&szBuf, &dwSize);
306 if (Err != ERROR_SUCCESS)
307 {
308 ERR("RegQueryValueEx failed: %d\n", Err);
310 SetLastError(Err);
311 return FALSE;
312 }
313
315 *puiID = _wtoi(szBuf);
316
317 return TRUE;
318}
319
322 PPOWER_POLICY pPowerPolicy)
323{
324 /*
325 SYSTEM_POWER_POLICY ACPower, DCPower;
326
327 FIXME("(%p, %p) stub!\n", pGlobalPowerPolicy, pPowerPolicy);
328
329 NtPowerInformation(SystemPowerPolicyAc, 0, 0, &ACPower, sizeof(SYSTEM_POWER_POLICY));
330 NtPowerInformation(SystemPowerPolicyDc, 0, 0, &DCPower, sizeof(SYSTEM_POWER_POLICY));
331
332 return FALSE;
333 */
334/*
335 Lohnegrim: I don't know why this Function should call NtPowerInformation, because as far as I know,
336 it simply returns the GlobalPowerPolicy and the AktivPowerScheme!
337 */
338 UINT uiID;
339
340 if (pGlobalPowerPolicy != NULL)
341 {
342 if (!ReadGlobalPwrPolicy(pGlobalPowerPolicy))
343 return FALSE;
344 }
345 if (pPowerPolicy != NULL)
346 {
347 if (!GetActivePwrScheme(&uiID))
348 return FALSE;
349
350 if (!ReadPwrScheme(uiID, pPowerPolicy))
351 return FALSE;
352 }
353
354 return TRUE;
355}
356
359{
361
362 TRACE("(%p)\n", lpSystemPowerCapabilities);
363
364 if (!lpSystemPowerCapabilities)
365 {
367 return FALSE;
368 }
369
370 Status = NtPowerInformation(SystemPowerCapabilities, 0, 0, lpSystemPowerCapabilities, sizeof(SYSTEM_POWER_CAPABILITIES));
371 if(!NT_SUCCESS(Status))
372 {
374 return FALSE;
375 }
376
377 return TRUE;
378}
379
382{
383 HKEY hKey;
384 BYTE lpValue[40];
385 LONG Ret;
386 DWORD cbValue = sizeof(lpValue);
387
388 TRACE("(%p, %p)\n", RangeMax, RangeMin);
389
390 if (RangeMax == NULL || RangeMin == NULL)
391 {
393 return FALSE;
394 }
395
397
399 if (Ret != ERROR_SUCCESS)
400 {
401 TRACE("RegOpenKeyEx failed: %d\n", Ret);
402 TRACE("Using defaults: 3600, 3\n");
403 *RangeMax = 3600;
404 *RangeMin = 3;
406 return TRUE;
407 }
408
409 Ret = RegQueryValueExW(hKey, szDiskMax, 0, 0, lpValue, &cbValue);
410 if (Ret != ERROR_SUCCESS)
411 {
412 TRACE("Couldn't open DiskSpinDownMax: %d\n", Ret);
413 TRACE("Using default: 3600\n");
414 *RangeMax = 3600;
415 }
416 else
417 {
418 *RangeMax = _wtoi((LPCWSTR)lpValue);
419 }
420
421 cbValue = sizeof(lpValue);
422
423 Ret = RegQueryValueExW(hKey, szDiskMin, 0, 0, lpValue, &cbValue);
424 if (Ret != ERROR_SUCCESS)
425 {
426 TRACE("Couldn't open DiskSpinDownMin: %d\n", Ret);
427 TRACE("Using default: 3\n");
428 *RangeMin = 3;
429 }
430 else
431 {
432 *RangeMin = _wtoi((LPCWSTR)lpValue);
433 }
434
436
438
439 return TRUE;
440}
441
444{
445 FIXME("( %p) stub!\n", p);
446 return FALSE;
447}
448
451{
454 BOOLEAN old;
455
457
458 Status = NtPowerInformation(SystemPowerCapabilities, NULL, 0, &PowerCaps, sizeof(PowerCaps));
459 if (!NT_SUCCESS(Status))
460 {
462 return FALSE;
463 }
464
465 return PowerCaps.SystemS4 && PowerCaps.HiberFilePresent; // IsHiberfilPresent();
466}
467
470{
473 BOOLEAN old;
474
476
477 Status = NtPowerInformation(SystemPowerCapabilities, NULL, 0, &PowerCaps, sizeof(PowerCaps));
478 if (!NT_SUCCESS(Status))
479 {
481 return FALSE;
482 }
483
484 return PowerCaps.SystemS5;
485}
486
489{
492 BOOLEAN old;
493
495
496 Status = NtPowerInformation(SystemPowerCapabilities, NULL, 0, &PowerCaps, sizeof(PowerCaps));
497 if (!NT_SUCCESS(Status))
498 {
500 return FALSE;
501 }
502
503 return PowerCaps.SystemS1 || PowerCaps.SystemS2 || PowerCaps.SystemS3;
504}
505
507PowerGetActiveScheme(HKEY UserRootPowerKey, GUID **polguid)
508{
509 FIXME("(%p,%p) stub!\n", UserRootPowerKey, polguid);
511}
512
514PowerReadDCValue(HKEY RootPowerKey, const GUID *Scheme, const GUID *SubGroup, const GUID *PowerSettings, PULONG Type, PUCHAR Buffer, DWORD *BufferSize)
515{
516 FIXME("(%p,%s,%s,%s,%p,%p,%p) stub!\n", RootPowerKey, debugstr_guid(Scheme), debugstr_guid(SubGroup), debugstr_guid(PowerSettings), Type, Buffer, BufferSize);
518}
519
522{
523 GLOBAL_MACHINE_POWER_POLICY glMachPwrPolicy;
524 GLOBAL_USER_POWER_POLICY glUserPwrPolicy;
525 HKEY hKey = NULL;
527 LONG Err;
528 BOOL bRet = FALSE;
529
531
532 // Getting user global power policy
533 Err = RegOpenKeyExW(HKEY_CURRENT_USER, L"Control Panel\\PowerCfg\\GlobalPowerPolicy", 0, KEY_READ, &hKey);
534 if (Err != ERROR_SUCCESS)
535 {
536 ERR("RegOpenKeyW failed: %d\n", Err);
537 SetLastError(Err);
538 goto cleanup;
539 }
540
541 dwSize = sizeof(glUserPwrPolicy);
542 Err = RegQueryValueExW(hKey, L"Policies", NULL, NULL, (LPBYTE)&glUserPwrPolicy, &dwSize);
543 if (Err != ERROR_SUCCESS)
544 {
545 ERR("RegQueryValueExW failed: %d\n", Err);
546 SetLastError(Err);
547 goto cleanup;
548 }
549
551
552 // Getting machine global power policy
553 Err = RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Controls Folder\\PowerCfg\\GlobalPowerPolicy", 0, KEY_READ, &hKey);
554 if (Err != ERROR_SUCCESS)
555 {
556 ERR("RegOpenKeyW failed: %d\n", Err);
557 SetLastError(Err);
558 goto cleanup;
559 }
560
561 dwSize = sizeof(glMachPwrPolicy);
562 Err = RegQueryValueExW(hKey, L"Policies", NULL, NULL, (LPBYTE)&glMachPwrPolicy, &dwSize);
563 if (Err != ERROR_SUCCESS)
564 {
565 ERR("RegQueryValueExW failed: %d\n", Err);
566 SetLastError(Err);
567 goto cleanup;
568 }
569
570 memcpy(&pGlobalPowerPolicy->user, &glUserPwrPolicy, sizeof(GLOBAL_USER_POWER_POLICY));
571 memcpy(&pGlobalPowerPolicy->mach, &glMachPwrPolicy, sizeof(GLOBAL_MACHINE_POWER_POLICY));
572 bRet = TRUE;
573
574cleanup:
575 if(hKey)
578
579 return bRet;
580}
581
582
585 PMACHINE_PROCESSOR_POWER_POLICY pMachineProcessorPowerPolicy)
586{
587 HKEY hKey;
590
591 swprintf(szPath, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Controls Folder\\PowerCfg\\ProcessorPolicies\\%i", uiID);
593 return FALSE;
594
595 if (RegQueryValueExW(hKey, szPolicies, NULL, 0, (LPBYTE)pMachineProcessorPowerPolicy, &dwSize) == ERROR_SUCCESS)
596 {
598 return TRUE;
599 }
600
602 if (uiID != 0)
603 return ReadProcessorPwrScheme(0, pMachineProcessorPowerPolicy);
604
605 return FALSE;
606}
607
608
611 PPOWER_POLICY pPowerPolicy)
612{
613 USER_POWER_POLICY userPwrPolicy;
614 MACHINE_POWER_POLICY machinePwrPolicy;
615 WCHAR szNum[16]; // max number - 999
616
618
619 swprintf(szNum, L"%d", uiID);
620
621 if (!POWRPROF_GetUserPowerPolicy(szNum, &userPwrPolicy, 0, NULL, 0, NULL))
622 {
624 return FALSE;
625 }
626
627 if (!POWRPROF_GetMachinePowerPolicy(szNum, &machinePwrPolicy))
628 {
630 return FALSE;
631 }
632
633 memcpy(&pPowerPolicy->user, &userPwrPolicy, sizeof(userPwrPolicy));
634 memcpy(&pPowerPolicy->mach, &machinePwrPolicy, sizeof(machinePwrPolicy));
635
637
638 return TRUE;
639}
640
643 PGLOBAL_POWER_POLICY lpGlobalPowerPolicy,
644 PPOWER_POLICY lpPowerPolicy)
645{
646 POWER_POLICY tmp;
647 HKEY hKey;
648 WCHAR Buf[16];
649
650 if (!ReadPwrScheme(uiID, &tmp))
651 return FALSE;
652
654 return FALSE;
655
656 swprintf(Buf, L"%i", uiID);
657
659 {
661 return FALSE;
662 }
664
665 if (lpGlobalPowerPolicy != NULL || lpPowerPolicy != NULL)
666 {
667 if (!ValidatePowerPolicies(lpGlobalPowerPolicy, lpPowerPolicy))
668 return FALSE;
669
670 if (lpGlobalPowerPolicy != NULL && !WriteGlobalPwrPolicy(lpGlobalPowerPolicy))
671 return FALSE;
672
673 if (lpPowerPolicy != NULL && !WritePwrPolicy(&uiID,lpPowerPolicy))
674 return FALSE;
675 }
676
677 return TRUE;
678}
679
682 BOOLEAN ForceCritical,
683 BOOLEAN DisableWakeEvent)
684{
685 FIXME("(%d, %d, %d) stub!\n", Hibernate, ForceCritical, DisableWakeEvent);
686 return TRUE;
687}
688
691{
692 HKEY hKey;
695
696 gupp = pGlobalPowerPolicy->user;
697 gmpp = pGlobalPowerPolicy->mach;
698
700 L"Control Panel\\PowerCfg\\GlobalPowerPolicy",
701 0,
702 KEY_WRITE,
703 &hKey) != ERROR_SUCCESS)
704 return FALSE;
705
706 if (RegSetValueExW(hKey, szPolicies, 0, REG_BINARY, (PBYTE)&gupp, sizeof(gupp)) != ERROR_SUCCESS)
707 {
709 return FALSE;
710 }
711
713
715 L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Controls Folder\\PowerCfg\\GlobalPowerPolicy",
716 0,
718 &hKey))
719 return FALSE;
720
721 if (RegSetValueExW(hKey,szPolicies, 0, REG_BINARY, (PBYTE)&gmpp, sizeof(gmpp)) != ERROR_SUCCESS)
722 {
724 return FALSE;
725 }
726
728 return TRUE;
729}
730
733 PMACHINE_PROCESSOR_POWER_POLICY pMachineProcessorPowerPolicy)
734{
735 WCHAR Buf[MAX_PATH];
736 HKEY hKey;
737
738 swprintf(Buf, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Controls Folder\\PowerCfg\\ProcessorPolicies\\%i", ID);
739
741 return FALSE;
742
743 RegSetValueExW(hKey, szPolicies, 0, REG_BINARY, (PBYTE)pMachineProcessorPowerPolicy, sizeof(MACHINE_PROCESSOR_POWER_POLICY));
745 return TRUE;
746}
747
748static VOID
750{
751 WCHAR Buf[16];
752 HKEY hKey;
753
756 0,
757 KEY_WRITE,
758 &hKey) != ERROR_SUCCESS)
759 return;
760 swprintf(Buf, L"%i", g_LastID);
761 RegSetValueExW(hKey, szLastID, 0, REG_SZ, (PBYTE)Buf, strlenW(Buf)*sizeof(WCHAR));
763}
764
767 LPWSTR lpszName,
768 LPWSTR lpszDescription,
769 PPOWER_POLICY pPowerPolicy)
770{
771 WCHAR Buf[MAX_PATH];
772 HKEY hKey;
773
774 if (*puiID == -1)
775 {
776 g_LastID++;
777 *puiID = g_LastID;
778 SetLastID();
779 }
780
781 swprintf(Buf, L"Control Panel\\PowerCfg\\PowerPolicies\\%i", *puiID);
782
784 return FALSE;
785
786 RegSetValueExW(hKey, szName, 0, REG_SZ, (PBYTE)lpszName, strlenW(lpszName)*sizeof(WCHAR));
787 RegSetValueExW(hKey, szDescription, 0, REG_SZ, (PBYTE)lpszDescription, strlenW(lpszDescription)*sizeof(WCHAR));
789 return WritePwrPolicy(puiID, pPowerPolicy);
790}
791
792static BOOLEAN
794{
795/*
796 Lohnegrim: this is an Helper function, it checks if the POWERACTIONPOLICY is valid
797 Also, if the System doesn't support Hibernation, then change the PowerAction
798*/
799 switch (pPAP->Action)
800 {
801 case PowerActionNone:
802 return TRUE;
804 if (PowerCaps.SystemS1 || PowerCaps.SystemS2 || PowerCaps.SystemS3)
805 pPAP->Action = PowerActionSleep;
806 else
808 case PowerActionSleep:
809 return TRUE;
811 if (!(PowerCaps.SystemS4 && PowerCaps.HiberFilePresent))
812 {
813 if (PowerCaps.SystemS1 || PowerCaps.SystemS2 || PowerCaps.SystemS3)
814 pPAP->Action = PowerActionSleep;
815 else
817 }
822 return TRUE;
823 default:
825 return FALSE;
826 };
827}
828
847static BOOLEAN
849{
851 PACL Dacl;
852 ULONG DaclSize, RelSDSize = 0;
853 PSID AuthenticatedUsersSid = NULL, SystemSid = NULL, AdminsSid = NULL;
857
859 1,
861 0, 0, 0, 0, 0, 0, 0,
862 &AuthenticatedUsersSid))
863 {
864 return FALSE;
865 }
866
868 1,
870 0, 0, 0, 0, 0, 0, 0,
871 &SystemSid))
872 {
873 goto Quit;
874 }
875
877 2,
880 0, 0, 0, 0, 0, 0,
881 &AdminsSid))
882 {
883 goto Quit;
884 }
885
887 {
888 goto Quit;
889 }
890
891 DaclSize = sizeof(ACL) +
892 sizeof(ACCESS_ALLOWED_ACE) + GetLengthSid(AuthenticatedUsersSid) +
893 sizeof(ACCESS_ALLOWED_ACE) + GetLengthSid(SystemSid) +
894 sizeof(ACCESS_ALLOWED_ACE) + GetLengthSid(AdminsSid);
895
897 if (!Dacl)
898 {
899 goto Quit;
900 }
901
903 {
904 goto Quit;
905 }
906
910 AuthenticatedUsersSid))
911 {
912 goto Quit;
913 }
914
918 SystemSid))
919 {
920 goto Quit;
921 }
922
926 AdminsSid))
927 {
928 goto Quit;
929 }
930
932 {
933 goto Quit;
934 }
935
936 if (!SetSecurityDescriptorOwner(&AbsSd, AdminsSid, FALSE))
937 {
938 goto Quit;
939 }
940
941 if (!SetSecurityDescriptorGroup(&AbsSd, SystemSid, FALSE))
942 {
943 goto Quit;
944 }
945
946 if (!MakeSelfRelativeSD(&AbsSd, NULL, &RelSDSize) && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
947 {
948 RelSd = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, RelSDSize);
949 if (RelSd == NULL)
950 {
951 goto Quit;
952 }
953
954 if (!MakeSelfRelativeSD(&AbsSd, RelSd, &RelSDSize))
955 {
956 goto Quit;
957 }
958 }
959
960 *PowrProfSd = RelSd;
961 Success = TRUE;
962
963Quit:
964 if (AuthenticatedUsersSid)
965 {
966 FreeSid(AuthenticatedUsersSid);
967 }
968
969 if (SystemSid)
970 {
971 FreeSid(SystemSid);
972 }
973
974 if (AdminsSid)
975 {
976 FreeSid(AdminsSid);
977 }
978
979 if (Dacl)
980 {
982 }
983
984 if (!Success)
985 {
986 if (RelSd)
987 {
988 HeapFree(GetProcessHeap(), 0, RelSd);
989 }
990 }
991
992 return Success;
993}
994
995static VOID
997{
998 //Lohnegrim: If the System doesn't support the Powerstates, then we have to change them
999 if (!PowerCaps.SystemS1 && *Psps == PowerSystemSleeping1)
1000 *Psps = PowerSystemSleeping2;
1001 if (!PowerCaps.SystemS2 && *Psps == PowerSystemSleeping2)
1002 *Psps = PowerSystemSleeping3;
1003 if (!PowerCaps.SystemS3 && *Psps == PowerSystemSleeping3)
1004 *Psps = PowerSystemHibernate;
1005 if (!(PowerCaps.SystemS4 && PowerCaps.HiberFilePresent) && *Psps == PowerSystemHibernate)
1006 *Psps = PowerSystemSleeping2;
1007 if (!PowerCaps.SystemS1 && *Psps == PowerSystemSleeping1)
1008 *Psps = PowerSystemSleeping2;
1009 if (!PowerCaps.SystemS2 && *Psps == PowerSystemSleeping2)
1010 *Psps = PowerSystemSleeping3;
1011 if (!PowerCaps.SystemS3 && *Psps == PowerSystemSleeping3)
1012 *Psps = PowerSystemShutdown;
1013
1014}
1015
1018{
1019 SYSTEM_POWER_CAPABILITIES PowerCaps;
1020 NTSTATUS ret;
1021 BOOLEAN old;
1022
1024 ret = NtPowerInformation(SystemPowerCapabilities, NULL, 0, &PowerCaps, sizeof(PowerCaps));
1025 if (ret != STATUS_SUCCESS)
1026 {
1028 return FALSE;
1029 }
1030
1031 if (pGPP)
1032 {
1033 if (pGPP->user.Revision != 1 || pGPP->mach.Revision != 1)
1034 {
1036 return FALSE;
1037 }
1039 {
1041 return FALSE;
1042 }
1043 if ((int)pGPP->mach.LidOpenWakeAc > PowerSystemShutdown)
1044 {
1046 return FALSE;
1047 }
1049 {
1051 return FALSE;
1052 }
1053 if ((int)pGPP->mach.LidOpenWakeDc > PowerSystemShutdown)
1054 {
1056 return FALSE;
1057 }
1058 //Lohnegrim: unneeded
1059 /*if ((pGPP->mach.LidOpenWakeDc < PowerSystemWorking) || (pGPP->mach.LidOpenWakeDc >= PowerSystemMaximum))
1060 {
1061 SetLastError(ERROR_GEN_FAILURE);
1062 return FALSE;
1063 }*/
1064 if (!CheckPowerActionPolicy(&pGPP->user.LidCloseAc,PowerCaps))
1065 {
1066 return FALSE;
1067 }
1068 if (!CheckPowerActionPolicy(&pGPP->user.LidCloseDc,PowerCaps))
1069 {
1070 return FALSE;
1071 }
1072 if (!CheckPowerActionPolicy(&pGPP->user.PowerButtonAc,PowerCaps))
1073 {
1074 return FALSE;
1075 }
1076 if (!CheckPowerActionPolicy(&pGPP->user.PowerButtonDc,PowerCaps))
1077 {
1078 return FALSE;
1079 }
1080 if (!CheckPowerActionPolicy(&pGPP->user.SleepButtonAc,PowerCaps))
1081 {
1082 return FALSE;
1083 }
1084 if (!CheckPowerActionPolicy(&pGPP->user.SleepButtonDc,PowerCaps))
1085 {
1086 return FALSE;
1087 }
1088 //Lohnegrim: The BroadcastCapacityResolution presents the Powerlevel in Percent, if invalid set th 100 == FULL
1089 if (pGPP->mach.BroadcastCapacityResolution > 100)
1091
1092 //Lohnegrim: I have no idea, if they are really needed, or if they are specific for my System, or what they mean, so I removed them
1093 //pGPP->user.DischargePolicy[1].PowerPolicy.EventCode = pGPP->user.DischargePolicy[1].PowerPolicy.EventCode | 0x010000;
1094 //pGPP->user.DischargePolicy[2].PowerPolicy.EventCode = pGPP->user.DischargePolicy[2].PowerPolicy.EventCode | 0x020000;
1095 //pGPP->user.DischargePolicy[3].PowerPolicy.EventCode = pGPP->user.DischargePolicy[3].PowerPolicy.EventCode | 0x030000;
1096
1097 FixSystemPowerState(&pGPP->mach.LidOpenWakeAc,PowerCaps);
1098 FixSystemPowerState(&pGPP->mach.LidOpenWakeDc,PowerCaps);
1099
1100 }
1101
1102 if (pPP)
1103 {
1104 if (pPP->user.Revision != 1 || pPP->mach.Revision != 1)
1105 {
1107 return FALSE;
1108 }
1109
1110 //Lohnegrim: unneeded
1111 //if (pPP->mach.MinSleepAc < PowerSystemWorking)
1112 //{
1113 // SetLastError(ERROR_GEN_FAILURE);
1114 // return FALSE;
1115 //}
1116 if ((int)pPP->mach.MinSleepAc >= PowerSystemShutdown)
1117 {
1119 return FALSE;
1120 }
1121 //Lohnegrim: unneeded
1122 //if (pPP->mach.MinSleepDc < PowerSystemWorking)
1123 //{
1124 // SetLastError(ERROR_GEN_FAILURE);
1125 // return FALSE;
1126 //}
1127 if ((int)pPP->mach.MinSleepDc >= PowerSystemShutdown)
1128 {
1130 return FALSE;
1131 }
1133 {
1135 return FALSE;
1136 }
1138 {
1140 return FALSE;
1141 }
1143 {
1145 return FALSE;
1146 }
1148 {
1150 return FALSE;
1151 }
1152
1153 if (!CheckPowerActionPolicy(&pPP->mach.OverThrottledAc,PowerCaps))
1154 {
1155 return FALSE;
1156 }
1157 if (!CheckPowerActionPolicy(&pPP->mach.OverThrottledDc,PowerCaps))
1158 {
1159 return FALSE;
1160 }
1161 if (!CheckPowerActionPolicy(&pPP->user.IdleAc,PowerCaps))
1162 {
1163 return FALSE;
1164 }
1165 if (!CheckPowerActionPolicy(&pPP->user.IdleDc,PowerCaps))
1166 {
1167 return FALSE;
1168 }
1170 {
1172 return FALSE;
1173 }
1174 //Lohnegrim: unneeded
1175 /*if ((int)pPP->user.MaxSleepAc > PowerSystemShutdown)
1176 {
1177 SetLastError(ERROR_GEN_FAILURE);
1178 return FALSE;
1179 }*/
1181 {
1183 return FALSE;
1184 }
1185 //Lohnegrim: unneeded
1186 /*if ((int)pPP->user.MaxSleepDc >= PowerSystemShutdown)
1187 {
1188 SetLastError(ERROR_GEN_FAILURE);
1189 return FALSE;
1190 }*/
1191 if (PowerCaps.SystemS1)
1192 {
1195 }
1196 else if (PowerCaps.SystemS2)
1197 {
1200 }
1201 else if (PowerCaps.SystemS3)
1202 {
1205 }
1206
1207 if (PowerCaps.SystemS4)
1208 {
1211 }
1212 else if (PowerCaps.SystemS3)
1213 {
1216 }
1217 else if (PowerCaps.SystemS1)
1218 {
1221 }
1222 //Lohnegrim: I don't know where to get this info from, so I removed it
1223 //pPP->user.OptimizeForPowerAc=TRUE;
1224 //pPP->user.OptimizeForPowerDc=TRUE;
1225
1228 }
1229
1231 return TRUE;
1232}
1233
1235{
1236 WCHAR Buf[MAX_PATH];
1237 HKEY hKey;
1238
1239 swprintf(Buf, L"Control Panel\\PowerCfg\\PowerPolicies\\%i", *puiID);
1240
1242 return FALSE;
1243
1244 RegSetValueExW(hKey, szPolicies, 0, REG_BINARY, (const unsigned char *)&pPowerPolicy->user, sizeof(USER_POWER_POLICY));
1246
1247 swprintf(Buf, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Controls Folder\\PowerCfg\\PowerPolicies\\%i", *puiID);
1248
1250 return FALSE;
1251
1252 RegSetValueExW(hKey, szPolicies, 0, REG_BINARY, (const unsigned char *)&pPowerPolicy->mach, sizeof(MACHINE_POWER_POLICY));
1254
1255 return TRUE;
1256}
1257
1260{
1261 switch(fdwReason)
1262 {
1263 case DLL_PROCESS_ATTACH:
1264 {
1265 HKEY hKey;
1266 LONG Err;
1267 SECURITY_ATTRIBUTES SecAttrs;
1269
1270 DisableThreadLibraryCalls(hinstDLL);
1271
1273
1274 if (Err != ERROR_SUCCESS)
1275 {
1276 TRACE("Couldn't open registry key HKLM\\%s, using some sane(?) defaults\n", debugstr_w(szPowerCfgSubKey));
1277 }
1278 else
1279 {
1280 WCHAR lpValue[MAX_PATH];
1281 DWORD cbValue = sizeof(lpValue);
1282
1283 Err = RegQueryValueExW(hKey, szLastID, 0, 0, (BYTE*)lpValue, &cbValue);
1284 if (Err == ERROR_SUCCESS)
1285 {
1286 g_LastID = _wtoi(lpValue);
1287 }
1288 else
1289 {
1290 TRACE("Couldn't open registry entry HKLM\\%s\\LastID, using some sane(?) defaults\n", debugstr_w(szPowerCfgSubKey));
1291 }
1293 }
1294
1296 {
1297 ERR("Couldn't create POWRPROF semaphore security descriptor!\n");
1298 return FALSE;
1299 }
1300
1301 SecAttrs.nLength = sizeof(SECURITY_ATTRIBUTES);
1302 SecAttrs.lpSecurityDescriptor = Sd;
1303 SecAttrs.bInheritHandle = FALSE;
1304
1306 HeapFree(GetProcessHeap(), 0, Sd);
1307 if (PPRegSemaphore == NULL)
1308 {
1309 ERR("Couldn't create Semaphore: %d\n", GetLastError());
1310 return FALSE;
1311 }
1312 break;
1313 }
1314 case DLL_PROCESS_DETACH:
1316 break;
1317 }
1318 return TRUE;
1319}
unsigned char BOOLEAN
Type
Definition: Type.h:7
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
LONG NTSTATUS
Definition: precomp.h:26
static SID_IDENTIFIER_AUTHORITY NtAuthority
Definition: security.c:40
#define FIXME(fmt,...)
Definition: debug.h:111
#define WARN(fmt,...)
Definition: debug.h:112
#define ERR(fmt,...)
Definition: debug.h:110
#define RegCloseKey(hKey)
Definition: registry.h:49
Definition: bufpool.h:45
LPARAM lParam
Definition: combotst.c:139
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
#define ERROR_SUCCESS
Definition: deptool.c:10
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3333
LONG WINAPI RegEnumKeyExW(_In_ HKEY hKey, _In_ DWORD dwIndex, _Out_ LPWSTR lpName, _Inout_ LPDWORD lpcbName, _Reserved_ LPDWORD lpReserved, _Out_opt_ LPWSTR lpClass, _Inout_opt_ LPDWORD lpcbClass, _Out_opt_ PFILETIME lpftLastWriteTime)
Definition: reg.c:2504
LONG WINAPI RegSetValueExW(_In_ HKEY hKey, _In_ LPCWSTR lpValueName, _In_ DWORD Reserved, _In_ DWORD dwType, _In_ CONST BYTE *lpData, _In_ DWORD cbData)
Definition: reg.c:4882
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4103
BOOL WINAPI AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, BYTE nSubAuthorityCount, DWORD nSubAuthority0, DWORD nSubAuthority1, DWORD nSubAuthority2, DWORD nSubAuthority3, DWORD nSubAuthority4, DWORD nSubAuthority5, DWORD nSubAuthority6, DWORD nSubAuthority7, PSID *pSid)
Definition: security.c:674
BOOL WINAPI InitializeAcl(PACL pAcl, DWORD nAclLength, DWORD dwAclRevision)
Definition: security.c:1006
BOOL WINAPI InitializeSecurityDescriptor(PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD dwRevision)
Definition: security.c:929
BOOL WINAPI AddAccessAllowedAce(PACL pAcl, DWORD dwAceRevision, DWORD AccessMask, PSID pSid)
Definition: security.c:1039
DWORD WINAPI GetLengthSid(PSID pSid)
Definition: security.c:919
PVOID WINAPI FreeSid(PSID pSid)
Definition: security.c:698
#define CloseHandle
Definition: compat.h:739
#define GetProcessHeap()
Definition: compat.h:736
#define ERROR_CALL_NOT_IMPLEMENTED
Definition: compat.h:102
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define DLL_PROCESS_ATTACH
Definition: compat.h:131
#define DLL_PROCESS_DETACH
Definition: compat.h:130
struct _SECURITY_ATTRIBUTES SECURITY_ATTRIBUTES
#define SetLastError(x)
Definition: compat.h:752
#define HeapAlloc
Definition: compat.h:733
#define MAX_PATH
Definition: compat.h:34
#define HeapFree(x, y, z)
Definition: compat.h:735
#define ERROR_ACCESS_DENIED
Definition: compat.h:97
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
static void cleanup(void)
Definition: main.c:1335
BOOL WINAPI DisableThreadLibraryCalls(IN HMODULE hLibModule)
Definition: loader.c:85
#define swprintf
Definition: precomp.h:40
#define INFINITE
Definition: serial.h:102
@ Success
Definition: eventcreate.c:712
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
FxAutoRegKey hKey
Status
Definition: gdiplustypes.h:25
GLfloat GLfloat p
Definition: glext.h:8902
_Check_return_ _CRTIMP int __cdecl _wtoi(_In_z_ const wchar_t *_Str)
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
NTSYSAPI ULONG WINAPI RtlNtStatusToDosError(NTSTATUS)
#define debugstr_guid
Definition: kernel32.h:35
#define debugstr_w
Definition: kernel32.h:32
#define REG_SZ
Definition: layer.c:22
static IN DWORD IN LPVOID lpvReserved
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
LPCWSTR szPath
Definition: env.c:37
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
#define SE_SHUTDOWN_PRIVILEGE
Definition: security.c:673
#define SE_CREATE_PAGEFILE_PRIVILEGE
Definition: security.c:669
struct _ACL ACL
struct _ACCESS_ALLOWED_ACE ACCESS_ALLOWED_ACE
#define _Out_
Definition: ms_sal.h:345
unsigned int * PUINT
Definition: ndis.h:50
unsigned int UINT
Definition: ndis.h:50
_Out_writes_bytes_to_opt_ AbsoluteSecurityDescriptorSize PSECURITY_DESCRIPTOR _Inout_ PULONG _Out_writes_bytes_to_opt_ DaclSize PACL Dacl
Definition: rtlfuncs.h:1593
_Out_writes_bytes_to_opt_ AbsoluteSecurityDescriptorSize PSECURITY_DESCRIPTOR _Inout_ PULONG _Out_writes_bytes_to_opt_ DaclSize PACL _Inout_ PULONG DaclSize
Definition: rtlfuncs.h:1594
NTSYSAPI NTSTATUS NTAPI RtlAdjustPrivilege(_In_ ULONG Privilege, _In_ BOOLEAN NewValue, _In_ BOOLEAN ForThread, _Out_ PBOOLEAN OldValue)
#define SYNCHRONIZE
Definition: nt_native.h:61
#define REG_BINARY
Definition: nt_native.h:1496
#define KEY_ALL_ACCESS
Definition: nt_native.h:1041
#define KEY_READ
Definition: nt_native.h:1023
#define STANDARD_RIGHTS_READ
Definition: nt_native.h:65
#define KEY_WRITE
Definition: nt_native.h:1031
NTSTATUS NTAPI NtPowerInformation(IN POWER_INFORMATION_LEVEL PowerInformationLevel, IN PVOID InputBuffer OPTIONAL, IN ULONG InputBufferLength, OUT PVOID OutputBuffer OPTIONAL, IN ULONG OutputBufferLength)
Definition: power.c:792
enum _SYSTEM_POWER_STATE * PSYSTEM_POWER_STATE
@ PowerSystemUnspecified
Definition: ntpoapi.h:35
@ PowerSystemSleeping1
Definition: ntpoapi.h:37
@ PowerSystemSleeping2
Definition: ntpoapi.h:38
@ PowerSystemSleeping3
Definition: ntpoapi.h:39
@ PowerSystemShutdown
Definition: ntpoapi.h:41
@ PowerSystemWorking
Definition: ntpoapi.h:36
@ PowerSystemHibernate
Definition: ntpoapi.h:40
@ PowerActionShutdownOff
Definition: ntpoapi.h:129
@ PowerActionNone
Definition: ntpoapi.h:123
@ PowerActionHibernate
Definition: ntpoapi.h:126
@ PowerActionShutdown
Definition: ntpoapi.h:127
@ PowerActionShutdownReset
Definition: ntpoapi.h:128
@ PowerActionWarmEject
Definition: ntpoapi.h:130
@ PowerActionReserved
Definition: ntpoapi.h:124
@ PowerActionSleep
Definition: ntpoapi.h:125
enum _POWER_INFORMATION_LEVEL POWER_INFORMATION_LEVEL
@ SystemPowerCapabilities
Definition: ntpoapi.h:71
#define L(x)
Definition: ntvdm.h:50
BYTE * PBYTE
Definition: pedump.c:66
long LONG
Definition: pedump.c:60
BOOLEAN WINAPI GetPwrCapabilities(PSYSTEM_POWER_CAPABILITIES lpSystemPowerCapabilities)
Definition: powrprof.c:358
static const WCHAR szCurrentPowerPolicies[]
Definition: powrprof.c:42
static const WCHAR szDiskMin[]
Definition: powrprof.c:49
static const WCHAR szPowerCfgSubKey[]
Definition: powrprof.c:38
BOOLEAN WINAPI IsPwrHibernateAllowed(VOID)
Definition: powrprof.c:450
BOOLEAN WINAPI ReadProcessorPwrScheme(UINT uiID, PMACHINE_PROCESSOR_POWER_POLICY pMachineProcessorPowerPolicy)
Definition: powrprof.c:584
BOOLEAN WINAPI GetCurrentPowerPolicies(PGLOBAL_POWER_POLICY pGlobalPowerPolicy, PPOWER_POLICY pPowerPolicy)
Definition: powrprof.c:321
BOOLEAN WINAPI IsPwrShutdownAllowed(VOID)
Definition: powrprof.c:469
NTSTATUS WINAPI CallNtPowerInformation(POWER_INFORMATION_LEVEL InformationLevel, PVOID lpInputBuffer, ULONG nInputBufferSize, PVOID lpOutputBuffer, ULONG nOutputBufferSize)
Definition: powrprof.c:59
BOOLEAN WINAPI IsAdminOverrideActive(PADMINISTRATOR_POWER_POLICY p)
Definition: powrprof.c:443
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
Definition: powrprof.c:1259
static const WCHAR szUserPowerConfigSubKey[]
Definition: powrprof.c:40
DWORD WINAPI PowerGetActiveScheme(HKEY UserRootPowerKey, GUID **polguid)
Definition: powrprof.c:507
BOOLEAN WINAPI ReadPwrScheme(UINT uiID, PPOWER_POLICY pPowerPolicy)
Definition: powrprof.c:610
BOOLEAN WINAPI GetActivePwrScheme(PUINT puiID)
Definition: powrprof.c:285
BOOLEAN WINAPI ValidatePowerPolicies(PGLOBAL_POWER_POLICY pGPP, PPOWER_POLICY pPP)
Definition: powrprof.c:1017
BOOLEAN WINAPI WritePwrScheme(PUINT puiID, LPWSTR lpszName, LPWSTR lpszDescription, PPOWER_POLICY pPowerPolicy)
Definition: powrprof.c:766
static BOOLEAN POWRPROF_GetMachinePowerPolicy(LPWSTR szNum, PMACHINE_POWER_POLICY pmachinePwrPolicy)
Definition: powrprof.c:185
static VOID FixSystemPowerState(PSYSTEM_POWER_STATE Psps, SYSTEM_POWER_CAPABILITIES PowerCaps)
Definition: powrprof.c:996
static const WCHAR szDiskMax[]
Definition: powrprof.c:48
BOOLEAN WINAPI SetActivePwrScheme(UINT uiID, PGLOBAL_POWER_POLICY lpGlobalPowerPolicy, PPOWER_POLICY lpPowerPolicy)
Definition: powrprof.c:642
BOOLEAN WINAPI SetSuspendState(BOOLEAN Hibernate, BOOLEAN ForceCritical, BOOLEAN DisableWakeEvent)
Definition: powrprof.c:681
static const WCHAR szSemaphoreName[]
Definition: powrprof.c:47
BOOLEAN WINAPI EnumPwrSchemes(PWRSCHEMESENUMPROC lpfnPwrSchemesEnumProc, LPARAM lParam)
Definition: powrprof.c:219
BOOLEAN WINAPI DeletePwrScheme(UINT uiIndex)
Definition: powrprof.c:99
BOOLEAN WINAPI WriteProcessorPwrScheme(UINT ID, PMACHINE_PROCESSOR_POWER_POLICY pMachineProcessorPowerPolicy)
Definition: powrprof.c:732
BOOLEAN WINAPI CanUserWritePwrScheme(VOID)
Definition: powrprof.c:79
BOOLEAN WINAPI WriteGlobalPwrPolicy(PGLOBAL_POWER_POLICY pGlobalPowerPolicy)
Definition: powrprof.c:690
BOOLEAN WINAPI WritePwrPolicy(PUINT puiID, PPOWER_POLICY pPowerPolicy)
Definition: powrprof.c:1234
UINT g_LastID
Definition: powrprof.c:52
static const WCHAR szPolicies[]
Definition: powrprof.c:44
static BOOLEAN CheckPowerActionPolicy(PPOWER_ACTION_POLICY pPAP, SYSTEM_POWER_CAPABILITIES PowerCaps)
Definition: powrprof.c:793
static BOOLEAN POWRPROF_GetUserPowerPolicy(LPWSTR szNum, PUSER_POWER_POLICY puserPwrPolicy, DWORD cchName, LPWSTR szName, DWORD cchDesc, LPWSTR szDesc)
Definition: powrprof.c:128
DWORD WINAPI PowerReadDCValue(HKEY RootPowerKey, const GUID *Scheme, const GUID *SubGroup, const GUID *PowerSettings, PULONG Type, PUCHAR Buffer, DWORD *BufferSize)
Definition: powrprof.c:514
BOOLEAN WINAPI ReadGlobalPwrPolicy(PGLOBAL_POWER_POLICY pGlobalPowerPolicy)
Definition: powrprof.c:521
static const WCHAR szLastID[]
Definition: powrprof.c:50
BOOLEAN WINAPI IsPwrSuspendAllowed(VOID)
Definition: powrprof.c:488
static const WCHAR szName[]
Definition: powrprof.c:45
static BOOLEAN CreatePowrProfSemaphoreSecurity(_Out_ PSECURITY_DESCRIPTOR *PowrProfSd)
Creates a security descriptor for the power management registry semaphore.
Definition: powrprof.c:848
static const WCHAR szDescription[]
Definition: powrprof.c:46
static VOID SetLastID(VOID)
Definition: powrprof.c:749
HANDLE PPRegSemaphore
Definition: powrprof.c:56
BOOLEAN WINAPI GetPwrDiskSpindownRange(PUINT RangeMax, PUINT RangeMin)
Definition: powrprof.c:381
struct _USER_POWER_POLICY USER_POWER_POLICY
BOOLEAN(CALLBACK * PWRSCHEMESENUMPROC)(UINT, DWORD, LPWSTR, DWORD, LPWSTR, PPOWER_POLICY, LPARAM)
Definition: powrprof.h:94
struct _MACHINE_POWER_POLICY MACHINE_POWER_POLICY
struct _MACHINE_PROCESSOR_POWER_POLICY MACHINE_PROCESSOR_POWER_POLICY
#define strlenW(s)
Definition: unicode.h:28
#define ID
Definition: ruserpass.c:36
BOOL WINAPI SetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR pSecurityDescriptor, BOOL bDaclPresent, PACL pDacl, BOOL bDaclDefaulted)
Definition: sec.c:262
BOOL WINAPI SetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID pOwner, BOOL bOwnerDefaulted)
Definition: sec.c:312
BOOL WINAPI MakeSelfRelativeSD(PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor, PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor, LPDWORD lpdwBufferLength)
Definition: sec.c:214
BOOL WINAPI SetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID pGroup, BOOL bGroupDefaulted)
Definition: sec.c:288
#define STATUS_SUCCESS
Definition: shellext.h:65
#define TRACE(s)
Definition: solgame.cpp:4
SYSTEM_POWER_STATE LidOpenWakeDc
Definition: powrprof.h:27
SYSTEM_POWER_STATE LidOpenWakeAc
Definition: powrprof.h:26
GLOBAL_USER_POWER_POLICY user
Definition: powrprof.h:42
GLOBAL_MACHINE_POWER_POLICY mach
Definition: powrprof.h:43
POWER_ACTION_POLICY PowerButtonDc
Definition: powrprof.h:33
POWER_ACTION_POLICY LidCloseDc
Definition: powrprof.h:37
POWER_ACTION_POLICY SleepButtonDc
Definition: powrprof.h:35
POWER_ACTION_POLICY PowerButtonAc
Definition: powrprof.h:32
POWER_ACTION_POLICY SleepButtonAc
Definition: powrprof.h:34
POWER_ACTION_POLICY LidCloseAc
Definition: powrprof.h:36
SYSTEM_POWER_STATE MinSleepAc
Definition: powrprof.h:47
SYSTEM_POWER_STATE ReducedLatencySleepDc
Definition: powrprof.h:50
POWER_ACTION_POLICY OverThrottledDc
Definition: powrprof.h:59
SYSTEM_POWER_STATE ReducedLatencySleepAc
Definition: powrprof.h:49
POWER_ACTION_POLICY OverThrottledAc
Definition: powrprof.h:58
SYSTEM_POWER_STATE MinSleepDc
Definition: powrprof.h:48
POWER_ACTION Action
Definition: ntpoapi.h:408
MACHINE_POWER_POLICY mach
Definition: powrprof.h:92
USER_POWER_POLICY user
Definition: powrprof.h:91
LPVOID lpSecurityDescriptor
Definition: compat.h:193
SYSTEM_POWER_STATE MaxSleepAc
Definition: powrprof.h:76
SYSTEM_POWER_STATE MaxSleepDc
Definition: powrprof.h:77
POWER_ACTION_POLICY IdleAc
Definition: powrprof.h:68
POWER_ACTION_POLICY IdleDc
Definition: powrprof.h:69
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
HANDLE WINAPI DECLSPEC_HOTPATCH CreateSemaphoreW(IN LPSECURITY_ATTRIBUTES lpSemaphoreAttributes OPTIONAL, IN LONG lInitialCount, IN LONG lMaximumCount, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:444
BOOL WINAPI DECLSPEC_HOTPATCH ReleaseSemaphore(IN HANDLE hSemaphore, IN LONG lReleaseCount, IN LPLONG lpPreviousCount)
Definition: synch.c:542
uint32_t * PULONG
Definition: typedefs.h:59
unsigned char * LPBYTE
Definition: typedefs.h:53
unsigned char * PUCHAR
Definition: typedefs.h:53
uint32_t ULONG
Definition: typedefs.h:59
int ret
_In_ WDFMEMORY _Out_opt_ size_t * BufferSize
Definition: wdfmemory.h:254
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
#define SEMAPHORE_ALL_ACCESS
Definition: winbase.h:160
_In_ PSID _Out_writes_to_opt_ cchName LPSTR _Inout_ LPDWORD cchName
Definition: winbase.h:2767
LONG_PTR LPARAM
Definition: windef.h:208
#define WINAPI
Definition: msvc.h:6
#define ERROR_GEN_FAILURE
Definition: winerror.h:134
#define ERROR_INVALID_DATA
Definition: winerror.h:116
#define ERROR_REVISION_MISMATCH
Definition: winerror.h:788
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
#define HKEY_CURRENT_USER
Definition: winreg.h:11
#define RegOpenKeyEx
Definition: winreg.h:520
#define RegDeleteKey
Definition: winreg.h:502
#define RegCreateKey
Definition: winreg.h:500
#define SECURITY_BUILTIN_DOMAIN_RID
Definition: setypes.h:581
#define SECURITY_LOCAL_SYSTEM_RID
Definition: setypes.h:574
#define SECURITY_AUTHENTICATED_USER_RID
Definition: setypes.h:568
#define SECURITY_NT_AUTHORITY
Definition: setypes.h:554
#define SECURITY_DESCRIPTOR_REVISION
Definition: setypes.h:58
#define ACL_REVISION
Definition: setypes.h:39
#define DOMAIN_ALIAS_RID_ADMINS
Definition: setypes.h:652
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184
const CHAR * LPCTSTR
Definition: xmlstorage.h:193
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
unsigned char BYTE
Definition: xxhash.c:193