reactos/drivers/sac/driver/concmd.c
2021-06-11 15:33:08 +03:00

642 lines
17 KiB
C

/*
* PROJECT: ReactOS Drivers
* LICENSE: BSD - See COPYING.ARM in the top level directory
* FILE: drivers/sac/driver/concmd.c
* PURPOSE: Driver for the Server Administration Console (SAC) for EMS
* PROGRAMMERS: ReactOS Portable Systems Group
*/
/* INCLUDES *******************************************************************/
#include "sacdrv.h"
#include <ndk/exfuncs.h>
/* GLOBALS ********************************************************************/
PVOID GlobalBuffer;
ULONG GlobalBufferSize;
/* FUNCTIONS ******************************************************************/
NTSTATUS
DoChannelListCommand(
VOID
)
{
return STATUS_NOT_IMPLEMENTED;
}
NTSTATUS
DoChannelCloseByNameCommand(
IN PCHAR Count
)
{
return STATUS_NOT_IMPLEMENTED;
}
NTSTATUS
DoChannelCloseByIndexCommand(
IN ULONG ChannelIndex
)
{
return STATUS_NOT_IMPLEMENTED;
}
NTSTATUS
DoChannelSwitchByNameCommand(
IN PCHAR Count
)
{
return STATUS_NOT_IMPLEMENTED;
}
NTSTATUS
DoChannelSwitchByIndexCommand(
IN ULONG ChannelIndex
)
{
return STATUS_NOT_IMPLEMENTED;
}
typedef struct _SAC_SYSTEM_INFORMATION
{
SYSTEM_BASIC_INFORMATION BasicInfo;
SYSTEM_TIMEOFDAY_INFORMATION TimeInfo;
SYSTEM_FILECACHE_INFORMATION CacheInfo;
SYSTEM_PERFORMANCE_INFORMATION PerfInfo;
ULONG RemainingSize;
ULONG ProcessDataOffset;
// SYSTEM_PAGEFILE_INFORMATION PageFileInfo;
// SYSTEM_PROCESS_INFORMATION ProcessInfo;
} SAC_SYSTEM_INFORMATION, *PSAC_SYSTEM_INFORMATION;
NTSTATUS
NTAPI
GetTListInfo(IN PSAC_SYSTEM_INFORMATION SacInfo,
IN ULONG InputSize,
OUT PULONG TotalSize)
{
NTSTATUS Status;
ULONG BufferLength, ReturnLength, RemainingSize;
PSYSTEM_PAGEFILE_INFORMATION PageFileInfo;
PSYSTEM_PROCESS_INFORMATION ProcessInfo;
ULONG_PTR P;
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Entering.\n");
/* Assume failure */
*TotalSize = 0;
/* Bail out if the buffer is way too small */
if (InputSize < 4)
{
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Exiting, no memory.\n");
return STATUS_NO_MEMORY;
}
/* Make sure it's at least big enough to hold the static structure */
BufferLength = InputSize - sizeof(SAC_SYSTEM_INFORMATION);
if (InputSize < sizeof(SAC_SYSTEM_INFORMATION))
{
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Exiting, no memory (2).\n");
return STATUS_NO_MEMORY;
}
/* Query the time */
Status = ZwQuerySystemInformation(SystemTimeOfDayInformation,
&SacInfo->TimeInfo,
sizeof(SacInfo->TimeInfo),
NULL);
if (!NT_SUCCESS(Status))
{
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Exiting, error.\n");
return Status;
}
/* Query basic information */
Status = ZwQuerySystemInformation(SystemBasicInformation,
&SacInfo->BasicInfo,
sizeof(SacInfo->BasicInfo),
NULL);
if (!NT_SUCCESS(Status))
{
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Exiting, error (2).\n");
return Status;
}
/* Now query the pagefile information, which comes right after */
P = (ULONG_PTR)(SacInfo + 1);
PageFileInfo = (PSYSTEM_PAGEFILE_INFORMATION)P;
Status = ZwQuerySystemInformation(SystemPageFileInformation,
PageFileInfo,
BufferLength,
&ReturnLength);
if (!NT_SUCCESS(Status) || !(ReturnLength))
{
/* We failed -- is it because our buffer was too small? */
if (BufferLength < ReturnLength)
{
/* Bail out */
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Exiting, no memory(5).\n");
return STATUS_NO_MEMORY;
}
/* Some other reason, assume the buffer is now full */
SacInfo->RemainingSize = 0;
}
else
{
/* This is the leftover data */
SacInfo->RemainingSize = InputSize - BufferLength;
/* This much has now been consumed, and where we are now */
BufferLength -= ReturnLength;
P += ReturnLength;
/* Are we out of memory? */
if ((LONG)BufferLength < 0)
{
/* Bail out */
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Exiting, no memory(3).\n");
return STATUS_NO_MEMORY;
}
/* All good, loop the pagefile data now */
while (TRUE)
{
/* Is the pagefile name too big to fit? */
if (PageFileInfo->PageFileName.Length > (LONG)BufferLength)
{
/* Bail out */
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Exiting, error(3).\n");
return STATUS_INFO_LENGTH_MISMATCH;
}
/* Copy the name into our own buffer */
RtlCopyMemory((PVOID)P,
PageFileInfo->PageFileName.Buffer,
PageFileInfo->PageFileName.Length);
PageFileInfo->PageFileName.Buffer = (PWCHAR)P;
/* Update buffer lengths and offset */
BufferLength -= PageFileInfo->PageFileName.Length;
P += PageFileInfo->PageFileName.Length;
/* Are we out of memory? */
if ((LONG)BufferLength < 0)
{
/* Bail out */
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Exiting, no memory(4).\n");
return STATUS_NO_MEMORY;
}
/* If this was the only pagefile, break out */
if (!PageFileInfo->NextEntryOffset) break;
/* Otherwise, move to the next one */
PageFileInfo = (PVOID)((ULONG_PTR)PageFileInfo +
PageFileInfo->NextEntryOffset);
}
}
/* Next, query the file cache information */
Status = ZwQuerySystemInformation(SystemFileCacheInformation,
&SacInfo->CacheInfo,
sizeof(SacInfo->CacheInfo),
NULL);
if (!NT_SUCCESS(Status))
{
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Exiting, error (4).\n");
return Status;
}
/* And then the performance information */
Status = ZwQuerySystemInformation(SystemPerformanceInformation,
&SacInfo->PerfInfo,
sizeof(SacInfo->PerfInfo),
NULL);
if (!NT_SUCCESS(Status))
{
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Exiting, error(5).\n");
return Status;
}
/* Finally, align the buffer to query process and thread information */
P = ALIGN_UP(P, SYSTEM_PROCESS_INFORMATION);
RemainingSize = (ULONG_PTR)SacInfo + InputSize - P;
/* Are we out of memory? */
if ((LONG)RemainingSize < 0)
{
/* Bail out */
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Exiting, no memory (6).\n");
return STATUS_NO_MEMORY;
}
/* Now query the processes and threads */
ProcessInfo = (PSYSTEM_PROCESS_INFORMATION)P;
Status = ZwQuerySystemInformation(SystemProcessInformation,
ProcessInfo,
RemainingSize,
&ReturnLength);
if (!NT_SUCCESS(Status))
{
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Exiting, error(6).\n");
return Status;
}
/* The first process name will be right after this buffer */
P += ReturnLength;
/* The caller should look for process info over here */
SacInfo->ProcessDataOffset = InputSize - RemainingSize;
/* This is how much buffer data we have left -- are we out? */
BufferLength = RemainingSize - ReturnLength;
if ((LONG)BufferLength < 0)
{
/* Bail out */
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Exiting, no memory(7).\n");
return STATUS_NO_MEMORY;
}
/* All good and ready to parse the process and thread list */
while (TRUE)
{
/* Does the process have a name? */
if (ProcessInfo->ImageName.Buffer)
{
/* Is the process name too big to fit? */
if ((LONG)BufferLength < ProcessInfo->ImageName.Length)
{
/* Bail out */
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Exiting, error(7).\n");
return STATUS_INFO_LENGTH_MISMATCH;
}
/* Copy the name into our own buffer */
RtlCopyMemory((PVOID)P,
ProcessInfo->ImageName.Buffer,
ProcessInfo->ImageName.Length);
ProcessInfo->ImageName.Buffer = (PWCHAR)P;
/* Update buffer lengths and offset */
BufferLength -= ProcessInfo->ImageName.Length;
P += ProcessInfo->ImageName.Length;
/* Are we out of memory? */
if ((LONG)BufferLength < 0)
{
/* Bail out */
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Exiting, no memory(8).\n");
return STATUS_NO_MEMORY;
}
}
/* If this was the only process, break out */
if (!ProcessInfo->NextEntryOffset) break;
/* Otherwise, move to the next one */
ProcessInfo = (PVOID)((ULONG_PTR)ProcessInfo +
ProcessInfo->NextEntryOffset);
}
/* All done! */
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Exiting.\n");
*TotalSize = InputSize - BufferLength;
return STATUS_SUCCESS;
}
VOID
NTAPI
PrintTListInfo(IN PSAC_SYSTEM_INFORMATION SacInfo)
{
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Testing: %d %d %I64d\n",
SacInfo->BasicInfo.NumberOfPhysicalPages,
SacInfo->PerfInfo.AvailablePages,
SacInfo->TimeInfo.BootTime);
}
VOID
NTAPI
PutMore(OUT PBOOLEAN ScreenFull)
{
*ScreenFull = FALSE;
}
BOOLEAN
RetrieveIpAddressFromString(
IN PWCHAR IpString,
OUT PULONG IpAddress
)
{
return FALSE;
}
NTSTATUS
CallQueryIPIOCTL(
IN HANDLE DriverHandle,
IN PVOID DriverObject,
IN HANDLE WaitEvent,
IN PIO_STATUS_BLOCK IoStatusBlock,
IN PVOID InputBuffer,
IN ULONG InputBufferLength,
IN PVOID OutputBuffer,
IN ULONG OutputBufferLength,
IN BOOLEAN PrintMessage,
OUT PBOOLEAN MessagePrinted
)
{
return STATUS_NOT_IMPLEMENTED;
}
VOID
NTAPI
DoRebootCommand(IN BOOLEAN Reboot)
{
LARGE_INTEGER Timeout, TickCount;
NTSTATUS Status;
KEVENT Event;
SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC DoRebootCommand: Entering.\n");
/* Get the current time now, and setup a timeout in 1 second */
KeQueryTickCount(&TickCount);
Timeout.QuadPart = TickCount.QuadPart / (10000000 / KeQueryTimeIncrement());
/* Check if the timeout is small enough */
if (Timeout.QuadPart < 60 )
{
/* Show the prompt */
ConMgrSimpleEventMessage(Reboot ?
SAC_RESTART_PROMPT : SAC_SHUTDOWN_PROMPT,
TRUE);
/* Do the wait */
KeInitializeEvent(&Event, SynchronizationEvent, 0);
Timeout.QuadPart = -10000000 * (60 - Timeout.LowPart);
KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, &Timeout);
}
/* Do a shutdown or a reboot, based on the request */
Status = NtShutdownSystem(Reboot ? ShutdownReboot : ShutdownPowerOff);
/* Check if anyone in the command channel already allocated this */
if (!GlobalBuffer)
{
/* Allocate it */
GlobalBuffer = SacAllocatePool(PAGE_SIZE, GLOBAL_BLOCK_TAG);
if (!GlobalBuffer)
{
/* We need the global buffer, bail out without it*/
SacPutSimpleMessage(SAC_OUT_OF_MEMORY_PROMPT);
SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC DoRebootCommand: Exiting (1).\n");
return;
}
/* Set the size of the buffer */
GlobalBufferSize = PAGE_SIZE;
}
/* We came back from a reboot, this doesn't make sense, tell the user */
SacPutSimpleMessage(Reboot ? SAC_RESTART_FAIL_PROMPT : SAC_SHUTDOWN_FAIL_PROMPT);
swprintf(GlobalBuffer, GetMessage(SAC_FAIL_PROMPT), Status);
SacPutString(GlobalBuffer);
SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC DoRebootCommand: Exiting.\n");
}
VOID
NTAPI
DoFullInfoCommand(VOID)
{
/* Flip the flag */
GlobalDoThreads = !GlobalDoThreads;
/* Print out the new state */
SacPutSimpleMessage(GlobalDoThreads ? 8 : 7);
}
VOID
NTAPI
DoPagingCommand(VOID)
{
/* Flip the flag */
GlobalPagingNeeded = !GlobalPagingNeeded;
/* Print out the new state */
SacPutSimpleMessage(GlobalPagingNeeded ? 10 : 9);
}
VOID
NTAPI
DoSetTimeCommand(IN PCHAR InputTime)
{
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Entering\n");
}
VOID
NTAPI
DoKillCommand(IN PCHAR KillString)
{
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Entering\n");
}
VOID
NTAPI
DoLowerPriorityCommand(IN PCHAR PrioString)
{
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Entering\n");
}
VOID
NTAPI
DoRaisePriorityCommand(IN PCHAR PrioString)
{
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Entering\n");
}
VOID
NTAPI
DoLimitMemoryCommand(IN PCHAR LimitString)
{
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Entering\n");
}
VOID
NTAPI
DoCrashCommand(VOID)
{
SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC DoCrashCommand: Entering.\n");
/* Crash the machine */
KeBugCheckEx(MANUALLY_INITIATED_CRASH, 0, 0, 0, 0);
__debugbreak();
}
VOID
NTAPI
DoMachineInformationCommand(VOID)
{
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Entering\n");
}
VOID
NTAPI
DoChannelCommand(IN PCHAR ChannelString)
{
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Entering\n");
}
VOID
NTAPI
DoCmdCommand(IN PCHAR InputString)
{
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Entering\n");
}
VOID
NTAPI
DoLockCommand(VOID)
{
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Entering\n");
}
FORCEINLINE
BOOLEAN
PrintHelpMessage(IN ULONG MessageId,
IN OUT PULONG Count)
{
BOOLEAN ScreenFull;
ULONG NewCount;
/* Get the amount of lines this message will take */
NewCount = GetMessageLineCount(MessageId);
if ((NewCount + *Count) > SAC_VTUTF8_ROW_HEIGHT)
{
/* We are going to overflow the screen, wait for input */
PutMore(&ScreenFull);
if (ScreenFull) return FALSE;
*Count = 0;
}
/* Print out the message and update the amount of lines printed */
SacPutSimpleMessage(MessageId);
*Count += NewCount;
return TRUE;
}
VOID
NTAPI
DoHelpCommand(VOID)
{
ULONG Count = 0;
/* Print out all the help messages */
if (!PrintHelpMessage(112, &Count)) return;
if (!PrintHelpMessage(12, &Count)) return;
if (!PrintHelpMessage(13, &Count)) return;
if (!PrintHelpMessage(14, &Count)) return;
if (!PrintHelpMessage(15, &Count)) return;
if (!PrintHelpMessage(16, &Count)) return;
if (!PrintHelpMessage(31, &Count)) return;
if (!PrintHelpMessage(18, &Count)) return;
if (!PrintHelpMessage(19, &Count)) return;
if (!PrintHelpMessage(32, &Count)) return;
if (!PrintHelpMessage(20, &Count)) return;
if (!PrintHelpMessage(21, &Count)) return;
if (!PrintHelpMessage(22, &Count)) return;
if (!PrintHelpMessage(23, &Count)) return;
if (!PrintHelpMessage(24, &Count)) return;
if (!PrintHelpMessage(25, &Count)) return;
if (!PrintHelpMessage(27, &Count)) return;
if (!PrintHelpMessage(28, &Count)) return;
if (!PrintHelpMessage(29, &Count)) return;
}
VOID
NTAPI
DoGetNetInfo(IN BOOLEAN DoPrint)
{
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Entering\n");
}
VOID
NTAPI
DoSetIpAddressCommand(IN PCHAR IpString)
{
SAC_DBG(SAC_DBG_ENTRY_EXIT, "Entering\n");
}
VOID
NTAPI
DoTlistCommand(VOID)
{
NTSTATUS Status;
PVOID NewGlobalBuffer;
ULONG Size;
SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC DoTlistCommand: Entering.\n");
/* Check if a global buffer already exists */
if (!GlobalBuffer)
{
/* It doesn't, allocate one */
GlobalBuffer = SacAllocatePool(4096, GLOBAL_BLOCK_TAG);
if (GlobalBuffer)
{
/* Remember its current size */
GlobalBufferSize = 4096;
}
else
{
/* Out of memory, bail out */
SacPutSimpleMessage(11);
SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC DoTlistCommand: Exiting.\n");
return;
}
}
/* Loop as long as the buffer is too small */
while (TRUE)
{
/* Get the process list */
Status = GetTListInfo(GlobalBuffer, GlobalBufferSize, &Size);
if ((Status != STATUS_NO_MEMORY) &&
(Status != STATUS_INFO_LENGTH_MISMATCH))
{
/* It fits! Bail out */
break;
}
/* We need a new bigger buffer */
NewGlobalBuffer = SacAllocatePool(GlobalBufferSize + 4096,
GLOBAL_BLOCK_TAG);
if (!NewGlobalBuffer)
{
/* Out of memory, bail out */
SacPutSimpleMessage(11);
SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC DoTlistCommand: Exiting.\n");
return;
}
/* Free the old one, update state */
SacFreePool(GlobalBuffer);
GlobalBufferSize += 4096;
GlobalBuffer = NewGlobalBuffer;
}
/* Did we get here because we have the whole list? */
if (!NT_SUCCESS(Status))
{
/* Nope, print out a failure message */
SacPutSimpleMessage(68);
swprintf(GlobalBuffer, GetMessage(48), Status);
SacPutString(GlobalBuffer);
}
else
{
/* Yep, print out the list */
PrintTListInfo(GlobalBuffer);
}
SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC DoTlistCommand: Exiting.\n");
}