console.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	HANDLE_DETACHED_PROCESS   (HANDLE)-1
#define	HANDLE_CREATE_NEW_CONSOLE   (HANDLE)-2
#define	HANDLE_CREATE_NO_WINDOW   (HANDLE)-3

Functions
BOOLEAN WINAPI	ConDllInitialize (IN ULONG Reason, IN PWSTR SessionDir)
VOID	InitializeCtrlHandling (VOID)
DWORD WINAPI	ConsoleControlDispatcher (IN LPVOID lpThreadParameter)
DWORD WINAPI	PropDialogHandler (IN LPVOID lpThreadParameter)
BOOL WINAPI	GetConsoleHandleInformation (IN HANDLE hHandle, OUT LPDWORD lpdwFlags)
BOOL WINAPI	SetConsoleHandleInformation (IN HANDLE hHandle, IN DWORD dwMask, IN DWORD dwFlags)
HANDLE	TranslateStdHandle (HANDLE hHandle)
VOID	SetTEBLangID (VOID)
	Internal helper function used to synchronize the current thread's language ID with the one from the console.
VOID	SetUpConsoleInfo (IN BOOLEAN CaptureTitle, IN OUT LPDWORD pTitleLength, IN OUT LPWSTR *lpTitle OPTIONAL, IN OUT LPDWORD pDesktopLength, IN OUT LPWSTR *lpDesktop OPTIONAL, IN OUT PCONSOLE_START_INFO ConsoleStartInfo)
VOID	SetUpHandles (IN PCONSOLE_START_INFO ConsoleStartInfo)
VOID	InitExeName (VOID)
VOID	SetUpAppName (IN BOOLEAN CaptureStrings, IN OUT LPDWORD CurDirLength, IN OUT LPWSTR *CurDir, IN OUT LPDWORD AppNameLength, IN OUT LPWSTR *AppName)
USHORT	GetCurrentExeName (OUT PWCHAR ExeName, IN USHORT BufferSize)
LPCWSTR	IntCheckForConsoleFileName (IN LPCWSTR pszName, IN DWORD dwDesiredAccess)

Macro Definition Documentation

HANDLE_CREATE_NEW_CONSOLE

#define HANDLE_CREATE_NEW_CONSOLE   (HANDLE)-2

Definition at line 14 of file console.h.

HANDLE_CREATE_NO_WINDOW

#define HANDLE_CREATE_NO_WINDOW   (HANDLE)-3

Definition at line 15 of file console.h.

HANDLE_DETACHED_PROCESS

#define HANDLE_DETACHED_PROCESS   (HANDLE)-1

Definition at line 13 of file console.h.

Function Documentation

ConDllInitialize()

BOOLEAN WINAPI ConDllInitialize	(	IN ULONG	Reason,
		IN PWSTR	SessionDir
	)

Definition at line 550 of file init.c.

{
    NTSTATUS Status;
    PRTL_USER_PROCESS_PARAMETERS Parameters = NtCurrentPeb()->ProcessParameters;
    BOOLEAN InServerProcess = FALSE;
    CONSRV_API_CONNECTINFO ConnectInfo;
 
    if (Reason != DLL_PROCESS_ATTACH)
    {
        if ((Reason == DLL_THREAD_ATTACH) && IsConsoleApp())
        {
            /* Sync the new thread's LangId with the console's one */
            SetTEBLangID();
        }
        else if (Reason == DLL_PROCESS_DETACH)
        {
            /* Free our resources */
            if (ConsoleInitialized != FALSE)
            {
                ConsoleInitialized = FALSE;
                RtlDeleteCriticalSection(&ConsoleLock);
            }
        }
 
        return TRUE;
    }
 
    DPRINT("ConDllInitialize for: %wZ\n"
           "Our current console handles are: 0x%p, 0x%p, 0x%p 0x%p\n",
           &Parameters->ImagePathName,
           Parameters->ConsoleHandle,
           Parameters->StandardInput,
           Parameters->StandardOutput,
           Parameters->StandardError);
 
    /* Initialize our global console DLL lock */
    Status = RtlInitializeCriticalSection(&ConsoleLock);
    if (!NT_SUCCESS(Status)) return FALSE;
    ConsoleInitialized = TRUE;
 
    /* Show by default the console window when applicable */
    ConnectInfo.IsWindowVisible = TRUE;
    /* If this is a console app, a console will be created/opened */
    ConnectInfo.IsConsoleApp = IsConsoleApp();
 
    /* Do nothing if this is not a console app... */
    if (!ConnectInfo.IsConsoleApp)
    {
        DPRINT("Image is not a console application\n");
    }
 
    /*
     * Handle the special flags given to us by BasePushProcessParameters.
     */
    if (Parameters->ConsoleHandle == HANDLE_DETACHED_PROCESS)
    {
        /* No console to create */
        DPRINT("No console to create\n");
        /*
         * The new process does not inherit its parent's console and cannot
         * attach to the console of its parent. The new process can call the
         * AllocConsole function at a later time to create a console.
         */
        Parameters->ConsoleHandle = NULL;  // Do not inherit the parent's console.
        ConnectInfo.IsConsoleApp  = FALSE; // Do not create any console.
    }
    else if (Parameters->ConsoleHandle == HANDLE_CREATE_NEW_CONSOLE)
    {
        /* We'll get the real one soon */
        DPRINT("Creating a new separate console\n");
        /*
         * The new process has a new console, instead of inheriting
         * its parent's console.
         */
        Parameters->ConsoleHandle = NULL; // Do not inherit the parent's console.
    }
    else if (Parameters->ConsoleHandle == HANDLE_CREATE_NO_WINDOW)
    {
        /* We'll get the real one soon */
        DPRINT("Creating a new invisible console\n");
        /*
         * The process is a console application that is being run
         * without a console window. Therefore, the console handle
         * for the application is not set.
         */
        Parameters->ConsoleHandle   = NULL;  // Do not inherit the parent's console.
        ConnectInfo.IsWindowVisible = FALSE; // A console is created but is not shown to the user.
    }
    else
    {
        DPRINT("Using existing console: 0x%p\n", Parameters->ConsoleHandle);
    }
 
    /* Do nothing if this is not a console app... */
    if (!ConnectInfo.IsConsoleApp)
    {
        /* Do not inherit the parent's console if we are not a console app */
        Parameters->ConsoleHandle = NULL;
    }
 
    /* Now use the proper console handle */
    ConnectInfo.ConsoleStartInfo.ConsoleHandle = Parameters->ConsoleHandle;
 
    /* Initialize the console dispatchers */
    ConnectInfo.CtrlRoutine = ConsoleControlDispatcher;
    ConnectInfo.PropRoutine = PropDialogHandler;
    ConnectInfo.ImeRoutine  = ConsoleIMERoutine;
 
    /* Set up the console properties */
    if (ConnectInfo.IsConsoleApp && Parameters->ConsoleHandle == NULL)
    {
        /*
         * We can set up the console properties only if we create a new one
         * (we do not inherit it from our parent).
         */
 
        LPWSTR ConsoleTitle = ConnectInfo.ConsoleTitle;
 
        ConnectInfo.TitleLength   = sizeof(ConnectInfo.ConsoleTitle);
        ConnectInfo.DesktopLength = 0; // SetUpConsoleInfo will give us the real length.
 
        SetUpConsoleInfo(TRUE,
                         &ConnectInfo.TitleLength,
                         &ConsoleTitle,
                         &ConnectInfo.DesktopLength,
                         &ConnectInfo.Desktop,
                         &ConnectInfo.ConsoleStartInfo);
        DPRINT("ConsoleTitle = '%S' - Desktop = '%S'\n",
               ConsoleTitle, ConnectInfo.Desktop);
    }
    else
    {
        ConnectInfo.TitleLength   = 0;
        ConnectInfo.DesktopLength = 0;
    }
 
    /* Initialize the Input EXE name */
    if (ConnectInfo.IsConsoleApp)
    {
        LPWSTR CurDir  = ConnectInfo.CurDir;
        LPWSTR AppName = ConnectInfo.AppName;
 
        InitExeName();
 
        ConnectInfo.CurDirLength  = sizeof(ConnectInfo.CurDir);
        ConnectInfo.AppNameLength = sizeof(ConnectInfo.AppName);
 
        SetUpAppName(TRUE,
                     &ConnectInfo.CurDirLength,
                     &CurDir,
                     &ConnectInfo.AppNameLength,
                     &AppName);
        DPRINT("CurDir = '%S' - AppName = '%S'\n",
               CurDir, AppName);
    }
    else
    {
        ConnectInfo.CurDirLength  = 0;
        ConnectInfo.AppNameLength = 0;
    }
 
    /*
     * Initialize Console Ctrl Handling, that needs to be supported by
     * all applications, especially because it is used at shutdown.
     */
    InitializeCtrlHandling();
 
    /* Connect to the Console Server */
    if (!ConnectConsole(SessionDir,
                        &ConnectInfo,
                        &InServerProcess))
    {
        // DPRINT1("Failed to connect to the Console Server (Status %lx)\n", Status);
        return FALSE;
    }
 
    /* If we are not doing server-to-server init and if this is a console app... */
    if (!InServerProcess && ConnectInfo.IsConsoleApp)
    {
        /* ... set the handles that we got */
        if (Parameters->ConsoleHandle == NULL)
            SetUpHandles(&ConnectInfo.ConsoleStartInfo);
 
        InputWaitHandle = ConnectInfo.ConsoleStartInfo.InputWaitHandle;
 
        /* Sync the current thread's LangId with the console's one */
        SetTEBLangID();
    }
 
    DPRINT("Console setup: 0x%p, 0x%p, 0x%p, 0x%p\n",
           Parameters->ConsoleHandle,
           Parameters->StandardInput,
           Parameters->StandardOutput,
           Parameters->StandardError);
 
    return TRUE;
}

Referenced by DllMain().

ConsoleControlDispatcher()

DWORD WINAPI ConsoleControlDispatcher

(

IN LPVOID

lpThreadParameter

)

Definition at line 89 of file console.c.

{
    DWORD nExitCode = 0;
    DWORD CodeAndFlag = PtrToUlong(lpThreadParameter);
    DWORD nCode = CodeAndFlag & MAXLONG;
    UINT i;
    EXCEPTION_RECORD erException;
 
    DPRINT1("Console Dispatcher Active: %lx %lx\n", CodeAndFlag, nCode);
    SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);
 
    switch(nCode)
    {
        case CTRL_C_EVENT:
        case CTRL_BREAK_EVENT:
        {
            if (IsDebuggerPresent())
            {
                erException.ExceptionCode = (nCode == CTRL_C_EVENT ?
                                             DBG_CONTROL_C : DBG_CONTROL_BREAK);
                erException.ExceptionFlags = 0;
                erException.ExceptionRecord = NULL;
                erException.ExceptionAddress = DefaultConsoleCtrlHandler;
                erException.NumberParameters = 0;
 
                _SEH2_TRY
                {
                    RtlRaiseException(&erException);
                }
                _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
                {
                    RtlEnterCriticalSection(&ConsoleLock);
 
                    if ((nCode != CTRL_C_EVENT) ||
                        (NtCurrentPeb()->ProcessParameters->ConsoleFlags != 1))
                    {
                        for (i = NrCtrlHandlers; i > 0; i--)
                        {
                            if (CtrlHandlers[i - 1](nCode)) break;
                        }
                    }
 
                    RtlLeaveCriticalSection(&ConsoleLock);
                }
                _SEH2_END;
 
                ExitThread(0);
            }
            break;
        }
 
        case CTRL_CLOSE_EVENT:
        case CTRL_LOGOFF_EVENT:
        case CTRL_SHUTDOWN_EVENT:
            break;
 
        case CTRL_LAST_CLOSE_EVENT:
            /*
             * In case the console app hasn't register for last close notification,
             * just kill this console handler thread. We don't want that such apps
             * get killed for unexpected reasons. On the contrary apps that registered
             * can be killed because they expect to be.
             */
            if (!LastCloseNotify) ExitThread(0);
            break;
 
        case 4:
            ExitProcess(CONTROL_C_EXIT);
            break;
 
        default:
            ASSERT(FALSE);
            break;
    }
 
    ASSERT(ConsoleInitialized);
 
    RtlEnterCriticalSection(&ConsoleLock);
 
    nExitCode = 0;
    if ((nCode != CTRL_C_EVENT) || (NtCurrentPeb()->ProcessParameters->ConsoleFlags != 1))
    {
        for (i = NrCtrlHandlers; i > 0; i--)
        {
            if ((i == 1) &&
                (CodeAndFlag & MINLONG) &&
                ((nCode == CTRL_LOGOFF_EVENT) || (nCode == CTRL_SHUTDOWN_EVENT)))
            {
                DPRINT("Skipping system/service apps\n");
                break;
            }
 
            if (CtrlHandlers[i - 1](nCode))
            {
                switch(nCode)
                {
                    case CTRL_CLOSE_EVENT:
                    case CTRL_LAST_CLOSE_EVENT:
                    case CTRL_LOGOFF_EVENT:
                    case CTRL_SHUTDOWN_EVENT:
                        nExitCode = CodeAndFlag;
                        break;
                }
                break;
            }
        }
    }
 
    RtlLeaveCriticalSection(&ConsoleLock);
 
    ExitThread(nExitCode);
    return STATUS_SUCCESS;
}

Referenced by AllocConsole(), AttachConsole(), and ConDllInitialize().

GetConsoleHandleInformation()

BOOL WINAPI GetConsoleHandleInformation	(	IN HANDLE	hHandle,
		OUT LPDWORD	lpdwFlags
	)

Definition at line 465 of file console.c.

{
    CONSOLE_API_MESSAGE ApiMessage;
    PCONSOLE_GETHANDLEINFO GetHandleInfoRequest = &ApiMessage.Data.GetHandleInfoRequest;
 
    GetHandleInfoRequest->ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
    GetHandleInfoRequest->Handle        = hHandle;
 
    CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
                        NULL,
                        CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepGetHandleInformation),
                        sizeof(*GetHandleInfoRequest));
    if (!NT_SUCCESS(ApiMessage.Status))
    {
        BaseSetLastNTError(ApiMessage.Status);
        return FALSE;
    }
 
    *lpdwFlags = GetHandleInfoRequest->Flags;
 
    return TRUE;
}

Referenced by GetHandleInformation().

GetCurrentExeName()

USHORT GetCurrentExeName	(	OUT PWCHAR	ExeName,
		IN USHORT	BufferSize
	)

Definition at line 316 of file console.c.

{
    USHORT ExeLength;
 
    if (ExeNameInitialized)
    {
        RtlEnterCriticalSection(&ExeNameLock);
 
        if (BufferSize > ExeNameLength * sizeof(WCHAR))
            BufferSize = ExeNameLength * sizeof(WCHAR);
 
        RtlCopyMemory(ExeName, ExeNameBuffer, BufferSize);
 
        RtlLeaveCriticalSection(&ExeNameLock);
        ExeLength = BufferSize;
    }
    else
    {
        *ExeName  = UNICODE_NULL;
        ExeLength = 0;
    }
 
    return ExeLength;
}

Referenced by IntReadConsole().

InitExeName()

VOID InitExeName

(

VOID

)

Definition at line 216 of file console.c.

{
    NTSTATUS Status;
    PPEB Peb = NtCurrentPeb();
    PCURDIR CurrentDirectory = &Peb->ProcessParameters->CurrentDirectory;
    PLDR_DATA_TABLE_ENTRY ImageEntry;
 
    if (ExeNameInitialized) return;
 
    /* Initialize the EXE name lock */
    Status = RtlInitializeCriticalSection(&ExeNameLock);
    if (!NT_SUCCESS(Status)) return;
    ExeNameInitialized = TRUE;
 
    ImageEntry = CONTAINING_RECORD(Peb->Ldr->InLoadOrderModuleList.Flink,
                                   LDR_DATA_TABLE_ENTRY,
                                   InLoadOrderLinks);
 
    /* Retrieve the EXE name, NULL-terminate it... */
    ExeNameLength = min(sizeof(ExeNameBuffer)/sizeof(ExeNameBuffer[0]),
                        ImageEntry->BaseDllName.Length / sizeof(WCHAR));
    RtlCopyMemory(ExeNameBuffer,
                  ImageEntry->BaseDllName.Buffer,
                  ImageEntry->BaseDllName.Length);
    ExeNameBuffer[ExeNameLength] = UNICODE_NULL;
 
    /* ... and retrieve the current directory path and NULL-terminate it. */
    StartDirLength = min(sizeof(StartDirBuffer)/sizeof(StartDirBuffer[0]),
                         CurrentDirectory->DosPath.Length / sizeof(WCHAR));
    RtlCopyMemory(StartDirBuffer,
                  CurrentDirectory->DosPath.Buffer,
                  CurrentDirectory->DosPath.Length);
    StartDirBuffer[StartDirLength] = UNICODE_NULL;
}

Referenced by AllocConsole(), and ConDllInitialize().

InitializeCtrlHandling()

VOID InitializeCtrlHandling

(

VOID

)

Definition at line 204 of file console.c.

{
    /* Initialize Console Ctrl Handler */
    NrAllocatedHandlers = NrCtrlHandlers = 1;
    CtrlHandlers = InitialHandler;
    CtrlHandlers[0] = DefaultConsoleCtrlHandler;
}

Referenced by AllocConsole(), AttachConsole(), and ConDllInitialize().

IntCheckForConsoleFileName()

LPCWSTR IntCheckForConsoleFileName	(	IN LPCWSTR	pszName,
		IN DWORD	dwDesiredAccess
	)

Definition at line 345 of file console.c.

{
    LPCWSTR ConsoleName = pszName;
    ULONG DeviceNameInfo;
 
    /*
     * Check whether we deal with a DOS device, and if so,
     * strip the path till the file name.
     * Therefore, things like \\.\CON or C:\some_path\CONIN$
     * are transformed into CON or CONIN$, for example.
     */
    DeviceNameInfo = RtlIsDosDeviceName_U(pszName);
    if (DeviceNameInfo != 0)
    {
        ConsoleName = (LPCWSTR)((ULONG_PTR)ConsoleName + ((DeviceNameInfo >> 16) & 0xFFFF));
    }
 
    /* Return a standard console "file" name according to what we passed in parameters */
    if (_wcsicmp(ConsoleName, BaseConInputFileName) == 0)
    {
        return BaseConInputFileName;
    }
    else if (_wcsicmp(ConsoleName, BaseConOutputFileName) == 0)
    {
        return BaseConOutputFileName;
    }
    else if (_wcsicmp(ConsoleName, BaseConFileName) == 0)
    {
        if ((dwDesiredAccess & (GENERIC_READ | GENERIC_WRITE)) == GENERIC_READ)
        {
            return BaseConInputFileName;
        }
        else if ((dwDesiredAccess & (GENERIC_READ | GENERIC_WRITE)) == GENERIC_WRITE)
        {
            return BaseConOutputFileName;
        }
    }
 
    /* If we are there, that means that either the file name or the desired access are wrong */
    return NULL;
}

Referenced by CreateFileW().

PropDialogHandler()

DWORD WINAPI PropDialogHandler

(

IN LPVOID

lpThreadParameter

)

Definition at line 35 of file init.c.

{
    // NOTE: lpThreadParameter corresponds to the client shared section handle.
 
    NTSTATUS Status = STATUS_SUCCESS;
    HMODULE hConsoleApplet = NULL;
    APPLET_PROC CPlApplet;
    static BOOL AlreadyDisplayingProps = FALSE;
    WCHAR szBuffer[MAX_PATH];
 
    /*
     * Do not launch more than once the console property dialog applet,
     * or (albeit less probable), if we are not initialized.
     */
    if (!ConsoleInitialized || AlreadyDisplayingProps)
    {
        /* Close the associated client shared section handle if needed */
        if (lpThreadParameter)
            CloseHandle((HANDLE)lpThreadParameter);
 
        return STATUS_UNSUCCESSFUL;
    }
 
    AlreadyDisplayingProps = TRUE;
 
    /* Load the control applet */
    GetSystemDirectoryW(szBuffer, MAX_PATH);
    wcscat(szBuffer, L"\\console.dll");
    hConsoleApplet = LoadLibraryW(szBuffer);
    if (hConsoleApplet == NULL)
    {
        DPRINT1("Failed to load console.dll\n");
        Status = STATUS_UNSUCCESSFUL;
        goto Quit;
    }
 
    /* Load its main function */
    CPlApplet = (APPLET_PROC)GetProcAddress(hConsoleApplet, "CPlApplet");
    if (CPlApplet == NULL)
    {
        DPRINT1("Error: console.dll misses CPlApplet export\n");
        Status = STATUS_UNSUCCESSFUL;
        goto Quit;
    }
 
    /* Initialize the applet */
    if (CPlApplet(NULL, CPL_INIT, 0, 0) == FALSE)
    {
        DPRINT1("Error: failed to initialize console.dll\n");
        Status = STATUS_UNSUCCESSFUL;
        goto Quit;
    }
 
    /* Check the count */
    if (CPlApplet(NULL, CPL_GETCOUNT, 0, 0) != 1)
    {
        DPRINT1("Error: console.dll returned unexpected CPL count\n");
        Status = STATUS_UNSUCCESSFUL;
        goto Quit;
    }
 
    /*
     * Start the applet. For Windows compatibility purposes we need
     * to pass the client shared section handle (lpThreadParameter)
     * via the hWnd parameter of the CPlApplet function.
     */
    CPlApplet((HWND)lpThreadParameter, CPL_DBLCLK, 0, 0);
 
    /* We have finished */
    CPlApplet(NULL, CPL_EXIT, 0, 0);
 
Quit:
    if (hConsoleApplet) FreeLibrary(hConsoleApplet);
    AlreadyDisplayingProps = FALSE;
    return Status;
}

Referenced by AllocConsole(), AttachConsole(), and ConDllInitialize().

SetConsoleHandleInformation()

BOOL WINAPI SetConsoleHandleInformation	(	IN HANDLE	hHandle,
		IN DWORD	dwMask,
		IN DWORD	dwFlags
	)

Definition at line 495 of file console.c.

{
    CONSOLE_API_MESSAGE ApiMessage;
    PCONSOLE_SETHANDLEINFO SetHandleInfoRequest = &ApiMessage.Data.SetHandleInfoRequest;
 
    SetHandleInfoRequest->ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
    SetHandleInfoRequest->Handle        = hHandle;
    SetHandleInfoRequest->Mask          = dwMask;
    SetHandleInfoRequest->Flags         = dwFlags;
 
    CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
                        NULL,
                        CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepSetHandleInformation),
                        sizeof(*SetHandleInfoRequest));
    if (!NT_SUCCESS(ApiMessage.Status))
    {
        BaseSetLastNTError(ApiMessage.Status);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by SetHandleInformation().

SetTEBLangID()

VOID SetTEBLangID

(

VOID

)

Internal helper function used to synchronize the current thread's language ID with the one from the console.

Definition at line 3177 of file console.c.

{
    CONSOLE_API_MESSAGE ApiMessage;
    PCONSOLE_GETLANGID LangIdRequest = &ApiMessage.Data.LangIdRequest;
 
    /* Retrieve the "best-suited" language ID corresponding
     * to the active console output code page. */
    LangIdRequest->ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
 
    CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
                        NULL,
                        CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepGetLangId),
                        sizeof(*LangIdRequest));
    if (!NT_SUCCESS(ApiMessage.Status))
    {
        /*
         * No best console language ID: keep the current thread's one.
         * Since this internal function only modifies an optional setting,
         * don't set any last error, as it could otherwise mess with the
         * main last error set by the caller.
         */
        return;
    }
 
    /*
     * We succeeded, set the current thread's language ID by
     * modifying its locale -- Windows <= 2003 does not have
     * the concept of a separate thread UI language.
     * Ignore the returned value.
     */
    if (!SetThreadLocale(MAKELCID(LangIdRequest->LangId, SORT_DEFAULT)))
    {
        DPRINT1("SetTEBLangID: Could not set thread locale to console lang ID %lu\n",
                LangIdRequest->LangId);
    }
}

Referenced by AllocConsole(), AttachConsole(), ConDllInitialize(), and SetConsoleOutputCP().

SetUpAppName()

VOID SetUpAppName	(	IN BOOLEAN	CaptureStrings,
		IN OUT LPDWORD	CurDirLength,
		IN OUT LPWSTR *	CurDir,
		IN OUT LPDWORD	AppNameLength,
		IN OUT LPWSTR *	AppName
	)

Definition at line 264 of file console.c.

{
    DWORD Length;
 
    /* Retrieve the needed buffer size */
    Length = (StartDirLength + 1) * sizeof(WCHAR);
    if (*CurDirLength > 0) Length = min(Length, *CurDirLength);
    *CurDirLength = Length;
 
    /* Capture the data if needed, or, return a pointer to it */
    if (CaptureStrings)
    {
        /*
         * Length is always >= sizeof(WCHAR). Copy everything but the
         * possible trailing NULL character, and then NULL-terminate.
         */
        Length -= sizeof(WCHAR);
        RtlCopyMemory(*CurDir, StartDirBuffer, Length);
        (*CurDir)[Length / sizeof(WCHAR)] = UNICODE_NULL;
    }
    else
    {
        *CurDir = StartDirBuffer;
    }
 
    /* Retrieve the needed buffer size */
    Length = (ExeNameLength + 1) * sizeof(WCHAR);
    if (*AppNameLength > 0) Length = min(Length, *AppNameLength);
    *AppNameLength = Length;
 
    /* Capture the data if needed, or, return a pointer to it */
    if (CaptureStrings)
    {
        /*
         * Length is always >= sizeof(WCHAR). Copy everything but the
         * possible trailing NULL character, and then NULL-terminate.
         */
        Length -= sizeof(WCHAR);
        RtlCopyMemory(*AppName, ExeNameBuffer, Length);
        (*AppName)[Length / sizeof(WCHAR)] = UNICODE_NULL;
    }
    else
    {
        *AppName = ExeNameBuffer;
    }
}

Referenced by AllocConsole(), and ConDllInitialize().

SetUpConsoleInfo()

VOID SetUpConsoleInfo	(	IN BOOLEAN	CaptureTitle,
		IN OUT LPDWORD	pTitleLength,
		IN OUT LPWSTR *lpTitle	OPTIONAL,
		IN OUT LPDWORD	pDesktopLength,
		IN OUT LPWSTR *lpDesktop	OPTIONAL,
		IN OUT PCONSOLE_START_INFO	ConsoleStartInfo
	)

Definition at line 135 of file init.c.

{
    PRTL_USER_PROCESS_PARAMETERS Parameters = NtCurrentPeb()->ProcessParameters;
    DWORD Length;
 
    /* Initialize the fields */
 
    ConsoleStartInfo->IconIndex = 0;
    ConsoleStartInfo->hIcon   = NULL;
    ConsoleStartInfo->hIconSm = NULL;
    ConsoleStartInfo->dwStartupFlags = Parameters->WindowFlags;
    ConsoleStartInfo->nFont = 0;
    ConsoleStartInfo->nInputBufferSize = 0;
    ConsoleStartInfo->uCodePage = GetOEMCP();
 
    if (lpTitle)
    {
        LPWSTR Title;
 
        /* If we don't have any title, use the default one */
        if (Parameters->WindowTitle.Buffer == NULL)
        {
            Title  = DefaultConsoleTitle;
            Length = lstrlenW(DefaultConsoleTitle) * sizeof(WCHAR); // sizeof(DefaultConsoleTitle);
        }
        else
        {
            Title  = Parameters->WindowTitle.Buffer;
            Length = Parameters->WindowTitle.Length;
        }
 
        /* Retrieve the needed buffer size */
        Length += sizeof(WCHAR);
        if (*pTitleLength > 0) Length = min(Length, *pTitleLength);
        *pTitleLength = Length;
 
        /* Capture the data if needed, or, return a pointer to it */
        if (CaptureTitle)
        {
            /*
             * Length is always >= sizeof(WCHAR). Copy everything but the
             * possible trailing NULL character, and then NULL-terminate.
             */
            Length -= sizeof(WCHAR);
            RtlCopyMemory(*lpTitle, Title, Length);
            (*lpTitle)[Length / sizeof(WCHAR)] = UNICODE_NULL;
        }
        else
        {
            *lpTitle = Title;
        }
    }
    else
    {
        *pTitleLength = 0;
    }
 
    if (lpDesktop && Parameters->DesktopInfo.Buffer && *Parameters->DesktopInfo.Buffer)
    {
        /* Retrieve the needed buffer size */
        Length = Parameters->DesktopInfo.Length + sizeof(WCHAR);
        if (*pDesktopLength > 0) Length = min(Length, *pDesktopLength);
        *pDesktopLength = Length;
 
        /* Return a pointer to the data */
        *lpDesktop = Parameters->DesktopInfo.Buffer;
    }
    else
    {
        *pDesktopLength = 0;
        if (lpDesktop) *lpDesktop = NULL;
    }
 
    if (Parameters->WindowFlags & STARTF_USEFILLATTRIBUTE)
    {
        ConsoleStartInfo->wFillAttribute = (WORD)Parameters->FillAttribute;
    }
    if (Parameters->WindowFlags & STARTF_USECOUNTCHARS)
    {
        ConsoleStartInfo->dwScreenBufferSize.X = (SHORT)Parameters->CountCharsX;
        ConsoleStartInfo->dwScreenBufferSize.Y = (SHORT)Parameters->CountCharsY;
    }
    if (Parameters->WindowFlags & STARTF_USESHOWWINDOW)
    {
        ConsoleStartInfo->wShowWindow = (WORD)Parameters->ShowWindowFlags;
    }
    if (Parameters->WindowFlags & STARTF_USEPOSITION)
    {
        ConsoleStartInfo->dwWindowOrigin.X = (SHORT)Parameters->StartingX;
        ConsoleStartInfo->dwWindowOrigin.Y = (SHORT)Parameters->StartingY;
    }
    if (Parameters->WindowFlags & STARTF_USESIZE)
    {
        ConsoleStartInfo->dwWindowSize.X = (SHORT)Parameters->CountX;
        ConsoleStartInfo->dwWindowSize.Y = (SHORT)Parameters->CountY;
    }
 
    /* Get shell information (ShellInfo.Buffer is NULL-terminated) */
    if (Parameters->ShellInfo.Buffer != NULL)
    {
        ConsoleStartInfo->IconIndex = ParseShellInfo(Parameters->ShellInfo.Buffer, L"dde.");
 
        if ((Parameters->WindowFlags & STARTF_USEHOTKEY) == 0)
            ConsoleStartInfo->dwHotKey = ParseShellInfo(Parameters->ShellInfo.Buffer, L"hotkey.");
        else
            ConsoleStartInfo->dwHotKey = HandleToUlong(Parameters->StandardInput);
    }
}

Referenced by AllocConsole(), AttachConsole(), and ConDllInitialize().

SetUpHandles()

VOID SetUpHandles

(

IN PCONSOLE_START_INFO

ConsoleStartInfo

)

Definition at line 251 of file init.c.

{
    PRTL_USER_PROCESS_PARAMETERS Parameters = NtCurrentPeb()->ProcessParameters;
 
    if (ConsoleStartInfo->dwStartupFlags & STARTF_USEHOTKEY)
    {
        Parameters->WindowFlags &= ~STARTF_USEHOTKEY;
    }
    if (ConsoleStartInfo->dwStartupFlags & STARTF_SHELLPRIVATE)
    {
        Parameters->WindowFlags &= ~STARTF_SHELLPRIVATE;
    }
 
    /* We got the handles, let's set them */
    Parameters->ConsoleHandle = ConsoleStartInfo->ConsoleHandle;
 
    if ((ConsoleStartInfo->dwStartupFlags & STARTF_USESTDHANDLES) == 0)
    {
        Parameters->StandardInput  = ConsoleStartInfo->InputHandle;
        Parameters->StandardOutput = ConsoleStartInfo->OutputHandle;
        Parameters->StandardError  = ConsoleStartInfo->ErrorHandle;
    }
}

Referenced by AllocConsole(), AttachConsole(), and ConDllInitialize().

TranslateStdHandle()

HANDLE TranslateStdHandle

(

HANDLE

hHandle

)