1400 lines
39 KiB
C
1400 lines
39 KiB
C
/*****************************************************************/
|
|
/** Microsoft LAN Manager **/
|
|
/** Copyright(c) Microsoft Corp., 1988-1991 **/
|
|
/*****************************************************************/
|
|
|
|
#include <stdio.h>
|
|
#include <process.h>
|
|
#include <setjmp.h>
|
|
#include <stdlib.h>
|
|
|
|
#include <time.h>
|
|
|
|
#include <nt.h>
|
|
#include <ntrtl.h>
|
|
#include <nturtl.h>
|
|
#include <windows.h>
|
|
|
|
PROCESSOR_POWER_POLICY PAc, PDc, PCurrent;
|
|
SYSTEM_POWER_POLICY Ac, Dc, Current;
|
|
SYSTEM_POWER_CAPABILITIES Cap;
|
|
SYSTEM_POWER_STATUS PS;
|
|
ADMINISTRATOR_POWER_POLICY Admin;
|
|
SYSTEM_BATTERY_STATE Batt;
|
|
|
|
typedef
|
|
VOID
|
|
(*PCUR_PRINT)(
|
|
IN PVOID Context
|
|
);
|
|
|
|
typedef
|
|
VOID
|
|
(*PCUR_ASSIGN)(
|
|
PUCHAR Variable,
|
|
PUCHAR Value
|
|
);
|
|
|
|
ULONG CurType;
|
|
POWER_INFORMATION_LEVEL CurInfo;
|
|
PVOID CurContext;
|
|
ULONG CurContextSize;
|
|
PCUR_PRINT CurPrint;
|
|
PCUR_ASSIGN CurAssign;
|
|
PUCHAR CurDesc;
|
|
|
|
PUCHAR CurValue;
|
|
BOOLEAN ItemUpdated;
|
|
BOOLEAN CurValueIsNumeric;
|
|
|
|
BOOLEAN Verbose1;
|
|
BOOLEAN Verbose2;
|
|
|
|
|
|
|
|
PUCHAR szBool[] = { "FALSE", "TRUE" };
|
|
|
|
|
|
typedef struct {
|
|
ULONG Flags;
|
|
PUCHAR String;
|
|
} DEFBITS, *PDEFBITS;
|
|
|
|
DEFBITS ActFlags[] = {
|
|
POWER_ACTION_QUERY_ALLOWED, "QueryApps",
|
|
POWER_ACTION_UI_ALLOWED, "UIAllowed",
|
|
POWER_ACTION_OVERRIDE_APPS, "OverrideApps",
|
|
POWER_ACTION_DISABLE_WAKES, "DisableWakes",
|
|
POWER_ACTION_CRITICAL, "Critical",
|
|
0, NULL
|
|
};
|
|
|
|
DEFBITS PsBatteryFlagBits[] = {
|
|
BATTERY_FLAG_HIGH, "high",
|
|
BATTERY_FLAG_LOW, "low",
|
|
BATTERY_FLAG_CRITICAL, "critical",
|
|
BATTERY_FLAG_CHARGING, "charing",
|
|
0, NULL
|
|
};
|
|
|
|
|
|
|
|
|
|
PUCHAR
|
|
ActionS(
|
|
IN POWER_ACTION Act
|
|
)
|
|
{
|
|
static char line[50];
|
|
PCHAR p;
|
|
|
|
switch (Act) {
|
|
case PowerActionNone: p = "None"; break;
|
|
case PowerActionSleep: p = "Sleep"; break;
|
|
case PowerActionHibernate: p = "Hibernate"; break;
|
|
case PowerActionShutdown: p = "Shutdown"; break;
|
|
case PowerActionShutdownReset: p = "ShutdownReset"; break;
|
|
case PowerActionShutdownOff: p = "ShutdownOff"; break;
|
|
default:
|
|
sprintf(line, "Unknown action %x", Act);
|
|
p = line;
|
|
break;
|
|
}
|
|
|
|
return p;
|
|
}
|
|
|
|
PUCHAR
|
|
SysPower(
|
|
IN SYSTEM_POWER_STATE State
|
|
)
|
|
{
|
|
static char line[50];
|
|
PCHAR p;
|
|
|
|
switch (State) {
|
|
case PowerSystemUnspecified: p = "Unspecified"; break;
|
|
case PowerSystemWorking: p = "Working"; break;
|
|
case PowerSystemSleeping1: p = "S1"; break;
|
|
case PowerSystemSleeping2: p = "S2"; break;
|
|
case PowerSystemSleeping3: p = "S3"; break;
|
|
case PowerSystemHibernate: p = "S4 - hibernate"; break;
|
|
case PowerSystemShutdown: p = "Shutdown"; break;
|
|
default:
|
|
sprintf(line, "Unknown power state %x", State);
|
|
p = line;
|
|
break;
|
|
}
|
|
|
|
return p;
|
|
}
|
|
|
|
PUCHAR
|
|
DynamicThrottle(
|
|
IN UCHAR Throttle
|
|
)
|
|
{
|
|
static char line[50];
|
|
PCHAR p;
|
|
|
|
switch (Throttle) {
|
|
case PO_THROTTLE_NONE: p = "None"; break;
|
|
case PO_THROTTLE_CONSTANT: p = "Constant"; break;
|
|
case PO_THROTTLE_DEGRADE: p = "Degrade"; break;
|
|
case PO_THROTTLE_ADAPTIVE: p = "Adaptive"; break;
|
|
default:
|
|
sprintf(line,"Unknown Dynamic Throttle state %x", Throttle);
|
|
p = line;
|
|
break;
|
|
}
|
|
return p;
|
|
}
|
|
|
|
PUCHAR
|
|
MicroSeconds(
|
|
IN ULONG Time
|
|
)
|
|
{
|
|
static char line[256];
|
|
PCHAR p;
|
|
ULONG MicroSeconds;
|
|
ULONG MilliSeconds;
|
|
ULONG Seconds;
|
|
ULONG Minutes;
|
|
ULONG Hours;
|
|
ULONG Days;
|
|
|
|
MicroSeconds = Time % 1000;
|
|
MilliSeconds = Time / 1000;
|
|
|
|
Seconds = MilliSeconds / 1000;
|
|
MilliSeconds = MilliSeconds % 1000;
|
|
|
|
Minutes = Seconds / 60;
|
|
Seconds = Seconds % 60;
|
|
|
|
Hours = Minutes / 60;
|
|
Minutes = Minutes % 60;
|
|
|
|
Days = Hours / 24;
|
|
Hours = Hours % 24;
|
|
|
|
if (Hours) {
|
|
|
|
sprintf(
|
|
line,
|
|
"%d [%2d:%2d %ds %dms %dus]",
|
|
Time,
|
|
Hours,
|
|
Minutes,
|
|
Seconds,
|
|
MilliSeconds,
|
|
MicroSeconds
|
|
);
|
|
|
|
} else if (Minutes) {
|
|
|
|
sprintf(
|
|
line,
|
|
"%d [0:%2d %ds %dms %dus]",
|
|
Time,
|
|
Minutes,
|
|
Seconds,
|
|
MilliSeconds,
|
|
MicroSeconds
|
|
);
|
|
|
|
} else if (Seconds) {
|
|
|
|
sprintf(
|
|
line,
|
|
"%d [%ds %dms %dus]",
|
|
Time,
|
|
Seconds,
|
|
MilliSeconds,
|
|
MicroSeconds
|
|
);
|
|
|
|
} else if (MilliSeconds) {
|
|
|
|
sprintf(
|
|
line,
|
|
"%d [%dms %dus]",
|
|
Time,
|
|
MilliSeconds,
|
|
MicroSeconds
|
|
);
|
|
|
|
} else {
|
|
|
|
sprintf(
|
|
line,
|
|
"%d [%dus]",
|
|
Time,
|
|
MicroSeconds
|
|
);
|
|
|
|
}
|
|
p = line;
|
|
return p;
|
|
}
|
|
|
|
VOID
|
|
GetBits (
|
|
IN PUCHAR Dest,
|
|
IN ULONG Flags,
|
|
IN PDEFBITS DefBits
|
|
)
|
|
{
|
|
UCHAR c;
|
|
ULONG i;
|
|
|
|
c = 0;
|
|
|
|
*Dest = 0;
|
|
for (i=0; DefBits[i].Flags; i++) {
|
|
if (Flags & DefBits[i].Flags) {
|
|
if (c) {
|
|
*Dest = c;
|
|
Dest += 1;
|
|
}
|
|
strcpy(Dest, DefBits[i].String);
|
|
Dest += strlen(DefBits[i].String);
|
|
c = '|';
|
|
}
|
|
}
|
|
}
|
|
|
|
VOID
|
|
PrintPowerStatus (
|
|
VOID
|
|
)
|
|
{
|
|
ULONG i;
|
|
PUCHAR Ls;
|
|
UCHAR Bf[200];
|
|
|
|
switch (PS.ACLineStatus) {
|
|
case AC_LINE_OFFLINE: Ls = "off line"; break;
|
|
case AC_LINE_ONLINE: Ls = "on line"; break;
|
|
case AC_LINE_BACKUP_POWER: Ls = "backup power"; break;
|
|
case AC_LINE_UNKNOWN: Ls = "unknown"; break;
|
|
default: Ls = "**invalid**"; break;
|
|
}
|
|
|
|
strcpy (Bf, "unkown");
|
|
if (PS.BatteryFlag != BATTERY_FLAG_UNKNOWN) {
|
|
GetBits(Bf, PS.BatteryFlag, PsBatteryFlagBits);
|
|
}
|
|
|
|
printf ("Win32 System power status\n"
|
|
"AC line status..........: %s\n", Ls);
|
|
printf ("Battery flag............: %s\n", Bf);
|
|
printf ("Battery life percent....: %d\n", PS.BatteryLifePercent);
|
|
printf ("Battery full life time..: %d\n\n", PS.BatteryFullLifeTime);
|
|
}
|
|
|
|
VOID
|
|
PrintBattStatus (
|
|
VOID
|
|
)
|
|
{
|
|
ULONG i;
|
|
PUCHAR Ls;
|
|
UCHAR Bf[200];
|
|
|
|
printf ("AC on line..............: %s\n", szBool[Batt.AcOnLine]);
|
|
printf ("Battery present ........: %s\n", szBool[Batt.BatteryPresent]);
|
|
printf ("Charging................: %s\n", szBool[Batt.Charging]);
|
|
printf ("Discharging.............: %s\n", szBool[Batt.Discharging]);
|
|
printf ("Max Capacity............: %d\n", Batt.MaxCapacity);
|
|
printf ("Remaining Capacity......: %d", Batt.RemainingCapacity);
|
|
if (Batt.MaxCapacity) {
|
|
printf (" %d%%\n", Batt.RemainingCapacity * 100 / Batt.MaxCapacity);
|
|
} else {
|
|
printf (" (divide by zero)%%\n");
|
|
}
|
|
|
|
printf ("Rate....................: %d\n", Batt.Rate);
|
|
printf ("Estimated time..........: %d\n", Batt.EstimatedTime);
|
|
printf ("Default alert 1 & 2.....: %d %d\n\n",Batt.DefaultAlert1, Batt.DefaultAlert2);
|
|
}
|
|
|
|
BOOLEAN
|
|
streql (
|
|
PUCHAR p1,
|
|
PUCHAR p2
|
|
)
|
|
{
|
|
return strcmp(p1, p2) == 0;
|
|
}
|
|
|
|
PUCHAR
|
|
_strtok (
|
|
PUCHAR Start
|
|
)
|
|
{
|
|
static PUCHAR Location;
|
|
PUCHAR p;
|
|
|
|
|
|
if (Start) {
|
|
Location = Start;
|
|
}
|
|
|
|
for (p = Location; *p && *p <'a' && *p >'z'; p++) ;
|
|
if (!*p) {
|
|
return NULL;
|
|
}
|
|
|
|
Start = p;
|
|
for (; *p && *p >= 'a' && *p <= 'z'; p++) ;
|
|
if (*p) {
|
|
*p++ = 0;
|
|
}
|
|
Location = p;
|
|
return Start;
|
|
}
|
|
|
|
|
|
VOID
|
|
PrintCap (
|
|
PVOID Context
|
|
)
|
|
{
|
|
ULONG i;
|
|
|
|
puts ("System power capabilties");
|
|
printf ("Power Button Present....: %s\n", szBool[Cap.PowerButtonPresent]);
|
|
printf ("Sleep Button Present....: %s\n", szBool[Cap.SleepButtonPresent]);
|
|
printf ("Lid Present.............: %s\n", szBool[Cap.LidPresent]);
|
|
printf ("System states supported.: %s%s%s%s%s\n",
|
|
Cap.SystemS1 ? "S1 " : "",
|
|
Cap.SystemS2 ? "S2 " : "",
|
|
Cap.SystemS3 ? "S3 " : "",
|
|
Cap.SystemS4 ? "S4 " : "",
|
|
Cap.SystemS5 ? "S5 " : ""
|
|
);
|
|
printf ("Hiber file reserved.....: %s\n", szBool[Cap.HiberFilePresent]);
|
|
printf ("Thermal control.........: %s\n", szBool[Cap.ThermalControl]);
|
|
printf ("CPU Throttle control....: %s\n", szBool[Cap.ProcessorThrottle]);
|
|
printf ("Processor min throttle..: %d\n", Cap.ProcessorMinThrottle);
|
|
printf ("Processor max throttle..: %d\n", Cap.ProcessorMaxThrottle);
|
|
printf ("Some disk will spindown.: %s\n", szBool[Cap.DiskSpinDown]);
|
|
printf ("System batteries present: %s %s\n",
|
|
szBool[Cap.SystemBatteriesPresent],
|
|
Cap.BatteriesAreShortTerm ? "- short term" : ""
|
|
);
|
|
printf ("System batteries scale..: ");
|
|
for (i=0; i<3; i++) {
|
|
printf ("(G:%d C:%d) ",
|
|
Cap.BatteryScale[i].Granularity,
|
|
Cap.BatteryScale[i].Capacity
|
|
);
|
|
}
|
|
printf ("\n"
|
|
"Ac on line wake ability.: %s\n", SysPower(Cap.AcOnLineWake));
|
|
printf ("Lid wake ability........: %s\n", SysPower(Cap.SoftLidWake));
|
|
printf ("RTC wake ability........: %s\n", SysPower(Cap.RtcWake));
|
|
printf ("Min device wake.........: %s\n", SysPower(Cap.MinDeviceWakeState));
|
|
printf ("Default low latency wake: %s\n\n", SysPower(Cap.DefaultLowLatencyWake));
|
|
}
|
|
|
|
PUCHAR
|
|
Action (
|
|
IN PBOOLEAN CapFlag,
|
|
IN PPOWER_ACTION_POLICY Act
|
|
)
|
|
{
|
|
static UCHAR text[200];
|
|
PUCHAR p;
|
|
UCHAR c;
|
|
ULONG i;
|
|
|
|
p = text;
|
|
|
|
if (CapFlag && !*CapFlag) {
|
|
strcpy(p, "Disabled ");
|
|
p += strlen("Disabled ");
|
|
}
|
|
|
|
strcpy(p, ActionS(Act->Action));
|
|
p+=strlen(ActionS(Act->Action));
|
|
if (Act->Action != PowerActionNone && Act->Flags) {
|
|
c = '(';
|
|
for (i=0; ActFlags[i].Flags; i++) {
|
|
if (Act->Flags & ActFlags[i].Flags) {
|
|
p += sprintf (p, "%c%s", c, ActFlags[i].String);
|
|
c = '|';
|
|
}
|
|
}
|
|
p += sprintf (p, ")");
|
|
}
|
|
|
|
if (Act->EventCode) {
|
|
p += sprintf (p, "-Code=%x", Act->EventCode);
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
VOID
|
|
SetAction (
|
|
IN PPOWER_ACTION_POLICY Action
|
|
)
|
|
{
|
|
PUCHAR p;
|
|
POWER_ACTION Act;
|
|
ULONG Flags;
|
|
|
|
|
|
Flags = 0;
|
|
p = _strtok (CurValue);
|
|
if (streql(p, "none")) { Act = PowerActionNone;
|
|
} else if (streql(p, "sleep")) { Act = PowerActionSleep;
|
|
} else if (streql(p, "hiber")) { Act = PowerActionHibernate;
|
|
} else if (streql(p, "shutdown")) { Act = PowerActionShutdown;
|
|
} else if (streql(p, "shutdownreset")) { Act = PowerActionShutdownReset;
|
|
} else if (streql(p, "shutdownoff")) { Act = PowerActionShutdownOff;
|
|
} else {
|
|
printf ("Unknown power action '%s'.\n", p);
|
|
puts ("use: doze, sleep, shutdown, shutdownreset, shutdownoff");
|
|
exit (1);
|
|
}
|
|
|
|
while (p = _strtok(NULL)) {
|
|
if (streql(p, "qapp")) { Flags |= POWER_ACTION_QUERY_ALLOWED;
|
|
} else if (streql(p, "ui")) { Flags |= POWER_ACTION_UI_ALLOWED;
|
|
} else if (streql(p, "override")) { Flags |= POWER_ACTION_OVERRIDE_APPS;
|
|
} else if (streql(p, "disablewake")) { Flags |= POWER_ACTION_DISABLE_WAKES;
|
|
} else if (streql(p, "critical")) { Flags |= POWER_ACTION_CRITICAL;
|
|
} else {
|
|
printf ("Unknown power action '%s'.\n", p);
|
|
puts ("use: qapp, io, override, disablewake, critical");
|
|
exit (1);
|
|
}
|
|
}
|
|
|
|
Action->Action = Act;
|
|
Action->Flags = Flags;
|
|
}
|
|
|
|
|
|
VOID
|
|
SetSysPower (
|
|
IN PSYSTEM_POWER_STATE SysPower
|
|
)
|
|
{
|
|
PUCHAR p;
|
|
|
|
p = CurValue;
|
|
if (streql(p, "s0")) { *SysPower = PowerSystemWorking;
|
|
} else if (streql(p, "s1")) { *SysPower = PowerSystemSleeping1;
|
|
} else if (streql(p, "s2")) { *SysPower = PowerSystemSleeping2;
|
|
} else if (streql(p, "s3")) { *SysPower = PowerSystemSleeping3;
|
|
} else if (streql(p, "s4")) { *SysPower = PowerSystemHibernate;
|
|
} else {
|
|
printf ("Unknown system power state '%s'. Use S0,S1,S2,S3 or S4\n", p);
|
|
exit (1);
|
|
}
|
|
}
|
|
|
|
VOID
|
|
SetPolicyCount(
|
|
IN PULONG Variable
|
|
)
|
|
{
|
|
ULONG local;
|
|
if (!CurValueIsNumeric) {
|
|
printf("'%s' is not numeric\n", CurValue);
|
|
exit(1);
|
|
}
|
|
local = atol(CurValue);
|
|
if (local > 3) {
|
|
puts("PolicyCount can only be in the range 0 to 3\n");
|
|
exit(1);
|
|
}
|
|
*Variable = local;
|
|
}
|
|
|
|
VOID
|
|
SetDynamicThrottle(
|
|
IN PUCHAR Variable
|
|
)
|
|
{
|
|
ULONG local;
|
|
PUCHAR p;
|
|
|
|
p = CurValue;
|
|
if (streql(p,"none")) { *Variable = PO_THROTTLE_NONE;
|
|
} else if (streql(p,"constant")) { *Variable = PO_THROTTLE_CONSTANT;
|
|
} else if (streql(p,"degrade")) { *Variable = PO_THROTTLE_DEGRADE;
|
|
} else if (streql(p,"degraded")) { *Variable = PO_THROTTLE_DEGRADE;
|
|
} else if (streql(p,"adaptive")) { *Variable = PO_THROTTLE_ADAPTIVE;
|
|
} else {
|
|
printf("Unknown Dynamic Throttle state %s\n", CurValue);
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
VOID
|
|
SetCStates(
|
|
IN PPROCESSOR_POWER_POLICY Pol
|
|
)
|
|
{
|
|
PUCHAR p;
|
|
|
|
p = CurValue;
|
|
if (streql(p,"true")) {
|
|
|
|
Pol->DisableCStates = 1;
|
|
|
|
} else {
|
|
|
|
Pol->DisableCStates = 0;
|
|
|
|
}
|
|
}
|
|
|
|
VOID
|
|
SetPercentage (
|
|
IN PUCHAR Variable
|
|
)
|
|
{
|
|
PUCHAR p;
|
|
|
|
if (!CurValueIsNumeric) {
|
|
|
|
for (p = CurValue; *p; p++) {
|
|
if (*p == '%') {
|
|
*p = '\0';
|
|
}
|
|
}
|
|
CurValueIsNumeric = TRUE;
|
|
for (p = CurValue; *p; p++) {
|
|
if (*p < '0' || *p > '9') {
|
|
CurValueIsNumeric = FALSE;
|
|
}
|
|
}
|
|
if (!CurValueIsNumeric) {
|
|
printf ("'%s' is not numeric\n", CurValue);
|
|
exit (1);
|
|
}
|
|
}
|
|
*Variable = (UCHAR) atol(CurValue);
|
|
}
|
|
|
|
|
|
VOID
|
|
SetValue (
|
|
IN PULONG Variable
|
|
)
|
|
{
|
|
if (!CurValueIsNumeric) {
|
|
printf ("'%s' is not numeric\n", CurValue);
|
|
exit (1);
|
|
}
|
|
|
|
*Variable = atol(CurValue);
|
|
}
|
|
|
|
VOID
|
|
SetBool (
|
|
IN PBOOLEAN Variable
|
|
)
|
|
{
|
|
BOOLEAN State;
|
|
|
|
State = 99;
|
|
if (CurValueIsNumeric) {
|
|
State = (BOOLEAN)atol(CurValue);
|
|
} else {
|
|
if (streql(CurValue, "true")) { State = TRUE;
|
|
} else if (streql(CurValue, "false")) { State = FALSE;
|
|
}
|
|
}
|
|
|
|
if (State != FALSE && State != TRUE) {
|
|
printf ("'%s' is not boolean\n", CurValue);
|
|
exit (1);
|
|
}
|
|
|
|
*Variable = State;
|
|
}
|
|
|
|
VOID
|
|
SetField(
|
|
IN PPROCESSOR_POWER_POLICY Pol,
|
|
IN ULONG Index,
|
|
IN PUCHAR What
|
|
)
|
|
{
|
|
BOOLEAN State;
|
|
|
|
State = 99;
|
|
if (CurValueIsNumeric) {
|
|
|
|
State = (BOOLEAN)atol(CurValue);
|
|
|
|
} else {
|
|
|
|
if (streql(CurValue, "true")) { State = TRUE;
|
|
} else if (streql(CurValue, "false")) { State = FALSE;
|
|
}
|
|
|
|
}
|
|
|
|
if (State != FALSE && State != TRUE) {
|
|
printf ("'%s' is not boolean\n", CurValue);
|
|
exit (1);
|
|
}
|
|
|
|
if (streql(What,"allowpromotion")) { Pol->Policy[Index].AllowPromotion = State;
|
|
} else if (streql(What,"allowdemotion")) { Pol->Policy[Index].AllowDemotion = State;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
PrintPol (
|
|
IN PSYSTEM_POWER_POLICY Pol
|
|
)
|
|
{
|
|
BOOLEAN AnySleep;
|
|
ULONG i;
|
|
UCHAR text[200];
|
|
PUCHAR p;
|
|
|
|
if (Pol->Revision != 1) {
|
|
puts ("** revision not 1**");
|
|
}
|
|
|
|
AnySleep = Cap.SystemS1 || Cap.SystemS2 || Cap.SystemS3 || Cap.SystemS4;
|
|
|
|
printf ("Power button.........: %s\n", Action(&Cap.PowerButtonPresent, &Pol->PowerButton));
|
|
printf ("Sleep button.........: %s\n", Action(&Cap.SleepButtonPresent, &Pol->SleepButton));
|
|
printf ("Lid close............: %s\n", Action(&Cap.LidPresent, &Pol->LidClose));
|
|
printf ("Lid open wake........: %s\n", SysPower(Pol->LidOpenWake));
|
|
|
|
printf ("Idle.................: %s\n", Action(&AnySleep, &Pol->Idle));
|
|
printf ("Settings.............: Timeout=%d, Sensitivity=%d\n",
|
|
Pol->IdleTimeout,
|
|
Pol->IdleSensitivity
|
|
);
|
|
|
|
printf ("Min sleep state......: %s\n", SysPower(Pol->MinSleep));
|
|
printf ("Max sleep state......: %s\n", SysPower(Pol->MaxSleep));
|
|
printf ("Reduced latency.sleep: %s\n", SysPower(Pol->ReducedLatencySleep));
|
|
printf ("WinLogonFlags........: %x\n", Pol->WinLogonFlags);
|
|
printf ("DynamicThrottle......: %s\n", DynamicThrottle(Pol->DynamicThrottle));
|
|
printf ("Doze S4 timeout......: %d\n", Pol->DozeS4Timeout);
|
|
|
|
printf ("Battery broadcast res: %d\n", Pol->BroadcastCapacityResolution);
|
|
for (i=0; i < NUM_DISCHARGE_POLICIES; i++) {
|
|
printf ("Battery discharge %d..: ", i);
|
|
p = "Disabled";
|
|
if (!Cap.SystemBatteriesPresent && Pol->DischargePolicy[i].Enable) {
|
|
p = "No battery, but enable is set";
|
|
}
|
|
if (Cap.SystemBatteriesPresent && Pol->DischargePolicy[i].Enable) {
|
|
sprintf (text, "%d, %s, Min=%s",
|
|
Pol->DischargePolicy[i].BatteryLevel,
|
|
Action (NULL, &Pol->DischargePolicy[i].PowerPolicy),
|
|
SysPower(Pol->DischargePolicy[i].MinSystemState)
|
|
);
|
|
p = text;
|
|
}
|
|
printf ("%s\n", p);
|
|
}
|
|
|
|
printf ("Video timeout.......: %d\n", Pol->VideoTimeout);
|
|
printf ("Hard disk timeout....: %d\n", Pol->SpindownTimeout);
|
|
printf ("Optimize for power...: %s\n", szBool[Pol->OptimizeForPower]);
|
|
printf ("Fan throttle toler...: %d\n", Pol->FanThrottleTolerance);
|
|
printf ("Forced throttle......: %d%% %s\n",
|
|
Pol->ForcedThrottle,
|
|
Pol->ForcedThrottle == 100 ? "(off)" : "(on)"
|
|
);
|
|
printf ("Min throttle.........: %d%%\n", Pol->MinThrottle);
|
|
printf ("Over throttle act....: %s\n", Action (NULL, &Pol->OverThrottled));
|
|
printf ("\n");
|
|
}
|
|
|
|
|
|
VOID
|
|
PrintPPol (
|
|
IN PPROCESSOR_POWER_POLICY Pol
|
|
)
|
|
{
|
|
ULONG i;
|
|
UCHAR text[200];
|
|
PUCHAR p;
|
|
|
|
if (Pol->Revision != 1) {
|
|
|
|
puts ("** revision not 1**");
|
|
|
|
}
|
|
|
|
printf ("Dynamic Throttle.....: %s\n", DynamicThrottle(Pol->DynamicThrottle) );
|
|
printf ("Disable CStates......: %s\n", szBool[Pol->DisableCStates] );
|
|
printf ("\n");
|
|
for (i = 0; i < Pol->PolicyCount; i++) {
|
|
|
|
printf ("C%x Processor Power Policy\n", (i+1) );
|
|
printf (" Allow Demotion....: %s\n", szBool[Pol->Policy[i].AllowDemotion]);
|
|
printf (" Allow Promotion...: %s\n", szBool[Pol->Policy[i].AllowPromotion]);
|
|
printf (" Demote Percent....: %d%%\n", Pol->Policy[i].DemotePercent);
|
|
printf (" Promote Percent...: %d%%\n", Pol->Policy[i].PromotePercent);
|
|
printf (" Demote Limit......: %s\n", MicroSeconds(Pol->Policy[i].DemoteLimit) );
|
|
printf (" Promote Limit.....: %s\n", MicroSeconds(Pol->Policy[i].PromoteLimit) );
|
|
printf (" Time Check........: %s\n", MicroSeconds(Pol->Policy[i].TimeCheck) );
|
|
printf ("\n");
|
|
}
|
|
printf ("\n");
|
|
}
|
|
|
|
VOID
|
|
PrintAdmin (
|
|
PVOID Context
|
|
)
|
|
{
|
|
printf ("Min sleep state......: %s\n", SysPower(Admin.MinSleep));
|
|
printf ("Max sleep state......: %s\n", SysPower(Admin.MaxSleep));
|
|
printf ("Min video timeout....: %d\n", Admin.MinVideoTimeout);
|
|
printf ("Max video timeout....: %d\n", Admin.MaxVideoTimeout);
|
|
printf ("Min spindown timeout.: %d\n", Admin.MinSpindownTimeout);
|
|
printf ("Max spindown timeout.: %d\n", Admin.MaxSpindownTimeout);
|
|
}
|
|
|
|
VOID
|
|
AssignSetting (
|
|
PUCHAR Variable,
|
|
PUCHAR Value
|
|
)
|
|
{
|
|
PSYSTEM_POWER_POLICY Pol;
|
|
PUCHAR p;
|
|
|
|
if (!CurContext) {
|
|
puts(
|
|
"must select one of:\n"
|
|
" ac - the system power policy while on AC\n"
|
|
" dc - the system power policy while on DC\n"
|
|
" pac - the processor power policy while on AC\n"
|
|
" pdc - the processor power policy while on DC\n"
|
|
" cap - the system capabilities\n"
|
|
" admin - the admin policy\n"
|
|
"before assigning settings"
|
|
);
|
|
exit (1);
|
|
}
|
|
|
|
CurValue = Value;
|
|
if (!*CurValue) {
|
|
printf ("null settings not allowed\n");
|
|
exit (1);
|
|
}
|
|
|
|
CurValueIsNumeric = TRUE;
|
|
for (p = Value; *p; p++) {
|
|
if (*p < '0' || *p > '9') {
|
|
CurValueIsNumeric = FALSE;
|
|
}
|
|
}
|
|
|
|
ItemUpdated = TRUE;
|
|
CurAssign (Variable, Value);
|
|
}
|
|
|
|
VOID
|
|
AssignPolicySetting (
|
|
PUCHAR Variable,
|
|
PUCHAR Value
|
|
)
|
|
{
|
|
PSYSTEM_POWER_POLICY Pol;
|
|
|
|
Pol = (PSYSTEM_POWER_POLICY) CurContext;
|
|
|
|
// set policy
|
|
if (streql(Variable, "pbutt")) { SetAction(&Pol->PowerButton);
|
|
} else if (streql(Variable, "sbutt")) { SetAction(&Pol->SleepButton);
|
|
} else if (streql(Variable, "lidclose")) { SetAction(&Pol->LidClose);
|
|
} else if (streql(Variable, "idle")) { SetAction(&Pol->Idle);
|
|
} else if (streql(Variable, "idlesense")) { SetValue((PULONG)&Pol->IdleSensitivity);
|
|
} else if (streql(Variable, "idletimeout")) { SetValue(&Pol->IdleTimeout);
|
|
} else if (streql(Variable, "minsleep")) { SetSysPower(&Pol->MinSleep);
|
|
} else if (streql(Variable, "maxsleep")) { SetSysPower(&Pol->MaxSleep);
|
|
} else if (streql(Variable, "reducedsleep")) { SetSysPower(&Pol->ReducedLatencySleep);
|
|
} else if (streql(Variable, "s4timeout")) { SetValue(&Pol->DozeS4Timeout);
|
|
} else if (streql(Variable, "videotimeout")) { SetValue(&Pol->VideoTimeout);
|
|
} else if (streql(Variable, "disktimeout")) { SetValue(&Pol->SpindownTimeout);
|
|
} else if (streql(Variable, "optpower")) { SetBool(&Pol->OptimizeForPower);
|
|
} else if (streql(Variable, "fantol")) { SetValue((PULONG)&Pol->FanThrottleTolerance);
|
|
} else if (streql(Variable, "minthrot")) { SetValue((PULONG)&Pol->MinThrottle);
|
|
} else if (streql(Variable, "forcethrot")) { SetValue((PULONG)&Pol->ForcedThrottle);
|
|
} else if (streql(Variable, "overthrot")) { SetAction(&Pol->OverThrottled);
|
|
} else {
|
|
puts (
|
|
"Variable not:\n"
|
|
" pbutt, sbutt, lidclose\n"
|
|
" idle, idlesense, idletime\n"
|
|
" minsleep, maxsleep, reducedsleep, s4timeout\n"
|
|
" videotimeout, disktimeout, optpower\n"
|
|
" optpower, fantol, minthrot, forcethrot, overthrot"
|
|
);
|
|
exit (1);
|
|
}
|
|
|
|
}
|
|
|
|
VOID
|
|
AssignPPolicySetting (
|
|
PUCHAR Variable,
|
|
PUCHAR Value
|
|
)
|
|
{
|
|
PPROCESSOR_POWER_POLICY Pol;
|
|
|
|
Pol = (PPROCESSOR_POWER_POLICY) CurContext;
|
|
if (streql(Variable,"policycount")) { SetPolicyCount(&(Pol->PolicyCount));
|
|
} else if (streql(Variable,"dynamicthrottle")) { SetDynamicThrottle(&(Pol->DynamicThrottle));
|
|
} else if (streql(Variable,"disablecstates")) { SetCStates(Pol);
|
|
} else if (streql(Variable,"c1allowpromotion")) { SetField(Pol,0,"allowpromotion");
|
|
} else if (streql(Variable,"c1allowdemotion")) { SetField(Pol,0,"allowdemotion");
|
|
} else if (streql(Variable,"c1demotepercent")) { SetPercentage(&(Pol->Policy[0].DemotePercent));
|
|
} else if (streql(Variable,"c1promotepercent")) { SetPercentage(&(Pol->Policy[0].PromotePercent));
|
|
} else if (streql(Variable,"c1demotelimit")) { SetValue(&(Pol->Policy[0].DemoteLimit));
|
|
} else if (streql(Variable,"c1promotelimit")) { SetValue(&(Pol->Policy[0].PromoteLimit));
|
|
} else if (streql(Variable,"c1timecheck")) { SetValue(&(Pol->Policy[0].TimeCheck));
|
|
} else if (streql(Variable,"c2allowpromotion")) { SetField(Pol,1,"allowpromotion");
|
|
} else if (streql(Variable,"c2allowdemotion")) { SetField(Pol,1,"allowdemotion");
|
|
} else if (streql(Variable,"c2demotepercent")) { SetPercentage(&(Pol->Policy[1].DemotePercent));
|
|
} else if (streql(Variable,"c2promotepercent")) { SetPercentage(&(Pol->Policy[1].PromotePercent));
|
|
} else if (streql(Variable,"c2demotelimit")) { SetValue(&(Pol->Policy[1].DemoteLimit));
|
|
} else if (streql(Variable,"c2promotelimit")) { SetValue(&(Pol->Policy[1].PromoteLimit));
|
|
} else if (streql(Variable,"c2timecheck")) { SetValue(&(Pol->Policy[1].TimeCheck));
|
|
} else if (streql(Variable,"c3allowpromotion")) { SetField(Pol,2,"allowpromotion");
|
|
} else if (streql(Variable,"c3allowdemotion")) { SetField(Pol,2,"allowdemotion");
|
|
} else if (streql(Variable,"c3demotepercent")) { SetPercentage(&(Pol->Policy[2].DemotePercent));
|
|
} else if (streql(Variable,"c3promotepercent")) { SetPercentage(&(Pol->Policy[2].PromotePercent));
|
|
} else if (streql(Variable,"c3demotelimit")) { SetValue(&(Pol->Policy[2].DemoteLimit));
|
|
} else if (streql(Variable,"c3promotelimit")) { SetValue(&(Pol->Policy[2].PromoteLimit));
|
|
} else if (streql(Variable,"c3timecheck")) { SetValue(&(Pol->Policy[2].TimeCheck));
|
|
} else {
|
|
puts(
|
|
"Variable not:\n"
|
|
" policycount - number of elements in policy\n"
|
|
" dynamicthrottle - which throttle policy to use\n"
|
|
" disablecstates - disable cstates if true\n"
|
|
" cXallowpromotion - allow promotion from state X\n"
|
|
" cXallowdemotion - allow demotion from state X\n"
|
|
" cXdemotepercent - set demote percent for state X\n"
|
|
" cXpromotepercent - set promote percent for state X\n"
|
|
" cXdemotelimit - set demote limit for state X\n"
|
|
" cXpromotelimit - set promote limit for state X\n"
|
|
" cXtimecheck - set time check interval for state X"
|
|
" where X = <1,2,3>\n"
|
|
);
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
VOID
|
|
AssignCurrentSetting(
|
|
PUCHAR Variable,
|
|
PUCHAR Value
|
|
)
|
|
{
|
|
if (CurInfo == ProcessorPowerPolicyCurrent) {
|
|
|
|
puts(
|
|
"PCurrent is only intended for use in displaying the current processor\n"
|
|
"power policy. You must use 'pac' or 'pdc' to actually set policy."
|
|
);
|
|
|
|
} else if (CurInfo == SystemPowerPolicyCurrent) {
|
|
|
|
puts(
|
|
"Current is only intended for use in displaying the current system\n"
|
|
"power policy. You muse use 'ac' or 'dc' to actually set policy."
|
|
);
|
|
|
|
} else {
|
|
|
|
puts(
|
|
"Unknown setting."
|
|
);
|
|
|
|
}
|
|
exit(1);
|
|
}
|
|
|
|
VOID
|
|
AssignAdminSetting (
|
|
PUCHAR Variable,
|
|
PUCHAR Value
|
|
)
|
|
{
|
|
if (streql(Variable, "minsleep")) { SetSysPower(&Admin.MinSleep);
|
|
} else if (streql(Variable, "maxsleep")) { SetSysPower(&Admin.MaxSleep);
|
|
} else if (streql(Variable, "minvideo")) { SetValue(&Admin.MinVideoTimeout);
|
|
} else if (streql(Variable, "maxvideo")) { SetValue(&Admin.MaxVideoTimeout);
|
|
} else if (streql(Variable, "mindisk")) { SetValue(&Admin.MinSpindownTimeout);
|
|
} else if (streql(Variable, "maxdisk")) { SetValue(&Admin.MaxSpindownTimeout);
|
|
} else {
|
|
puts(
|
|
"Variable not:\n"
|
|
" minsleep, maxsleep\n"
|
|
" minvideo, maxvideo, mindisk, maxdisk"
|
|
);
|
|
exit (1);
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
AssignCapSetting (
|
|
PUCHAR Variable,
|
|
PUCHAR Value
|
|
)
|
|
{
|
|
// set capability
|
|
if (streql(Variable, "pbutt")) { SetBool(&Cap.PowerButtonPresent);
|
|
} else if (streql(Variable, "sbutt")) { SetBool(&Cap.SleepButtonPresent);
|
|
} else if (streql(Variable, "lid")) { SetBool(&Cap.LidPresent);
|
|
} else if (streql(Variable, "s1")) { SetBool(&Cap.SystemS1);
|
|
} else if (streql(Variable, "s2")) { SetBool(&Cap.SystemS2);
|
|
} else if (streql(Variable, "s3")) { SetBool(&Cap.SystemS3);
|
|
} else if (streql(Variable, "s4")) { SetBool(&Cap.SystemS4);
|
|
} else if (streql(Variable, "s5")) { SetBool(&Cap.SystemS5);
|
|
} else if (streql(Variable, "batt")) { SetBool(&Cap.SystemBatteriesPresent);
|
|
} else if (streql(Variable, "shortterm")) { SetBool(&Cap.BatteriesAreShortTerm);
|
|
} else if (streql(Variable, "acwake")) { SetSysPower(&Cap.AcOnLineWake);
|
|
} else if (streql(Variable, "lidwake")) { SetSysPower(&Cap.SoftLidWake);
|
|
} else if (streql(Variable, "rtcwake")) { SetSysPower(&Cap.RtcWake);
|
|
} else if (streql(Variable, "lowlat")) { SetSysPower(&Cap.DefaultLowLatencyWake);
|
|
} else {
|
|
puts (
|
|
"Variable not:\n"
|
|
" pbutt, sbutt, lid, s1, s2, s3, s4, s5\n"
|
|
" batt, shortterm, acwake, lidwake, rtcwak, lowlat"
|
|
);
|
|
exit (1);
|
|
}
|
|
}
|
|
|
|
|
|
#define SEL_NONE 0
|
|
#define SEL_AC 1
|
|
#define SEL_DC 2
|
|
#define SEL_CAP 3
|
|
#define SEL_ADMIN 4
|
|
#define SEL_PAC 5
|
|
#define SEL_PDC 6
|
|
#define SEL_CURRENT 7
|
|
#define SEL_PCURRENT 8
|
|
|
|
VOID
|
|
SelectItem(
|
|
IN ULONG Type
|
|
)
|
|
{
|
|
NTSTATUS Status;
|
|
|
|
if (CurType) {
|
|
if (ItemUpdated) {
|
|
if (Verbose2) {
|
|
printf ("%s being set as:\n", CurDesc);
|
|
CurPrint (CurContext);
|
|
}
|
|
|
|
Status = NtPowerInformation (
|
|
CurInfo,
|
|
CurContext,
|
|
CurContextSize,
|
|
CurContext,
|
|
CurContextSize
|
|
);
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
printf ("NtPowerInformation failed with %x\n", Status);
|
|
}
|
|
|
|
}
|
|
|
|
puts (CurDesc);
|
|
CurPrint (CurContext);
|
|
}
|
|
|
|
switch (Type) {
|
|
case SEL_NONE:
|
|
CurPrint = NULL;
|
|
CurAssign = NULL;
|
|
CurContext = NULL;
|
|
break;
|
|
|
|
case SEL_AC:
|
|
CurPrint = PrintPol;
|
|
CurInfo = SystemPowerPolicyAc;
|
|
CurContext = &Ac;
|
|
CurContextSize = sizeof(SYSTEM_POWER_POLICY);
|
|
CurAssign = AssignPolicySetting;
|
|
CurDesc = "AC power policy";
|
|
break;
|
|
|
|
case SEL_DC:
|
|
CurPrint = PrintPol;
|
|
CurInfo = SystemPowerPolicyDc;
|
|
CurContext = &Dc;
|
|
CurContextSize = sizeof(SYSTEM_POWER_POLICY);
|
|
CurAssign = AssignPolicySetting;
|
|
CurDesc = "DC power policy";
|
|
break;
|
|
|
|
case SEL_CURRENT:
|
|
CurPrint = PrintPol;
|
|
CurInfo = SystemPowerPolicyCurrent;
|
|
CurContext = &Current;
|
|
CurContextSize = sizeof(SYSTEM_POWER_POLICY);
|
|
CurAssign = AssignCurrentSetting;
|
|
CurDesc = "Current power policy";
|
|
break;
|
|
|
|
case SEL_PAC:
|
|
CurPrint = PrintPPol;
|
|
CurInfo = ProcessorPowerPolicyAc;
|
|
CurContext = &PAc;
|
|
CurContextSize = sizeof(PROCESSOR_POWER_POLICY);
|
|
CurAssign = AssignPPolicySetting;
|
|
CurDesc = "AC processor power policy";
|
|
break;
|
|
|
|
case SEL_PDC:
|
|
CurPrint = PrintPPol;
|
|
CurInfo = ProcessorPowerPolicyDc;
|
|
CurContext = &PDc;
|
|
CurContextSize = sizeof(PROCESSOR_POWER_POLICY);
|
|
CurAssign = AssignPPolicySetting;
|
|
CurDesc = "DC processor power policy";
|
|
break;
|
|
|
|
case SEL_PCURRENT:
|
|
CurPrint = PrintPPol;
|
|
CurInfo = ProcessorPowerPolicyCurrent;
|
|
CurContext = &PCurrent;
|
|
CurContextSize = sizeof(PROCESSOR_POWER_POLICY);
|
|
CurAssign = AssignCurrentSetting;
|
|
CurDesc = "Current processor power policy";
|
|
break;
|
|
|
|
case SEL_CAP:
|
|
CurPrint = PrintCap;
|
|
CurInfo = SystemPowerCapabilities,
|
|
CurContext = ⋒
|
|
CurContextSize = sizeof(SYSTEM_POWER_CAPABILITIES);
|
|
CurAssign = AssignCapSetting;
|
|
CurDesc = "power capabilties";
|
|
break;
|
|
|
|
case SEL_ADMIN:
|
|
CurPrint = PrintAdmin;
|
|
CurInfo = AdministratorPowerPolicy;
|
|
CurContext = &Admin;
|
|
CurContextSize = sizeof(ADMINISTRATOR_POWER_POLICY);
|
|
CurAssign = AssignAdminSetting;
|
|
CurDesc = "Admin policy overrides";
|
|
break;
|
|
}
|
|
|
|
CurType = Type;
|
|
ItemUpdated = FALSE;
|
|
}
|
|
|
|
|
|
VOID
|
|
UpdateAdmin (
|
|
VOID
|
|
)
|
|
{
|
|
ADMINISTRATOR_POWER_POLICY AdminPolicy;
|
|
NTSTATUS Status;
|
|
|
|
|
|
Status = NtPowerInformation (
|
|
AdministratorPowerPolicy,
|
|
NULL,
|
|
0,
|
|
&AdminPolicy,
|
|
sizeof (AdminPolicy)
|
|
);
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
printf ("Error reading admin policy %x\n", Status);
|
|
exit (1);
|
|
}
|
|
|
|
Status = NtPowerInformation (
|
|
AdministratorPowerPolicy,
|
|
&AdminPolicy,
|
|
sizeof (AdminPolicy),
|
|
NULL,
|
|
0
|
|
);
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
printf ("Error writing admin policy %x\n", Status);
|
|
exit (1);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
VOID __cdecl
|
|
main (argc, argv)
|
|
int argc;
|
|
char *argv[];
|
|
{
|
|
NTSTATUS Status;
|
|
PUCHAR p, p1;
|
|
BOOLEAN Result;
|
|
HANDLE hToken;
|
|
TOKEN_PRIVILEGES tkp;
|
|
|
|
if (argc < 2) {
|
|
puts ("dumppo: cap ps bs admin ac dc current pac pdc pcurrent");
|
|
exit (1);
|
|
}
|
|
|
|
Status = NtPowerInformation (
|
|
SystemPowerCapabilities,
|
|
NULL,
|
|
0,
|
|
&Cap,
|
|
sizeof (Cap)
|
|
);
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
printf ("Error reading power capabilities %x\n", Status);
|
|
exit (1);
|
|
}
|
|
|
|
Status = NtPowerInformation (
|
|
AdministratorPowerPolicy,
|
|
NULL,
|
|
0,
|
|
&Admin,
|
|
sizeof (Admin)
|
|
);
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
printf ("Error reading admin power overrides %x\n", Status);
|
|
exit (1);
|
|
}
|
|
|
|
Status = NtPowerInformation (
|
|
SystemPowerPolicyAc,
|
|
NULL,
|
|
0,
|
|
&Ac,
|
|
sizeof (Ac)
|
|
);
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
printf ("Error reading AC policies %x\n", Status);
|
|
exit (1);
|
|
}
|
|
|
|
Status = NtPowerInformation (
|
|
SystemPowerPolicyDc,
|
|
NULL,
|
|
0,
|
|
&Dc,
|
|
sizeof (Dc)
|
|
);
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
printf ("Error reading DC policies %x\n", Status);
|
|
exit (1);
|
|
}
|
|
|
|
Status = NtPowerInformation (
|
|
SystemPowerPolicyCurrent,
|
|
NULL,
|
|
0,
|
|
&Current,
|
|
sizeof (Current)
|
|
);
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
printf ("Error reading Current policies %x\n", Status);
|
|
exit (1);
|
|
}
|
|
|
|
Result = (BOOLEAN)GetSystemPowerStatus (&PS);
|
|
if (!Result) {
|
|
printf ("False returned from GetSystemPowerStatus %x\n", GetLastError());
|
|
exit (1);
|
|
}
|
|
|
|
Status = NtPowerInformation (
|
|
SystemBatteryState,
|
|
NULL,
|
|
0,
|
|
&Batt,
|
|
sizeof (Batt)
|
|
);
|
|
if (!NT_SUCCESS(Status)) {
|
|
printf ("Error reading system battery status %x\n", Status);
|
|
exit (1);
|
|
}
|
|
|
|
Status = NtPowerInformation (
|
|
ProcessorPowerPolicyAc,
|
|
NULL,
|
|
0,
|
|
&PAc,
|
|
sizeof (PAc)
|
|
);
|
|
if (!NT_SUCCESS(Status)) {
|
|
printf ("Error reading processor AC policy %x\n", Status);
|
|
exit (1);
|
|
}
|
|
|
|
Status = NtPowerInformation(
|
|
ProcessorPowerPolicyDc,
|
|
NULL,
|
|
0,
|
|
&PDc,
|
|
sizeof (PDc)
|
|
);
|
|
if (!NT_SUCCESS(Status)) {
|
|
printf("Error reading processor DC policy %x\n", Status);
|
|
exit (1);
|
|
}
|
|
|
|
Status = NtPowerInformation(
|
|
ProcessorPowerPolicyCurrent,
|
|
NULL,
|
|
0,
|
|
&PCurrent,
|
|
sizeof (PCurrent)
|
|
);
|
|
if (!NT_SUCCESS(Status)) {
|
|
printf("Error reading processor Current policy %x\n", Status);
|
|
exit (1);
|
|
}
|
|
|
|
//
|
|
// Upgrade premissions
|
|
//
|
|
|
|
OpenProcessToken (
|
|
GetCurrentProcess(),
|
|
TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
|
|
&hToken
|
|
);
|
|
|
|
LookupPrivilegeValue (
|
|
NULL,
|
|
SE_SHUTDOWN_NAME,
|
|
&tkp.Privileges[0].Luid
|
|
);
|
|
|
|
tkp.PrivilegeCount = 1;
|
|
tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
|
|
|
|
AdjustTokenPrivileges (
|
|
hToken,
|
|
FALSE,
|
|
&tkp,
|
|
0,
|
|
NULL,
|
|
0
|
|
);
|
|
|
|
//
|
|
// Process args
|
|
//
|
|
|
|
while (argc) {
|
|
argc--;
|
|
|
|
if (streql(*argv, "-v")) {
|
|
Verbose1 = TRUE;
|
|
}
|
|
|
|
if (streql(*argv, "-V")) {
|
|
Verbose1 = TRUE;
|
|
Verbose2 = TRUE;
|
|
}
|
|
|
|
for (p = *argv; *p; p++) {
|
|
if (*p >= 'A' && *p <= 'Z') {
|
|
*p += 'a' - 'A';
|
|
}
|
|
}
|
|
|
|
p = *argv;
|
|
argv += 1;
|
|
|
|
if (streql(p, "ac")) {
|
|
SelectItem(SEL_AC);
|
|
}
|
|
|
|
if (streql(p, "dc")) {
|
|
SelectItem(SEL_DC);
|
|
}
|
|
|
|
if (streql(p, "current")) {
|
|
SelectItem(SEL_CURRENT);
|
|
}
|
|
|
|
if (streql(p, "cap")) {
|
|
SelectItem(SEL_CAP);
|
|
}
|
|
|
|
if (streql(p, "ps")) {
|
|
SelectItem(SEL_NONE);
|
|
PrintPowerStatus ();
|
|
}
|
|
|
|
if (streql(p, "bs")) {
|
|
SelectItem(SEL_NONE);
|
|
PrintBattStatus();
|
|
}
|
|
|
|
if (streql(p, "admin")) {
|
|
SelectItem(SEL_ADMIN);
|
|
}
|
|
|
|
if (streql(p, "pdc")) {
|
|
SelectItem(SEL_PDC);
|
|
}
|
|
|
|
if (streql(p, "pac")) {
|
|
SelectItem(SEL_PAC);
|
|
}
|
|
|
|
if (streql(p, "pcurrent")) {
|
|
SelectItem(SEL_PCURRENT);
|
|
}
|
|
|
|
//
|
|
// Check if this is a assignment
|
|
//
|
|
|
|
for (p1=p; *p1; p1++) {
|
|
if (*p1 == '=') {
|
|
*p1 = 0;
|
|
AssignSetting (p, p1+1);
|
|
}
|
|
}
|
|
}
|
|
|
|
// flush
|
|
SelectItem(SEL_NONE);
|
|
}
|