history.c File Reference

#include "consrv.h"
#include "popup.h"
#include <debug.h>

Include dependency graph for history.c:

Go to the source code of this file.

Classes
struct	_HISTORY_BUFFER

Macros
#define	NDEBUG

Typedefs
typedef struct _HISTORY_BUFFER	HISTORY_BUFFER
typedef struct _HISTORY_BUFFER *	PHISTORY_BUFFER

Functions
BOOLEAN	ConvertInputAnsiToUnicode (PCONSRV_CONSOLE Console, PVOID Source, USHORT SourceLength, PWCHAR *Target, PUSHORT TargetLength)
BOOLEAN	ConvertInputUnicodeToAnsi (PCONSRV_CONSOLE Console, PVOID Source, USHORT SourceLength, PCHAR Target, USHORT TargetLength)
static PHISTORY_BUFFER	HistoryCurrentBuffer (IN PCONSRV_CONSOLE Console, IN PUNICODE_STRING ExeName)
static PHISTORY_BUFFER	HistoryFindBuffer (PCONSRV_CONSOLE Console, PVOID ExeName, USHORT ExeLength, BOOLEAN UnicodeExe)
static VOID	HistoryDeleteBuffer (PHISTORY_BUFFER Hist)
static NTSTATUS	HistoryResizeBuffer (IN PHISTORY_BUFFER Hist, IN ULONG NumCommands)
VOID	HistoryAddEntry (PCONSRV_CONSOLE Console, PUNICODE_STRING ExeName, PUNICODE_STRING Entry)
VOID	HistoryGetCurrentEntry (PCONSRV_CONSOLE Console, PUNICODE_STRING ExeName, PUNICODE_STRING Entry)
BOOL	HistoryRecallHistory (PCONSRV_CONSOLE Console, PUNICODE_STRING ExeName, INT Offset, PUNICODE_STRING Entry)
BOOL	HistoryFindEntryByPrefix (PCONSRV_CONSOLE Console, PUNICODE_STRING ExeName, PUNICODE_STRING Prefix, PUNICODE_STRING Entry)
PPOPUP_WINDOW	HistoryDisplayCurrentHistory (PCONSRV_CONSOLE Console, PUNICODE_STRING ExeName)
VOID	HistoryDeleteCurrentBuffer (PCONSRV_CONSOLE Console, PUNICODE_STRING ExeName)
VOID	HistoryDeleteBuffers (PCONSRV_CONSOLE Console)
VOID	HistoryReshapeAllBuffers (IN PCONSRV_CONSOLE Console, IN ULONG HistoryBufferSize, IN ULONG MaxNumberOfHistoryBuffers, IN BOOLEAN HistoryNoDup)
	CON_API (SrvGetConsoleCommandHistory, CONSOLE_GETCOMMANDHISTORY, GetCommandHistoryRequest)
	CON_API (SrvGetConsoleCommandHistoryLength, CONSOLE_GETCOMMANDHISTORYLENGTH, GetCommandHistoryLengthRequest)
	CON_API (SrvExpungeConsoleCommandHistory, CONSOLE_EXPUNGECOMMANDHISTORY, ExpungeCommandHistoryRequest)
	CON_API (SrvSetConsoleNumberOfCommands, CONSOLE_SETHISTORYNUMBERCOMMANDS, SetHistoryNumberCommandsRequest)
	CON_API_NOCONSOLE (SrvGetConsoleHistory, CONSOLE_GETSETHISTORYINFO, HistoryInfoRequest)
	CON_API_NOCONSOLE (SrvSetConsoleHistory, CONSOLE_GETSETHISTORYINFO, HistoryInfoRequest)
	CON_API (SrvSetConsoleCommandHistoryMode, CONSOLE_SETHISTORYMODE, SetHistoryModeRequest)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 14 of file history.c.

Typedef Documentation

HISTORY_BUFFER

typedef struct _HISTORY_BUFFER HISTORY_BUFFER

PHISTORY_BUFFER

typedef struct _HISTORY_BUFFER * PHISTORY_BUFFER

Function Documentation

CON_API() [1/5]

CON_API	(	SrvExpungeConsoleCommandHistory	,
		CONSOLE_EXPUNGECOMMANDHISTORY	,
		ExpungeCommandHistoryRequest
	)

Definition at line 545 of file history.c.

{
    PHISTORY_BUFFER Hist;
 
    if (!CsrValidateMessageBuffer(ApiMessage,
                                  (PVOID*)&ExpungeCommandHistoryRequest->ExeName,
                                  ExpungeCommandHistoryRequest->ExeLength,
                                  sizeof(BYTE)))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    Hist = HistoryFindBuffer(Console,
                             ExpungeCommandHistoryRequest->ExeName,
                             ExpungeCommandHistoryRequest->ExeLength,
                             ExpungeCommandHistoryRequest->Unicode2);
    HistoryDeleteBuffer(Hist);
 
    return STATUS_SUCCESS;
}

CON_API() [2/5]

CON_API	(	SrvGetConsoleCommandHistory	,
		CONSOLE_GETCOMMANDHISTORY	,
		GetCommandHistoryRequest
	)

Definition at line 426 of file history.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    ULONG BytesWritten = 0;
    PHISTORY_BUFFER Hist;
 
    if ( !CsrValidateMessageBuffer(ApiMessage,
                                   (PVOID*)&GetCommandHistoryRequest->History,
                                   GetCommandHistoryRequest->HistoryLength,
                                   sizeof(BYTE))                    ||
         !CsrValidateMessageBuffer(ApiMessage,
                                   (PVOID*)&GetCommandHistoryRequest->ExeName,
                                   GetCommandHistoryRequest->ExeLength,
                                   sizeof(BYTE)) )
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    Hist = HistoryFindBuffer(Console,
                             GetCommandHistoryRequest->ExeName,
                             GetCommandHistoryRequest->ExeLength,
                             GetCommandHistoryRequest->Unicode2);
    if (Hist)
    {
        ULONG i;
 
        LPSTR  TargetBufferA;
        LPWSTR TargetBufferW;
        ULONG BufferSize = GetCommandHistoryRequest->HistoryLength;
 
        ULONG Offset = 0;
        ULONG SourceLength;
 
        if (GetCommandHistoryRequest->Unicode)
        {
            TargetBufferW = GetCommandHistoryRequest->History;
            BufferSize /= sizeof(WCHAR);
        }
        else
        {
            TargetBufferA = GetCommandHistoryRequest->History;
        }
 
        for (i = 0; i < Hist->NumEntries; i++)
        {
            SourceLength = Hist->Entries[i].Length / sizeof(WCHAR);
            if (Offset + SourceLength + 1 > BufferSize)
            {
                Status = STATUS_BUFFER_OVERFLOW;
                break;
            }
 
            if (GetCommandHistoryRequest->Unicode)
            {
                RtlCopyMemory(&TargetBufferW[Offset], Hist->Entries[i].Buffer, SourceLength * sizeof(WCHAR));
                Offset += SourceLength;
                TargetBufferW[Offset++] = L'\0';
            }
            else
            {
                ConvertInputUnicodeToAnsi(Console,
                                          Hist->Entries[i].Buffer, SourceLength * sizeof(WCHAR),
                                          &TargetBufferA[Offset], SourceLength);
                Offset += SourceLength;
                TargetBufferA[Offset++] = '\0';
            }
        }
 
        if (GetCommandHistoryRequest->Unicode)
            BytesWritten = Offset * sizeof(WCHAR);
        else
            BytesWritten = Offset;
    }
 
    // GetCommandHistoryRequest->HistoryLength = TargetBuffer - (PBYTE)GetCommandHistoryRequest->History;
    GetCommandHistoryRequest->HistoryLength = BytesWritten;
 
    return Status;
}

CON_API() [3/5]

CON_API	(	SrvGetConsoleCommandHistoryLength	,
		CONSOLE_GETCOMMANDHISTORYLENGTH	,
		GetCommandHistoryLengthRequest
	)

Definition at line 508 of file history.c.

{
    PHISTORY_BUFFER Hist;
    ULONG Length = 0;
 
    if (!CsrValidateMessageBuffer(ApiMessage,
                                  (PVOID*)&GetCommandHistoryLengthRequest->ExeName,
                                  GetCommandHistoryLengthRequest->ExeLength,
                                  sizeof(BYTE)))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    Hist = HistoryFindBuffer(Console,
                             GetCommandHistoryLengthRequest->ExeName,
                             GetCommandHistoryLengthRequest->ExeLength,
                             GetCommandHistoryLengthRequest->Unicode2);
    if (Hist)
    {
        ULONG i;
        for (i = 0; i < Hist->NumEntries; i++)
            Length += Hist->Entries[i].Length + sizeof(WCHAR); // Each entry is returned NULL-terminated
    }
    /*
     * Quick and dirty way of getting the number of bytes of the
     * corresponding ANSI string from the one in UNICODE.
     */
    if (!GetCommandHistoryLengthRequest->Unicode)
        Length /= sizeof(WCHAR);
 
    GetCommandHistoryLengthRequest->HistoryLength = Length;
 
    return STATUS_SUCCESS;
}

CON_API() [4/5]

CON_API	(	SrvSetConsoleCommandHistoryMode	,
		CONSOLE_SETHISTORYMODE	,
		SetHistoryModeRequest
	)

Definition at line 646 of file history.c.

{
    DPRINT("SrvSetConsoleCommandHistoryMode(Mode = %d) is not yet implemented\n",
            SetHistoryModeRequest->Mode);
 
    Console->InsertMode = !!(SetHistoryModeRequest->Mode & CONSOLE_OVERSTRIKE);
    return STATUS_SUCCESS;
}

CON_API() [5/5]

CON_API	(	SrvSetConsoleNumberOfCommands	,
		CONSOLE_SETHISTORYNUMBERCOMMANDS	,
		SetHistoryNumberCommandsRequest
	)

Definition at line 568 of file history.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PHISTORY_BUFFER Hist;
 
    if (!CsrValidateMessageBuffer(ApiMessage,
                                  (PVOID*)&SetHistoryNumberCommandsRequest->ExeName,
                                  SetHistoryNumberCommandsRequest->ExeLength,
                                  sizeof(BYTE)))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    Hist = HistoryFindBuffer(Console,
                             SetHistoryNumberCommandsRequest->ExeName,
                             SetHistoryNumberCommandsRequest->ExeLength,
                             SetHistoryNumberCommandsRequest->Unicode2);
    if (Hist)
    {
        Status = HistoryResizeBuffer(Hist, SetHistoryNumberCommandsRequest->NumCommands);
    }
 
    return Status;
}

CON_API_NOCONSOLE() [1/2]

CON_API_NOCONSOLE	(	SrvGetConsoleHistory	,
		CONSOLE_GETSETHISTORYINFO	,
		HistoryInfoRequest
	)

Definition at line 595 of file history.c.

{
#if (_WIN32_WINNT >= _WIN32_WINNT_VISTA)
    NTSTATUS Status;
    PCONSRV_CONSOLE Console;
 
    Status = ConSrvGetConsole(ProcessData,
                              &Console, TRUE);
    if (!NT_SUCCESS(Status))
        return Status;
 
    HistoryInfoRequest->HistoryBufferSize      = Console->HistoryBufferSize;
    HistoryInfoRequest->NumberOfHistoryBuffers = Console->MaxNumberOfHistoryBuffers;
    HistoryInfoRequest->dwFlags                = (Console->HistoryNoDup ? HISTORY_NO_DUP_FLAG : 0);
 
    ConSrvReleaseConsole(Console, TRUE);
    return Status;
#else
    DPRINT1("%s not yet implemented\n", __FUNCTION__);
    return STATUS_NOT_IMPLEMENTED;
#endif
}

CON_API_NOCONSOLE() [2/2]

CON_API_NOCONSOLE	(	SrvSetConsoleHistory	,
		CONSOLE_GETSETHISTORYINFO	,
		HistoryInfoRequest
	)

Definition at line 620 of file history.c.

{
#if (_WIN32_WINNT >= _WIN32_WINNT_VISTA)
    NTSTATUS Status;
    PCONSRV_CONSOLE Console;
 
    Status = ConSrvGetConsole(ProcessData,
                              &Console, TRUE);
    if (!NT_SUCCESS(Status))
        return Status;
 
    HistoryReshapeAllBuffers(Console,
                             HistoryInfoRequest->HistoryBufferSize,
                             HistoryInfoRequest->NumberOfHistoryBuffers,
                             !!(HistoryInfoRequest->dwFlags & HISTORY_NO_DUP_FLAG));
 
    ConSrvReleaseConsole(Console, TRUE);
    return STATUS_SUCCESS;
#else
    DPRINT1("%s not yet implemented\n", __FUNCTION__);
    return STATUS_NOT_IMPLEMENTED;
#endif
}

ConvertInputAnsiToUnicode()

BOOLEAN ConvertInputAnsiToUnicode	(	PCONSRV_CONSOLE	Console,
		PVOID	Source,
		USHORT	SourceLength,
		PWCHAR *	Target,
		PUSHORT	TargetLength
	)

Definition at line 37 of file alias.c.

{
    ASSERT(Source && Target && TargetLength);
 
    /* Use the console input CP for the conversion */
    *TargetLength = MultiByteToWideChar(Console->InputCodePage, 0,
                                        Source, SourceLength,
                                        NULL, 0);
    *Target = ConsoleAllocHeap(0, *TargetLength * sizeof(WCHAR));
    if (*Target == NULL) return FALSE;
 
    MultiByteToWideChar(Console->InputCodePage, 0,
                        Source, SourceLength,
                        *Target, *TargetLength);
 
    /* The returned Length was in number of WCHARs, convert it in bytes */
    *TargetLength *= sizeof(WCHAR);
 
    return TRUE;
}

Referenced by HistoryFindBuffer().

ConvertInputUnicodeToAnsi()

BOOLEAN ConvertInputUnicodeToAnsi	(	PCONSRV_CONSOLE	Console,
		PVOID	Source,
		USHORT	SourceLength,
		PCHAR	Target,
		USHORT	TargetLength
	)

Definition at line 64 of file alias.c.

{
    ASSERT(Source && Target && TargetLength);
 
    /*
     * From MSDN:
     * "The lpMultiByteStr and lpWideCharStr pointers must not be the same.
     *  If they are the same, the function fails, and GetLastError returns
     *  ERROR_INVALID_PARAMETER."
     */
    ASSERT((ULONG_PTR)Source != (ULONG_PTR)Target);
 
    /* Use the console input CP for the conversion */
    // *TargetLength = WideCharToMultiByte(Console->InputCodePage, 0,
                                        // Source, SourceLength,
                                        // NULL, 0, NULL, NULL);
    // *Target = ConsoleAllocHeap(0, *TargetLength * sizeof(WCHAR));
    // if (*Target == NULL) return FALSE;
 
    WideCharToMultiByte(Console->InputCodePage, 0,
                        Source, SourceLength,
                        /* * */Target, /* * */TargetLength,
                        NULL, NULL);
 
    // /* The returned Length was in number of WCHARs, convert it in bytes */
    // *TargetLength *= sizeof(WCHAR);
 
    return TRUE;
}

Referenced by CON_API().

HistoryAddEntry()

VOID HistoryAddEntry	(	PCONSRV_CONSOLE	Console,
		PUNICODE_STRING	ExeName,
		PUNICODE_STRING	Entry
	)

Definition at line 185 of file history.c.

{
    // UNICODE_STRING NewEntry;
    PHISTORY_BUFFER Hist = HistoryCurrentBuffer(Console, ExeName);
 
    if (!Hist) return;
 
    // NewEntry.Length = NewEntry.MaximumLength = Console->LineSize * sizeof(WCHAR);
    // NewEntry.Buffer = Console->LineBuffer;
 
    /* Don't add blank or duplicate entries */
    if (Entry->Length == 0 || Hist->MaxEntries == 0 ||
        (Hist->NumEntries > 0 &&
         RtlEqualUnicodeString(&Hist->Entries[Hist->NumEntries - 1], Entry, FALSE)))
    {
        return;
    }
 
    if (Console->HistoryNoDup)
    {
        INT i;
 
        /* Check if this line has been entered before */
        for (i = Hist->NumEntries - 1; i >= 0; i--)
        {
            if (RtlEqualUnicodeString(&Hist->Entries[i], Entry, FALSE))
            {
                UNICODE_STRING NewEntry;
 
                /* Just rotate the list to bring this entry to the end */
                NewEntry = Hist->Entries[i];
                RtlMoveMemory(&Hist->Entries[i], &Hist->Entries[i + 1],
                              (Hist->NumEntries - (i + 1)) * sizeof(UNICODE_STRING));
                Hist->Entries[Hist->NumEntries - 1] = NewEntry;
                Hist->Position = Hist->NumEntries - 1;
                return;
            }
        }
    }
 
    if (Hist->NumEntries == Hist->MaxEntries)
    {
        /* List is full, remove oldest entry */
        RtlFreeUnicodeString(&Hist->Entries[0]);
        RtlMoveMemory(&Hist->Entries[0], &Hist->Entries[1],
                      --Hist->NumEntries * sizeof(UNICODE_STRING));
    }
 
    if (NT_SUCCESS(RtlDuplicateUnicodeString(0, Entry, &Hist->Entries[Hist->NumEntries])))
        Hist->NumEntries++;
    Hist->Position = Hist->NumEntries - 1;
}

Referenced by LineInputKeyDown().

HistoryCurrentBuffer()

static PHISTORY_BUFFER HistoryCurrentBuffer ( IN PCONSRV_CONSOLE  Console, IN PUNICODE_STRING  ExeName  )

static

Definition at line 47 of file history.c.

{
    PLIST_ENTRY Entry;
    PHISTORY_BUFFER Hist;
 
    for (Entry = Console->HistoryBuffers.Flink;
         Entry != &Console->HistoryBuffers;
         Entry = Entry->Flink)
    {
        Hist = CONTAINING_RECORD(Entry, HISTORY_BUFFER, ListEntry);
        if (RtlEqualUnicodeString(ExeName, &Hist->ExeName, FALSE))
            return Hist;
    }
 
    /* Could not find the buffer, create a new one */
 
    if (Console->NumberOfHistoryBuffers < Console->MaxNumberOfHistoryBuffers)
    {
        Hist = ConsoleAllocHeap(0, sizeof(HISTORY_BUFFER) + ExeName->Length);
        if (!Hist) return NULL;
        Hist->MaxEntries = Console->HistoryBufferSize;
        Hist->NumEntries = 0;
        Hist->Entries = ConsoleAllocHeap(0, Hist->MaxEntries * sizeof(UNICODE_STRING));
        if (!Hist->Entries)
        {
            ConsoleFreeHeap(Hist);
            return NULL;
        }
        Hist->ExeName.Length = Hist->ExeName.MaximumLength = ExeName->Length;
        Hist->ExeName.Buffer = (PWCHAR)(Hist + 1);
        RtlCopyMemory(Hist->ExeName.Buffer, ExeName->Buffer, ExeName->Length);
        InsertHeadList(&Console->HistoryBuffers, &Hist->ListEntry);
        Console->NumberOfHistoryBuffers++;
        return Hist;
    }
    else
    {
        // FIXME: TODO !!!!!!!
        // Reuse an older history buffer, if possible with the same Exe name,
        // otherwise take the oldest one and reset its contents.
        // And move the history buffer back to the head of the list.
        UNIMPLEMENTED;
        return NULL;
    }
}

Referenced by HistoryAddEntry(), HistoryDeleteCurrentBuffer(), HistoryDisplayCurrentHistory(), HistoryFindEntryByPrefix(), HistoryGetCurrentEntry(), HistoryRecallHistory(), LineInputKeyDown(), and LineInputRecallHistory().

HistoryDeleteBuffer()

static VOID HistoryDeleteBuffer ( PHISTORY_BUFFER  Hist )

static

Definition at line 144 of file history.c.

{
    if (!Hist) return;
 
    while (Hist->NumEntries != 0)
        RtlFreeUnicodeString(&Hist->Entries[--Hist->NumEntries]);
 
    ConsoleFreeHeap(Hist->Entries);
    RemoveEntryList(&Hist->ListEntry);
    ConsoleFreeHeap(Hist);
}

Referenced by CON_API(), HistoryDeleteBuffers(), HistoryDeleteCurrentBuffer(), and HistoryReshapeAllBuffers().

HistoryDeleteBuffers()

VOID HistoryDeleteBuffers

(

PCONSRV_CONSOLE

Console

)

Definition at line 357 of file history.c.

{
    PLIST_ENTRY CurrentEntry;
    PHISTORY_BUFFER HistoryBuffer;
 
    while (!IsListEmpty(&Console->HistoryBuffers))
    {
        CurrentEntry = RemoveHeadList(&Console->HistoryBuffers);
        HistoryBuffer = CONTAINING_RECORD(CurrentEntry, HISTORY_BUFFER, ListEntry);
        HistoryDeleteBuffer(HistoryBuffer);
    }
}

Referenced by ConSrvDeleteConsole().

HistoryDeleteCurrentBuffer()

VOID HistoryDeleteCurrentBuffer	(	PCONSRV_CONSOLE	Console,
		PUNICODE_STRING	ExeName
	)

Definition at line 350 of file history.c.

{
    HistoryDeleteBuffer(HistoryCurrentBuffer(Console, ExeName));
}

Referenced by LineInputKeyDown().

HistoryDisplayCurrentHistory()

PPOPUP_WINDOW HistoryDisplayCurrentHistory	(	PCONSRV_CONSOLE	Console,
		PUNICODE_STRING	ExeName
	)

Definition at line 315 of file history.c.

{
    PCONSOLE_SCREEN_BUFFER ActiveBuffer;
    PPOPUP_WINDOW Popup;
 
    SHORT xLeft, yTop;
    SHORT Width, Height;
 
    PHISTORY_BUFFER Hist = HistoryCurrentBuffer(Console, ExeName);
 
    if (!Hist) return NULL;
    if (Hist->NumEntries == 0) return NULL;
 
    if (GetType(Console->ActiveBuffer) != TEXTMODE_BUFFER) return NULL;
    ActiveBuffer = Console->ActiveBuffer;
 
    Width  = 40;
    Height = 10;
 
    /* Center the popup window on the screen */
    xLeft = ActiveBuffer->ViewOrigin.X + (ActiveBuffer->ViewSize.X - Width ) / 2;
    yTop  = ActiveBuffer->ViewOrigin.Y + (ActiveBuffer->ViewSize.Y - Height) / 2;
 
    /* Create the popup */
    Popup = CreatePopupWindow(Console, ActiveBuffer,
                              xLeft, yTop, Width, Height);
    if (Popup == NULL) return NULL;
 
    Popup->PopupInputRoutine = NULL;
 
    return Popup;
}

Referenced by LineInputKeyDown().

HistoryFindBuffer()

static PHISTORY_BUFFER HistoryFindBuffer ( PCONSRV_CONSOLE  Console, PVOID  ExeName, USHORT  ExeLength, BOOLEAN  UnicodeExe  )

static

Definition at line 96 of file history.c.

{
    UNICODE_STRING ExeNameU;
 
    PLIST_ENTRY Entry;
    PHISTORY_BUFFER Hist = NULL;
 
    if (ExeName == NULL) return NULL;
 
    if (UnicodeExe)
    {
        ExeNameU.Buffer = ExeName;
        /* Length is in bytes */
        ExeNameU.MaximumLength = ExeLength;
    }
    else
    {
        if (!ConvertInputAnsiToUnicode(Console,
                                       ExeName, ExeLength,
                                       &ExeNameU.Buffer, &ExeNameU.MaximumLength))
        {
            return NULL;
        }
    }
    ExeNameU.Length = ExeNameU.MaximumLength;
 
    for (Entry = Console->HistoryBuffers.Flink;
         Entry != &Console->HistoryBuffers;
         Entry = Entry->Flink)
    {
        Hist = CONTAINING_RECORD(Entry, HISTORY_BUFFER, ListEntry);
 
        /* For the history APIs, the caller is allowed to give only part of the name */
        if (RtlPrefixUnicodeString(&ExeNameU, &Hist->ExeName, TRUE))
        {
            if (!UnicodeExe) ConsoleFreeHeap(ExeNameU.Buffer);
            return Hist;
        }
    }
 
    if (!UnicodeExe) ConsoleFreeHeap(ExeNameU.Buffer);
    return NULL;
}

Referenced by CON_API().

HistoryFindEntryByPrefix()

BOOL HistoryFindEntryByPrefix	(	PCONSRV_CONSOLE	Console,
		PUNICODE_STRING	ExeName,
		PUNICODE_STRING	Prefix,
		PUNICODE_STRING	Entry
	)

Definition at line 273 of file history.c.

{
    INT HistPos;
 
    /* Search for history entries starting with input. */
    PHISTORY_BUFFER Hist = HistoryCurrentBuffer(Console, ExeName);
    if (!Hist || Hist->NumEntries == 0) return FALSE;
 
    /*
     * Like Up/F5, on first time start from current (usually last) entry,
     * but on subsequent times start at previous entry.
     */
    if (Console->LineUpPressed)
        Hist->Position = (Hist->Position ? Hist->Position : Hist->NumEntries) - 1;
    Console->LineUpPressed = TRUE;
 
    // Entry.Length = Console->LinePos * sizeof(WCHAR); // == Pos * sizeof(WCHAR)
    // Entry.Buffer = Console->LineBuffer;
 
    /*
     * Keep going backwards, even wrapping around to the end,
     * until we get back to starting point.
     */
    HistPos = Hist->Position;
    do
    {
        if (RtlPrefixUnicodeString(Prefix, &Hist->Entries[HistPos], FALSE))
        {
            Hist->Position = HistPos;
            *Entry = Hist->Entries[HistPos];
            return TRUE;
        }
        if (--HistPos < 0) HistPos += Hist->NumEntries;
    } while (HistPos != Hist->Position);
 
    return FALSE;
}

Referenced by LineInputKeyDown().

HistoryGetCurrentEntry()

VOID HistoryGetCurrentEntry	(	PCONSRV_CONSOLE	Console,
		PUNICODE_STRING	ExeName,
		PUNICODE_STRING	Entry
	)

Definition at line 241 of file history.c.

{
    PHISTORY_BUFFER Hist = HistoryCurrentBuffer(Console, ExeName);
 
    if (!Hist || Hist->NumEntries == 0)
        Entry->Length = 0;
    else
        *Entry = Hist->Entries[Hist->Position];
}

Referenced by LineInputKeyDown().

HistoryRecallHistory()

BOOL HistoryRecallHistory	(	PCONSRV_CONSOLE	Console,
		PUNICODE_STRING	ExeName,
		INT	Offset,
		PUNICODE_STRING	Entry
	)

Definition at line 254 of file history.c.

{
    PHISTORY_BUFFER Hist = HistoryCurrentBuffer(Console, ExeName);
    ULONG Position = 0;
 
    if (!Hist || Hist->NumEntries == 0) return FALSE;
 
    Position = Hist->Position + Offset;
    Position = min(max(Position, 0), Hist->NumEntries - 1);
    Hist->Position = Position;
 
    *Entry = Hist->Entries[Hist->Position];
    return TRUE;
}

Referenced by LineInputRecallHistory().

HistoryReshapeAllBuffers()

VOID HistoryReshapeAllBuffers	(	IN PCONSRV_CONSOLE	Console,
		IN ULONG	HistoryBufferSize,
		IN ULONG	MaxNumberOfHistoryBuffers,
		IN BOOLEAN	HistoryNoDup
	)

Definition at line 371 of file history.c.

{
    PLIST_ENTRY Entry;
    PHISTORY_BUFFER Hist;
    NTSTATUS Status;
 
    // ASSERT(Console->NumberOfHistoryBuffers <= Console->MaxNumberOfHistoryBuffers);
    if (MaxNumberOfHistoryBuffers < Console->NumberOfHistoryBuffers)
    {
        /*
         * Trim the history buffers list and reduce it up to MaxNumberOfHistoryBuffers.
         * We loop the history buffers list backwards so as to trim the oldest
         * buffers first.
         */
        while (!IsListEmpty(&Console->HistoryBuffers) &&
               (Console->NumberOfHistoryBuffers > MaxNumberOfHistoryBuffers))
        {
            Entry = RemoveTailList(&Console->HistoryBuffers);
            Hist = CONTAINING_RECORD(Entry, HISTORY_BUFFER, ListEntry);
            HistoryDeleteBuffer(Hist);
            Console->NumberOfHistoryBuffers--;
        }
        ASSERT(Console->NumberOfHistoryBuffers == MaxNumberOfHistoryBuffers);
        ASSERT(((Console->NumberOfHistoryBuffers == 0) &&  IsListEmpty(&Console->HistoryBuffers)) ||
               ((Console->NumberOfHistoryBuffers  > 0) && !IsListEmpty(&Console->HistoryBuffers)));
    }
    Console->MaxNumberOfHistoryBuffers = MaxNumberOfHistoryBuffers;
 
    /* Resize each history buffer */
    for (Entry = Console->HistoryBuffers.Flink;
         Entry != &Console->HistoryBuffers;
         Entry = Entry->Flink)
    {
        Hist = CONTAINING_RECORD(Entry, HISTORY_BUFFER, ListEntry);
        Status = HistoryResizeBuffer(Hist, HistoryBufferSize);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("HistoryResizeBuffer(0x%p, %lu) failed, Status 0x%08lx\n",
                    Hist, HistoryBufferSize, Status);
        }
    }
    Console->HistoryBufferSize = HistoryBufferSize;
 
    /* No duplicates */
    Console->HistoryNoDup = !!HistoryNoDup;
}

Referenced by CON_API_NOCONSOLE(), and ConSrvApplyUserSettings().

HistoryResizeBuffer()

static NTSTATUS HistoryResizeBuffer ( IN PHISTORY_BUFFER  Hist, IN ULONG  NumCommands  )

static

Definition at line 157 of file history.c.

{
    PUNICODE_STRING OldEntryList = Hist->Entries;
    PUNICODE_STRING NewEntryList;
 
    NewEntryList = ConsoleAllocHeap(0, NumCommands * sizeof(UNICODE_STRING));
    if (!NewEntryList)
        return STATUS_NO_MEMORY;
 
    /* If necessary, shrink by removing oldest entries */
    for (; Hist->NumEntries > NumCommands; Hist->NumEntries--)
    {
        RtlFreeUnicodeString(Hist->Entries++);
        Hist->Position += (Hist->Position == 0);
    }
 
    Hist->MaxEntries = NumCommands;
    RtlCopyMemory(NewEntryList, Hist->Entries,
                  Hist->NumEntries * sizeof(UNICODE_STRING));
    Hist->Entries = NewEntryList;
    ConsoleFreeHeap(OldEntryList);
 
    return STATUS_SUCCESS;
}

Referenced by CON_API(), and HistoryReshapeAllBuffers().