ReactOS  0.4.14-dev-98-gb0d4763
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 
38 static const WCHAR szPowerCfgSubKey[] =
39  L"Software\\Microsoft\\Windows\\CurrentVersion\\Controls Folder\\PowerCfg";
40 static const WCHAR szUserPowerConfigSubKey[] =
41  L"Control Panel\\PowerCfg";
42 static const WCHAR szCurrentPowerPolicies[] =
43  L"CurrentPowerPolicy";
44 static const WCHAR szPolicies[] = L"Policies";
45 static const WCHAR szName[] = L"Name";
46 static const WCHAR szDescription[] = L"Description";
47 static const WCHAR szSemaphoreName[] = L"PowerProfileRegistrySemaphore";
48 static const WCHAR szDiskMax[] = L"DiskSpindownMax";
49 static const WCHAR szDiskMin[] = L"DiskSpindownMin";
50 static const WCHAR szLastID[] = L"LastID";
51 
53 
54 BOOLEAN WINAPI WritePwrPolicy(PUINT puiID, PPOWER_POLICY pPowerPolicy);
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 
94  RegCloseKey(hKey);
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 
127 static BOOLEAN
129  PUSER_POWER_POLICY puserPwrPolicy,
131  DWORD cchDesc, LPWSTR szDesc)
132 {
133  HKEY hSubKey = NULL;
134  DWORD dwSize;
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 
178 cleanup:
179  RegCloseKey(hSubKey);
180 
181  return bRet;
182 }
183 
184 static BOOLEAN
186 {
187  HKEY hKey;
188  LONG Err;
190  DWORD dwSize;
191 
192  swprintf(szPath, L"Software\\Microsoft\\Windows\\CurrentVersion\\Controls Folder\\PowerCfg\\PowerPolicies\\%s", szNum);
193 
194  Err = RegOpenKeyExW(HKEY_LOCAL_MACHINE, szPath, 0, KEY_READ, &hKey);
195  if (Err != ERROR_SUCCESS)
196  {
197  ERR("RegOpenKeyExW failed: %d\n", Err);
198  SetLastError(Err);
199  return FALSE;
200  }
201 
202  dwSize = sizeof(MACHINE_POWER_POLICY);
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);
209  RegCloseKey(hKey);
210  return FALSE;
211  }
212 
213  RegCloseKey(hKey);
214 
215  return TRUE;
216 }
217 
219 EnumPwrSchemes(PWRSCHEMESENUMPROC lpfnPwrSchemesEnumProc,
220  LPARAM lParam)
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 
277 cleanup:
278  RegCloseKey(hKey);
280 
281  return bRet;
282 }
283 
286 {
287  HKEY hKey;
288  WCHAR szBuf[MAX_PATH];
289  DWORD dwSize;
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);
309  RegCloseKey(hKey);
310  SetLastError(Err);
311  return FALSE;
312  }
313 
314  RegCloseKey(hKey);
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 
435  RegCloseKey(hKey);
436 
438 
439  return TRUE;
440 }
441 
444 {
445  FIXME("( %p) stub!\n", p);
446  return FALSE;
447 }
448 
451 {
452  SYSTEM_POWER_CAPABILITIES PowerCaps;
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 {
471  SYSTEM_POWER_CAPABILITIES PowerCaps;
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 {
490  SYSTEM_POWER_CAPABILITIES PowerCaps;
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 
507 PowerGetActiveScheme(HKEY UserRootPowerKey, GUID **polguid)
508 {
509  FIXME("(%p,%p) stub!\n", UserRootPowerKey, polguid);
511 }
512 
514 PowerReadDCValue(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;
526  DWORD dwSize;
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 
550  RegCloseKey(hKey);
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 
574 cleanup:
575  if(hKey)
576  RegCloseKey(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  {
597  RegCloseKey(hKey);
598  return TRUE;
599  }
600 
601  RegCloseKey(hKey);
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 
658  if (RegSetValueExW(hKey, szCurrentPowerPolicies, 0, REG_SZ, (PBYTE)Buf, strlenW(Buf)*sizeof(WCHAR)) != ERROR_SUCCESS)
659  {
660  RegCloseKey(hKey);
661  return FALSE;
662  }
663  RegCloseKey(hKey);
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  {
708  RegCloseKey(hKey);
709  return FALSE;
710  }
711 
712  RegCloseKey(hKey);
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  {
723  RegCloseKey(hKey);
724  return FALSE;
725  }
726 
727  RegCloseKey(hKey);
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 
740  if (RegCreateKey(HKEY_LOCAL_MACHINE, Buf, &hKey) != ERROR_SUCCESS)
741  return FALSE;
742 
743  RegSetValueExW(hKey, szPolicies, 0, REG_BINARY, (PBYTE)pMachineProcessorPowerPolicy, sizeof(MACHINE_PROCESSOR_POWER_POLICY));
744  RegCloseKey(hKey);
745  return TRUE;
746 }
747 
748 static 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));
762  RegCloseKey(hKey);
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 
783  if (RegCreateKey(HKEY_CURRENT_USER, Buf, &hKey) != ERROR_SUCCESS)
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));
788  RegCloseKey(hKey);
789  return WritePwrPolicy(puiID, pPowerPolicy);
790 }
791 
792 static 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;
803  case PowerActionReserved:
804  if (PowerCaps.SystemS1 || PowerCaps.SystemS2 || PowerCaps.SystemS3)
805  pPAP->Action = PowerActionSleep;
806  else
807  pPAP->Action = PowerActionReserved;
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
816  pPAP->Action = PowerActionReserved;
817  }
818  case PowerActionShutdown:
822  return TRUE;
823  default:
825  return FALSE;
826  };
827 }
828 
829 static VOID
831 {
832  //Lohnegrim: If the System doesn't support the Powerstates, then we have to change them
833  if (!PowerCaps.SystemS1 && *Psps == PowerSystemSleeping1)
834  *Psps = PowerSystemSleeping2;
835  if (!PowerCaps.SystemS2 && *Psps == PowerSystemSleeping2)
836  *Psps = PowerSystemSleeping3;
837  if (!PowerCaps.SystemS3 && *Psps == PowerSystemSleeping3)
838  *Psps = PowerSystemHibernate;
839  if (!(PowerCaps.SystemS4 && PowerCaps.HiberFilePresent) && *Psps == PowerSystemHibernate)
840  *Psps = PowerSystemSleeping2;
841  if (!PowerCaps.SystemS1 && *Psps == PowerSystemSleeping1)
842  *Psps = PowerSystemSleeping2;
843  if (!PowerCaps.SystemS2 && *Psps == PowerSystemSleeping2)
844  *Psps = PowerSystemSleeping3;
845  if (!PowerCaps.SystemS3 && *Psps == PowerSystemSleeping3)
846  *Psps = PowerSystemShutdown;
847 
848 }
849 
852 {
853  SYSTEM_POWER_CAPABILITIES PowerCaps;
854  NTSTATUS ret;
855  BOOLEAN old;
856 
858  ret = NtPowerInformation(SystemPowerCapabilities, NULL, 0, &PowerCaps, sizeof(PowerCaps));
859  if (ret != STATUS_SUCCESS)
860  {
862  return FALSE;
863  }
864 
865  if (pGPP)
866  {
867  if (pGPP->user.Revision != 1 || pGPP->mach.Revision != 1)
868  {
870  return FALSE;
871  }
873  {
875  return FALSE;
876  }
877  if ((int)pGPP->mach.LidOpenWakeAc > PowerSystemShutdown)
878  {
880  return FALSE;
881  }
883  {
885  return FALSE;
886  }
887  if ((int)pGPP->mach.LidOpenWakeDc > PowerSystemShutdown)
888  {
890  return FALSE;
891  }
892  //Lohnegrim: unneeded
893  /*if ((pGPP->mach.LidOpenWakeDc < PowerSystemWorking) || (pGPP->mach.LidOpenWakeDc >= PowerSystemMaximum))
894  {
895  SetLastError(ERROR_GEN_FAILURE);
896  return FALSE;
897  }*/
898  if (!CheckPowerActionPolicy(&pGPP->user.LidCloseAc,PowerCaps))
899  {
900  return FALSE;
901  }
902  if (!CheckPowerActionPolicy(&pGPP->user.LidCloseDc,PowerCaps))
903  {
904  return FALSE;
905  }
906  if (!CheckPowerActionPolicy(&pGPP->user.PowerButtonAc,PowerCaps))
907  {
908  return FALSE;
909  }
910  if (!CheckPowerActionPolicy(&pGPP->user.PowerButtonDc,PowerCaps))
911  {
912  return FALSE;
913  }
914  if (!CheckPowerActionPolicy(&pGPP->user.SleepButtonAc,PowerCaps))
915  {
916  return FALSE;
917  }
918  if (!CheckPowerActionPolicy(&pGPP->user.SleepButtonDc,PowerCaps))
919  {
920  return FALSE;
921  }
922  //Lohnegrim: The BroadcastCapacityResolution presents the Powerlevel in Percent, if invalid set th 100 == FULL
923  if (pGPP->mach.BroadcastCapacityResolution > 100)
924  pGPP->mach.BroadcastCapacityResolution = 100;
925 
926  //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
927  //pGPP->user.DischargePolicy[1].PowerPolicy.EventCode = pGPP->user.DischargePolicy[1].PowerPolicy.EventCode | 0x010000;
928  //pGPP->user.DischargePolicy[2].PowerPolicy.EventCode = pGPP->user.DischargePolicy[2].PowerPolicy.EventCode | 0x020000;
929  //pGPP->user.DischargePolicy[3].PowerPolicy.EventCode = pGPP->user.DischargePolicy[3].PowerPolicy.EventCode | 0x030000;
930 
931  FixSystemPowerState(&pGPP->mach.LidOpenWakeAc,PowerCaps);
932  FixSystemPowerState(&pGPP->mach.LidOpenWakeDc,PowerCaps);
933 
934  }
935 
936  if (pPP)
937  {
938  if (pPP->user.Revision != 1 || pPP->mach.Revision != 1)
939  {
941  return FALSE;
942  }
943 
944  //Lohnegrim: unneeded
945  //if (pPP->mach.MinSleepAc < PowerSystemWorking)
946  //{
947  // SetLastError(ERROR_GEN_FAILURE);
948  // return FALSE;
949  //}
950  if ((int)pPP->mach.MinSleepAc >= PowerSystemShutdown)
951  {
953  return FALSE;
954  }
955  //Lohnegrim: unneeded
956  //if (pPP->mach.MinSleepDc < PowerSystemWorking)
957  //{
958  // SetLastError(ERROR_GEN_FAILURE);
959  // return FALSE;
960  //}
961  if ((int)pPP->mach.MinSleepDc >= PowerSystemShutdown)
962  {
964  return FALSE;
965  }
967  {
969  return FALSE;
970  }
972  {
974  return FALSE;
975  }
977  {
979  return FALSE;
980  }
982  {
984  return FALSE;
985  }
986 
987  if (!CheckPowerActionPolicy(&pPP->mach.OverThrottledAc,PowerCaps))
988  {
989  return FALSE;
990  }
991  if (!CheckPowerActionPolicy(&pPP->mach.OverThrottledDc,PowerCaps))
992  {
993  return FALSE;
994  }
995  if (!CheckPowerActionPolicy(&pPP->user.IdleAc,PowerCaps))
996  {
997  return FALSE;
998  }
999  if (!CheckPowerActionPolicy(&pPP->user.IdleDc,PowerCaps))
1000  {
1001  return FALSE;
1002  }
1003  if (pPP->user.MaxSleepAc < PowerSystemWorking)
1004  {
1006  return FALSE;
1007  }
1008  //Lohnegrim: unneeded
1009  /*if ((int)pPP->user.MaxSleepAc > PowerSystemShutdown)
1010  {
1011  SetLastError(ERROR_GEN_FAILURE);
1012  return FALSE;
1013  }*/
1014  if (pPP->user.MaxSleepDc < PowerSystemWorking)
1015  {
1017  return FALSE;
1018  }
1019  //Lohnegrim: unneeded
1020  /*if ((int)pPP->user.MaxSleepDc >= PowerSystemShutdown)
1021  {
1022  SetLastError(ERROR_GEN_FAILURE);
1023  return FALSE;
1024  }*/
1025  if (PowerCaps.SystemS1)
1026  {
1029  }
1030  else if (PowerCaps.SystemS2)
1031  {
1034  }
1035  else if (PowerCaps.SystemS3)
1036  {
1039  }
1040 
1041  if (PowerCaps.SystemS4)
1042  {
1045  }
1046  else if (PowerCaps.SystemS3)
1047  {
1050  }
1051  else if (PowerCaps.SystemS1)
1052  {
1055  }
1056  //Lohnegrim: I don't know where to get this info from, so I removed it
1057  //pPP->user.OptimizeForPowerAc=TRUE;
1058  //pPP->user.OptimizeForPowerDc=TRUE;
1059 
1062  }
1063 
1065  return TRUE;
1066 }
1067 
1069 {
1070  WCHAR Buf[MAX_PATH];
1071  HKEY hKey;
1072 
1073  swprintf(Buf, L"Control Panel\\PowerCfg\\PowerPolicies\\%i", *puiID);
1074 
1075  if (RegCreateKey(HKEY_CURRENT_USER, Buf, &hKey) != ERROR_SUCCESS)
1076  return FALSE;
1077 
1078  RegSetValueExW(hKey, szPolicies, 0, REG_BINARY, (const unsigned char *)&pPowerPolicy->user, sizeof(USER_POWER_POLICY));
1079  RegCloseKey(hKey);
1080 
1081  swprintf(Buf, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Controls Folder\\PowerCfg\\PowerPolicies\\%i", *puiID);
1082 
1083  if (RegCreateKey(HKEY_LOCAL_MACHINE, Buf, &hKey) != ERROR_SUCCESS)
1084  return FALSE;
1085 
1086  RegSetValueExW(hKey, szPolicies, 0, REG_BINARY, (const unsigned char *)&pPowerPolicy->mach, sizeof(MACHINE_POWER_POLICY));
1087  RegCloseKey(hKey);
1088 
1089  return TRUE;
1090 }
1091 
1092 BOOL WINAPI
1094 {
1095  switch(fdwReason)
1096  {
1097  case DLL_PROCESS_ATTACH:
1098  {
1099  HKEY hKey;
1100  LONG Err;
1101 
1102  DisableThreadLibraryCalls(hinstDLL);
1103 
1105 
1106  if (Err != ERROR_SUCCESS)
1107  {
1108  TRACE("Couldn't open registry key HKLM\\%s, using some sane(?) defaults\n", debugstr_w(szPowerCfgSubKey));
1109  }
1110  else
1111  {
1112  WCHAR lpValue[MAX_PATH];
1113  DWORD cbValue = sizeof(lpValue);
1114 
1115  Err = RegQueryValueExW(hKey, szLastID, 0, 0, (BYTE*)lpValue, &cbValue);
1116  if (Err == ERROR_SUCCESS)
1117  {
1118  g_LastID = _wtoi(lpValue);
1119  }
1120  else
1121  {
1122  TRACE("Couldn't open registry entry HKLM\\%s\\LastID, using some sane(?) defaults\n", debugstr_w(szPowerCfgSubKey));
1123  }
1124  RegCloseKey(hKey);
1125  }
1126 
1128  if (PPRegSemaphore == NULL)
1129  {
1130  ERR("Couldn't create Semaphore: %d\n", GetLastError());
1131  return FALSE;
1132  }
1133  break;
1134  }
1135  case DLL_PROCESS_DETACH:
1137  break;
1138  }
1139  return TRUE;
1140 }
BOOLEAN WINAPI SetSuspendState(BOOLEAN Hibernate, BOOLEAN ForceCritical, BOOLEAN DisableWakeEvent)
Definition: powrprof.c:681
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
Definition: powrprof.c:1093
static const WCHAR szName[]
Definition: powrprof.c:45
BOOLEAN WINAPI WritePwrPolicy(PUINT puiID, PPOWER_POLICY pPowerPolicy)
Definition: powrprof.c:1068
#define TRUE
Definition: types.h:120
POWER_ACTION_POLICY SleepButtonDc
Definition: powrprof.h:35
const CHAR * LPCTSTR
Definition: xmlstorage.h:193
#define CloseHandle
Definition: compat.h:398
UINT g_LastID
Definition: powrprof.c:52
BOOLEAN WINAPI IsPwrSuspendAllowed(VOID)
Definition: powrprof.c:488
WINE_UNICODE_INLINE unsigned int strlenW(const WCHAR *str)
Definition: unicode.h:212
Type
Definition: Type.h:6
#define ERROR_SUCCESS
Definition: deptool.c:10
SYSTEM_POWER_STATE LidOpenWakeDc
Definition: powrprof.h:27
SYSTEM_POWER_STATE MaxSleepAc
Definition: powrprof.h:76
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
HANDLE WINAPI DECLSPEC_HOTPATCH CreateSemaphoreW(IN LPSECURITY_ATTRIBUTES lpSemaphoreAttributes OPTIONAL, IN LONG lInitialCount, IN LONG lMaximumCount, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:444
GLOBAL_USER_POWER_POLICY user
Definition: powrprof.h:42
#define REG_BINARY
Definition: nt_native.h:1496
#define KEY_READ
Definition: nt_native.h:1023
BOOLEAN WINAPI SetActivePwrScheme(UINT uiID, PGLOBAL_POWER_POLICY lpGlobalPowerPolicy, PPOWER_POLICY lpPowerPolicy)
Definition: powrprof.c:642
#define HKEY_CURRENT_USER
Definition: winreg.h:11
unsigned char * PUCHAR
Definition: retypes.h:3
_Check_return_ _CRTIMP int __cdecl _wtoi(_In_z_ const wchar_t *_Str)
#define WARN(fmt,...)
Definition: debug.h:111
LONG NTSTATUS
Definition: precomp.h:26
POWER_ACTION_POLICY PowerButtonDc
Definition: powrprof.h:33
static VOID FixSystemPowerState(PSYSTEM_POWER_STATE Psps, SYSTEM_POWER_CAPABILITIES PowerCaps)
Definition: powrprof.c:830
BOOL WINAPI DisableThreadLibraryCalls(IN HMODULE hLibModule)
Definition: loader.c:85
BOOLEAN WINAPI GetPwrCapabilities(PSYSTEM_POWER_CAPABILITIES lpSystemPowerCapabilities)
Definition: powrprof.c:358
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
NTSYSAPI NTSTATUS NTAPI RtlAdjustPrivilege(_In_ ULONG Privilege, _In_ BOOLEAN NewValue, _In_ BOOLEAN ForThread, _Out_ PBOOLEAN OldValue)
POWER_ACTION_POLICY IdleDc
Definition: powrprof.h:69
BOOLEAN WINAPI ReadPwrScheme(UINT uiID, PPOWER_POLICY pPowerPolicy)
Definition: powrprof.c:610
#define DLL_PROCESS_ATTACH
Definition: compat.h:120
#define ERROR_REVISION_MISMATCH
Definition: winerror.h:788
#define RegCreateKey
Definition: winreg.h:500
static IN DWORD IN LPVOID lpvReserved
BOOLEAN WINAPI GetPwrDiskSpindownRange(PUINT RangeMax, PUINT RangeMin)
Definition: powrprof.c:381
struct _MACHINE_POWER_POLICY MACHINE_POWER_POLICY
static const WCHAR szPowerCfgSubKey[]
Definition: powrprof.c:38
GLOBAL_MACHINE_POWER_POLICY mach
Definition: powrprof.h:43
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
_In_ PSID _Out_writes_to_opt_ cchName LPSTR _Inout_ LPDWORD cchName
Definition: winbase.h:2713
SYSTEM_POWER_STATE MaxSleepDc
Definition: powrprof.h:77
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
unsigned char * LPBYTE
Definition: typedefs.h:52
#define ERROR_ACCESS_DENIED
Definition: compat.h:87
unsigned int BOOL
Definition: ntddk_ex.h:94
long LONG
Definition: pedump.c:60
NTSTATUS WINAPI CallNtPowerInformation(POWER_INFORMATION_LEVEL InformationLevel, PVOID lpInputBuffer, ULONG nInputBufferSize, PVOID lpOutputBuffer, ULONG nOutputBufferSize)
Definition: powrprof.c:59
#define debugstr_w
Definition: kernel32.h:32
#define FIXME(fmt,...)
Definition: debug.h:110
static const WCHAR szLastID[]
Definition: powrprof.c:50
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
POWER_ACTION Action
Definition: ntpoapi.h:408
static const WCHAR szCurrentPowerPolicies[]
Definition: powrprof.c:42
LONG_PTR LPARAM
Definition: windef.h:208
POWER_ACTION_POLICY IdleAc
Definition: powrprof.h:68
MACHINE_POWER_POLICY mach
Definition: powrprof.h:92
Definition: bufpool.h:45
enum _SYSTEM_POWER_STATE * PSYSTEM_POWER_STATE
BOOLEAN(CALLBACK * PWRSCHEMESENUMPROC)(UINT, DWORD, LPWSTR, DWORD, LPWSTR, PPOWER_POLICY, LPARAM)
Definition: powrprof.h:94
#define SE_SHUTDOWN_PRIVILEGE
Definition: security.c:673
#define debugstr_guid
Definition: kernel32.h:35
static const WCHAR szSemaphoreName[]
Definition: powrprof.c:47
POWER_ACTION_POLICY LidCloseAc
Definition: powrprof.h:36
#define DLL_PROCESS_DETACH
Definition: compat.h:119
static const WCHAR szDiskMin[]
Definition: powrprof.c:49
#define SE_CREATE_PAGEFILE_PRIVILEGE
Definition: security.c:669
USER_POWER_POLICY user
Definition: powrprof.h:91
#define KEY_WRITE
Definition: nt_native.h:1031
WINE_DEFAULT_DEBUG_CHANNEL(powrprof)
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:4895
#define TRACE(s)
Definition: solgame.cpp:4
BOOLEAN WINAPI ReadProcessorPwrScheme(UINT uiID, PMACHINE_PROCESSOR_POWER_POLICY pMachineProcessorPowerPolicy)
Definition: powrprof.c:584
static const WCHAR szPolicies[]
Definition: powrprof.c:44
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4116
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
BOOLEAN WINAPI WritePwrScheme(PUINT puiID, LPWSTR lpszName, LPWSTR lpszDescription, PPOWER_POLICY pPowerPolicy)
Definition: powrprof.c:766
#define MAX_PATH
Definition: compat.h:26
#define swprintf(buf, format,...)
Definition: sprintf.c:56
#define WINAPI
Definition: msvc.h:8
enum _POWER_INFORMATION_LEVEL POWER_INFORMATION_LEVEL
#define BufferSize
Definition: classpnp.h:419
BOOLEAN WINAPI EnumPwrSchemes(PWRSCHEMESENUMPROC lpfnPwrSchemesEnumProc, LPARAM lParam)
Definition: powrprof.c:219
BOOLEAN WINAPI GetActivePwrScheme(PUINT puiID)
Definition: powrprof.c:285
unsigned long DWORD
Definition: ntddk_ex.h:95
POWER_ACTION_POLICY LidCloseDc
Definition: powrprof.h:37
static BOOLEAN CheckPowerActionPolicy(PPOWER_ACTION_POLICY pPAP, SYSTEM_POWER_CAPABILITIES PowerCaps)
Definition: powrprof.c:793
HANDLE PPRegSemaphore
Definition: powrprof.c:56
#define SetLastError(x)
Definition: compat.h:409
BOOLEAN WINAPI WriteProcessorPwrScheme(UINT ID, PMACHINE_PROCESSOR_POWER_POLICY pMachineProcessorPowerPolicy)
Definition: powrprof.c:732
BOOLEAN WINAPI IsAdminOverrideActive(PADMINISTRATOR_POWER_POLICY p)
Definition: powrprof.c:443
int ret
static const WCHAR L[]
Definition: oid.c:1250
BOOLEAN WINAPI IsPwrShutdownAllowed(VOID)
Definition: powrprof.c:469
SYSTEM_POWER_STATE ReducedLatencySleepAc
Definition: powrprof.h:49
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
unsigned char BYTE
Definition: mem.h:68
BOOLEAN WINAPI ValidatePowerPolicies(PGLOBAL_POWER_POLICY pGPP, PPOWER_POLICY pPP)
Definition: powrprof.c:851
#define ID
Definition: ruserpass.c:36
DWORD WINAPI PowerGetActiveScheme(HKEY UserRootPowerKey, GUID **polguid)
Definition: powrprof.c:507
Status
Definition: gdiplustypes.h:24
#define ERROR_INVALID_DATA
Definition: winerror.h:116
SYSTEM_POWER_STATE MinSleepDc
Definition: powrprof.h:48
NTSYSAPI ULONG WINAPI RtlNtStatusToDosError(NTSTATUS)
#define ERR(fmt,...)
Definition: debug.h:109
DWORD WINAPI PowerReadDCValue(HKEY RootPowerKey, const GUID *Scheme, const GUID *SubGroup, const GUID *PowerSettings, PULONG Type, PUCHAR Buffer, DWORD *BufferSize)
Definition: powrprof.c:514
#define RegOpenKeyEx
Definition: winreg.h:520
static BOOLEAN POWRPROF_GetUserPowerPolicy(LPWSTR szNum, PUSER_POWER_POLICY puserPwrPolicy, DWORD cchName, LPWSTR szName, DWORD cchDesc, LPWSTR szDesc)
Definition: powrprof.c:128
BOOLEAN WINAPI ReadGlobalPwrPolicy(PGLOBAL_POWER_POLICY pGlobalPowerPolicy)
Definition: powrprof.c:521
LPCWSTR szPath
Definition: env.c:35
SYSTEM_POWER_STATE MinSleepAc
Definition: powrprof.h:47
#define KEY_ALL_ACCESS
Definition: nt_native.h:1041
POWER_ACTION_POLICY OverThrottledDc
Definition: powrprof.h:59
BOOLEAN WINAPI CanUserWritePwrScheme(VOID)
Definition: powrprof.c:79
unsigned int * PULONG
Definition: retypes.h:1
unsigned int UINT
Definition: ndis.h:50
static const WCHAR szDiskMax[]
Definition: powrprof.c:48
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:660
#define RegDeleteKey
Definition: winreg.h:502
struct _MACHINE_PROCESSOR_POWER_POLICY MACHINE_PROCESSOR_POWER_POLICY
BOOL WINAPI DECLSPEC_HOTPATCH ReleaseSemaphore(IN HANDLE hSemaphore, IN LONG lReleaseCount, IN LPLONG lpPreviousCount)
Definition: synch.c:542
static BOOLEAN POWRPROF_GetMachinePowerPolicy(LPWSTR szNum, PMACHINE_POWER_POLICY pmachinePwrPolicy)
Definition: powrprof.c:185
SYSTEM_POWER_STATE ReducedLatencySleepDc
Definition: powrprof.h:50
BOOLEAN WINAPI WriteGlobalPwrPolicy(PGLOBAL_POWER_POLICY pGlobalPowerPolicy)
Definition: powrprof.c:690
BOOLEAN WINAPI GetCurrentPowerPolicies(PGLOBAL_POWER_POLICY pGlobalPowerPolicy, PPOWER_POLICY pPowerPolicy)
Definition: powrprof.c:321
unsigned int ULONG
Definition: retypes.h:1
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3366
#define ERROR_CALL_NOT_IMPLEMENTED
Definition: compat.h:92
static VOID SetLastID(VOID)
Definition: powrprof.c:749
char * cleanup(char *str)
Definition: wpickclick.c:99
POWER_ACTION_POLICY PowerButtonAc
Definition: powrprof.h:32
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:2527
#define ERROR_GEN_FAILURE
Definition: winerror.h:134
GLfloat GLfloat p
Definition: glext.h:8902
WCHAR * LPWSTR
Definition: xmlstorage.h:184
POWER_ACTION_POLICY OverThrottledAc
Definition: powrprof.h:58
#define INFINITE
Definition: serial.h:102
return STATUS_SUCCESS
Definition: btrfs.c:2966
BOOLEAN WINAPI IsPwrHibernateAllowed(VOID)
Definition: powrprof.c:450
static const WCHAR szUserPowerConfigSubKey[]
Definition: powrprof.c:40
SYSTEM_POWER_STATE LidOpenWakeAc
Definition: powrprof.h:26
BOOLEAN WINAPI DeletePwrScheme(UINT uiIndex)
Definition: powrprof.c:99
BYTE * PBYTE
Definition: pedump.c:66
LPARAM lParam
Definition: combotst.c:139
struct _USER_POWER_POLICY USER_POWER_POLICY
size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
POWER_ACTION_POLICY SleepButtonAc
Definition: powrprof.h:34
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:54
static const WCHAR szDescription[]
Definition: powrprof.c:46
unsigned int * PUINT
Definition: ndis.h:50
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
#define REG_SZ
Definition: layer.c:22