tasklist.c File Reference

#include "tasklist.h"

Include dependency graph for tasklist.c:

Go to the source code of this file.

Macros
#define	OPTION_INVALID   -1
#define	OPTION_HELP   0
#define	OPTION_NOHEADER   1
#define	RES_STR_MAXLEN   64

Functions
VOID	PrintSplitLine (UINT Length)
VOID	PrintSpace (UINT Length)
VOID	PrintString (LPCWSTR String, UINT MaxWidth, BOOL bAlignLeft)
VOID	PrintResString (UINT uID, UINT MaxWidth, BOOL bAlignLeft)
VOID	PrintNum (LONGLONG Number, UINT MaxWidth)
BOOL	PrintMemory (SIZE_T MemorySizeByte, UINT MaxWidth)
VOID	PrintHeader (VOID)
BOOL	EnumProcessAndPrint (BOOL bNoHeader)
INT	GetOptionType (LPCWSTR szOption)
BOOL	ProcessArguments (INT argc, WCHAR **argv)
int	wmain (int argc, WCHAR **argv)

Variables
static PCWSTR	OptionList [] = { L"?", L"nh" }

Macro Definition Documentation

OPTION_HELP

#define OPTION_HELP   0

Definition at line 15 of file tasklist.c.

OPTION_INVALID

#define OPTION_INVALID   -1

Definition at line 14 of file tasklist.c.

OPTION_NOHEADER

#define OPTION_NOHEADER   1

Definition at line 16 of file tasklist.c.

RES_STR_MAXLEN

#define RES_STR_MAXLEN   64

Definition at line 19 of file tasklist.c.

Function Documentation

EnumProcessAndPrint()

BOOL EnumProcessAndPrint

(

BOOL

bNoHeader

)

Definition at line 134 of file tasklist.c.

{
    // Call NtQuerySystemInformation for the process information
    ULONG ProcessInfoBufferLength = 0;
    ULONG ResultLength = 0;
    PBYTE ProcessInfoBuffer = NULL;
 
    // Get the buffer size we need
    NTSTATUS Status = NtQuerySystemInformation(SystemProcessInformation, NULL, 0, &ResultLength);
 
    // New process/thread might appear before we call for the actual data.
    // Try to avoid this by retrying several times.
    for (UINT Retry = 0; Retry < NT_SYSTEM_QUERY_MAX_RETRY; Retry++)
    {
        // (Re)allocate buffer
        ProcessInfoBufferLength = ResultLength;
        ResultLength = 0;
        if (ProcessInfoBuffer)
        {
            PBYTE NewProcessInfoBuffer = HeapReAlloc(GetProcessHeap(), 0,
                                                     ProcessInfoBuffer,
                                                     ProcessInfoBufferLength);
            if (NewProcessInfoBuffer)
            {
                ProcessInfoBuffer = NewProcessInfoBuffer;
            }
            else
            {
                // out of memory
                ConResMsgPrintf(StdErr, 0, IDS_OUT_OF_MEMORY);
                HeapFree(GetProcessHeap(), 0, ProcessInfoBuffer);
                return FALSE;
            }
        }
        else
        {
            ProcessInfoBuffer = HeapAlloc(GetProcessHeap(), 0, ProcessInfoBufferLength);
            if (!ProcessInfoBuffer)
            {
                // out of memory
                ConResMsgPrintf(StdErr, 0, IDS_OUT_OF_MEMORY);
                return FALSE;
            }
        }
 
        // Query information
        Status = NtQuerySystemInformation(SystemProcessInformation,
                                          ProcessInfoBuffer,
                                          ProcessInfoBufferLength,
                                          &ResultLength);
        if (Status != STATUS_INFO_LENGTH_MISMATCH)
        {
            break;
        }
    }
 
    if (!NT_SUCCESS(Status))
    {
        // tried NT_SYSTEM_QUERY_MAX_RETRY times, or failed with some other reason
        ConResMsgPrintf(StdErr, 0, IDS_ENUM_FAILED);
        HeapFree(GetProcessHeap(), 0, ProcessInfoBuffer);
        return FALSE;
    }
 
    ConPuts(StdOut, L"\n");
 
    if (!bNoHeader)
        PrintHeader();
 
    PSYSTEM_PROCESS_INFORMATION pSPI;
    pSPI = (PSYSTEM_PROCESS_INFORMATION)ProcessInfoBuffer;
    while (pSPI)
    {
        PrintString(pSPI->UniqueProcessId ? pSPI->ImageName.Buffer : L"System Idle Process", COLUMNWIDTH_IMAGENAME, TRUE);
        PrintSpace(1);
        PrintNum((LONGLONG)(INT_PTR)pSPI->UniqueProcessId, COLUMNWIDTH_PID);
        PrintSpace(1);
        PrintNum((ULONGLONG)pSPI->SessionId, COLUMNWIDTH_SESSION);
        PrintSpace(1);
        PrintMemory(pSPI->WorkingSetSize, COLUMNWIDTH_MEMUSAGE);
 
        ConPuts(StdOut, L"\n");
 
        if (pSPI->NextEntryOffset == 0)
            break;
        pSPI = (PSYSTEM_PROCESS_INFORMATION)((LPBYTE)pSPI + pSPI->NextEntryOffset);
    }
 
    HeapFree(GetProcessHeap(), 0, ProcessInfoBuffer);
    return TRUE;
}

Referenced by ProcessArguments().

GetOptionType()

INT GetOptionType

(

LPCWSTR

szOption

)

Definition at line 226 of file tasklist.c.

{
    if (szOption[0] != L'/' && szOption[0] != L'-')
    {
        return OPTION_INVALID;
    }
    szOption++;
 
    for (UINT i = 0; i < _countof(OptionList); i++)
    {
        if (!_wcsicmp(OptionList[i], szOption))
        {
            return i;
        }
    }
    return OPTION_INVALID;
}

Referenced by ProcessArguments().

PrintHeader()

VOID PrintHeader

(

VOID

)

Definition at line 111 of file tasklist.c.

{
    PrintResString(IDS_HEADER_IMAGENAME, COLUMNWIDTH_IMAGENAME, TRUE);
    PrintSpace(1);
    PrintResString(IDS_HEADER_PID,       COLUMNWIDTH_PID,       FALSE);
    PrintSpace(1);
    PrintResString(IDS_HEADER_SESSION,   COLUMNWIDTH_SESSION,   FALSE);
    PrintSpace(1);
    PrintResString(IDS_HEADER_MEMUSAGE,  COLUMNWIDTH_MEMUSAGE,  FALSE);
 
    ConPuts(StdOut, L"\n");
 
    PrintSplitLine(COLUMNWIDTH_IMAGENAME);
    PrintSpace(1);
    PrintSplitLine(COLUMNWIDTH_PID);
    PrintSpace(1);
    PrintSplitLine(COLUMNWIDTH_SESSION);
    PrintSpace(1);
    PrintSplitLine(COLUMNWIDTH_MEMUSAGE);
 
    ConPuts(StdOut, L"\n");
}

Referenced by EnumProcessAndPrint().

PrintMemory()

BOOL PrintMemory	(	SIZE_T	MemorySizeByte,
		UINT	MaxWidth
	)

Definition at line 66 of file tasklist.c.

{
    SIZE_T MemorySize = MemorySizeByte >> 10;
 
    WCHAR NumberString[27] = { 0 }; // length 26 is enough to display ULLONG_MAX in decimal with comma, one more for zero-terminated.
    C_ASSERT(sizeof(SIZE_T) <= 8);
 
    PWCHAR pNumberStr = NumberString;
 
    // calculate the length
    UINT PrintLength = 0;
    SIZE_T Tmp = MemorySize;
    UINT Mod = 1;
 
    do
    {
        Tmp /= 10;
        PrintLength++;
        Mod *= 10;
    } while (Tmp);
 
    for (UINT i = PrintLength; i; i--)
    {
        Mod /= 10;
        *pNumberStr = L'0' + (MemorySize / Mod);
        MemorySize %= Mod;
        pNumberStr++;
 
        if (i != 1 && i % 3 == 1)
        {
            *pNumberStr = L',';
            pNumberStr++;
        }
    }
 
    WCHAR FormatStr[RES_STR_MAXLEN];
    LoadStringW(NULL, IDS_MEMORY_STR, FormatStr, _countof(FormatStr));
 
    WCHAR String[RES_STR_MAXLEN + _countof(NumberString)] = { 0 };
    StringCchPrintfW(String, _countof(String), FormatStr, NumberString);
    PrintString(String, MaxWidth, FALSE);
 
    return TRUE;
}

Referenced by EnumProcessAndPrint().

PrintNum()

VOID PrintNum	(	LONGLONG	Number,
		UINT	MaxWidth
	)

Definition at line 58 of file tasklist.c.

{
    ConPrintf(StdOut, L"%*lld", MaxWidth, Number);
}

Referenced by EnumProcessAndPrint().

PrintResString()

VOID PrintResString	(	UINT	uID,
		UINT	MaxWidth,
		BOOL	bAlignLeft
	)

Definition at line 48 of file tasklist.c.

{
    WCHAR StringBuffer[RES_STR_MAXLEN];
    LoadStringW(NULL, uID, StringBuffer, _countof(StringBuffer));
    PrintString(StringBuffer, MaxWidth, bAlignLeft);
}

Referenced by PrintHeader().

PrintSpace()

VOID PrintSpace

(

UINT

Length

)

Definition at line 31 of file tasklist.c.

{
    ConPrintf(StdOut, L"%*ls", (INT)Length, L"");
}

Referenced by EnumProcessAndPrint(), and PrintHeader().

PrintSplitLine()

VOID PrintSplitLine

(

UINT

Length

)

Definition at line 22 of file tasklist.c.

{
    for (; Length; Length--)
    {
        ConPuts(StdOut, L"=");
    }
}

Referenced by PrintHeader().

PrintString()

VOID PrintString	(	LPCWSTR	String,
		UINT	MaxWidth,
		BOOL	bAlignLeft
	)

Definition at line 39 of file tasklist.c.

{
    ConPrintf(StdOut, bAlignLeft ? L"%-*.*ls" : L"%*.*ls", MaxWidth, MaxWidth, String);
}

Referenced by EnumProcessAndPrint(), PrintMemory(), and PrintResString().

ProcessArguments()

BOOL ProcessArguments	(	INT	argc,
		WCHAR **	argv
	)

Definition at line 244 of file tasklist.c.

{
    BOOL bHasHelp = FALSE, bHasNoHeader = FALSE;
 
    for (INT i = 1; i < argc; i++)
    {
        INT Option = GetOptionType(argv[i]);
 
        switch (Option)
        {
            case OPTION_HELP:
            {
                if (bHasHelp)
                {
                    // -? already specified
                    ConResMsgPrintf(StdErr, 0, IDS_OPTION_TOO_MUCH, argv[i], 1);
                    ConResMsgPrintf(StdErr, 0, IDS_USAGE);
                    return FALSE;
                }
                bHasHelp = TRUE;
                break;
            }
            case OPTION_NOHEADER:
            {
                if (bHasNoHeader)
                {
                    // -nh already specified
                    ConResMsgPrintf(StdErr, 0, IDS_OPTION_TOO_MUCH, argv[i], 1);
                    ConResMsgPrintf(StdErr, 0, IDS_USAGE);
                    return FALSE;
                }
                bHasNoHeader = TRUE;
                break;
            }
            case OPTION_INVALID:
            default:
            {
                ConResMsgPrintf(StdErr, 0, IDS_INVALID_OPTION);
                ConResMsgPrintf(StdErr, 0, IDS_USAGE);
                return FALSE;
            }
        }
    }
 
    if (bHasHelp)
    {
        if (argc > 2) // any arguments other than -? exists
        {
            ConResMsgPrintf(StdErr, 0, IDS_INVALID_SYNTAX);
            ConResMsgPrintf(StdErr, 0, IDS_USAGE);
            return FALSE;
        }
        else
        {
            ConResMsgPrintf(StdOut, 0, IDS_USAGE);
            ConResMsgPrintf(StdOut, 0, IDS_DESCRIPTION);
            return FALSE;
        }
    }
    else
    {
        EnumProcessAndPrint(bHasNoHeader);
    }
    return TRUE;
}

Referenced by wmain().

wmain()

int wmain	(	int	argc,
		WCHAR **	argv
	)

Definition at line 310 of file tasklist.c.

{
    /* Initialize the Console Standard Streams */
    ConInitStdStreams();
 
    if (!ProcessArguments(argc, argv))
    {
        return 1;
    }
    return 0;
}

Variable Documentation

OptionList

PCWSTR OptionList[] = { L"?", L"nh" }

static

Definition at line 12 of file tasklist.c.

Referenced by GetOptionType().