ctm.c File Reference

#include <windows.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <process.h>
#include <stdio.h>
#include <ndk/ntndk.h>
#include <epsapi/epsapi.h>
#include "ctm.h"
#include "resource.h"

Include dependency graph for ctm.c:

Go to the source code of this file.

Macros
#define	WIN32_LEAN_AND_MEAN
#define	WIN32_NO_STATUS
#define	NTOS_MODE_USER
#define	TIMES
#define	NEW_CONSOLE

Functions
void *	PsaiMalloc (SIZE_T size)
void *	PsaiRealloc (void *ptr, SIZE_T size)
void	PsaiFree (void *ptr)
unsigned int	GetKeyPressed ()
void	GetInputOutputHandles ()
void	RestoreConsole ()
void	DisplayScreen ()
int	ProcessKeys (int numEvents)
void	PerfInit ()
void	PerfDataRefresh ()
unsigned int	GetKeyPressed (int events)
int	_tmain (int argc, char **argv)

Variables
HANDLE	hStdin
HANDLE	hStdout
HINSTANCE	hInst
DWORD	inConMode
DWORD	outConMode
DWORD	columnRightPositions [6]
TCHAR	lpSeparator [80]
TCHAR	lpSeparatorUp [80]
TCHAR	lpSeparatorDown [80]
TCHAR	lpHeader [80]
TCHAR	lpMemUnit [3]
TCHAR	lpIdleProcess [80]
TCHAR	lpTitle [80]
TCHAR	lpMenu [80]
TCHAR	lpEmpty [80]
TCHAR	KEY_QUIT
TCHAR	KEY_KILL
TCHAR	KEY_YES
TCHAR	KEY_NO
int	ProcPerScreen = 17
int	ScreenLines =25
ULONG	ProcessCountOld = 0
ULONG	ProcessCount = 0
double	dbIdleTime
double	dbKernelTime
double	dbSystemTime
LARGE_INTEGER	liOldIdleTime = {{0,0}}
LARGE_INTEGER	liOldKernelTime = {{0,0}}
LARGE_INTEGER	liOldSystemTime = {{0,0}}
PPERFDATA	pPerfDataOld = NULL
PPERFDATA	pPerfData = NULL
int	selection =0
int	scrolled =0
int	first = 0
SYSTEM_BASIC_INFORMATION	SystemBasicInfo
CONSOLE_SCREEN_BUFFER_INFO	screenBufferInfo

Macro Definition Documentation

NEW_CONSOLE

#define NEW_CONSOLE

Definition at line 98 of file ctm.c.

NTOS_MODE_USER

#define NTOS_MODE_USER

Definition at line 45 of file ctm.c.

TIMES

#define TIMES

Definition at line 53 of file ctm.c.

WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

Definition at line 34 of file ctm.c.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 35 of file ctm.c.

Function Documentation

_tmain()

int _tmain	(	int	argc,
		char **	argv
	)

Definition at line 617 of file ctm.c.

{
    int i;
    TCHAR lpStr[80];
 
    for (i = 0; i < 80; i++)
        lpEmpty[i] = lpHeader[i] = _T(' ');
    lpEmpty[79] = _T('\0');
 
    /* Initialize global variables */
    hInst = 0 /* FIXME: which value? [used with LoadString(hInst, ..., ..., ...)] */;
 
    if (LoadString(hInst, IDS_COLUMN_NUMBER, lpStr, 80))
    {
        columnRightPositions[0] = _tcslen(lpStr) + 3;
        _tcsncpy(&lpHeader[2], lpStr, _tcslen(lpStr));
    }
    if (LoadString(hInst, IDS_COLUMN_IMAGENAME, lpStr, 80))
    {
        columnRightPositions[1] = columnRightPositions[0] + _tcslen(lpStr) + 3;
        _tcsncpy(&lpHeader[columnRightPositions[0] + 2], lpStr, _tcslen(lpStr));
    }
    if (LoadString(hInst, IDS_COLUMN_PID, lpStr, 80))
    {
        columnRightPositions[2] = columnRightPositions[1] + _tcslen(lpStr) + 3;
        _tcsncpy(&lpHeader[columnRightPositions[1] + 2], lpStr, _tcslen(lpStr));
    }
    if (LoadString(hInst, IDS_COLUMN_CPU, lpStr, 80))
    {
        columnRightPositions[3] = columnRightPositions[2] + _tcslen(lpStr) + 3;
        _tcsncpy(&lpHeader[columnRightPositions[2] + 2], lpStr, _tcslen(lpStr));
    }
    if (LoadString(hInst, IDS_COLUMN_MEM, lpStr, 80))
    {
        columnRightPositions[4] = columnRightPositions[3] + _tcslen(lpStr) + 3;
        _tcsncpy(&lpHeader[columnRightPositions[3] + 2], lpStr, _tcslen(lpStr));
    }
    if (LoadString(hInst, IDS_COLUMN_PF, lpStr, 80))
    {
        columnRightPositions[5] = columnRightPositions[4] + _tcslen(lpStr) + 3;
        _tcsncpy(&lpHeader[columnRightPositions[4] + 2], lpStr, _tcslen(lpStr));
    }
 
    for (i = 0; i < columnRightPositions[5]; i++)
    {
        lpSeparator[i] = _T('-');
        lpSeparatorUp[i] = _T('^');
        lpSeparatorDown[i] = _T('v');
    }
    lpHeader[0] = _T('|');
    lpSeparator[0] = _T('+');
    lpSeparatorUp[0] = _T('^');
    lpSeparatorDown[0] = _T('v');
    for (i = 0; i < 6; i++)
    {
        lpHeader[columnRightPositions[i]] = _T('|');
        lpSeparator[columnRightPositions[i]] = _T('+');
        lpSeparatorUp[columnRightPositions[i]] = _T('^');
        lpSeparatorDown[columnRightPositions[i]] = _T('v');
    }
    lpHeader[columnRightPositions[5] + 1] = _T('\0');
    lpSeparator[columnRightPositions[5] + 1] = _T('\0');
    lpSeparatorUp[columnRightPositions[5] + 1] = _T('\0');
    lpSeparatorDown[columnRightPositions[5] + 1] = _T('\0');
 
 
    if (!LoadString(hInst, IDS_APP_TITLE, lpTitle, 80))
        lpTitle[0] = _T('\0');
    if (!LoadString(hInst, IDS_COLUMN_MEM_UNIT, lpMemUnit, 3))
        lpMemUnit[0] = _T('\0');
    if (!LoadString(hInst, IDS_MENU, lpMenu, 80))
        lpMenu[0] = _T('\0');
    if (!LoadString(hInst, IDS_IDLE_PROCESS, lpIdleProcess, 80))
        lpIdleProcess[0] = _T('\0');
 
    if (LoadString(hInst, IDS_MENU_QUIT, lpStr, 2))
        KEY_QUIT = lpStr[0];
    if (LoadString(hInst, IDS_MENU_KILL_PROCESS, lpStr, 2))
        KEY_KILL = lpStr[0];
    if (LoadString(hInst, IDS_YES, lpStr, 2))
        KEY_YES = lpStr[0];
    if (LoadString(hInst, IDS_NO, lpStr, 2))
        KEY_NO = lpStr[0];
 
    GetInputOutputHandles();
 
    if (hStdin == INVALID_HANDLE_VALUE || hStdout == INVALID_HANDLE_VALUE)
    {
        if (LoadString(hInst, IDS_CTM_GENERAL_ERR1, lpStr, 80))
            _tprintf(lpStr);
        return -1;
    }
 
    if (GetConsoleMode(hStdin, &inConMode) == 0)
    {
        if (LoadString(hInst, IDS_CTM_GENERAL_ERR2, lpStr, 80))
            _tprintf(lpStr);
        return -1;
    }
 
    if (GetConsoleMode(hStdout, &outConMode) == 0)
    {
        if (LoadString(hInst, IDS_CTM_GENERAL_ERR3, lpStr, 80))
            _tprintf(lpStr);
        return -1;
    }
 
    SetConsoleMode(hStdin, 0); //FIXME: Should check for error!
    SetConsoleMode(hStdout, 0); //FIXME: Should check for error!
 
    PerfInit();
 
    while (1)
    {
        DWORD numEvents;
 
        PerfDataRefresh();
        DisplayScreen();
 
        /* WaitForSingleObject for console handles is not implemented in ROS */
        WaitForSingleObject(hStdin, 1000);
        GetNumberOfConsoleInputEvents(hStdin, &numEvents);
 
        if (numEvents > 0)
        {
            if (ProcessKeys(numEvents) == TRUE)
                break;
            first = 0;
        }
    }
 
    RestoreConsole();
    return 0;
}

DisplayScreen()

void DisplayScreen

(

)

Definition at line 141 of file ctm.c.

{
    COORD pos;
    COORD size;
    TCHAR lpStr[80];
    DWORD numChars;
    int lines;
    int idx;
    GetConsoleScreenBufferInfo(hStdout,&screenBufferInfo);
    size=screenBufferInfo.dwSize;
    ScreenLines=size.Y;
    ProcPerScreen = ScreenLines-7;
    if (first == 0)
    {
        // Header
        pos.X = 1; pos.Y = 1;
        WriteConsoleOutputCharacter(hStdout, lpTitle, _tcslen(lpTitle), pos, &numChars);
 
        pos.X = 1; pos.Y = 2;
        WriteConsoleOutputCharacter(hStdout, lpSeparator, _tcslen(lpSeparator), pos, &numChars);
 
        pos.X = 1; pos.Y = 3;
        WriteConsoleOutputCharacter(hStdout, lpHeader, _tcslen(lpHeader), pos, &numChars);
 
        pos.X = 1; pos.Y = 4;
        if (scrolled)
            WriteConsoleOutputCharacter(hStdout, lpSeparatorUp, _tcslen(lpSeparatorUp), pos, &numChars);
        else
            WriteConsoleOutputCharacter(hStdout, lpSeparator, _tcslen(lpSeparator), pos, &numChars);
 
        // Footer
        pos.X = 1; pos.Y = ScreenLines-2;
        if ((ProcPerScreen+scrolled < ProcessCount))
            WriteConsoleOutputCharacter(hStdout, lpSeparatorDown, _tcslen(lpSeparatorDown), pos, &numChars);
        else
            WriteConsoleOutputCharacter(hStdout, lpSeparator, _tcslen(lpSeparator), pos, &numChars);
 
        // Menu
        pos.X = 1; pos.Y = ScreenLines-1;
        WriteConsoleOutputCharacter(hStdout, lpEmpty, _tcslen(lpEmpty), pos, &numChars);
        WriteConsoleOutputCharacter(hStdout, lpMenu, _tcslen(lpMenu), pos, &numChars);
 
        first = 1;
    }
 
    // Processess
    lines = ProcessCount;
    if (lines > ProcPerScreen)
        lines = ProcPerScreen;
    for (idx=0; idx<ProcPerScreen; idx++)
    {
        int i;
        SIZE_T len;
        TCHAR lpNumber[5];
        TCHAR lpPid[8];
        TCHAR lpCpu[6];
        TCHAR lpMemUsg[12];
        TCHAR lpPageFaults[15];
        WORD wColor;
 
        for (i = 0; i < 80; i++)
            lpStr[i] = _T(' ');
 
        // data
        if (idx < lines && scrolled + idx < ProcessCount)
        {
 
            // number
            _stprintf(lpNumber, _T("%3d"), idx+scrolled);
            _tcsncpy(&lpStr[2], lpNumber, 3);
 
            // image name
#ifdef _UNICODE
           len = wcslen(pPerfData[scrolled+idx].ImageName);
#else
           WideCharToMultiByte(CP_ACP, 0, pPerfData[scrolled+idx].ImageName, -1,
                           imgName, MAX_PATH, NULL, NULL);
           len = strlen(imgName);
#endif
            if (len > columnRightPositions[1])
            {
                len = columnRightPositions[1];
            }
#ifdef _UNICODE
           wcsncpy(&lpStr[columnRightPositions[0]+3], pPerfData[scrolled+idx].ImageName, len);
#else
           strncpy(&lpStr[columnRightPositions[0]+3], imgName, len);
#endif
 
            // PID
            _stprintf(lpPid, _T("%6ld"), pPerfData[scrolled+idx].ProcessId);
            _tcsncpy(&lpStr[columnRightPositions[2] - 6], lpPid, 6);
 
#ifdef TIMES
            // CPU
            _stprintf(lpCpu, _T("%3d%%"), pPerfData[scrolled+idx].CPUUsage);
            _tcsncpy(&lpStr[columnRightPositions[3] - 4], lpCpu, 4);
#endif
 
            // Mem usage
             _stprintf(lpMemUsg, _T("%6ld %s"), pPerfData[scrolled+idx].WorkingSetSizeBytes / 1024, lpMemUnit);
             _tcsncpy(&lpStr[columnRightPositions[4] - 9], lpMemUsg, 9);
 
            // Page Fault
            _stprintf(lpPageFaults, _T("%12ld"), pPerfData[scrolled+idx].PageFaultCount);
            _tcsncpy(&lpStr[columnRightPositions[5] - 12], lpPageFaults, 12);
        }
 
        // columns
        lpStr[0] = _T(' ');
        lpStr[1] = _T('|');
        for (i = 0; i < 6; i++)
            lpStr[columnRightPositions[i] + 1] = _T('|');
                pos.X = 0; pos.Y = 5+idx;
        WriteConsoleOutputCharacter(hStdout, lpStr, 80, pos, &numChars);
 
        // Attributes now...
        pos.X = columnRightPositions[0] + 1; pos.Y = 5+idx;
        if (selection == idx)
        {
            wColor = BACKGROUND_GREEN |
                FOREGROUND_RED |
                FOREGROUND_GREEN |
                FOREGROUND_BLUE;
        }
        else
        {
            wColor = BACKGROUND_BLUE |
                    FOREGROUND_RED |
                    FOREGROUND_GREEN |
                    FOREGROUND_BLUE;
        }
 
        FillConsoleOutputAttribute(
            hStdout,          // screen buffer handle
            wColor,           // color to fill with
            columnRightPositions[1] - 4,    // number of cells to fill
            pos,            // first cell to write to
            &numChars);       // actual number written
    }
 
    return;
}

Referenced by _tmain().

GetInputOutputHandles()

void GetInputOutputHandles

(

)

Definition at line 108 of file ctm.c.

{
#ifdef NEW_CONSOLE
    HANDLE console = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
                                        FILE_SHARE_READ | FILE_SHARE_WRITE,
                                        0, CONSOLE_TEXTMODE_BUFFER, 0);
 
    if (SetConsoleActiveScreenBuffer(console) == FALSE)
    {
        hStdin = GetStdHandle(STD_INPUT_HANDLE);
        hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
    }
    else
    {
        hStdin = GetStdHandle(STD_INPUT_HANDLE);//console;
        hStdout = console;
    }
#else
    hStdin = GetStdHandle(STD_INPUT_HANDLE);
    hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
#endif
}

Referenced by _tmain().

GetKeyPressed() [1/2]

unsigned int GetKeyPressed

(

)

Referenced by ProcessKeys().

GetKeyPressed() [2/2]

unsigned int GetKeyPressed

(

int

events

)

Definition at line 596 of file ctm.c.

{
    DWORD bytesRead;
    INPUT_RECORD record;
    int i;
 
 
    for (i=0; i<events; i++)
    {
        if (!ReadConsoleInput(hStdin, &record, 1, &bytesRead)) {
            return 0;
        }
 
        if (record.EventType == KEY_EVENT && record.Event.KeyEvent.bKeyDown)
            return record.Event.KeyEvent.wVirtualKeyCode;//.uChar.AsciiChar;
    }
 
    return 0;
}

PerfDataRefresh()

void PerfDataRefresh

(

void

)

Definition at line 410 of file ctm.c.

{
    LONG                            status;
    ULONG                           ulSize;
    LPBYTE                          pBuffer;
    ULONG                           Idx, Idx2;
    PSYSTEM_PROCESS_INFORMATION     pSPI;
    PPERFDATA                       pPDOld;
#ifdef EXTRA_INFO
    HANDLE                          hProcess;
    HANDLE                          hProcessToken;
    TCHAR                           szTemp[MAX_PATH];
    DWORD                           dwSize;
#endif
#ifdef TIMES
    LARGE_INTEGER                       liCurrentKernelTime;
    LARGE_INTEGER                       liCurrentIdleTime;
    LARGE_INTEGER                       liCurrentTime;
#endif
    PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION       SysProcessorTimeInfo;
    SYSTEM_TIMEOFDAY_INFORMATION                SysTimeInfo;
 
#ifdef TIMES
    // Get new system time
    status = NtQuerySystemInformation(SystemTimeInformation, &SysTimeInfo, sizeof(SysTimeInfo), 0);
    if (status != NO_ERROR)
        return;
#endif
    // Get processor information
    SysProcessorTimeInfo = (PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION)malloc(sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION) * SystemBasicInfo.NumberOfProcessors);
    status = NtQuerySystemInformation(SystemProcessorPerformanceInformation, SysProcessorTimeInfo, sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION) * SystemBasicInfo.NumberOfProcessors, &ulSize);
 
 
    // Get process information
    PsaCaptureProcessesAndThreads((PSYSTEM_PROCESS_INFORMATION *)&pBuffer);
 
#ifdef TIMES
    liCurrentKernelTime.QuadPart = 0;
    liCurrentIdleTime.QuadPart = 0;
    for (Idx=0; Idx<SystemBasicInfo.NumberOfProcessors; Idx++) {
        liCurrentKernelTime.QuadPart += SysProcessorTimeInfo[Idx].KernelTime.QuadPart;
        liCurrentKernelTime.QuadPart += SysProcessorTimeInfo[Idx].DpcTime.QuadPart;
        liCurrentKernelTime.QuadPart += SysProcessorTimeInfo[Idx].InterruptTime.QuadPart;
        liCurrentIdleTime.QuadPart += SysProcessorTimeInfo[Idx].IdleTime.QuadPart;
    }
 
    // If it's a first call - skip idle time calcs
    if (liOldIdleTime.QuadPart != 0) {
        // CurrentValue = NewValue - OldValue
        liCurrentTime.QuadPart = liCurrentIdleTime.QuadPart - liOldIdleTime.QuadPart;
        dbIdleTime = Li2Double(liCurrentTime);
        liCurrentTime.QuadPart = liCurrentKernelTime.QuadPart - liOldKernelTime.QuadPart;
        dbKernelTime = Li2Double(liCurrentTime);
        liCurrentTime.QuadPart = SysTimeInfo.CurrentTime.QuadPart - liOldSystemTime.QuadPart;
            dbSystemTime = Li2Double(liCurrentTime);
 
        // CurrentCpuIdle = IdleTime / SystemTime
        dbIdleTime = dbIdleTime / dbSystemTime;
        dbKernelTime = dbKernelTime / dbSystemTime;
 
        // CurrentCpuUsage% = 100 - (CurrentCpuIdle * 100) / NumberOfProcessors
        dbIdleTime = 100.0 - dbIdleTime * 100.0 / (double)SystemBasicInfo.NumberOfProcessors;// + 0.5;
        dbKernelTime = 100.0 - dbKernelTime * 100.0 / (double)SystemBasicInfo.NumberOfProcessors;// + 0.5;
    }
 
    // Store new CPU's idle and system time
    liOldIdleTime = liCurrentIdleTime;
    liOldSystemTime = SysTimeInfo.CurrentTime;
    liOldKernelTime = liCurrentKernelTime;
#endif
 
    // Determine the process count
    // We loop through the data we got from PsaCaptureProcessesAndThreads
    // and count how many structures there are (until PsaWalkNextProcess
        // returns NULL)
    ProcessCountOld = ProcessCount;
    ProcessCount = 0;
        pSPI = PsaWalkFirstProcess((PSYSTEM_PROCESS_INFORMATION)pBuffer);
    while (pSPI) {
        ProcessCount++;
        pSPI = PsaWalkNextProcess(pSPI);
    }
 
    // Now alloc a new PERFDATA array and fill in the data
    if (pPerfDataOld) {
        free(pPerfDataOld);
    }
    pPerfDataOld = pPerfData;
    pPerfData = (PPERFDATA)malloc(sizeof(PERFDATA) * ProcessCount);
        pSPI = PsaWalkFirstProcess((PSYSTEM_PROCESS_INFORMATION)pBuffer);
    for (Idx=0; Idx<ProcessCount; Idx++) {
        // Get the old perf data for this process (if any)
        // so that we can establish delta values
        pPDOld = NULL;
        for (Idx2=0; Idx2<ProcessCountOld; Idx2++) {
            if (pPerfDataOld[Idx2].ProcessId == HandleToUlong(pSPI->UniqueProcessId) &&
                /* check also for the creation time, a new process may have an id of an old one */
                pPerfDataOld[Idx2].CreateTime.QuadPart == pSPI->CreateTime.QuadPart) {
                pPDOld = &pPerfDataOld[Idx2];
                break;
            }
        }
 
        // Clear out process perf data structure
        memset(&pPerfData[Idx], 0, sizeof(PERFDATA));
 
        if (pSPI->ImageName.Buffer) {
            wcsncpy(pPerfData[Idx].ImageName, pSPI->ImageName.Buffer, pSPI->ImageName.Length / sizeof(WCHAR));
                        pPerfData[Idx].ImageName[pSPI->ImageName.Length / sizeof(WCHAR)] = 0;
        }
        else
        {
#ifdef _UNICODE
            wcscpy(pPerfData[Idx].ImageName, lpIdleProcess);
#else
            MultiByteToWideChar(CP_ACP, 0, lpIdleProcess, strlen(lpIdleProcess), pPerfData[Idx].ImageName, MAX_PATH);
#endif
        }
 
        pPerfData[Idx].ProcessId = HandleToUlong(pSPI->UniqueProcessId);
        pPerfData[Idx].CreateTime = pSPI->CreateTime;
 
        if (pPDOld) {
#ifdef TIMES
            double  CurTime = Li2Double(pSPI->KernelTime) + Li2Double(pSPI->UserTime);
            double  OldTime = Li2Double(pPDOld->KernelTime) + Li2Double(pPDOld->UserTime);
            double  CpuTime = (CurTime - OldTime) / dbSystemTime;
            CpuTime = CpuTime * 100.0 / (double)SystemBasicInfo.NumberOfProcessors; // + 0.5;
 
            pPerfData[Idx].CPUUsage = (ULONG)CpuTime;
#else
            pPerfData[Idx].CPUUsage = 0;
#endif
        }
 
        pPerfData[Idx].CPUTime.QuadPart = pSPI->UserTime.QuadPart + pSPI->KernelTime.QuadPart;
        pPerfData[Idx].WorkingSetSizeBytes = pSPI->WorkingSetSize;
        pPerfData[Idx].PeakWorkingSetSizeBytes = pSPI->PeakWorkingSetSize;
        if (pPDOld)
            pPerfData[Idx].WorkingSetSizeDelta = labs((LONG)pSPI->WorkingSetSize - (LONG)pPDOld->WorkingSetSizeBytes);
        else
            pPerfData[Idx].WorkingSetSizeDelta = 0;
        pPerfData[Idx].PageFaultCount = pSPI->PageFaultCount;
        if (pPDOld)
            pPerfData[Idx].PageFaultCountDelta = labs((LONG)pSPI->PageFaultCount - (LONG)pPDOld->PageFaultCount);
        else
            pPerfData[Idx].PageFaultCountDelta = 0;
        pPerfData[Idx].VirtualMemorySizeBytes = pSPI->VirtualSize;
        pPerfData[Idx].PagedPoolUsagePages = pSPI->QuotaPagedPoolUsage;
        pPerfData[Idx].NonPagedPoolUsagePages = pSPI->QuotaNonPagedPoolUsage;
        pPerfData[Idx].BasePriority = pSPI->BasePriority;
        pPerfData[Idx].HandleCount = pSPI->HandleCount;
        pPerfData[Idx].ThreadCount = pSPI->NumberOfThreads;
        //pPerfData[Idx].SessionId = pSPI->SessionId;
 
#ifdef EXTRA_INFO
        hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, (DWORD)pSPI->UniqueProcessId);
        if (hProcess) {
            if (OpenProcessToken(hProcess, TOKEN_QUERY|TOKEN_DUPLICATE|TOKEN_IMPERSONATE, &hProcessToken)) {
                ImpersonateLoggedOnUser(hProcessToken);
                memset(szTemp, 0, sizeof(TCHAR[MAX_PATH]));
                dwSize = MAX_PATH;
                GetUserName(szTemp, &dwSize);
#ifndef UNICODE
                MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szTemp, -1, pPerfData[Idx].UserName, MAX_PATH);
#endif
                RevertToSelf();
                CloseHandle(hProcessToken);
            }
            CloseHandle(hProcess);
        }
#endif
#ifdef TIMES
        pPerfData[Idx].UserTime.QuadPart = pSPI->UserTime.QuadPart;
        pPerfData[Idx].KernelTime.QuadPart = pSPI->KernelTime.QuadPart;
#endif
        pSPI = PsaWalkNextProcess(pSPI);
    }
    PsaFreeCapture(pBuffer);
 
    free(SysProcessorTimeInfo);
    if (ProcessCount != ProcessCountOld)
        first = 0;
}

Referenced by _tmain().

PerfInit()

void PerfInit

(

)

Definition at line 405 of file ctm.c.

{
    NtQuerySystemInformation(SystemBasicInformation, &SystemBasicInfo, sizeof(SystemBasicInfo), 0);
}

Referenced by _tmain().

ProcessKeys()

int ProcessKeys

(

int

numEvents

)

Definition at line 286 of file ctm.c.

{
    DWORD numChars;
    TCHAR key;
    if ((ProcessCount-scrolled < 17) && (ProcessCount > 17))
        scrolled = ProcessCount-17;
 
    key = GetKeyPressed(numEvents);
    if (key == KEY_QUIT)
        return TRUE;
    else if (key == KEY_KILL)
    {
        // user wants to kill some process, get his acknowledgement
        DWORD pId;
        COORD pos;
        TCHAR lpStr[100];
 
        pos.X = 1; pos.Y =ScreenLines-1;
        if (LoadString(hInst, IDS_KILL_PROCESS, lpStr, 100))
            WriteConsoleOutputCharacter(hStdout, lpStr, _tcslen(lpStr), pos, &numChars);
 
        do {
            GetNumberOfConsoleInputEvents(hStdin, &pId);
            key = GetKeyPressed(pId);
        } while (key != KEY_YES && key != KEY_NO);
 
        if (key == KEY_YES)
        {
            HANDLE hProcess;
            pId = pPerfData[selection+scrolled].ProcessId;
            hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, pId);
 
            if (hProcess)
            {
                if (!TerminateProcess(hProcess, 0))
                {
                    if (LoadString(hInst, IDS_KILL_PROCESS_ERR1, lpStr, 80))
                    {
                        WriteConsoleOutputCharacter(hStdout, lpEmpty, _tcslen(lpEmpty), pos, &numChars);
                        WriteConsoleOutputCharacter(hStdout, lpStr, _tcslen(lpStr), pos, &numChars);
                    }
                    Sleep(1000);
                }
 
                CloseHandle(hProcess);
            }
            else
            {
                if (LoadString(hInst, IDS_KILL_PROCESS_ERR2, lpStr, 80))
                {
                    WriteConsoleOutputCharacter(hStdout, lpEmpty, _tcslen(lpEmpty), pos, &numChars);
                    _stprintf(lpStr, lpStr, pId);
                    WriteConsoleOutputCharacter(hStdout, lpStr, _tcslen(lpStr), pos, &numChars);
                }
                Sleep(1000);
            }
        }
 
        first = 0;
    }
    else if (key == VK_UP)
    {
        if (selection > 0)
            selection--;
        else if ((selection == 0) && (scrolled > 0))
            scrolled--;
    }
    else if (key == VK_DOWN)
    {
        if ((selection < ProcPerScreen-1) && (selection < ProcessCount-1))
            selection++;
        else if ((selection == ProcPerScreen-1) && (selection+scrolled < ProcessCount-1))
            scrolled++;
    }
    else if (key == VK_PRIOR)
    {
        if (scrolled>ProcPerScreen-1)
            scrolled-=ProcPerScreen-1;
        else
        {
            scrolled=0; //First
            selection=0;
        }
        //selection=0;
    }
    else if (key == VK_NEXT)
    {
        scrolled+=ProcPerScreen-1;
        if (scrolled>ProcessCount-ProcPerScreen)
        {
            scrolled=ProcessCount-ProcPerScreen; //End
            selection=ProcPerScreen-1;
        }
 
        //selection=ProcPerScreen-1;
        if (ProcessCount<=ProcPerScreen) //If there are less process than fits on the screen
        {
            scrolled=0;
            selection=(ProcessCount%ProcPerScreen)-1;
        }
    }
    else if  (key == VK_HOME)
    {
        selection=0;
        scrolled=0;
    }
    else if  (key == VK_END)
    {
        selection=ProcPerScreen-1;
        scrolled=ProcessCount-ProcPerScreen;
        if (ProcessCount<=ProcPerScreen) //If there are less process than fits on the screen
        {
            scrolled=0;
            selection=(ProcessCount%ProcPerScreen)-1;
        }
    }
    return FALSE;
}

Referenced by _tmain().

PsaiFree()

void PsaiFree

(

void *

ptr

)

Definition at line 103 of file ctm.c.

{ free(ptr); }

Referenced by PsaCaptureProcessesAndThreads(), PsaCaptureSystemModules(), and PsaFreeCapture().

PsaiMalloc()

void * PsaiMalloc

(

SIZE_T

size

)

Definition at line 101 of file ctm.c.

{ return malloc(size); }

Referenced by PsaCaptureProcessesAndThreads(), and PsaCaptureSystemModules().

PsaiRealloc()

void * PsaiRealloc	(	void *	ptr,
		SIZE_T	size
	)

Definition at line 102 of file ctm.c.

{ return realloc(ptr, size); }

RestoreConsole()

void RestoreConsole

(

)

Definition at line 131 of file ctm.c.

{
    SetConsoleMode(hStdin, inConMode);
    SetConsoleMode(hStdout, outConMode);
 
#ifdef NEW_CONSOLE
    SetConsoleActiveScreenBuffer(GetStdHandle(STD_OUTPUT_HANDLE));
#endif
}

Referenced by _tmain().

Variable Documentation

columnRightPositions

DWORD columnRightPositions[6]

Definition at line 62 of file ctm.c.

Referenced by _tmain(), and DisplayScreen().

dbIdleTime

double dbIdleTime

Definition at line 82 of file ctm.c.

Referenced by PerfDataRefresh().

dbKernelTime

double dbKernelTime

Definition at line 83 of file ctm.c.

Referenced by PerfDataRefresh().

dbSystemTime

double dbSystemTime

Definition at line 84 of file ctm.c.

Referenced by PerfDataRefresh().

first

int first = 0

Definition at line 94 of file ctm.c.

hInst

HINSTANCE hInst

Definition at line 57 of file ctm.c.

Referenced by _tmain(), and ProcessKeys().

hStdin

HANDLE hStdin

Definition at line 55 of file ctm.c.

Referenced by _tmain(), GetInputOutputHandles(), GetKeyPressed(), ProcessKeys(), ReadCommand(), and RestoreConsole().

hStdout

HANDLE hStdout

Definition at line 56 of file ctm.c.

Referenced by _tmain(), DisplayScreen(), GetInputOutputHandles(), newBuffer(), ProcessKeys(), RestoreConsole(), restoreScreen(), saveScreen(), and TScroller::ScrollBack().

inConMode

DWORD inConMode

Definition at line 59 of file ctm.c.

Referenced by _tmain(), and RestoreConsole().

KEY_KILL

TCHAR KEY_KILL

Definition at line 74 of file ctm.c.

Referenced by _tmain(), and ProcessKeys().

KEY_NO

TCHAR KEY_NO

Definition at line 75 of file ctm.c.

Referenced by _tmain(), and ProcessKeys().

KEY_QUIT

TCHAR KEY_QUIT

Definition at line 74 of file ctm.c.

Referenced by _tmain(), and ProcessKeys().

KEY_YES

TCHAR KEY_YES

Definition at line 75 of file ctm.c.

Referenced by _tmain(), and ProcessKeys().

liOldIdleTime

LARGE_INTEGER liOldIdleTime = {{0,0}}

Definition at line 85 of file ctm.c.

Referenced by PerfDataRefresh().

liOldKernelTime

LARGE_INTEGER liOldKernelTime = {{0,0}}

Definition at line 86 of file ctm.c.

Referenced by PerfDataRefresh().

liOldSystemTime

LARGE_INTEGER liOldSystemTime = {{0,0}}

Definition at line 87 of file ctm.c.

Referenced by PerfDataRefresh().

lpEmpty

TCHAR lpEmpty[80]

Definition at line 72 of file ctm.c.

Referenced by _tmain(), DisplayScreen(), and ProcessKeys().

lpHeader

TCHAR lpHeader

Definition at line 66 of file ctm.c.

Referenced by _tmain(), CommitWaveBufferApc(), DisplayScreen(), and WdmAudCommitWaveBufferByMMixer().

lpIdleProcess

TCHAR lpIdleProcess[80]

Definition at line 68 of file ctm.c.

Referenced by _tmain(), and PerfDataRefresh().

lpMemUnit

TCHAR lpMemUnit[3]

Definition at line 67 of file ctm.c.

Referenced by _tmain(), and DisplayScreen().

lpMenu

TCHAR lpMenu[80]

Definition at line 71 of file ctm.c.

Referenced by _tmain(), and DisplayScreen().

lpSeparator

TCHAR lpSeparator[80]

Definition at line 63 of file ctm.c.

Referenced by _tmain(), and DisplayScreen().

lpSeparatorDown

TCHAR lpSeparatorDown[80]

Definition at line 65 of file ctm.c.

Referenced by _tmain(), and DisplayScreen().

lpSeparatorUp

TCHAR lpSeparatorUp[80]

Definition at line 64 of file ctm.c.

Referenced by _tmain(), and DisplayScreen().

lpTitle

TCHAR lpTitle[80]

Definition at line 69 of file ctm.c.

Referenced by _tmain(), _tWinMain(), cmd_start(), CreateNewConsoleTitle(), DisplayMessage(), DisplayScreen(), ErrorMessageBox(), FrameOnCommand(), GetFileTitleA(), GetFileTitleW(), InfoMessageBox(), MDI_UpdateFrameText(), OnPaint(), RealShellExecuteA(), RealShellExecuteExA(), RealShellExecuteExW(), RealShellExecuteW(), SetUpConsoleInfo(), test_pack_STARTUPINFOA(), and test_pack_STARTUPINFOW().

outConMode

DWORD outConMode

Definition at line 60 of file ctm.c.

Referenced by _tmain(), and RestoreConsole().

pPerfData

PPERFDATA pPerfData = NULL

Definition at line 90 of file ctm.c.

Referenced by DisplayScreen(), PerfDataRefresh(), and ProcessKeys().

pPerfDataOld

PPERFDATA pPerfDataOld = NULL

Definition at line 89 of file ctm.c.

Referenced by PerfDataRefresh().

ProcessCount

ULONG ProcessCount = 0

Definition at line 80 of file ctm.c.

Referenced by DisplayScreen(), PerfDataRefresh(), and ProcessKeys().

ProcessCountOld

ULONG ProcessCountOld = 0

Definition at line 79 of file ctm.c.

Referenced by PerfDataRefresh().

ProcPerScreen

int ProcPerScreen = 17

Definition at line 77 of file ctm.c.

Referenced by DisplayScreen(), and ProcessKeys().

screenBufferInfo

CONSOLE_SCREEN_BUFFER_INFO screenBufferInfo

Definition at line 97 of file ctm.c.

Referenced by DisplayScreen().

ScreenLines

int ScreenLines =25

Definition at line 78 of file ctm.c.

Referenced by DisplayScreen(), and ProcessKeys().

scrolled

int scrolled =0

Definition at line 93 of file ctm.c.

Referenced by DisplayScreen(), and ProcessKeys().

selection

int selection =0

Definition at line 92 of file ctm.c.

Referenced by _check_selection(), _reset_selection(), ActivateThemeFile(), CShellDispatch::BrowseForFolder(), cert_mgr_dlg_proc(), cert_mgr_do_export(), cert_mgr_do_remove(), DATETIME_Refresh(), DisplayScreen(), DesktopShellView::DoContextMenu(), EditSession_DoEditSession(), FTC_MruList_RemoveSelection(), PIDList::GetData(), hierarchy_dlg_proc(), HTMLSelectionObject_Create(), ITextDocument2Old_fnGetSelection(), ITextDocument2Old_fnGetSelectionEx(), ITextSelection_fnInRange(), ITextSelection_fnIsEqual(), LISTVIEW_SetGroupSelection(), ME_StreamInRTFString(), MONTHCAL_SetCurSel(), nsContextMenuListener_OnShowContextMenu(), IShellBrowserImpl::OnDefaultCommand(), ProcessKeys(), select_cert_get_selected(), select_purposes(), select_store_dlg_proc(), show_dialog_for_selected_cert(), test_default_selection(), test_Expand(), test_GetFont(), test_GetPara(), test_GetStoryLength(), test_GetStoryType(), test_InRange(), test_ITextRange_IsEqual(), test_ITextSelection_GetDuplicate(), test_MoveEnd(), test_Select(), test_selection(), test_SetFont(), test_txtrange(), TRACKBAR_CalcSelection(), TREEVIEW_LButtonDown(), TREEVIEW_SelectItem(), TREEVIEW_SingleExpand(), WMReaderAdvanced_GetManualStreamSelection(), WMReaderAdvanced_GetStreamSelected(), WMReaderAdvanced_SetManualStreamSelection(), and WMSyncReader_GetStreamSelected().

SystemBasicInfo

SYSTEM_BASIC_INFORMATION SystemBasicInfo

Definition at line 95 of file ctm.c.

Referenced by PerfDataRefresh(), and PerfInit().