console.c File Reference

#include "consrv.h"
#include <shlobj.h>
#include "../concfg/font.h"
#include <alias.h>
#include <history.h>
#include "procinit.h"
#include <debug.h>

Include dependency graph for console.c:

Go to the source code of this file.

Macros
#define	COBJMACROS
#define	NDEBUG
#define	ConSrvLockConsoleListExclusive()    RtlAcquireResourceExclusive(&ListLock, TRUE)
#define	ConSrvLockConsoleListShared()    RtlAcquireResourceShared(&ListLock, TRUE)
#define	ConSrvUnlockConsoleList()    RtlReleaseResource(&ListLock)
#define	CONSOLE_HANDLES_INCREMENT   2 * 3
#define	PATH_SEPARATOR   L'\\'
#define	CONSOLE_VALID_CONTROL_MODES

Functions
static NTSTATUS	InsertConsole (OUT PHANDLE Handle, IN PCONSRV_CONSOLE Console)
static NTSTATUS	RemoveConsoleByPointer (IN PCONSRV_CONSOLE Console)
static BOOLEAN	ConsoleCreateUnicodeString (IN OUT PUNICODE_STRING UniDest, IN PCWSTR Source)
static VOID	ConsoleFreeUnicodeString (IN PUNICODE_STRING UnicodeString)
BOOLEAN NTAPI	ConSrvValidateConsole (OUT PCONSRV_CONSOLE *Console, IN HANDLE ConsoleHandle, IN CONSOLE_STATE ExpectedState, IN BOOLEAN LockConsole)
NTSTATUS	ConSrvGetConsole (IN PCONSOLE_PROCESS_DATA ProcessData, OUT PCONSRV_CONSOLE *Console, IN BOOLEAN LockConsole)
VOID	ConSrvReleaseConsole (IN PCONSRV_CONSOLE Console, IN BOOLEAN IsConsoleLocked)
VOID NTAPI	ConSrvInitConsoleSupport (VOID)
NTSTATUS NTAPI	ConSrvInitTerminal (IN OUT PTERMINAL Terminal, IN OUT PCONSOLE_STATE_INFO ConsoleInfo, IN OUT PCONSOLE_INIT_INFO ConsoleInitInfo, IN HANDLE ConsoleLeaderProcessHandle)
NTSTATUS NTAPI	ConSrvDeinitTerminal (IN OUT PTERMINAL Terminal)
static BOOL	LoadShellLinkConsoleInfo (IN OUT PCONSOLE_STATE_INFO ConsoleInfo, IN OUT PCONSOLE_INIT_INFO ConsoleInitInfo)
NTSTATUS NTAPI	ConSrvInitConsole (OUT PHANDLE NewConsoleHandle, OUT PCONSRV_CONSOLE *NewConsole, IN OUT PCONSOLE_INIT_INFO ConsoleInitInfo, IN PCSR_PROCESS ConsoleLeaderProcess)
VOID NTAPI	ConSrvDeleteConsole (PCONSRV_CONSOLE Console)
VOID	ConioPause (PCONSRV_CONSOLE Console, UCHAR Flags)
VOID	ConioUnpause (PCONSRV_CONSOLE Console, UCHAR Flags)
static NTSTATUS	ConSrvInitProcessHandles (IN OUT PCONSOLE_PROCESS_DATA ProcessData, IN PCONSRV_CONSOLE Console, OUT PHANDLE pInputHandle, OUT PHANDLE pOutputHandle, OUT PHANDLE pErrorHandle)
NTSTATUS	ConSrvAllocateConsole (IN OUT PCONSOLE_PROCESS_DATA ProcessData, OUT PHANDLE pInputHandle, OUT PHANDLE pOutputHandle, OUT PHANDLE pErrorHandle, IN OUT PCONSOLE_INIT_INFO ConsoleInitInfo)
NTSTATUS	ConSrvInheritConsole (IN OUT PCONSOLE_PROCESS_DATA ProcessData, IN HANDLE ConsoleHandle, IN BOOLEAN CreateNewHandleTable, OUT PHANDLE pInputHandle, OUT PHANDLE pOutputHandle, OUT PHANDLE pErrorHandle, IN OUT PCONSOLE_START_INFO ConsoleStartInfo)
NTSTATUS	ConSrvRemoveConsole (IN OUT PCONSOLE_PROCESS_DATA ProcessData)
NTSTATUS	ConSrvConsoleCtrlEventTimeout (IN ULONG CtrlEvent, IN PCONSOLE_PROCESS_DATA ProcessData, IN ULONG Timeout)
NTSTATUS	ConSrvConsoleCtrlEvent (IN ULONG CtrlEvent, IN PCONSOLE_PROCESS_DATA ProcessData)
PCONSOLE_PROCESS_DATA NTAPI	ConSrvGetConsoleLeaderProcess (IN PCONSRV_CONSOLE Console)
NTSTATUS NTAPI	ConSrvGetConsoleProcessList (IN PCONSRV_CONSOLE Console, IN OUT PULONG ProcessIdsList, IN ULONG MaxIdListItems, OUT PULONG ProcessIdsTotal)
NTSTATUS NTAPI	ConSrvConsoleProcessCtrlEvent (IN PCONSRV_CONSOLE Console, IN ULONG ProcessGroupId, IN ULONG CtrlEvent)
VOID	ConSrvSetProcessFocus (IN PCSR_PROCESS CsrProcess, IN BOOLEAN SetForeground)
NTSTATUS NTAPI	ConSrvSetConsoleProcessFocus (IN PCONSRV_CONSOLE Console, IN BOOLEAN SetForeground)
	CON_API_NOCONSOLE (SrvAllocConsole, CONSOLE_ALLOCCONSOLE, AllocConsoleRequest)
	CON_API_NOCONSOLE (SrvAttachConsole, CONSOLE_ATTACHCONSOLE, AttachConsoleRequest)
	CON_API_NOCONSOLE (SrvFreeConsole, CONSOLE_FREECONSOLE, FreeConsoleRequest)
NTSTATUS NTAPI	ConDrvGetConsoleMode (IN PCONSOLE Console, IN PCONSOLE_IO_OBJECT Object, OUT PULONG ConsoleMode)
	CON_API (SrvGetConsoleMode, CONSOLE_GETSETCONSOLEMODE, ConsoleModeRequest)
NTSTATUS NTAPI	ConDrvSetConsoleMode (IN PCONSOLE Console, IN PCONSOLE_IO_OBJECT Object, IN ULONG ConsoleMode)
	CON_API (SrvSetConsoleMode, CONSOLE_GETSETCONSOLEMODE, ConsoleModeRequest)
	CON_API (SrvGetConsoleTitle, CONSOLE_GETSETCONSOLETITLE, TitleRequest)
	CON_API (SrvSetConsoleTitle, CONSOLE_GETSETCONSOLETITLE, TitleRequest)
NTSTATUS NTAPI	ConDrvGetConsoleCP (IN PCONSOLE Console, OUT PUINT CodePage, IN BOOLEAN OutputCP)
	CON_API (SrvGetConsoleCP, CONSOLE_GETINPUTOUTPUTCP, GetConsoleCPRequest)
NTSTATUS NTAPI	ConDrvSetConsoleCP (IN PCONSOLE Console, IN UINT CodePage, IN BOOLEAN OutputCP)
	CON_API (SrvSetConsoleCP, CONSOLE_SETINPUTOUTPUTCP, SetConsoleCPRequest)
	CON_API (SrvGetConsoleProcessList, CONSOLE_GETPROCESSLIST, GetProcessListRequest)
	CON_API (SrvGenerateConsoleCtrlEvent, CONSOLE_GENERATECTRLEVENT, GenerateCtrlEventRequest)
	CON_API (SrvConsoleNotifyLastClose, CONSOLE_NOTIFYLASTCLOSE, NotifyLastCloseRequest)
	CON_API (SrvGetConsoleMouseInfo, CONSOLE_GETMOUSEINFO, GetMouseInfoRequest)
	CSR_API (SrvSetConsoleKeyShortcuts)
	CON_API (SrvGetConsoleKeyboardLayoutName, CONSOLE_GETKBDLAYOUTNAME, GetKbdLayoutNameRequest)
	CSR_API (SrvGetConsoleCharType)
	CSR_API (SrvSetConsoleLocalEUDC)
	CSR_API (SrvSetConsoleCursorMode)
	CSR_API (SrvGetConsoleCursorMode)
	CSR_API (SrvGetConsoleNlsMode)
	CSR_API (SrvSetConsoleNlsMode)
	CON_API (SrvGetConsoleLangId, CONSOLE_GETLANGID, LangIdRequest)

Variables
static ULONG	ConsoleListSize
static PCONSRV_CONSOLE *	ConsoleList
static RTL_RESOURCE	ListLock

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 16 of file console.c.

CONSOLE_HANDLES_INCREMENT

#define CONSOLE_HANDLES_INCREMENT   2 * 3

CONSOLE_VALID_CONTROL_MODES

#define CONSOLE_VALID_CONTROL_MODES

Value:

                                      ( ENABLE_EXTENDED_FLAGS | \
                                      ENABLE_INSERT_MODE    | ENABLE_QUICK_EDIT_MODE )

ConSrvLockConsoleListExclusive

#define ConSrvLockConsoleListExclusive

(

)

RtlAcquireResourceExclusive(&ListLock, TRUE)

Definition at line 38 of file console.c.

ConSrvLockConsoleListShared

#define ConSrvLockConsoleListShared

(

)

RtlAcquireResourceShared(&ListLock, TRUE)

Definition at line 41 of file console.c.

ConSrvUnlockConsoleList

#define ConSrvUnlockConsoleList

(

)

RtlReleaseResource(&ListLock)

Definition at line 44 of file console.c.

NDEBUG

#define NDEBUG

Definition at line 24 of file console.c.

PATH_SEPARATOR

#define PATH_SEPARATOR   L'\\'

Function Documentation

CON_API() [1/12]

CON_API	(	SrvConsoleNotifyLastClose	,
		CONSOLE_NOTIFYLASTCLOSE	,
		NotifyLastCloseRequest
	)

Definition at line 1933 of file console.c.

{
    /* Only one process is allowed to be registered for last close notification */
    if (Console->NotifyLastClose)
        return STATUS_ACCESS_DENIED;
 
    Console->NotifyLastClose = TRUE;
    Console->NotifiedLastCloseProcess = ProcessData;
    return STATUS_SUCCESS;
}

CON_API() [2/12]

CON_API	(	SrvGenerateConsoleCtrlEvent	,
		CONSOLE_GENERATECTRLEVENT	,
		GenerateCtrlEventRequest
	)

Definition at line 1924 of file console.c.

{
    return ConSrvConsoleProcessCtrlEvent(Console,
                                         GenerateCtrlEventRequest->ProcessGroupId,
                                         GenerateCtrlEventRequest->CtrlEvent);
}

CON_API() [3/12]

CON_API	(	SrvGetConsoleCP	,
		CONSOLE_GETINPUTOUTPUTCP	,
		GetConsoleCPRequest
	)

Definition at line 1878 of file console.c.

{
    DPRINT("SrvGetConsoleCP, getting %s Code Page\n",
            GetConsoleCPRequest->OutputCP ? "Output" : "Input");
 
    return ConDrvGetConsoleCP((PCONSOLE)Console,
                              &GetConsoleCPRequest->CodePage,
                              GetConsoleCPRequest->OutputCP);
}

CON_API() [4/12]

CON_API	(	SrvGetConsoleKeyboardLayoutName	,
		CONSOLE_GETKBDLAYOUTNAME	,
		GetKbdLayoutNameRequest
	)

Definition at line 1962 of file console.c.

{
    /* Retrieve the keyboard layout name of the system */
    if (GetKbdLayoutNameRequest->Ansi)
        GetKeyboardLayoutNameA((PCHAR)GetKbdLayoutNameRequest->LayoutBuffer);
    else
        GetKeyboardLayoutNameW((PWCHAR)GetKbdLayoutNameRequest->LayoutBuffer);
 
    return STATUS_SUCCESS;
}

CON_API() [5/12]

CON_API	(	SrvGetConsoleLangId	,
		CONSOLE_GETLANGID	,
		LangIdRequest
	)

ReactOS-specific: do nothing if the code page is UTF-8. This will allow programs to naturally output in whatever current language they are.

End ReactOS-specific

Definition at line 2017 of file console.c.

{
    /*
     * Quoting MS Terminal, see function GetConsoleLangId() at
     * https://github.com/microsoft/terminal/blob/1e00843598d980c5009d17ff943cb78b78d4af9e/src/host/srvinit.cpp#L694
     * "Only attempt to return the Lang ID if the Windows ACP on console
     * launch was an East Asian Code Page."
     *
     * The underlying logic is as follows:
     *
     * - When the current user's UI language is *not* CJK, the user expects
     *   to not see any CJK output to the console by default, even if its
     *   output has been set to a CJK code page (this is possible when CJK
     *   fonts are installed on the system). That is, of course, unless if
     *   the attached console program chooses to actually output CJK text.
     *   Whatever current language of the running program's thread should
     *   be kept: STATUS_NOT_SUPPORTED is returned.
     *
     * - When the current user's UI language *is* CJK, the user expects to
     *   see CJK output to the console by default when its code page is CJK.
     *   A valid LangId is returned in this case to ensure this.
     *   However, if the console code page is not CJK, then it is evident
     *   that CJK text will not be able to be correctly shown, and therefore
     *   we should fall back to a standard language that can be shown, namely
     *   en-US english, instead of keeping the current language.
     */
 
    BYTE UserCharSet = CodePageToCharSet(GetACP());
    if (!IsCJKCharSet(UserCharSet))
        return STATUS_NOT_SUPPORTED;
 
    /* Return a "best-suited" language ID corresponding
     * to the active console output code page. */
    switch (Console->OutputCodePage)
    {
    case CP_UTF8:
        return STATUS_NOT_SUPPORTED;
    case CP_JAPANESE:
        LangIdRequest->LangId = MAKELANGID(LANG_JAPANESE, SUBLANG_DEFAULT);
        break;
    case CP_KOREAN:
        LangIdRequest->LangId = MAKELANGID(LANG_KOREAN, SUBLANG_KOREAN);
        break;
    case CP_CHINESE_SIMPLIFIED:
        LangIdRequest->LangId = MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED);
        break;
    case CP_CHINESE_TRADITIONAL:
        LangIdRequest->LangId = MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_TRADITIONAL);
        break;
    default:
        /* Default to en-US english otherwise */
        LangIdRequest->LangId = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US);
        break;
    }
 
    return STATUS_SUCCESS;
}

CON_API() [6/12]

CON_API	(	SrvGetConsoleMode	,
		CONSOLE_GETSETCONSOLEMODE	,
		ConsoleModeRequest
	)

Definition at line 1660 of file console.c.

{
    NTSTATUS Status;
    PCONSOLE_IO_OBJECT Object;
    PULONG ConsoleMode = &ConsoleModeRequest->Mode;
 
    Status = ConSrvGetObject(ProcessData,
                             ConsoleModeRequest->Handle,
                             &Object, NULL, GENERIC_READ, TRUE, 0);
    if (!NT_SUCCESS(Status))
        return Status;
 
    ASSERT((PCONSOLE)Console == Object->Console);
 
    /* Get the standard console modes */
    Status = ConDrvGetConsoleMode((PCONSOLE)Console, Object, ConsoleMode);
    if (NT_SUCCESS(Status))
    {
        /*
         * If getting the console modes succeeds, then retrieve
         * the extended CONSRV-specific input modes.
         */
        if (INPUT_BUFFER == Object->Type)
        {
            if (Console->InsertMode || Console->QuickEdit)
            {
                /* Windows also adds ENABLE_EXTENDED_FLAGS, even if it's not documented on MSDN */
                *ConsoleMode |= ENABLE_EXTENDED_FLAGS;
 
                if (Console->InsertMode) *ConsoleMode |= ENABLE_INSERT_MODE;
                if (Console->QuickEdit ) *ConsoleMode |= ENABLE_QUICK_EDIT_MODE;
            }
        }
    }
 
    ConSrvReleaseObject(Object, TRUE);
    return Status;
}

CON_API() [7/12]

CON_API	(	SrvGetConsoleMouseInfo	,
		CONSOLE_GETMOUSEINFO	,
		GetMouseInfoRequest
	)

Definition at line 1946 of file console.c.

{
    /* Just retrieve the number of buttons of the mouse attached to this console */
    GetMouseInfoRequest->NumButtons = GetSystemMetrics(SM_CMOUSEBUTTONS);
    return STATUS_SUCCESS;
}

CON_API() [8/12]

CON_API	(	SrvGetConsoleProcessList	,
		CONSOLE_GETPROCESSLIST	,
		GetProcessListRequest
	)

Definition at line 1906 of file console.c.

{
    if (!CsrValidateMessageBuffer(ApiMessage,
                                  (PVOID)&GetProcessListRequest->ProcessIdsList,
                                  GetProcessListRequest->ProcessCount,
                                  sizeof(DWORD)))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    return ConSrvGetConsoleProcessList(Console,
                                       GetProcessListRequest->ProcessIdsList,
                                       GetProcessListRequest->ProcessCount,
                                       &GetProcessListRequest->ProcessCount);
}

CON_API() [9/12]

CON_API	(	SrvGetConsoleTitle	,
		CONSOLE_GETSETCONSOLETITLE	,
		TitleRequest
	)

Definition at line 1761 of file console.c.

{
    ULONG Length;
 
    if (!CsrValidateMessageBuffer(ApiMessage,
                                  (PVOID)&TitleRequest->Title,
                                  TitleRequest->Length,
                                  sizeof(BYTE)))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Copy title of the console to the user title buffer */
    if (TitleRequest->Unicode)
    {
        if (TitleRequest->Length >= sizeof(WCHAR))
        {
            Length = min(TitleRequest->Length - sizeof(WCHAR), Console->Title.Length);
            RtlCopyMemory(TitleRequest->Title, Console->Title.Buffer, Length);
            ((PWCHAR)TitleRequest->Title)[Length / sizeof(WCHAR)] = UNICODE_NULL;
            TitleRequest->Length = Length;
        }
        else
        {
            TitleRequest->Length = Console->Title.Length;
        }
    }
    else
    {
        if (TitleRequest->Length >= sizeof(CHAR))
        {
            Length = min(TitleRequest->Length - sizeof(CHAR), Console->Title.Length / sizeof(WCHAR));
            Length = WideCharToMultiByte(Console->InputCodePage, 0,
                                         Console->Title.Buffer, Length,
                                         TitleRequest->Title, Length,
                                         NULL, NULL);
            ((PCHAR)TitleRequest->Title)[Length] = ANSI_NULL;
            TitleRequest->Length = Length;
        }
        else
        {
            TitleRequest->Length = Console->Title.Length / sizeof(WCHAR);
        }
    }
 
    return STATUS_SUCCESS;
}

CON_API() [10/12]

CON_API	(	SrvSetConsoleCP	,
		CONSOLE_SETINPUTOUTPUTCP	,
		SetConsoleCPRequest
	)

Definition at line 1894 of file console.c.

{
    DPRINT("SrvSetConsoleCP, setting %s Code Page\n",
            SetConsoleCPRequest->OutputCP ? "Output" : "Input");
 
    return ConDrvSetConsoleCP((PCONSOLE)Console,
                              SetConsoleCPRequest->CodePage,
                              SetConsoleCPRequest->OutputCP);
}

CON_API() [11/12]

CON_API	(	SrvSetConsoleMode	,
		CONSOLE_GETSETCONSOLEMODE	,
		ConsoleModeRequest
	)

Definition at line 1705 of file console.c.

{
#define CONSOLE_VALID_CONTROL_MODES ( ENABLE_EXTENDED_FLAGS | \
                                      ENABLE_INSERT_MODE    | ENABLE_QUICK_EDIT_MODE )
// NOTE: Vista+ ENABLE_AUTO_POSITION is also a control mode.
 
    NTSTATUS Status;
    PCONSOLE_IO_OBJECT Object;
    ULONG ConsoleMode = ConsoleModeRequest->Mode;
 
    Status = ConSrvGetObject(ProcessData,
                             ConsoleModeRequest->Handle,
                             &Object, NULL, GENERIC_WRITE, TRUE, 0);
    if (!NT_SUCCESS(Status))
        return Status;
 
    ASSERT((PCONSOLE)Console == Object->Console);
 
    /* Set the standard console modes (without the CONSRV-specific input modes) */
    ConsoleMode &= ~CONSOLE_VALID_CONTROL_MODES; // Remove CONSRV-specific input modes.
    Status = ConDrvSetConsoleMode((PCONSOLE)Console, Object, ConsoleMode);
    if (NT_SUCCESS(Status))
    {
        /*
         * If setting the console modes succeeds, then set
         * the extended CONSRV-specific input modes.
         */
        if (INPUT_BUFFER == Object->Type)
        {
            ConsoleMode = ConsoleModeRequest->Mode;
 
            if (ConsoleMode & CONSOLE_VALID_CONTROL_MODES)
            {
                /*
                 * If we use control mode flags without ENABLE_EXTENDED_FLAGS,
                 * then consider the flags invalid.
                 */
                if ((ConsoleMode & ENABLE_EXTENDED_FLAGS) == 0)
                {
                    Status = STATUS_INVALID_PARAMETER;
                }
                else
                {
                    Console->InsertMode = !!(ConsoleMode & ENABLE_INSERT_MODE);
                    Console->QuickEdit  = !!(ConsoleMode & ENABLE_QUICK_EDIT_MODE);
                }
            }
        }
    }
 
    ConSrvReleaseObject(Object, TRUE);
    return Status;
}

CON_API() [12/12]

CON_API	(	SrvSetConsoleTitle	,
		CONSOLE_GETSETCONSOLETITLE	,
		TitleRequest
	)

Definition at line 1811 of file console.c.

{
    PWCHAR Buffer;
    ULONG  Length;
 
    if (!CsrValidateMessageBuffer(ApiMessage,
                                  (PVOID)&TitleRequest->Title,
                                  TitleRequest->Length,
                                  sizeof(BYTE)))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    if (TitleRequest->Unicode)
    {
        /* Length is in bytes */
        Length = TitleRequest->Length;
    }
    else
    {
        /* Use the console input CP for the conversion */
        Length = MultiByteToWideChar(Console->InputCodePage, 0,
                                     TitleRequest->Title, TitleRequest->Length,
                                     NULL, 0);
        /* The returned Length was in number of wchars, convert it in bytes */
        Length *= sizeof(WCHAR);
    }
 
    /* Allocate a new buffer to hold the new title (NULL-terminated) */
    Buffer = ConsoleAllocHeap(HEAP_ZERO_MEMORY, Length + sizeof(WCHAR));
    if (!Buffer)
        return STATUS_NO_MEMORY;
 
    /* Free the old title */
    ConsoleFreeUnicodeString(&Console->Title);
 
    /* Copy title to console */
    Console->Title.Buffer = Buffer;
    Console->Title.Length = Length;
    Console->Title.MaximumLength = Console->Title.Length + sizeof(WCHAR);
 
    if (TitleRequest->Unicode)
    {
        RtlCopyMemory(Console->Title.Buffer, TitleRequest->Title, Console->Title.Length);
    }
    else
    {
        MultiByteToWideChar(Console->InputCodePage, 0,
                            TitleRequest->Title, TitleRequest->Length,
                            Console->Title.Buffer,
                            Console->Title.Length / sizeof(WCHAR));
    }
 
    /* NULL-terminate */
    Console->Title.Buffer[Console->Title.Length / sizeof(WCHAR)] = UNICODE_NULL;
 
    TermChangeTitle(Console);
 
    return STATUS_SUCCESS;
}

CON_API_NOCONSOLE() [1/3]

CON_API_NOCONSOLE	(	SrvAllocConsole	,
		CONSOLE_ALLOCCONSOLE	,
		AllocConsoleRequest
	)

Definition at line 1483 of file console.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    CONSOLE_INIT_INFO ConsoleInitInfo;
 
    if (ProcessData->ConsoleHandle != NULL)
    {
        DPRINT1("Process already has a console\n");
        return STATUS_ACCESS_DENIED;
    }
 
    if ( !CsrValidateMessageBuffer(ApiMessage,
                                   (PVOID*)&AllocConsoleRequest->ConsoleStartInfo,
                                   1,
                                   sizeof(CONSOLE_START_INFO))      ||
         !CsrValidateMessageBuffer(ApiMessage,
                                   (PVOID*)&AllocConsoleRequest->ConsoleTitle,
                                   AllocConsoleRequest->TitleLength,
                                   sizeof(BYTE))                    ||
         !CsrValidateMessageBuffer(ApiMessage,
                                   (PVOID*)&AllocConsoleRequest->Desktop,
                                   AllocConsoleRequest->DesktopLength,
                                   sizeof(BYTE))                    ||
         !CsrValidateMessageBuffer(ApiMessage,
                                   (PVOID*)&AllocConsoleRequest->CurDir,
                                   AllocConsoleRequest->CurDirLength,
                                   sizeof(BYTE))                    ||
         !CsrValidateMessageBuffer(ApiMessage,
                                   (PVOID*)&AllocConsoleRequest->AppName,
                                   AllocConsoleRequest->AppNameLength,
                                   sizeof(BYTE)) )
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Initialize the console initialization info structure */
    ConsoleInitInfo.ConsoleStartInfo = AllocConsoleRequest->ConsoleStartInfo;
    ConsoleInitInfo.IsWindowVisible  = TRUE; // The console window is always visible.
    ConsoleInitInfo.TitleLength      = AllocConsoleRequest->TitleLength;
    ConsoleInitInfo.ConsoleTitle     = AllocConsoleRequest->ConsoleTitle;
    ConsoleInitInfo.DesktopLength    = AllocConsoleRequest->DesktopLength;
    ConsoleInitInfo.Desktop          = AllocConsoleRequest->Desktop;
    ConsoleInitInfo.AppNameLength    = AllocConsoleRequest->AppNameLength;
    ConsoleInitInfo.AppName          = AllocConsoleRequest->AppName;
    ConsoleInitInfo.CurDirLength     = AllocConsoleRequest->CurDirLength;
    ConsoleInitInfo.CurDir           = AllocConsoleRequest->CurDir;
 
    /* Initialize a new Console owned by the Console Leader Process */
    Status = ConSrvAllocateConsole(ProcessData,
                                   &AllocConsoleRequest->ConsoleStartInfo->InputHandle,
                                   &AllocConsoleRequest->ConsoleStartInfo->OutputHandle,
                                   &AllocConsoleRequest->ConsoleStartInfo->ErrorHandle,
                                   &ConsoleInitInfo);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Console allocation failed\n");
        return Status;
    }
 
    /* Set the Property-Dialog and Control-Dispatcher handlers */
    ProcessData->PropRoutine = AllocConsoleRequest->PropRoutine;
    ProcessData->CtrlRoutine = AllocConsoleRequest->CtrlRoutine;
 
    return STATUS_SUCCESS;
}

CON_API_NOCONSOLE() [2/3]

CON_API_NOCONSOLE	(	SrvAttachConsole	,
		CONSOLE_ATTACHCONSOLE	,
		AttachConsoleRequest
	)

Definition at line 1551 of file console.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PCSR_PROCESS SourceProcess = NULL;  // The parent process.
    PCSR_PROCESS TargetProcess = CsrGetClientThread()->Process; // Ourselves.
    HANDLE ProcessId = ULongToHandle(AttachConsoleRequest->ProcessId);
    PCONSOLE_PROCESS_DATA SourceProcessData, TargetProcessData;
 
    TargetProcessData = ConsoleGetPerProcessData(TargetProcess);
 
    if (TargetProcessData->ConsoleHandle != NULL)
    {
        DPRINT1("Process already has a console\n");
        return STATUS_ACCESS_DENIED;
    }
 
    if (!CsrValidateMessageBuffer(ApiMessage,
                                  (PVOID*)&AttachConsoleRequest->ConsoleStartInfo,
                                  1,
                                  sizeof(CONSOLE_START_INFO)))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Check whether we try to attach to the parent's console */
    if (ProcessId == ULongToHandle(ATTACH_PARENT_PROCESS))
    {
        PROCESS_BASIC_INFORMATION ProcessInfo;
        ULONG Length = sizeof(ProcessInfo);
 
        /* Get the real parent's PID */
 
        Status = NtQueryInformationProcess(TargetProcess->ProcessHandle,
                                           ProcessBasicInformation,
                                           &ProcessInfo,
                                           Length, &Length);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("SrvAttachConsole - Cannot retrieve basic process info, Status = 0x%08lx\n", Status);
            return Status;
        }
 
        ProcessId = ULongToHandle(ProcessInfo.InheritedFromUniqueProcessId);
    }
 
    /* Lock the source process via its PID */
    Status = CsrLockProcessByClientId(ProcessId, &SourceProcess);
    if (!NT_SUCCESS(Status)) return Status;
 
    SourceProcessData = ConsoleGetPerProcessData(SourceProcess);
 
    if (SourceProcessData->ConsoleHandle == NULL)
    {
        Status = STATUS_INVALID_HANDLE;
        goto Quit;
    }
 
    /*
     * Inherit the console from the parent,
     * if any, otherwise return an error.
     */
    Status = ConSrvInheritConsole(TargetProcessData,
                                  SourceProcessData->ConsoleHandle,
                                  TRUE,
                                  &AttachConsoleRequest->ConsoleStartInfo->InputHandle,
                                  &AttachConsoleRequest->ConsoleStartInfo->OutputHandle,
                                  &AttachConsoleRequest->ConsoleStartInfo->ErrorHandle,
                                  AttachConsoleRequest->ConsoleStartInfo);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Console inheritance failed\n");
        goto Quit;
    }
 
    /* Set the Property-Dialog and Control-Dispatcher handlers */
    TargetProcessData->PropRoutine = AttachConsoleRequest->PropRoutine;
    TargetProcessData->CtrlRoutine = AttachConsoleRequest->CtrlRoutine;
 
    Status = STATUS_SUCCESS;
 
Quit:
    /* Unlock the "source" process and exit */
    CsrUnlockProcess(SourceProcess);
    return Status;
}

CON_API_NOCONSOLE() [3/3]

CON_API_NOCONSOLE	(	SrvFreeConsole	,
		CONSOLE_FREECONSOLE	,
		FreeConsoleRequest
	)

Definition at line 1639 of file console.c.

{
    /*
     * If this process doesn't have a console handle, bail out immediately.
     * Also the passed console handle should be the same as the process' one.
     */
    if ((FreeConsoleRequest->ConsoleHandle == NULL) ||
        (FreeConsoleRequest->ConsoleHandle != ProcessData->ConsoleHandle))
    {
        return STATUS_INVALID_HANDLE; // STATUS_ACCESS_DENIED;
    }
 
    return ConSrvRemoveConsole(ProcessData);
}

ConDrvGetConsoleCP()

NTSTATUS NTAPI ConDrvGetConsoleCP	(	IN PCONSOLE	Console,
		OUT PUINT	CodePage,
		IN BOOLEAN	OutputCP
	)

Definition at line 411 of file console.c.

{
    if (Console == NULL || CodePage == NULL)
        return STATUS_INVALID_PARAMETER;
 
    *CodePage = (OutputCP ? Console->OutputCodePage : Console->InputCodePage);
 
    return STATUS_SUCCESS;
}

Referenced by CON_API().

ConDrvGetConsoleMode()

NTSTATUS NTAPI ConDrvGetConsoleMode	(	IN PCONSOLE	Console,
		IN PCONSOLE_IO_OBJECT	Object,
		OUT PULONG	ConsoleMode
	)

Definition at line 324 of file console.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
 
    if (Console == NULL || Object == NULL || ConsoleMode == NULL)
        return STATUS_INVALID_PARAMETER;
 
    /* Validity check */
    ASSERT(Console == Object->Console);
 
    /*** FIXME: */ *ConsoleMode = 0; /***/
 
    if (INPUT_BUFFER == Object->Type)
    {
        PCONSOLE_INPUT_BUFFER InputBuffer = (PCONSOLE_INPUT_BUFFER)Object;
        *ConsoleMode = InputBuffer->Mode;
    }
    else if (TEXTMODE_BUFFER == Object->Type || GRAPHICS_BUFFER == Object->Type)
    {
        PCONSOLE_SCREEN_BUFFER Buffer = (PCONSOLE_SCREEN_BUFFER)Object;
        *ConsoleMode = Buffer->Mode;
    }
    else
    {
        Status = STATUS_INVALID_HANDLE;
    }
 
    return Status;
}

Referenced by CON_API().

ConDrvSetConsoleCP()

NTSTATUS NTAPI ConDrvSetConsoleCP	(	IN PCONSOLE	Console,
		IN UINT	CodePage,
		IN BOOLEAN	OutputCP
	)

Definition at line 424 of file console.c.

{
    if (Console == NULL || !IsValidCodePage(CodePage))
        return STATUS_INVALID_PARAMETER;
 
    if (OutputCP)
    {
        /* Request the terminal to change its code page support */
        if (!TermSetCodePage(Console, CodePage))
            return STATUS_UNSUCCESSFUL;
 
        /* All is fine, actually set the output code page */
        CON_SET_OUTPUT_CP(Console, CodePage);
        return STATUS_SUCCESS;
    }
    else
    {
        Console->InputCodePage = CodePage;
        return STATUS_SUCCESS;
    }
}

Referenced by CON_API().

ConDrvSetConsoleMode()

NTSTATUS NTAPI ConDrvSetConsoleMode	(	IN PCONSOLE	Console,
		IN PCONSOLE_IO_OBJECT	Object,
		IN ULONG	ConsoleMode
	)

Definition at line 357 of file console.c.

{
#define CONSOLE_VALID_INPUT_MODES   ( ENABLE_PROCESSED_INPUT  | ENABLE_LINE_INPUT   | \
                                      ENABLE_ECHO_INPUT       | ENABLE_WINDOW_INPUT | \
                                      ENABLE_MOUSE_INPUT )
#define CONSOLE_VALID_OUTPUT_MODES  ( ENABLE_PROCESSED_OUTPUT | ENABLE_WRAP_AT_EOL_OUTPUT )
 
    NTSTATUS Status = STATUS_SUCCESS;
 
    if (Console == NULL || Object == NULL)
        return STATUS_INVALID_PARAMETER;
 
    /* Validity check */
    ASSERT(Console == Object->Console);
 
    if (INPUT_BUFFER == Object->Type)
    {
        PCONSOLE_INPUT_BUFFER InputBuffer = (PCONSOLE_INPUT_BUFFER)Object;
 
        /* Only the presence of valid mode flags is allowed */
        if (ConsoleMode & ~CONSOLE_VALID_INPUT_MODES)
        {
            Status = STATUS_INVALID_PARAMETER;
        }
        else
        {
            InputBuffer->Mode = (ConsoleMode & CONSOLE_VALID_INPUT_MODES);
        }
    }
    else if (TEXTMODE_BUFFER == Object->Type || GRAPHICS_BUFFER == Object->Type)
    {
        PCONSOLE_SCREEN_BUFFER Buffer = (PCONSOLE_SCREEN_BUFFER)Object;
 
        /* Only the presence of valid mode flags is allowed */
        if (ConsoleMode & ~CONSOLE_VALID_OUTPUT_MODES)
        {
            Status = STATUS_INVALID_PARAMETER;
        }
        else
        {
            Buffer->Mode = (ConsoleMode & CONSOLE_VALID_OUTPUT_MODES);
        }
    }
    else
    {
        Status = STATUS_INVALID_HANDLE;
    }
 
    return Status;
}

Referenced by CON_API().

ConioPause()

VOID ConioPause	(	PCONSRV_CONSOLE	Console,
		UCHAR	Flags
	)

Definition at line 859 of file console.c.

{
    Console->PauseFlags |= Flags;
    ConDrvPause((PCONSOLE)Console);
}

Referenced by OnScroll(), PreprocessInput(), and UpdateSelection().

ConioUnpause()

VOID ConioUnpause	(	PCONSRV_CONSOLE	Console,
		UCHAR	Flags
	)

Definition at line 866 of file console.c.

{
    Console->PauseFlags &= ~Flags;
 
    // if ((Console->PauseFlags & (PAUSED_FROM_KEYBOARD | PAUSED_FROM_SCROLLBAR | PAUSED_FROM_SELECTION)) == 0)
    if (Console->PauseFlags == 0)
    {
        ConDrvUnpause((PCONSOLE)Console);
 
        CsrNotifyWait(&Console->WriteWaitQueue,
                      TRUE,
                      NULL,
                      NULL);
        if (!IsListEmpty(&Console->WriteWaitQueue))
        {
            CsrDereferenceWait(&Console->WriteWaitQueue);
        }
    }
}

Referenced by OnScroll(), PreprocessInput(), and UpdateSelection().

ConsoleCreateUnicodeString()

static BOOLEAN ConsoleCreateUnicodeString ( IN OUT PUNICODE_STRING  UniDest, IN PCWSTR  Source  )

static

Definition at line 216 of file console.c.

{
    SIZE_T Size = (wcslen(Source) + 1) * sizeof(WCHAR);
    if (Size > MAXUSHORT) return FALSE;
 
    UniDest->Buffer = ConsoleAllocHeap(HEAP_ZERO_MEMORY, Size);
    if (UniDest->Buffer == NULL) return FALSE;
 
    RtlCopyMemory(UniDest->Buffer, Source, Size);
    UniDest->MaximumLength = (USHORT)Size;
    UniDest->Length = (USHORT)Size - sizeof(WCHAR);
 
    return TRUE;
}

Referenced by ConSrvInitConsole().

ConsoleFreeUnicodeString()

static VOID ConsoleFreeUnicodeString ( IN PUNICODE_STRING  UnicodeString )

static

Definition at line 234 of file console.c.

{
    if (UnicodeString->Buffer)
    {
        ConsoleFreeHeap(UnicodeString->Buffer);
        RtlZeroMemory(UnicodeString, sizeof(UNICODE_STRING));
    }
}

Referenced by CON_API(), and ConSrvDeleteConsole().

ConSrvAllocateConsole()

NTSTATUS ConSrvAllocateConsole	(	IN OUT PCONSOLE_PROCESS_DATA	ProcessData,
		OUT PHANDLE	pInputHandle,
		OUT PHANDLE	pOutputHandle,
		OUT PHANDLE	pErrorHandle,
		IN OUT PCONSOLE_INIT_INFO	ConsoleInitInfo
	)

Definition at line 968 of file console.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    HANDLE ConsoleHandle;
    PCONSRV_CONSOLE Console;
 
    /*
     * We are about to create a new console. However when ConSrvNewProcess()
     * was called, we didn't know that we wanted to create a new console and
     * therefore, we by default inherited the handle table from our parent
     * process. It's only now that we notice that in fact we do not need
     * them, because we've created a new console and thus we must use it.
     *
     * Therefore, free the handle table so that we can recreate
     * a new one later on.
     */
    ConSrvFreeHandlesTable(ProcessData);
 
    /* Initialize a new Console owned by this process */
    Status = ConSrvInitConsole(&ConsoleHandle,
                               &Console,
                               ConsoleInitInfo,
                               ProcessData->Process);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Console initialization failed\n");
        return Status;
    }
 
    /* Assign the new console handle */
    ProcessData->ConsoleHandle = ConsoleHandle;
 
    /* Initialize the process handles */
    Status = ConSrvInitProcessHandles(ProcessData,
                                      Console,
                                      pInputHandle,
                                      pOutputHandle,
                                      pErrorHandle);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to initialize the process handles\n");
        ConSrvDeleteConsole(Console);
        ProcessData->ConsoleHandle = NULL;
        return Status;
    }
 
    /* Duplicate the Initialization Events */
    Status = NtDuplicateObject(NtCurrentProcess(),
                               Console->InitEvents[INIT_SUCCESS],
                               ProcessData->Process->ProcessHandle,
                               &ConsoleInitInfo->ConsoleStartInfo->InitEvents[INIT_SUCCESS],
                               EVENT_ALL_ACCESS, 0, 0);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtDuplicateObject(InitEvents[INIT_SUCCESS]) failed: %lu\n", Status);
        ConSrvFreeHandlesTable(ProcessData);
        ConSrvDeleteConsole(Console);
        ProcessData->ConsoleHandle = NULL;
        return Status;
    }
 
    Status = NtDuplicateObject(NtCurrentProcess(),
                               Console->InitEvents[INIT_FAILURE],
                               ProcessData->Process->ProcessHandle,
                               &ConsoleInitInfo->ConsoleStartInfo->InitEvents[INIT_FAILURE],
                               EVENT_ALL_ACCESS, 0, 0);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtDuplicateObject(InitEvents[INIT_FAILURE]) failed: %lu\n", Status);
        NtDuplicateObject(ProcessData->Process->ProcessHandle,
                          ConsoleInitInfo->ConsoleStartInfo->InitEvents[INIT_SUCCESS],
                          NULL, NULL, 0, 0, DUPLICATE_CLOSE_SOURCE);
        ConSrvFreeHandlesTable(ProcessData);
        ConSrvDeleteConsole(Console);
        ProcessData->ConsoleHandle = NULL;
        return Status;
    }
 
    /* Duplicate the Input Event */
    Status = NtDuplicateObject(NtCurrentProcess(),
                               Console->InputBuffer.ActiveEvent,
                               ProcessData->Process->ProcessHandle,
                               &ConsoleInitInfo->ConsoleStartInfo->InputWaitHandle,
                               EVENT_ALL_ACCESS, 0, 0);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtDuplicateObject(InputWaitHandle) failed: %lu\n", Status);
        NtDuplicateObject(ProcessData->Process->ProcessHandle,
                          ConsoleInitInfo->ConsoleStartInfo->InitEvents[INIT_FAILURE],
                          NULL, NULL, 0, 0, DUPLICATE_CLOSE_SOURCE);
        NtDuplicateObject(ProcessData->Process->ProcessHandle,
                          ConsoleInitInfo->ConsoleStartInfo->InitEvents[INIT_SUCCESS],
                          NULL, NULL, 0, 0, DUPLICATE_CLOSE_SOURCE);
        ConSrvFreeHandlesTable(ProcessData);
        ConSrvDeleteConsole(Console);
        ProcessData->ConsoleHandle = NULL;
        return Status;
    }
 
    /* Mark the process as having a console */
    ProcessData->ConsoleApp = TRUE;
    ProcessData->Process->Flags |= CsrProcessIsConsoleApp;
 
    /* Return the console handle to the caller */
    ConsoleInitInfo->ConsoleStartInfo->ConsoleHandle = ProcessData->ConsoleHandle;
 
    /*
     * Insert the process into the processes list of the console,
     * and set its foreground priority.
     */
    InsertHeadList(&Console->ProcessList, &ProcessData->ConsoleLink);
    ConSrvSetProcessFocus(ProcessData->Process, Console->HasFocus);
 
    /* Add a reference count because the process is tied to the console */
    _InterlockedIncrement(&Console->ReferenceCount);
 
    /* Update the internal info of the terminal */
    TermRefreshInternalInfo(Console);
 
    return STATUS_SUCCESS;
}

Referenced by CON_API_NOCONSOLE(), and ConSrvConnect().

ConSrvConsoleCtrlEvent()

NTSTATUS ConSrvConsoleCtrlEvent	(	IN ULONG	CtrlEvent,
		IN PCONSOLE_PROCESS_DATA	ProcessData
	)

Definition at line 1356 of file console.c.

{
    return ConSrvConsoleCtrlEventTimeout(CtrlEvent, ProcessData, 0);
}

Referenced by ConSrvConsoleProcessCtrlEvent(), and ConSrvRemoveConsole().

ConSrvConsoleCtrlEventTimeout()

NTSTATUS ConSrvConsoleCtrlEventTimeout	(	IN ULONG	CtrlEvent,
		IN PCONSOLE_PROCESS_DATA	ProcessData,
		IN ULONG	Timeout
	)

Definition at line 1305 of file console.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
 
    DPRINT("ConSrvConsoleCtrlEventTimeout Parent ProcessId = %x\n", ProcessData->Process->ClientId.UniqueProcess);
 
    /*
     * Be sure we effectively have a control routine. It resides in kernel32.dll (client).
     */
    if (ProcessData->CtrlRoutine == NULL) return Status;
 
    _SEH2_TRY
    {
        HANDLE Thread = NULL;
 
        _SEH2_TRY
        {
            Thread = CreateRemoteThread(ProcessData->Process->ProcessHandle, NULL, 0,
                                        ProcessData->CtrlRoutine,
                                        UlongToPtr(CtrlEvent), 0, NULL);
            if (NULL == Thread)
            {
                Status = RtlGetLastNtStatus();
                DPRINT1("Failed thread creation, Status = 0x%08lx\n", Status);
            }
            else
            {
                DPRINT("ProcessData->CtrlRoutine remote thread creation succeeded, ProcessId = %x, Process = 0x%p\n",
                       ProcessData->Process->ClientId.UniqueProcess, ProcessData->Process);
                WaitForSingleObject(Thread, Timeout);
            }
        }
        _SEH2_FINALLY
        {
            CloseHandle(Thread);
        }
        _SEH2_END;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = _SEH2_GetExceptionCode();
        DPRINT1("ConSrvConsoleCtrlEventTimeout - Caught an exception, Status = 0x%08lx\n", Status);
    }
    _SEH2_END;
 
    return Status;
}

Referenced by ConSrvConsoleCtrlEvent(), and NotifyConsoleProcessForShutdown().

ConSrvConsoleProcessCtrlEvent()

NTSTATUS NTAPI ConSrvConsoleProcessCtrlEvent	(	IN PCONSRV_CONSOLE	Console,
		IN ULONG	ProcessGroupId,
		IN ULONG	CtrlEvent
	)

Definition at line 1402 of file console.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PLIST_ENTRY current_entry;
    PCONSOLE_PROCESS_DATA current;
 
    /* If the console is already being destroyed, just return */
    if (!ConDrvValidateConsoleState((PCONSOLE)Console, CONSOLE_RUNNING))
        return STATUS_UNSUCCESSFUL;
 
    /*
     * Loop through the process list, from the most recent process
     * (the active one) to the oldest one (the first created, i.e.
     * the console leader process), and for each, send an event
     * (new processes are inserted at the head of the console process list).
     */
    current_entry = Console->ProcessList.Flink;
    while (current_entry != &Console->ProcessList)
    {
        current = CONTAINING_RECORD(current_entry, CONSOLE_PROCESS_DATA, ConsoleLink);
        current_entry = current_entry->Flink;
 
        /*
         * Only processes belonging to the same process group are signaled.
         * If the process group ID is zero, then all the processes are signaled.
         */
        if (ProcessGroupId == 0 || current->Process->ProcessGroupId == ProcessGroupId)
        {
            Status = ConSrvConsoleCtrlEvent(CtrlEvent, current);
        }
    }
 
    return Status;
}

Referenced by CON_API(), ConioProcessInputEvent(), and OnClose().

ConSrvDeinitTerminal()

NTSTATUS NTAPI ConSrvDeinitTerminal

(

IN OUT PTERMINAL

Terminal

)

Definition at line 237 of file terminal.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PFRONTEND FrontEnd = Terminal->Context;
 
    /* Reset the ConSrv terminal */
    Terminal->Context = NULL;
    Terminal->Vtbl = NULL;
 
    /* Unload the frontend */
    if (FrontEnd != NULL)
    {
        Status = ConSrvUnloadFrontEnd(FrontEnd);
        ConsoleFreeHeap(FrontEnd);
    }
 
    return Status;
}

Referenced by ConSrvInitConsole().

ConSrvDeleteConsole()

VOID NTAPI ConSrvDeleteConsole

(

PCONSRV_CONSOLE

Console

)

Definition at line 822 of file console.c.

{
    DPRINT("ConSrvDeleteConsole\n");
 
    // FIXME: Send a terminate message to all the processes owning this console.
    // NOTE: In principle there should be none, because such processes would
    // have a reference to the console and thus this function would not have
    // been called in the first place.
 
    /* Remove the console from the list */
    RemoveConsoleByPointer(Console);
 
    /* Destroy the Initialization Events */
    NtClose(Console->InitEvents[INIT_FAILURE]);
    NtClose(Console->InitEvents[INIT_SUCCESS]);
 
    /* Clean the Input Line Discipline */
    if (Console->LineBuffer) ConsoleFreeHeap(Console->LineBuffer);
 
    /* Clean aliases and history */
    IntDeleteAllAliases(Console);
    HistoryDeleteBuffers(Console);
 
    /* Free the console title */
    ConsoleFreeUnicodeString(&Console->OriginalTitle);
    ConsoleFreeUnicodeString(&Console->Title);
 
    /* Now, call the driver. ConDrvDetachTerminal is called on-demand. */
    ConDrvDeleteConsole((PCONSOLE)Console);
 
    /* Deinit the ConSrv terminal */
    // FIXME!!
    // ConSrvDeinitTerminal(&Terminal);
}

Referenced by ConSrvAllocateConsole(), and ConSrvReleaseConsole().

ConSrvGetConsole()

NTSTATUS ConSrvGetConsole	(	IN PCONSOLE_PROCESS_DATA	ProcessData,
		OUT PCONSRV_CONSOLE *	Console,
		IN BOOLEAN	LockConsole
	)

Definition at line 291 of file console.c.

{
    NTSTATUS Status = STATUS_INVALID_HANDLE;
    PCONSRV_CONSOLE GrabConsole;
 
    // if (Console == NULL) return STATUS_INVALID_PARAMETER;
    ASSERT(Console);
    *Console = NULL;
 
    if (ConSrvValidateConsole(&GrabConsole,
                              ProcessData->ConsoleHandle,
                              CONSOLE_RUNNING,
                              LockConsole))
    {
        _InterlockedIncrement(&GrabConsole->ReferenceCount);
        *Console = GrabConsole;
        Status = STATUS_SUCCESS;
    }
 
    return Status;
}

Referenced by CON_API_NOCONSOLE(), and GetThreadConsoleDesktop().

ConSrvGetConsoleLeaderProcess()

PCONSOLE_PROCESS_DATA NTAPI ConSrvGetConsoleLeaderProcess

(

IN PCONSRV_CONSOLE

Console

)

Definition at line 1363 of file console.c.

{
    if (Console == NULL) return NULL;
 
    return CONTAINING_RECORD(Console->ProcessList.Blink,
                             CONSOLE_PROCESS_DATA,
                             ConsoleLink);
}

Referenced by ConSrvRemoveConsole(), GuiApplyUserSettings(), GuiConsoleShowConsoleProperties(), and SetConWndConsoleLeaderCID().

ConSrvGetConsoleProcessList()

NTSTATUS NTAPI ConSrvGetConsoleProcessList	(	IN PCONSRV_CONSOLE	Console,
		IN OUT PULONG	ProcessIdsList,
		IN ULONG	MaxIdListItems,
		OUT PULONG	ProcessIdsTotal
	)

Definition at line 1373 of file console.c.

{
    PCONSOLE_PROCESS_DATA current;
    PLIST_ENTRY current_entry;
 
    if (Console == NULL || ProcessIdsList == NULL || ProcessIdsTotal == NULL)
        return STATUS_INVALID_PARAMETER;
 
    *ProcessIdsTotal = 0;
 
    for (current_entry = Console->ProcessList.Flink;
         current_entry != &Console->ProcessList;
         current_entry = current_entry->Flink)
    {
        current = CONTAINING_RECORD(current_entry, CONSOLE_PROCESS_DATA, ConsoleLink);
        if (++(*ProcessIdsTotal) <= MaxIdListItems)
        {
            *ProcessIdsList++ = HandleToUlong(current->Process->ClientId.UniqueProcess);
        }
    }
 
    return STATUS_SUCCESS;
}

Referenced by CON_API().

ConSrvInheritConsole()

NTSTATUS ConSrvInheritConsole	(	IN OUT PCONSOLE_PROCESS_DATA	ProcessData,
		IN HANDLE	ConsoleHandle,
		IN BOOLEAN	CreateNewHandleTable,
		OUT PHANDLE	pInputHandle,
		OUT PHANDLE	pOutputHandle,
		OUT PHANDLE	pErrorHandle,
		IN OUT PCONSOLE_START_INFO	ConsoleStartInfo
	)

Definition at line 1096 of file console.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PCONSRV_CONSOLE Console;
 
    /* Validate and lock the console */
    if (!ConSrvValidateConsole(&Console,
                               ConsoleHandle,
                               CONSOLE_RUNNING, TRUE))
    {
        // FIXME: Find another status code
        return STATUS_UNSUCCESSFUL;
    }
 
    /* Inherit the console */
    ProcessData->ConsoleHandle = ConsoleHandle;
 
    if (CreateNewHandleTable)
    {
        /*
         * We are about to create a new console. However when ConSrvNewProcess()
         * was called, we didn't know that we wanted to create a new console and
         * therefore, we by default inherited the handle table from our parent
         * process. It's only now that we notice that in fact we do not need
         * them, because we've created a new console and thus we must use it.
         *
         * Therefore, free the handle table so that we can recreate
         * a new one later on.
         */
        ConSrvFreeHandlesTable(ProcessData);
 
        /* Initialize the process handles */
        Status = ConSrvInitProcessHandles(ProcessData,
                                          Console,
                                          pInputHandle,
                                          pOutputHandle,
                                          pErrorHandle);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("Failed to initialize the process handles\n");
            ProcessData->ConsoleHandle = NULL;
            goto Quit;
        }
    }
 
    /* Duplicate the Initialization Events */
    Status = NtDuplicateObject(NtCurrentProcess(),
                               Console->InitEvents[INIT_SUCCESS],
                               ProcessData->Process->ProcessHandle,
                               &ConsoleStartInfo->InitEvents[INIT_SUCCESS],
                               EVENT_ALL_ACCESS, 0, 0);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtDuplicateObject(InitEvents[INIT_SUCCESS]) failed: %lu\n", Status);
        ConSrvFreeHandlesTable(ProcessData);
        ProcessData->ConsoleHandle = NULL;
        goto Quit;
    }
 
    Status = NtDuplicateObject(NtCurrentProcess(),
                               Console->InitEvents[INIT_FAILURE],
                               ProcessData->Process->ProcessHandle,
                               &ConsoleStartInfo->InitEvents[INIT_FAILURE],
                               EVENT_ALL_ACCESS, 0, 0);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtDuplicateObject(InitEvents[INIT_FAILURE]) failed: %lu\n", Status);
        NtDuplicateObject(ProcessData->Process->ProcessHandle,
                          ConsoleStartInfo->InitEvents[INIT_SUCCESS],
                          NULL, NULL, 0, 0, DUPLICATE_CLOSE_SOURCE);
        ConSrvFreeHandlesTable(ProcessData);
        ProcessData->ConsoleHandle = NULL;
        goto Quit;
    }
 
    /* Duplicate the Input Event */
    Status = NtDuplicateObject(NtCurrentProcess(),
                               Console->InputBuffer.ActiveEvent,
                               ProcessData->Process->ProcessHandle,
                               &ConsoleStartInfo->InputWaitHandle,
                               EVENT_ALL_ACCESS, 0, 0);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtDuplicateObject(InputWaitHandle) failed: %lu\n", Status);
        NtDuplicateObject(ProcessData->Process->ProcessHandle,
                          ConsoleStartInfo->InitEvents[INIT_FAILURE],
                          NULL, NULL, 0, 0, DUPLICATE_CLOSE_SOURCE);
        NtDuplicateObject(ProcessData->Process->ProcessHandle,
                          ConsoleStartInfo->InitEvents[INIT_SUCCESS],
                          NULL, NULL, 0, 0, DUPLICATE_CLOSE_SOURCE);
        ConSrvFreeHandlesTable(ProcessData); // NOTE: Always free the handle table.
        ProcessData->ConsoleHandle = NULL;
        goto Quit;
    }
 
    /* Mark the process as having a console */
    ProcessData->ConsoleApp = TRUE;
    ProcessData->Process->Flags |= CsrProcessIsConsoleApp;
 
    /* Return the console handle to the caller */
    ConsoleStartInfo->ConsoleHandle = ProcessData->ConsoleHandle;
 
    /*
     * Insert the process into the processes list of the console,
     * and set its foreground priority.
     */
    InsertHeadList(&Console->ProcessList, &ProcessData->ConsoleLink);
    ConSrvSetProcessFocus(ProcessData->Process, Console->HasFocus);
 
    /* Add a reference count because the process is tied to the console */
    _InterlockedIncrement(&Console->ReferenceCount);
 
    /* Update the internal info of the terminal */
    TermRefreshInternalInfo(Console);
 
    Status = STATUS_SUCCESS;
 
Quit:
    /* Unlock the console and return */
    LeaveCriticalSection(&Console->Lock);
    return Status;
}

Referenced by CON_API_NOCONSOLE(), and ConSrvConnect().

ConSrvInitConsole()

NTSTATUS NTAPI ConSrvInitConsole	(	OUT PHANDLE	NewConsoleHandle,
		OUT PCONSRV_CONSOLE *	NewConsole,
		IN OUT PCONSOLE_INIT_INFO	ConsoleInitInfo,
		IN PCSR_PROCESS	ConsoleLeaderProcess
	)

Definition at line 532 of file console.c.

{
    NTSTATUS Status;
    HANDLE ConsoleHandle;
    PCONSRV_CONSOLE Console;
 
    BYTE ConsoleInfoBuffer[sizeof(CONSOLE_STATE_INFO) + MAX_PATH * sizeof(WCHAR)]; // CONSRV console information
    PCONSOLE_STATE_INFO ConsoleInfo = (PCONSOLE_STATE_INFO)&ConsoleInfoBuffer;
    CONSOLE_INFO DrvConsoleInfo; // Console information for CONDRV
 
    SIZE_T Length = 0;
 
    TERMINAL Terminal; /* The ConSrv terminal for this console */
 
    if (NewConsole == NULL || ConsoleInitInfo == NULL)
        return STATUS_INVALID_PARAMETER;
 
    *NewConsole = NULL;
 
    DPRINT("Initialization of console '%S' for process '%S' on desktop '%S'\n",
           ConsoleInitInfo->ConsoleTitle ? ConsoleInitInfo->ConsoleTitle : L"n/a",
           ConsoleInitInfo->AppName ? ConsoleInitInfo->AppName : L"n/a",
           ConsoleInitInfo->Desktop ? ConsoleInitInfo->Desktop : L"n/a");
 
    /*
     * Load the console settings
     */
    RtlZeroMemory(ConsoleInfo, sizeof(ConsoleInfoBuffer));
    ConsoleInfo->cbSize = sizeof(ConsoleInfoBuffer);
 
    /* 1. Get the title of the console (initialize ConsoleInfo->ConsoleTitle) */
    Length = min(ConsoleInitInfo->TitleLength,
                 (ConsoleInfo->cbSize - FIELD_OFFSET(CONSOLE_STATE_INFO, ConsoleTitle) - sizeof(UNICODE_NULL)) / sizeof(WCHAR));
    wcsncpy(ConsoleInfo->ConsoleTitle, ConsoleInitInfo->ConsoleTitle, Length);
    ConsoleInfo->ConsoleTitle[Length] = UNICODE_NULL; // NULL-terminate it.
 
    /* 2. Impersonate the caller in order to retrieve settings in its context */
    if (!CsrImpersonateClient(NULL))
        return STATUS_BAD_IMPERSONATION_LEVEL;
 
    /* 3. Load the default settings */
    ConCfgGetDefaultSettings(ConsoleInfo);
 
    /*
     * 4. Load per-application terminal settings.
     *
     * Check whether the process creating the console was launched via
     * a shell-link. ConsoleInfo->ConsoleTitle may be updated with the
     * name of the shortcut, and ConsoleStartInfo->Icon[Path|Index] too.
     */
    // if (ConsoleInitInfo->ConsoleStartInfo->dwStartupFlags & STARTF_TITLEISLINKNAME) // FIXME!! (for icon loading)
    {
        if (!LoadShellLinkConsoleInfo(ConsoleInfo, ConsoleInitInfo))
        {
            ConsoleInitInfo->ConsoleStartInfo->dwStartupFlags &= ~STARTF_TITLEISLINKNAME;
        }
    }
 
    /*
     * 5. Load the remaining console settings via the registry.
     */
    if ((ConsoleInitInfo->ConsoleStartInfo->dwStartupFlags & STARTF_TITLEISLINKNAME) == 0)
    {
        /*
         * Either we weren't created by an app launched via a shell-link,
         * or we failed to load shell-link console properties.
         * Therefore, load the console infos for the application from the registry.
         */
        ConCfgReadUserSettings(ConsoleInfo, FALSE);
 
        /*
         * Now, update them with the properties the user might gave to us
         * via the STARTUPINFO structure before calling CreateProcess
         * (and which was transmitted via the ConsoleStartInfo structure).
         * We therefore overwrite the values read in the registry.
         */
        if (ConsoleInitInfo->ConsoleStartInfo->dwStartupFlags & STARTF_USEFILLATTRIBUTE)
        {
            ConsoleInfo->ScreenAttributes = (USHORT)ConsoleInitInfo->ConsoleStartInfo->wFillAttribute;
        }
        if (ConsoleInitInfo->ConsoleStartInfo->dwStartupFlags & STARTF_USECOUNTCHARS)
        {
            ConsoleInfo->ScreenBufferSize = ConsoleInitInfo->ConsoleStartInfo->dwScreenBufferSize;
        }
        if (ConsoleInitInfo->ConsoleStartInfo->dwStartupFlags & STARTF_USESIZE)
        {
            ConsoleInfo->WindowSize = ConsoleInitInfo->ConsoleStartInfo->dwWindowSize;
        }
 
#if 0
        /*
         * Now, update them with the properties the user might gave to us
         * via the STARTUPINFO structure before calling CreateProcess
         * (and which was transmitted via the ConsoleStartInfo structure).
         * We therefore overwrite the values read in the registry.
         */
        if (ConsoleInitInfo->ConsoleStartInfo->dwStartupFlags & STARTF_USEPOSITION)
        {
            ConsoleInfo->AutoPosition = FALSE;
            ConsoleInfo->WindowPosition.x = ConsoleInitInfo->ConsoleStartInfo->dwWindowOrigin.X;
            ConsoleInfo->WindowPosition.y = ConsoleInitInfo->ConsoleStartInfo->dwWindowOrigin.Y;
        }
        if (ConsoleInitInfo->ConsoleStartInfo->dwStartupFlags & STARTF_RUNFULLSCREEN)
        {
            ConsoleInfo->FullScreen = TRUE;
        }
#endif
    }
 
    /* 6. Revert impersonation */
    CsrRevertToSelf();
 
    /* Set-up the code page */
    ConsoleInfo->CodePage = GetOEMCP();
 
    /*
     * Initialize the ConSrv terminal and give it a chance to load
     * its own settings and override the console settings.
     */
    Status = ConSrvInitTerminal(&Terminal,
                                ConsoleInfo,
                                ConsoleInitInfo,
                                ConsoleLeaderProcess->ProcessHandle);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CONSRV: Failed to initialize a terminal, Status = 0x%08lx\n", Status);
        return Status;
    }
    DPRINT("CONSRV: Terminal initialized\n");
 
    /* Initialize a new console via the driver */
    // DrvConsoleInfo.InputBufferSize = 0;
    DrvConsoleInfo.ScreenBufferSize = ConsoleInfo->ScreenBufferSize;
    DrvConsoleInfo.ConsoleSize = ConsoleInfo->WindowSize;
    DrvConsoleInfo.CursorSize = ConsoleInfo->CursorSize;
    // DrvConsoleInfo.CursorBlinkOn = ConsoleInfo->CursorBlinkOn;
    DrvConsoleInfo.ScreenAttrib = ConsoleInfo->ScreenAttributes;
    DrvConsoleInfo.PopupAttrib = ConsoleInfo->PopupAttributes;
    DrvConsoleInfo.CodePage = ConsoleInfo->CodePage;
 
    /*
     * Allocate a new console
     */
    Console = ConsoleAllocHeap(HEAP_ZERO_MEMORY, sizeof(*Console));
    if (Console == NULL)
    {
        DPRINT1("Not enough memory for console creation.\n");
        ConSrvDeinitTerminal(&Terminal);
        return STATUS_NO_MEMORY;
    }
 
    Status = ConDrvInitConsole((PCONSOLE)Console, &DrvConsoleInfo);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Creating a new console failed, Status = 0x%08lx\n", Status);
        ConsoleFreeHeap(Console);
        ConSrvDeinitTerminal(&Terminal);
        return Status;
    }
 
    DPRINT("Console initialized\n");
 
    /*** Register ConSrv features ***/
 
    /* Initialize the console title */
#if 0
    WCHAR DefaultTitle[128];
#endif
    ConsoleCreateUnicodeString(&Console->OriginalTitle, ConsoleInfo->ConsoleTitle);
#if 0
    if (ConsoleInfo->ConsoleTitle[0] == UNICODE_NULL)
    {
        if (LoadStringW(ConSrvDllInstance, IDS_CONSOLE_TITLE, DefaultTitle, sizeof(DefaultTitle) / sizeof(DefaultTitle[0])))
        {
            ConsoleCreateUnicodeString(&Console->Title, DefaultTitle);
        }
        else
        {
            ConsoleCreateUnicodeString(&Console->Title, L"ReactOS Console");
        }
    }
    else
    {
#endif
        ConsoleCreateUnicodeString(&Console->Title, ConsoleInfo->ConsoleTitle);
#if 0
    }
#endif
 
    /* Initialize process support */
    // InitProcessSupport(Console);
    InitializeListHead(&Console->ProcessList);
    Console->NotifiedLastCloseProcess = NULL;
    Console->NotifyLastClose = FALSE;
    Console->HasFocus = FALSE;
 
    /* Initialize pausing support */
    Console->PauseFlags = 0;
    InitializeListHead(&Console->ReadWaitQueue);
    InitializeListHead(&Console->WriteWaitQueue);
 
    /* Initialize the alias and history buffers */
    // InitAliasesHistory(Console);
    Console->Aliases = NULL;
    InitializeListHead(&Console->HistoryBuffers);
    Console->NumberOfHistoryBuffers = 0;
    Console->MaxNumberOfHistoryBuffers = ConsoleInfo->NumberOfHistoryBuffers;
    Console->HistoryBufferSize = ConsoleInfo->HistoryBufferSize;
    Console->HistoryNoDup      = ConsoleInfo->HistoryNoDup;
 
    /* Initialize the Input Line Discipline */
    // InitLineInput(Console);
    Console->LineBuffer = NULL;
    Console->LinePos = Console->LineMaxSize = Console->LineSize = 0;
    Console->LineComplete = Console->LineUpPressed = FALSE;
    // LineWakeupMask
    Console->LineInsertToggle =
    Console->InsertMode = ConsoleInfo->InsertMode;
    Console->QuickEdit  = ConsoleInfo->QuickEdit;
 
    /* Popup windows */
    InitializeListHead(&Console->PopupWindows);
 
    /* Colour table */
    RtlCopyMemory(Console->Colors, ConsoleInfo->ColorTable,
                  sizeof(ConsoleInfo->ColorTable));
 
    /* Create the Initialization Events */
    Status = NtCreateEvent(&Console->InitEvents[INIT_SUCCESS], EVENT_ALL_ACCESS,
                           NULL, NotificationEvent, FALSE);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtCreateEvent(InitEvents[INIT_SUCCESS]) failed: %lu\n", Status);
        ConDrvDeleteConsole((PCONSOLE)Console);
        ConSrvDeinitTerminal(&Terminal);
        return Status;
    }
    Status = NtCreateEvent(&Console->InitEvents[INIT_FAILURE], EVENT_ALL_ACCESS,
                           NULL, NotificationEvent, FALSE);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtCreateEvent(InitEvents[INIT_FAILURE]) failed: %lu\n", Status);
        NtClose(Console->InitEvents[INIT_SUCCESS]);
        ConDrvDeleteConsole((PCONSOLE)Console);
        ConSrvDeinitTerminal(&Terminal);
        return Status;
    }
 
    /*
     * Attach the ConSrv terminal to the console.
     * This call makes a copy of our local Terminal variable.
     */
    Status = ConDrvAttachTerminal((PCONSOLE)Console, &Terminal);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to register terminal to the given console, Status = 0x%08lx\n", Status);
        NtClose(Console->InitEvents[INIT_FAILURE]);
        NtClose(Console->InitEvents[INIT_SUCCESS]);
        ConDrvDeleteConsole((PCONSOLE)Console);
        ConSrvDeinitTerminal(&Terminal);
        return Status;
    }
    DPRINT("Terminal attached\n");
 
    /* All went right, so add the console to the list */
#if 0
    Status = ConDrvInsertConsole((PCONSOLE)Console);
    if (!NT_SUCCESS(Status))
    {
        /* Fail */
        ConDrvDeleteConsole((PCONSOLE)Console);
        return Status;
    }
#endif
    Status = InsertConsole(&ConsoleHandle, Console);
 
    // FIXME! We do not support at all asynchronous console creation!
    NtSetEvent(Console->InitEvents[INIT_SUCCESS], NULL);
    // NtSetEvent(Console->InitEvents[INIT_FAILURE], NULL);
 
    /* Return the newly created console to the caller and a success code too */
    *NewConsoleHandle = ConsoleHandle;
    *NewConsole       = Console;
    return STATUS_SUCCESS;
}

Referenced by ConSrvAllocateConsole().

ConSrvInitConsoleSupport()

VOID NTAPI ConSrvInitConsoleSupport

(

VOID

)

Definition at line 347 of file console.c.

{
    DPRINT("CONSRV: ConSrvInitConsoleSupport()\n");
 
    /* Initialize the console list and its lock */
    ConsoleListSize = 0;
    ConsoleList = NULL;
    // InitializeListHead(&ConDrvConsoleList);
    RtlInitializeResource(&ListLock);
 
    /* Should call LoadKeyboardLayout */
}

Referenced by CSR_SERVER_DLL_INIT().

ConSrvInitProcessHandles()

static NTSTATUS ConSrvInitProcessHandles ( IN OUT PCONSOLE_PROCESS_DATA  ProcessData, IN PCONSRV_CONSOLE  Console, OUT PHANDLE  pInputHandle, OUT PHANDLE  pOutputHandle, OUT PHANDLE  pErrorHandle  )

static

Definition at line 890 of file console.c.

{
    NTSTATUS Status;
    HANDLE InputHandle  = INVALID_HANDLE_VALUE,
           OutputHandle = INVALID_HANDLE_VALUE,
           ErrorHandle  = INVALID_HANDLE_VALUE;
 
    /*
     * Initialize the process handles. Use temporary variables to store
     * the handles values in such a way that, if we fail, we don't
     * return to the caller invalid handle values.
     *
     * Insert the IO handles.
     */
 
    RtlEnterCriticalSection(&ProcessData->HandleTableLock);
 
    /* Insert the Input handle */
    Status = ConSrvInsertObject(ProcessData,
                                &InputHandle,
                                &Console->InputBuffer.Header,
                                GENERIC_READ | GENERIC_WRITE,
                                TRUE,
                                FILE_SHARE_READ | FILE_SHARE_WRITE);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to insert the input handle\n");
        RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
        ConSrvFreeHandlesTable(ProcessData);
        return Status;
    }
 
    /* Insert the Output handle */
    Status = ConSrvInsertObject(ProcessData,
                                &OutputHandle,
                                &Console->ActiveBuffer->Header,
                                GENERIC_READ | GENERIC_WRITE,
                                TRUE,
                                FILE_SHARE_READ | FILE_SHARE_WRITE);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to insert the output handle\n");
        RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
        ConSrvFreeHandlesTable(ProcessData);
        return Status;
    }
 
    /* Insert the Error handle */
    Status = ConSrvInsertObject(ProcessData,
                                &ErrorHandle,
                                &Console->ActiveBuffer->Header,
                                GENERIC_READ | GENERIC_WRITE,
                                TRUE,
                                FILE_SHARE_READ | FILE_SHARE_WRITE);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to insert the error handle\n");
        RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
        ConSrvFreeHandlesTable(ProcessData);
        return Status;
    }
 
    RtlLeaveCriticalSection(&ProcessData->HandleTableLock);
 
    /* Return the newly created handles */
    *pInputHandle  = InputHandle;
    *pOutputHandle = OutputHandle;
    *pErrorHandle  = ErrorHandle;
 
    return STATUS_SUCCESS;
}

Referenced by ConSrvAllocateConsole(), and ConSrvInheritConsole().

ConSrvInitTerminal()

NTSTATUS NTAPI ConSrvInitTerminal	(	IN OUT PTERMINAL	Terminal,
		IN OUT PCONSOLE_STATE_INFO	ConsoleInfo,
		IN OUT PCONSOLE_INIT_INFO	ConsoleInitInfo,
		IN HANDLE	ConsoleLeaderProcessHandle
	)

Definition at line 204 of file terminal.c.

{
    NTSTATUS Status;
    PFRONTEND FrontEnd;
 
    /* Load a suitable frontend for the ConSrv terminal */
    FrontEnd = ConsoleAllocHeap(HEAP_ZERO_MEMORY, sizeof(*FrontEnd));
    if (!FrontEnd) return STATUS_NO_MEMORY;
 
    Status = ConSrvLoadFrontEnd(FrontEnd,
                                ConsoleInfo,
                                ConsoleInitInfo,
                                ConsoleLeaderProcessHandle);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CONSRV: Failed to initialize a frontend, Status = 0x%08lx\n", Status);
        ConsoleFreeHeap(FrontEnd);
        return Status;
    }
    DPRINT("CONSRV: Frontend initialized\n");
 
    /* Initialize the ConSrv terminal */
    Terminal->Vtbl = &ConSrvTermVtbl;
    // Terminal->Console will be initialized by ConDrvAttachTerminal
    Terminal->Context = FrontEnd; /* We store the frontend pointer in the terminal private context */
 
    return STATUS_SUCCESS;
}

Referenced by ConSrvInitConsole().

ConSrvReleaseConsole()

VOID ConSrvReleaseConsole	(	IN PCONSRV_CONSOLE	Console,
		IN BOOLEAN	IsConsoleLocked
	)

Definition at line 316 of file console.c.

{
    LONG RefCount = 0;
 
    if (!Console) return;
    // if (Console->ReferenceCount == 0) return; // This shouldn't happen
    ASSERT(Console->ReferenceCount > 0);
 
    /* The console must be locked */
    // ASSERT(Console_locked);
 
    /*
     * Decrement the reference count. Save the new value too,
     * because Console->ReferenceCount might be modified after
     * the console gets unlocked but before we check whether we
     * can destroy it.
     */
    RefCount = _InterlockedDecrement(&Console->ReferenceCount);
 
    /* Unlock the console if needed */
    if (IsConsoleLocked) LeaveCriticalSection(&Console->Lock);
 
    /* Delete the console if needed */
    if (RefCount <= 0) ConSrvDeleteConsole(Console);
}

Referenced by CON_API_NOCONSOLE(), ConSrvReleaseObject(), ConSrvRemoveConsole(), and GetThreadConsoleDesktop().

ConSrvRemoveConsole()

NTSTATUS ConSrvRemoveConsole

(

IN OUT PCONSOLE_PROCESS_DATA

ProcessData

)

Definition at line 1227 of file console.c.

{
    PCONSRV_CONSOLE Console;
    PCONSOLE_PROCESS_DATA ConsoleLeaderProcess;
 
    DPRINT("ConSrvRemoveConsole\n");
 
    /* Mark the process as not having a console anymore */
    ProcessData->ConsoleApp = FALSE;
    ProcessData->Process->Flags &= ~CsrProcessIsConsoleApp;
 
    /* Validate and lock the console */
    if (!ConSrvValidateConsole(&Console,
                               ProcessData->ConsoleHandle,
                               CONSOLE_RUNNING, TRUE))
    {
        // FIXME: Find another status code
        return STATUS_UNSUCCESSFUL;
    }
 
    DPRINT("ConSrvRemoveConsole - Locking OK\n");
 
    /* Retrieve the console leader process */
    ConsoleLeaderProcess = ConSrvGetConsoleLeaderProcess(Console);
 
    /* Close all console handles and free the handle table */
    ConSrvFreeHandlesTable(ProcessData);
 
    /* Detach the process from the console */
    ProcessData->ConsoleHandle = NULL;
 
    /* Remove the process from the console's list of processes */
    RemoveEntryList(&ProcessData->ConsoleLink);
 
    /* Check whether the console should send a last close notification */
    if (Console->NotifyLastClose)
    {
        /* If we are removing the process which wants the last close notification... */
        if (ProcessData == Console->NotifiedLastCloseProcess)
        {
            /* ... just reset the flag and the pointer... */
            Console->NotifyLastClose = FALSE;
            Console->NotifiedLastCloseProcess = NULL;
        }
        /*
         * ... otherwise, if we are removing the console leader process
         * (that cannot be the process wanting the notification, because
         * the previous case already dealt with it)...
         */
        else if (ProcessData == ConsoleLeaderProcess)
        {
            /*
             * ... reset the flag first (so that we avoid multiple notifications)
             * and then send the last close notification.
             */
            Console->NotifyLastClose = FALSE;
            ConSrvConsoleCtrlEvent(CTRL_LAST_CLOSE_EVENT, Console->NotifiedLastCloseProcess);
 
            /* Only now, reset the pointer */
            Console->NotifiedLastCloseProcess = NULL;
        }
    }
 
    /* Update the internal info of the terminal */
    TermRefreshInternalInfo(Console);
 
    /* Release the console */
    DPRINT("ConSrvRemoveConsole - Decrement Console->ReferenceCount = %lu\n", Console->ReferenceCount);
    ConSrvReleaseConsole(Console, TRUE);
 
    return STATUS_SUCCESS;
}

Referenced by CON_API_NOCONSOLE(), and ConSrvDisconnect().

ConSrvSetConsoleProcessFocus()

NTSTATUS NTAPI ConSrvSetConsoleProcessFocus	(	IN PCONSRV_CONSOLE	Console,
		IN BOOLEAN	SetForeground
	)

Definition at line 1453 of file console.c.

{
    PLIST_ENTRY current_entry;
    PCONSOLE_PROCESS_DATA current;
 
    /* If the console is already being destroyed, just return */
    if (!ConDrvValidateConsoleState((PCONSOLE)Console, CONSOLE_RUNNING))
        return STATUS_UNSUCCESSFUL;
 
    /*
     * Loop through the process list, from the most recent process
     * to the oldest one, and for each, set its foreground priority.
     */
    current_entry = Console->ProcessList.Flink;
    while (current_entry != &Console->ProcessList)
    {
        current = CONTAINING_RECORD(current_entry, CONSOLE_PROCESS_DATA, ConsoleLink);
        current_entry = current_entry->Flink;
 
        ConSrvSetProcessFocus(current->Process, SetForeground);
    }
 
    return STATUS_SUCCESS;
}

Referenced by OnFocus().

ConSrvSetProcessFocus()

VOID ConSrvSetProcessFocus	(	IN PCSR_PROCESS	CsrProcess,
		IN BOOLEAN	SetForeground
	)

Definition at line 1440 of file console.c.

{
    // FIXME: Call NtUserSetInformationProcess (currently unimplemented!)
    // for setting Win32 foreground/background flags.
 
    if (SetForeground)
        CsrSetForegroundPriority(CsrProcess);
    else
        CsrSetBackgroundPriority(CsrProcess);
}

Referenced by ConSrvAllocateConsole(), ConSrvInheritConsole(), and ConSrvSetConsoleProcessFocus().

ConSrvValidateConsole()

BOOLEAN NTAPI ConSrvValidateConsole	(	OUT PCONSRV_CONSOLE *	Console,
		IN HANDLE	ConsoleHandle,
		IN CONSOLE_STATE	ExpectedState,
		IN BOOLEAN	LockConsole
	)

Definition at line 247 of file console.c.

{
    BOOLEAN RetVal = FALSE;
    PCONSRV_CONSOLE ValidatedConsole;
 
    BOOLEAN ValidHandle = ((HandleToULong(ConsoleHandle) & 0x3) == 0x3);
    ULONG Index = HandleToULong(ConsoleHandle) >> 2;
 
    if (!ValidHandle) return FALSE;
 
    if (!Console) return FALSE;
    *Console = NULL;
 
    /*
     * Forbid creation or deletion of consoles when
     * checking for the existence of a console.
     */
    ConSrvLockConsoleListShared();
 
    if (Index >= ConsoleListSize ||
        (ValidatedConsole = ConsoleList[Index]) == NULL)
    {
        /* Unlock the console list and return */
        ConSrvUnlockConsoleList();
        return FALSE;
    }
 
    ValidatedConsole = ConsoleList[Index];
 
    /* Unlock the console list */
    ConSrvUnlockConsoleList();
 
    RetVal = ConDrvValidateConsoleUnsafe((PCONSOLE)ValidatedConsole,
                                         ExpectedState,
                                         LockConsole);
    if (RetVal) *Console = ValidatedConsole;
 
    return RetVal;
}

Referenced by ConSrvGetConsole(), ConSrvInheritConsole(), ConSrvNewProcess(), and ConSrvRemoveConsole().

CSR_API() [1/7]

CSR_API

(

SrvGetConsoleCharType

)

Definition at line 1975 of file console.c.

{
    DPRINT1("%s not yet implemented\n", __FUNCTION__);
    return STATUS_NOT_IMPLEMENTED;
}

CSR_API() [2/7]

CSR_API

(

SrvGetConsoleCursorMode

)

Definition at line 1996 of file console.c.

{
    DPRINT1("%s not yet implemented\n", __FUNCTION__);
    return STATUS_NOT_IMPLEMENTED;
}

CSR_API() [3/7]

CSR_API

(

SrvGetConsoleNlsMode

)

Definition at line 2003 of file console.c.

{
    DPRINT1("%s not yet implemented\n", __FUNCTION__);
    return STATUS_NOT_IMPLEMENTED;
}

CSR_API() [4/7]

CSR_API

(

SrvSetConsoleCursorMode

)

Definition at line 1989 of file console.c.

{
    DPRINT1("%s not yet implemented\n", __FUNCTION__);
    return STATUS_NOT_IMPLEMENTED;
}

CSR_API() [5/7]

CSR_API

(

SrvSetConsoleKeyShortcuts

)

Definition at line 1955 of file console.c.

{
    DPRINT1("%s not yet implemented\n", __FUNCTION__);
    return STATUS_NOT_IMPLEMENTED;
}

CSR_API() [6/7]

CSR_API

(

SrvSetConsoleLocalEUDC

)

Definition at line 1982 of file console.c.

{
    DPRINT1("%s not yet implemented\n", __FUNCTION__);
    return STATUS_NOT_IMPLEMENTED;
}

CSR_API() [7/7]

CSR_API

(

SrvSetConsoleNlsMode

)

Definition at line 2010 of file console.c.

{
    DPRINT1("%s not yet implemented\n", __FUNCTION__);
    return STATUS_NOT_IMPLEMENTED;
}

InsertConsole()

static NTSTATUS InsertConsole ( OUT PHANDLE  Handle, IN PCONSRV_CONSOLE  Console  )

static

Definition at line 72 of file console.c.

{
#define CONSOLE_HANDLES_INCREMENT   2 * 3
 
    NTSTATUS Status = STATUS_SUCCESS;
    ULONG i = 0;
    PCONSRV_CONSOLE* Block;
 
    ASSERT( (ConsoleList == NULL && ConsoleListSize == 0) ||
            (ConsoleList != NULL && ConsoleListSize != 0) );
 
    /* All went right, so add the console to the list */
    ConSrvLockConsoleListExclusive();
    DPRINT("Insert in the list\n");
 
    if (ConsoleList)
    {
        for (i = 0; i < ConsoleListSize; i++)
        {
            if (ConsoleList[i] == NULL) break;
        }
    }
 
    if (i >= ConsoleListSize)
    {
        DPRINT("Creation of a new handles table\n");
        /* Allocate a new handles table */
        Block = ConsoleAllocHeap(HEAP_ZERO_MEMORY,
                                 (ConsoleListSize +
                                    CONSOLE_HANDLES_INCREMENT) * sizeof(PCONSRV_CONSOLE));
        if (Block == NULL)
        {
            Status = STATUS_UNSUCCESSFUL;
            goto Quit;
        }
 
        /* If we previously had a handles table, free it and use the new one */
        if (ConsoleList)
        {
            /* Copy the handles from the old table to the new one */
            RtlCopyMemory(Block,
                          ConsoleList,
                          ConsoleListSize * sizeof(PCONSRV_CONSOLE));
            ConsoleFreeHeap(ConsoleList);
        }
        ConsoleList = Block;
        ConsoleListSize += CONSOLE_HANDLES_INCREMENT;
    }
 
    ConsoleList[i] = Console;
    *Handle = ULongToHandle((i << 2) | 0x3);
 
Quit:
    /* Unlock the console list and return status */
    ConSrvUnlockConsoleList();
    return Status;
}

Referenced by ConSrvInitConsole().

LoadShellLinkConsoleInfo()

static BOOL LoadShellLinkConsoleInfo ( IN OUT PCONSOLE_STATE_INFO  ConsoleInfo, IN OUT PCONSOLE_INIT_INFO  ConsoleInitInfo  )

static

Definition at line 370 of file console.c.

{
#define PATH_SEPARATOR L'\\'
 
    BOOL    RetVal   = FALSE;
    HRESULT hRes     = S_OK;
    SIZE_T  Length   = 0;
    LPWSTR  LinkName = NULL;
    LPWSTR  IconPath = NULL;
    WCHAR   Buffer[MAX_PATH + 1];
 
    ConsoleInitInfo->ConsoleStartInfo->IconIndex = 0;
 
    if ((ConsoleInitInfo->ConsoleStartInfo->dwStartupFlags & STARTF_TITLEISLINKNAME) == 0)
    {
        // return FALSE; // FIXME!! (for icon loading)
        RetVal = TRUE;
        goto Finish;
    }
 
    /* 1- Find the last path separator if any */
    LinkName = wcsrchr(ConsoleInfo->ConsoleTitle, PATH_SEPARATOR);
    if (LinkName == NULL)
        LinkName = ConsoleInfo->ConsoleTitle;
    else
        ++LinkName; // Skip the path separator
 
    /* 2- Check for the link extension. The name ".lnk" is considered invalid. */
    Length = wcslen(LinkName);
    if ( (Length <= 4) || (_wcsicmp(LinkName + (Length - 4), L".lnk") != 0) )
        return FALSE;
 
    /* 3- It may be a link. Try to retrieve some properties */
    hRes = CoInitialize(NULL);
    if (SUCCEEDED(hRes))
    {
        /* Get a pointer to the IShellLink interface */
        IShellLinkW* pshl = NULL;
        hRes = CoCreateInstance(&CLSID_ShellLink,
                                NULL,
                                CLSCTX_INPROC_SERVER,
                                &IID_IShellLinkW,
                                (LPVOID*)&pshl);
        if (SUCCEEDED(hRes))
        {
            /* Get a pointer to the IPersistFile interface */
            IPersistFile* ppf = NULL;
            hRes = IPersistFile_QueryInterface(pshl, &IID_IPersistFile, (LPVOID*)&ppf);
            if (SUCCEEDED(hRes))
            {
                /* Load the shortcut */
                hRes = IPersistFile_Load(ppf, ConsoleInfo->ConsoleTitle, STGM_READ);
                if (SUCCEEDED(hRes))
                {
                    /*
                     * Finally we can get the properties !
                     * Update the old ones if needed.
                     */
                    INT ShowCmd = 0;
                    // WORD HotKey = 0;
 
                    /* Reset the name of the console with the name of the shortcut */
                    Length = min(/*Length*/ Length - 4, // 4 == len(".lnk")
                                 (ConsoleInfo->cbSize - FIELD_OFFSET(CONSOLE_STATE_INFO, ConsoleTitle) - sizeof(UNICODE_NULL)) / sizeof(WCHAR));
                    wcsncpy(ConsoleInfo->ConsoleTitle, LinkName, Length);
                    ConsoleInfo->ConsoleTitle[Length] = UNICODE_NULL;
 
                    /* Get the window showing command */
                    hRes = IShellLinkW_GetShowCmd(pshl, &ShowCmd);
                    if (SUCCEEDED(hRes)) ConsoleInitInfo->ConsoleStartInfo->wShowWindow = (WORD)ShowCmd;
 
                    /* Get the hotkey */
                    // hRes = pshl->GetHotkey(&ShowCmd);
                    // if (SUCCEEDED(hRes)) ConsoleInitInfo->ConsoleStartInfo->HotKey = HotKey;
 
                    /* Get the icon location, if any */
                    hRes = IShellLinkW_GetIconLocation(pshl,
                                                       Buffer,
                                                       sizeof(Buffer)/sizeof(Buffer[0]) - 1, // == MAX_PATH
                                                       &ConsoleInitInfo->ConsoleStartInfo->IconIndex);
                    if (!SUCCEEDED(hRes))
                    {
                        ConsoleInitInfo->ConsoleStartInfo->IconIndex = 0;
                    }
                    else
                    {
                        IconPath = Buffer;
                    }
 
                    // FIXME: Since we still don't load console properties from the shortcut,
                    // return false. When this will be done, we will return true instead.
                    RetVal = TRUE; // FALSE;
                }
                IPersistFile_Release(ppf);
            }
            IShellLinkW_Release(pshl);
        }
        CoUninitialize();
    }
 
Finish:
 
    if (RetVal)
    {
        /* Get the associated icon, if any */
        if (IconPath == NULL)
        {
            // Question: How to retrieve the full path name
            // of the app we are going to run??
            Length = RtlDosSearchPath_U(ConsoleInitInfo->CurDir,
                                        ConsoleInitInfo->AppName,
                                        NULL,
                                        sizeof(Buffer),
                                        Buffer,
                                        NULL);
            if (Length > 0 && Length < sizeof(Buffer))
                IconPath = Buffer;
            else
                IconPath = ConsoleInitInfo->AppName;
 
            // ConsoleInitInfo->ConsoleStartInfo->IconIndex = 0;
        }
        DPRINT("IconPath = '%S' ; IconIndex = %lu\n",
               IconPath, ConsoleInitInfo->ConsoleStartInfo->IconIndex);
        if (IconPath && *IconPath)
        {
            HICON hIcon = NULL, hIconSm = NULL;
            /*
             * FIXME!! Because of a strange bug we have in PrivateExtractIconExW
             * (see r65683 for more details), we cannot use this API to extract
             * at the same time the large and small icons from the app.
             * Instead we just use PrivateExtractIconsW.
             *
            PrivateExtractIconExW(IconPath,
                                  ConsoleInitInfo->ConsoleStartInfo->IconIndex,
                                  &hIcon,
                                  &hIconSm,
                                  1);
             */
            PrivateExtractIconsW(IconPath,
                                 ConsoleInitInfo->ConsoleStartInfo->IconIndex,
                                 32, 32,
                                 &hIcon, NULL, 1, LR_COPYFROMRESOURCE);
            PrivateExtractIconsW(IconPath,
                                 ConsoleInitInfo->ConsoleStartInfo->IconIndex,
                                 16, 16,
                                 &hIconSm, NULL, 1, LR_COPYFROMRESOURCE);
 
            DPRINT("hIcon = 0x%p ; hIconSm = 0x%p\n", hIcon, hIconSm);
            if (hIcon   != NULL) ConsoleInitInfo->ConsoleStartInfo->hIcon   = hIcon;
            if (hIconSm != NULL) ConsoleInitInfo->ConsoleStartInfo->hIconSm = hIconSm;
        }
    }
 
    // FIXME: See the previous FIXME above.
    RetVal = FALSE;
 
    return RetVal;
}

Referenced by ConSrvInitConsole().

RemoveConsoleByPointer()

static NTSTATUS RemoveConsoleByPointer ( IN PCONSRV_CONSOLE  Console )

static

Definition at line 168 of file console.c.

{
    ULONG i = 0;
 
    if (!Console) return STATUS_INVALID_PARAMETER;
 
    ASSERT( (ConsoleList == NULL && ConsoleListSize == 0) ||
            (ConsoleList != NULL && ConsoleListSize != 0) );
 
    /* Remove the console from the list */
    ConSrvLockConsoleListExclusive();
 
    if (ConsoleList)
    {
        for (i = 0; i < ConsoleListSize; i++)
        {
            if (ConsoleList[i] == Console) ConsoleList[i] = NULL;
        }
    }
 
    /* Unlock the console list and return */
    ConSrvUnlockConsoleList();
    return STATUS_SUCCESS;
}

Referenced by ConSrvDeleteConsole().

Variable Documentation

ConsoleList

PCONSRV_CONSOLE* ConsoleList

static

Definition at line 34 of file console.c.

Referenced by ConSrvInitConsoleSupport(), ConSrvValidateConsole(), InsertConsole(), and RemoveConsoleByPointer().

ConsoleListSize

ULONG ConsoleListSize

static

Definition at line 33 of file console.c.

Referenced by ConSrvInitConsoleSupport(), ConSrvValidateConsole(), InsertConsole(), and RemoveConsoleByPointer().

ListLock

RTL_RESOURCE ListLock

static

Definition at line 36 of file console.c.

Referenced by ConSrvInitConsoleSupport().