dllinit.c File Reference

#include "precomp.h"
#include <cpl.h>

Go to the source code of this file.

Defines
#define	DEFAULT_WINDOW_TITLE   (L"Command Prompt")
#define	MAX_SESSION_PATH   256
#define	SESSION_ROOT   L"\\Sessions"
Functions
DWORD	CtrlRoutine (IN LPVOID lpThreadParameter)
DWORD	PropRoutine (IN LPVOID lpThreadParameter)
VOID	InitExeName (VOID)
BOOLEAN	ConsoleApp (VOID)
VOID	SetUpAppName (IN OUT LPDWORD CurDirLength, OUT LPWSTR CurDir, IN OUT LPDWORD AppNameLength, OUT LPWSTR AppName)
ULONG	ParseReserved (WCHAR *pchReserved, WCHAR *pchFind)
VOID	SetUpConsoleInfo (IN BOOL DllInit, OUT LPDWORD TitleLength, OUT LPWSTR Title OPTIONAL, OUT LPDWORD DesktopLength, OUT LPWSTR *Desktop OPTIONAL, OUT PCONSOLE_INFO ConsoleInfo)
VOID	SetUpHandles (IN PCONSOLE_INFO ConsoleInfo)
BOOL WINAPI	GetConsoleLangId (OUT LANGID *lpLangId)
	defined(BUILD_WOW64)
VOID	SetTEBLangID (VOID)
	defined(BUILD_WOW6432)
BOOL APIENTRY	ConnectConsoleInternal (IN PWSTR pObjectDirectory, IN OUT PCONSOLE_API_CONNECTINFO pConnectInfo, OUT PBOOLEAN pServerProcess)
	defined(BUILD_WOW64)
BOOLEAN	ConDllInitialize (IN PVOID DllHandle, IN ULONG Reason, IN PCONTEXT Context OPTIONAL)
	defined(BUILD_WOW6432)
BOOL APIENTRY	AllocConsoleInternal (IN LPWSTR lpTitle, IN DWORD dwTitleLength, IN LPWSTR lpDesktop, IN DWORD dwDesktopLength, IN LPWSTR lpCurDir, IN DWORD dwCurDirLength, IN LPWSTR lpAppName, IN DWORD dwAppNameLength, IN LPTHREAD_START_ROUTINE CtrlRoutine, IN LPTHREAD_START_ROUTINE PropRoutine, IN OUT PCONSOLE_INFO pConsoleInfo)
	defined(BUILD_WOW64)
BOOL APIENTRY	AllocConsole (VOID)
	defined(BUILD_WOW6432)
BOOL APIENTRY	FreeConsoleInternal (VOID)
	defined(BUILD_WOW64)
BOOL APIENTRY	FreeConsole (VOID)
	defined(BUILD_WOW6432)
Variables
HANDLE	InputWaitHandle
WCHAR	ExeNameBuffer []
USHORT	ExeNameLength
WCHAR	StartDirBuffer []
USHORT	StartDirLength

---

Define Documentation

#define DEFAULT_WINDOW_TITLE   (L"Command Prompt")

Definition at line 28 of file dllinit.c. Referenced by AllocConsole(), and SetUpConsoleInfo().

#define MAX_SESSION_PATH   256

Definition at line 56 of file dllinit.c. Referenced by CleanupSessionObjectDirectories(), ConDllInitialize(), InitiateWin32kCleanup(), NotificationThread(), NtUserCreateWindowStation(), RawInputThread(), UserClientDllInitialize(), and xxxCreateWindowStation().

#define SESSION_ROOT   L"\\Sessions"

Definition at line 57 of file dllinit.c. Referenced by CleanupSessionObjectDirectories(), ConDllInitialize(), NotificationThread(), UserClientDllInitialize(), and UserInitialize().

---

Function Documentation

BOOL APIENTRY AllocConsole (  VOID   )

defined(BUILD_WOW6432) Definition at line 803 of file dllinit.c. References AllocConsoleInternal(), BOOL, CtrlRoutine, DEFAULT_WINDOW_TITLE, DWORD, FALSE, GET_CONSOLE_HANDLE, InitExeName(), InitializeCtrlHandling(), _CONSOLE_INFO::InputWaitHandle, InputWaitHandle, LockDll, MAX_APP_NAME_LENGTH, MAX_PATH, MAX_TITLE_LENGTH, min, NULL, PropRoutine(), SetTEBLangID(), SetUpAppName(), SetUpConsoleInfo(), SetUpHandles(), Status, TRUE, UnlockDll, and USHORT. Referenced by main(). : This API creates a console for the calling process. Arguments: none. Return Value: TRUE - function was successful. --*/ { CONSOLE_INFO ConsoleInfo; STARTUPINFOW StartupInfo; WCHAR CurDir[MAX_PATH+1]; WCHAR AppName[MAX_APP_NAME_LENGTH/2]; BOOL Status = FALSE; DWORD dwTitleLength; DWORD dwDesktopLength; DWORD dwCurDirLength; DWORD dwAppNameLength; LockDll(); try { if (GET_CONSOLE_HANDLE != NULL) { SetLastError(ERROR_ACCESS_DENIED); Status = FALSE; leave; } // // set up initialization parameters // SetUpConsoleInfo(FALSE, &dwTitleLength, NULL, &dwDesktopLength, NULL, &ConsoleInfo); InitExeName(); dwCurDirLength = sizeof(CurDir); dwAppNameLength = sizeof(AppName); SetUpAppName(&dwCurDirLength, CurDir, &dwAppNameLength, AppName); GetStartupInfoW(&StartupInfo); if (StartupInfo.lpTitle == NULL) { StartupInfo.lpTitle = DEFAULT_WINDOW_TITLE; } dwTitleLength = (USHORT)((lstrlenW(StartupInfo.lpTitle)+1)*sizeof(WCHAR)); dwTitleLength = (USHORT)(min(dwTitleLength,MAX_TITLE_LENGTH)); if (StartupInfo.lpDesktop != NULL && *StartupInfo.lpDesktop != 0) { dwDesktopLength = (USHORT)((lstrlenW(StartupInfo.lpDesktop)+1)*sizeof(WCHAR)); dwDesktopLength = (USHORT)(min(dwDesktopLength,MAX_TITLE_LENGTH)); } else { dwDesktopLength = 0; } Status = AllocConsoleInternal(StartupInfo.lpTitle, dwTitleLength, StartupInfo.lpDesktop, dwDesktopLength, CurDir, dwCurDirLength, AppName, dwAppNameLength, CtrlRoutine, PropRoutine, &ConsoleInfo ); if (!Status) { leave; } // // fill in peb values // SetUpHandles(&ConsoleInfo); // // create ctrl-c thread // InitializeCtrlHandling(); InputWaitHandle = ConsoleInfo.InputWaitHandle; SetTEBLangID(); Status = TRUE; } finally { UnlockDll(); } return Status; }

BOOL APIENTRY AllocConsoleInternal (  IN LPWSTR  lpTitle, IN DWORD  dwTitleLength, IN LPWSTR  lpDesktop, IN DWORD  dwDesktopLength, IN LPWSTR  lpCurDir, IN DWORD  dwCurDirLength, IN LPWSTR  lpAppName, IN DWORD  dwAppNameLength, IN LPTHREAD_START_ROUTINE  CtrlRoutine, IN LPTHREAD_START_ROUTINE  PropRoutine, IN OUT PCONSOLE_INFO  pConsoleInfo )

defined(BUILD_WOW64) Definition at line 656 of file dllinit.c. References _CONSOLE_ALLOC_MSG::AppName, _CONSOLE_ALLOC_MSG::AppNameLength, BOOL, CONSOLE_INFO, _CONSOLE_ALLOC_MSG::ConsoleInfo, ConsolepAlloc, CsrAllocateCaptureBuffer(), CsrCaptureMessageBuffer(), CsrClientCallServer(), CsrFreeCaptureBuffer(), CtrlRoutine, _CONSOLE_ALLOC_MSG::CtrlRoutine, _CONSOLE_ALLOC_MSG::CurDir, _CONSOLE_ALLOC_MSG::CurDirLength, _CONSOLE_ALLOC_MSG::Desktop, _CONSOLE_ALLOC_MSG::DesktopLength, FALSE, INITIALIZATION_FAILED, INITIALIZATION_SUCCEEDED, NT_SUCCESS, NtClose(), NTSTATUS(), NtWaitForMultipleObjects(), NULL, NUMBER_OF_INITIALIZATION_EVENTS, PropRoutine(), _CONSOLE_ALLOC_MSG::PropRoutine, SET_CONSOLE_HANDLE, SET_LAST_ERROR, SET_LAST_NT_ERROR, Status, _CONSOLE_ALLOC_MSG::Title, _CONSOLE_ALLOC_MSG::TitleLength, TRUE, and _CONSOLE_API_MSG::u. Referenced by AllocConsole(). : Marshels the parameters for the ConsolepAlloc command. Arguments: See the CONSOLE_ALLOC_MSG structure and AllocConsole. Return Value: TRUE - Success FALSE - An error occured. --*/ { CONSOLE_API_MSG m; PCONSOLE_ALLOC_MSG a = &m.u.AllocConsole; PCSR_CAPTURE_HEADER CaptureBuffer = NULL; BOOL Status = FALSE; NTSTATUS St; try { a->CtrlRoutine = CtrlRoutine; a->PropRoutine = PropRoutine; // Allocate 4 extra pointer sizes to compensate for any alignment done // by CsrCaptureMessageBuffer. CaptureBuffer = CsrAllocateCaptureBuffer( 5, dwTitleLength + dwDesktopLength + dwCurDirLength + dwAppNameLength + sizeof( CONSOLE_INFO ) + (4 * sizeof(PVOID)) ); if (CaptureBuffer == NULL) { SET_LAST_ERROR(ERROR_NOT_ENOUGH_MEMORY); Status = FALSE; leave; } // Allocate the CONSOLE_INFO first so that it is aligned on a pointer // boundry. This is necessary since NtWaitForMultipleObject expects // its arguments aligned on a handle boundry. CsrCaptureMessageBuffer( CaptureBuffer, pConsoleInfo, sizeof( CONSOLE_INFO ), (PVOID *) &a->ConsoleInfo ); a->TitleLength = dwTitleLength; CsrCaptureMessageBuffer( CaptureBuffer, lpTitle, dwTitleLength, (PVOID *) &a->Title ); a->DesktopLength = dwDesktopLength; CsrCaptureMessageBuffer( CaptureBuffer, lpDesktop, dwDesktopLength, (PVOID *) &a->Desktop ); a->CurDirLength = dwCurDirLength; CsrCaptureMessageBuffer( CaptureBuffer, lpCurDir, dwCurDirLength, (PVOID *) &a->CurDir ); a->AppNameLength = dwAppNameLength; CsrCaptureMessageBuffer( CaptureBuffer, lpAppName, dwAppNameLength, (PVOID *) &a->AppName ); // // Connect to the server process // CsrClientCallServer( (PCSR_API_MSG)&m, CaptureBuffer, CSR_MAKE_API_NUMBER( CONSRV_SERVERDLL_INDEX, ConsolepAlloc ), sizeof( *a ) ); if (!NT_SUCCESS( m.ReturnValue )) { SET_LAST_NT_ERROR (m.ReturnValue); Status = FALSE; leave; } St = NtWaitForMultipleObjects(NUMBER_OF_INITIALIZATION_EVENTS, a->ConsoleInfo->InitEvents, WaitAny, FALSE, NULL ); if (!NT_SUCCESS(St)) { SET_LAST_NT_ERROR(St); Status = FALSE; leave; } //The handles to be closed are events, so NtClose works fine. NtClose(a->ConsoleInfo->InitEvents[INITIALIZATION_SUCCEEDED]); NtClose(a->ConsoleInfo->InitEvents[INITIALIZATION_FAILED]); if (St != INITIALIZATION_SUCCEEDED) { SET_CONSOLE_HANDLE(NULL); Status = FALSE; leave; } RtlCopyMemory(pConsoleInfo, a->ConsoleInfo, sizeof(CONSOLE_INFO)); Status = TRUE; } finally { if (CaptureBuffer) { CsrFreeCaptureBuffer( CaptureBuffer ); } } return Status; }

BOOLEAN ConDllInitialize (  IN PVOID  DllHandle, IN ULONG  Reason, IN PCONTEXT Context  OPTIONAL )

defined(BUILD_WOW6432) Definition at line 470 of file dllinit.c. References _CONSOLE_API_CONNECTINFO::AppName, _CONSOLE_API_CONNECTINFO::AppNameLength, BOOL, ConnectConsoleInternal(), ConsoleApp(), _CONSOLE_API_CONNECTINFO::ConsoleApp, _CONSOLE_INFO::ConsoleHandle, ConsoleIMERoutine, _CONSOLE_API_CONNECTINFO::ConsoleInfo, CtrlRoutine, _CONSOLE_API_CONNECTINFO::CtrlRoutine, _CONSOLE_API_CONNECTINFO::CurDir, _CONSOLE_API_CONNECTINFO::CurDirLength, _CONSOLE_API_CONNECTINFO::Desktop, _CONSOLE_API_CONNECTINFO::DesktopLength, DllLock, FALSE, GET_CONSOLE_HANDLE, InitExeName(), InitializeCtrlHandling(), _CONSOLE_INFO::InputWaitHandle, InputWaitHandle, L, MAX_SESSION_PATH, NT_SUCCESS, NTSTATUS(), NULL, PropRoutine(), _CONSOLE_API_CONNECTINFO::PropRoutine, RtlInitializeCriticalSection(), SESSION_ROOT, SET_CONSOLE_HANDLE, SetTEBLangID(), SetUpAppName(), SetUpConsoleInfo(), SetUpHandles(), Status, _CONSOLE_API_CONNECTINFO::Title, _CONSOLE_API_CONNECTINFO::TitleLength, TRUE, and _CONSOLE_API_CONNECTINFO::WindowVisible. : This function implements console dll initialization. Arguments: DllHandle - Not Used Context - Not Used Return Value: STATUS_SUCCESS --*/ { NTSTATUS Status; BOOL bStatus; CONSOLE_API_CONNECTINFO ConnectionInformation; BOOLEAN ServerProcess; ULONG SessionId = NtCurrentPeb()->SessionId; WCHAR szSessionDir[MAX_SESSION_PATH]; Status = STATUS_SUCCESS; // // if we're attaching the DLL, we need to connect to the server. // if no console exists, we also need to create it and set up stdin, // stdout, and stderr. // if ( Reason == DLL_PROCESS_ATTACH ) { // // Remember in the connect information if this app is a console // app. need to actually connect to the console server for windowed // apps so that we know NOT to do any special work during // ConsoleClientDisconnectRoutine(). Store ConsoleApp info in the // CSR managed per-process data. // Status = RtlInitializeCriticalSection(&DllLock); if (!NT_SUCCESS(Status)) { return FALSE; } ConnectionInformation.CtrlRoutine = CtrlRoutine; ConnectionInformation.PropRoutine = PropRoutine; #if defined(FE_SB) #if defined(FE_IME) ConnectionInformation.ConsoleIMERoutine = ConsoleIMERoutine; #endif // FE_IME #endif // FE_SB ConnectionInformation.WindowVisible = TRUE; ConnectionInformation.ConsoleApp = ConsoleApp(); if (GET_CONSOLE_HANDLE == (HANDLE)CONSOLE_DETACHED_PROCESS) { SET_CONSOLE_HANDLE(NULL); ConnectionInformation.ConsoleApp = FALSE; } else if (GET_CONSOLE_HANDLE == (HANDLE)CONSOLE_NEW_CONSOLE) { SET_CONSOLE_HANDLE(NULL); } else if (GET_CONSOLE_HANDLE == (HANDLE)CONSOLE_CREATE_NO_WINDOW) { SET_CONSOLE_HANDLE(NULL); ConnectionInformation.WindowVisible = FALSE; } if (!ConnectionInformation.ConsoleApp) { SET_CONSOLE_HANDLE(NULL); } ConnectionInformation.ConsoleInfo.ConsoleHandle = GET_CONSOLE_HANDLE; // // if no console exists, pass parameters for console creation // if (GET_CONSOLE_HANDLE == NULL && ConnectionInformation.ConsoleApp) { SetUpConsoleInfo(TRUE, &ConnectionInformation.TitleLength, ConnectionInformation.Title, &ConnectionInformation.DesktopLength, &ConnectionInformation.Desktop, &ConnectionInformation.ConsoleInfo); } else { ConnectionInformation.TitleLength = 0; ConnectionInformation.DesktopLength = 0; } if (ConnectionInformation.ConsoleApp) { InitExeName(); ConnectionInformation.CurDirLength = sizeof(ConnectionInformation.CurDir); ConnectionInformation.AppNameLength = sizeof(ConnectionInformation.AppName); SetUpAppName(&ConnectionInformation.CurDirLength, ConnectionInformation.CurDir, &ConnectionInformation.AppNameLength, ConnectionInformation.AppName); } else { ConnectionInformation.AppNameLength = 0; ConnectionInformation.CurDirLength = 0; } // // initialize ctrl handling. This should work for all apps, so // initialize it before we check for ConsoleApp (which means the // console bit was set in the module header). // InitializeCtrlHandling(); // // Connect to the server process // if ( SessionId == 0 ) { // // Console Session // wcscpy(szSessionDir, WINSS_OBJECT_DIRECTORY_NAME); } else { swprintf(szSessionDir,L"%ws\\%ld%ws",SESSION_ROOT,SessionId,WINSS_OBJECT_DIRECTORY_NAME); } bStatus = ConnectConsoleInternal(szSessionDir, &ConnectionInformation, &ServerProcess ); if (!bStatus) { return FALSE; } // // we return success although no console api can be called because // loading shouldn't fail. we'll fail the api calls later. // if (ServerProcess) { return TRUE; } // // if this is not a console app, return success - nothing else to do. // if (!ConnectionInformation.ConsoleApp) { return TRUE; } // // if console was just created, fill in peb values // if (GET_CONSOLE_HANDLE == NULL) { SetUpHandles(&ConnectionInformation.ConsoleInfo ); } InputWaitHandle = ConnectionInformation.ConsoleInfo.InputWaitHandle; SetTEBLangID(); } else if ( Reason == DLL_THREAD_ATTACH ) { if (ConsoleApp()) { SetTEBLangID(); } } return TRUE; UNREFERENCED_PARAMETER(DllHandle); UNREFERENCED_PARAMETER(Context); }

BOOL APIENTRY ConnectConsoleInternal (  IN PWSTR  pObjectDirectory, IN OUT PCONSOLE_API_CONNECTINFO  pConnectInfo, OUT PBOOLEAN  pServerProcess )

defined(BUILD_WOW64) Definition at line 373 of file dllinit.c. References CsrClientConnectToServer(), FALSE, INITIALIZATION_FAILED, INITIALIZATION_SUCCEEDED, NT_SUCCESS, NtClose(), NTSTATUS(), NtWaitForMultipleObjects(), NULL, NUMBER_OF_INITIALIZATION_EVENTS, SET_CONSOLE_HANDLE, SET_LAST_NT_ERROR, Status, and TRUE. Referenced by ConDllInitialize(). : Helper function for establishing a connection with the console server. Waits for the server to signal completion. Arguments: pObjectDirectory - Supplies a null terminated string that is the same as the value of the ObjectDirectory= argument passed to the CSRSS program. pConnectInfo - Supplies and recieves the connection information. pServerProcess - Recieves TRUE if this is a server process. Return Value: TRUE - Success FALSE - An error occured. --*/ { NTSTATUS Status; ULONG ConnectionInformationLength; ConnectionInformationLength = sizeof(CONSOLE_API_CONNECTINFO); Status = CsrClientConnectToServer( pObjectDirectory, CONSRV_SERVERDLL_INDEX, NULL, pConnectInfo, &ConnectionInformationLength, pServerProcess ); if (!NT_SUCCESS( Status )) { return FALSE; } // // we return success although no console api can be called because // loading shouldn't fail. we'll fail the api calls later. // if (*pServerProcess) { return TRUE; } // // if this is not a console app, return success - nothing else to do. // if (!pConnectInfo->ConsoleApp) { return TRUE; } // // wait for initialization to complete. we have to use the NT // wait because the heap hasn't been initialized yet. // Status = NtWaitForMultipleObjects(NUMBER_OF_INITIALIZATION_EVENTS, pConnectInfo->ConsoleInfo.InitEvents, WaitAny, FALSE, NULL ); if (!NT_SUCCESS(Status)) { SET_LAST_NT_ERROR(Status); return FALSE; } NtClose(pConnectInfo->ConsoleInfo.InitEvents[INITIALIZATION_SUCCEEDED]); NtClose(pConnectInfo->ConsoleInfo.InitEvents[INITIALIZATION_FAILED]); if (Status != INITIALIZATION_SUCCEEDED) { SET_CONSOLE_HANDLE(NULL); return FALSE; } return TRUE; }

BOOLEAN ConsoleApp (  VOID   )

Definition at line 63 of file dllinit.c. References FALSE, NULL, RtlImageNtHeader(), and TRUE. Referenced by ConDllInitialize(). : none. Return Value: TRUE if console app. --*/ { PIMAGE_NT_HEADERS NtHeaders; NtHeaders = RtlImageNtHeader(GetModuleHandle(NULL)); return (NtHeaders->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_CUI) ? TRUE : FALSE; }

DWORD CtrlRoutine (  IN LPVOID  lpThreadParameter  )

Definition at line 93 of file ctrlc.c. References ASSERT, DefaultHandler(), DWORD, EXCEPTION_EXECUTE_HANDLER, HandlerList, HandlerListLength, IGNORE_CTRL_C, LastConsoleEventActive, LockDll, NULL, NUMBER_OF_CTRL_EVENTS, RtlRaiseException(), SYSTEM_CLOSE_EVENT, and UnlockDll. : This thread is created when ctrl-c or ctrl-break is entered, or when close is selected. it calls the appropriate handlers. Arguments: lpThreadParameter - what type of event happened. Return Value: STATUS_SUCCESS --*/ { ULONG i; ULONG EventNumber,OriginalEventNumber; DWORD fNoExit; DWORD dwExitCode; EXCEPTION_RECORD ExceptionRecord; SetThreadPriority(NtCurrentThread(), THREAD_PRIORITY_HIGHEST); OriginalEventNumber = EventNumber = PtrToUlong(lpThreadParameter); // // If this bit is set, it means we don't want to cause this process // to exit itself if it is a logoff or shutdown event. // fNoExit = 0x80000000 & EventNumber; EventNumber &= ~0x80000000; // // the ctrl_close event is set when the user selects the window // close option from the system menu, or EndTask, or Settings-Terminate. // the system close event is used when another ctrl-thread times out. // switch (EventNumber) { default: ASSERT (EventNumber < NUMBER_OF_CTRL_EVENTS); if (EventNumber >= NUMBER_OF_CTRL_EVENTS) return (DWORD)STATUS_UNSUCCESSFUL; break; case CTRL_C_EVENT: case CTRL_BREAK_EVENT: // // If the process is being debugged, give the debugger // a shot. If the debugger handles the exception, then // go back and wait. // if (!IsDebuggerPresent()) break; if ( EventNumber == CTRL_C_EVENT ) { ExceptionRecord.ExceptionCode = DBG_CONTROL_C; } else { ExceptionRecord.ExceptionCode = DBG_CONTROL_BREAK; } ExceptionRecord.ExceptionFlags = 0; ExceptionRecord.ExceptionRecord = NULL; ExceptionRecord.ExceptionAddress = (PVOID)DefaultHandler; ExceptionRecord.NumberParameters = 0; try { RtlRaiseException(&ExceptionRecord); } except (EXCEPTION_EXECUTE_HANDLER) { LockDll(); try { if (EventNumber != CTRL_C_EVENT || NtCurrentPeb()->ProcessParameters->ConsoleFlags != IGNORE_CTRL_C) { for (i=HandlerListLength;i>0;i--) { if ((HandlerList[i-1])(EventNumber)) { break; } } } } finally { UnlockDll(); } } ExitThread(0); break; case SYSTEM_CLOSE_EVENT: ExitProcess((DWORD)CONTROL_C_EXIT); break; case SYSTEM_ROOT_CONSOLE_EVENT: if (!LastConsoleEventActive) ExitThread(0); break; case CTRL_CLOSE_EVENT: case CTRL_LOGOFF_EVENT: case CTRL_SHUTDOWN_EVENT: //if (LastConsoleEventActive) //EventNumber = SYSTEM_ROOT_CONSOLE_EVENT; break; } LockDll(); dwExitCode = 0; try { if (EventNumber != CTRL_C_EVENT || NtCurrentPeb()->ProcessParameters->ConsoleFlags != IGNORE_CTRL_C) { for (i=HandlerListLength;i>0;i--) { // // Don't call the last handler (the default one which calls // ExitProcess() if this process isn't supposed to exit (system // process are not supposed to exit because of shutdown or // logoff event notification). // if ((i-1) == 0 && fNoExit) { if (EventNumber == CTRL_LOGOFF_EVENT || EventNumber == CTRL_SHUTDOWN_EVENT) { break; } } if ((HandlerList[i-1])(EventNumber)) { switch (EventNumber) { case CTRL_CLOSE_EVENT: case CTRL_LOGOFF_EVENT: case CTRL_SHUTDOWN_EVENT: case SYSTEM_ROOT_CONSOLE_EVENT: dwExitCode = OriginalEventNumber; break; } break; } } } } finally { UnlockDll(); } ExitThread(dwExitCode); return STATUS_SUCCESS; }

BOOL APIENTRY FreeConsole (  VOID   )

defined(BUILD_WOW6432) Definition at line 979 of file dllinit.c. References BOOL, FALSE, FreeConsoleInternal(), GET_CONSOLE_HANDLE, InputWaitHandle, LockDll, NULL, SET_LAST_ERROR, TRUE, and UnlockDll. Referenced by main(). : This API frees the calling process's console. Arguments: none. Return Value: TRUE - function was successful. --*/ { BOOL Success=TRUE; LockDll(); if (GET_CONSOLE_HANDLE == NULL) { SET_LAST_ERROR(ERROR_INVALID_PARAMETER); Success = FALSE; } else { Success = FreeConsoleInternal(); if (Success) { CloseHandle(InputWaitHandle); } } UnlockDll(); return Success; }

BOOL APIENTRY FreeConsoleInternal (  VOID   )

defined(BUILD_WOW64) Definition at line 922 of file dllinit.c. References _CONSOLE_FREE_MSG::ConsoleHandle, ConsolepFree, CsrClientCallServer(), FALSE, GET_CONSOLE_HANDLE, NT_SUCCESS, NULL, SET_CONSOLE_HANDLE, SET_LAST_NT_ERROR, TRUE, and _CONSOLE_API_MSG::u. Referenced by FreeConsole(). : Marshels the parameters for the ConsolepFree command. Arguments: See the CONSOLE_FREE_MSG structure and FreeConsole. Return Value: TRUE - Success FALSE - An error occured. --*/ { CONSOLE_API_MSG m; PCONSOLE_FREE_MSG a = &m.u.FreeConsole; a->ConsoleHandle = GET_CONSOLE_HANDLE; // // Connect to the server process // CsrClientCallServer( (PCSR_API_MSG)&m, NULL, CSR_MAKE_API_NUMBER( CONSRV_SERVERDLL_INDEX, ConsolepFree ), sizeof( *a ) ); if (!NT_SUCCESS( m.ReturnValue )) { SET_LAST_NT_ERROR (m.ReturnValue); return FALSE; } else { SET_CONSOLE_HANDLE(NULL); return TRUE; } }

BOOL WINAPI GetConsoleLangId (  OUT LANGID *  lpLangId  )

defined(BUILD_WOW64) Definition at line 296 of file dllinit.c. References _CONSOLE_LANGID_MSG::ConsoleHandle, ConsolepGetLangId, CsrClientCallServer(), EXCEPTION_EXECUTE_HANDLER, FALSE, GET_CONSOLE_HANDLE, NT_SUCCESS, NULL, TRUE, and _CONSOLE_API_MSG::u. : lpLangId - Supplies a pointer to a LANGID in which to store the Language ID. Return Value: TRUE - The operation was successful. FALSE/NULL - The operation failed. Extended error status is available using GetLastError. --*/ { CONSOLE_API_MSG m; PCONSOLE_LANGID_MSG a = &m.u.GetConsoleLangId; a->ConsoleHandle = GET_CONSOLE_HANDLE; CsrClientCallServer( (PCSR_API_MSG)&m, NULL, CSR_MAKE_API_NUMBER( CONSRV_SERVERDLL_INDEX, ConsolepGetLangId ), sizeof( *a ) ); if (NT_SUCCESS( m.ReturnValue )) { try { *lpLangId = a->LangId; } except( EXCEPTION_EXECUTE_HANDLER ) { return FALSE; } return TRUE; } else { return FALSE; } }

VOID InitExeName (  VOID   )

Definition at line 39 of file client/cmdline.c. References CONSOLE_NAME_PATH_TERMINATOR, ExeNameBuffer, ExeNameCriticalSection, ExeNameInitialized, ExeNameLength, RtlInitializeCriticalSection(), StartDirBuffer, StartDirLength, and TRUE. Referenced by AllocConsole(), and ConDllInitialize(). { PPEB Peb; PLDR_DATA_TABLE_ENTRY ImageEntry; if (ExeNameInitialized) { return; } RtlInitializeCriticalSection(&ExeNameCriticalSection); ExeNameInitialized = TRUE; Peb = NtCurrentPeb(); ImageEntry = (PLDR_DATA_TABLE_ENTRY)Peb->Ldr->InLoadOrderModuleList.Flink; ImageEntry = CONTAINING_RECORD(ImageEntry, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks); ExeNameLength = ImageEntry->BaseDllName.Length/sizeof(WCHAR); RtlCopyMemory(ExeNameBuffer, ImageEntry->BaseDllName.Buffer, ImageEntry->BaseDllName.Length ); ExeNameBuffer[ExeNameLength] = CONSOLE_NAME_PATH_TERMINATOR; StartDirLength = Peb->ProcessParameters->CurrentDirectory.DosPath.Length/sizeof(WCHAR); RtlCopyMemory(StartDirBuffer, Peb->ProcessParameters->CurrentDirectory.DosPath.Buffer, Peb->ProcessParameters->CurrentDirectory.DosPath.Length ); StartDirBuffer[StartDirLength] = CONSOLE_NAME_PATH_TERMINATOR; }

ULONG ParseReserved (  WCHAR *  pchReserved, WCHAR *  pchFind )

Definition at line 111 of file dllinit.c. References NULL, RtlInitUnicodeString(), and RtlUnicodeStringToInteger(). { ULONG dw; WCHAR *pch, *pchT, ch; UNICODE_STRING uString; dw = 0; if ((pch = wcsstr(pchReserved, pchFind)) != NULL) { pch += lstrlenW(pchFind); pchT = pch; while (*pchT >= '0' && *pchT <= '9') pchT++; ch = *pchT; *pchT = 0; RtlInitUnicodeString(&uString, pch); *pchT = ch; RtlUnicodeStringToInteger(&uString, 0, &dw); } return dw; }

DWORD PropRoutine (  IN LPVOID  lpThreadParameter  )

Definition at line 1019 of file dllinit.c. References BOOL, FALSE, L, NTSTATUS(), NULL, Status, and TRUE. Referenced by AllocConsole(), AllocConsoleInternal(), and ConDllInitialize(). : This thread is created when the user tries to change console properties from the system menu. It invokes the control panel applet. Arguments: lpThreadParameter - not used. Return Value: STATUS_SUCCESS - function was successful --*/ { NTSTATUS Status; HANDLE hLibrary; APPLET_PROC pfnCplApplet; static BOOL fInPropRoutine = FALSE; // // Prevent the user from launching multiple applets attached // to a single console // if (fInPropRoutine) { if (lpThreadParameter) { CloseHandle((HANDLE)lpThreadParameter); } return (ULONG)STATUS_UNSUCCESSFUL; } fInPropRoutine = TRUE; hLibrary = LoadLibraryW(L"CONSOLE.DLL"); if (hLibrary != NULL) { pfnCplApplet = (APPLET_PROC)GetProcAddress(hLibrary, "CPlApplet"); if (pfnCplApplet != NULL) { (*pfnCplApplet)((HWND)lpThreadParameter, CPL_INIT, 0, 0); (*pfnCplApplet)((HWND)lpThreadParameter, CPL_DBLCLK, 0, 0); (*pfnCplApplet)((HWND)lpThreadParameter, CPL_EXIT, 0, 0); Status = STATUS_SUCCESS; } else { Status = STATUS_UNSUCCESSFUL; } FreeLibrary(hLibrary); } else { Status = STATUS_UNSUCCESSFUL; } fInPropRoutine = FALSE; return Status; }

VOID SetTEBLangID (  VOID   )

defined(BUILD_WOW6432) Definition at line 346 of file dllinit.c. References GetConsoleLangId(). Referenced by AllocConsole(), ConDllInitialize(), and SetConsoleOutputCP(). { LANGID LangId; if (GetConsoleLangId(&LangId)) { SetThreadLocale( MAKELCID(LangId, SORT_DEFAULT) ); } }

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

Definition at line 89 of file dllinit.c. References DWORD, ExeNameBuffer, ExeNameLength, StartDirBuffer, and StartDirLength. Referenced by AllocConsole(), and ConDllInitialize(). { DWORD Length; *CurDirLength -= sizeof(WCHAR); Length = (StartDirLength*sizeof(WCHAR)) > *CurDirLength ? *CurDirLength : (StartDirLength*sizeof(WCHAR)); RtlCopyMemory(CurDir,StartDirBuffer,Length+sizeof(WCHAR)); *CurDirLength = Length + sizeof(WCHAR); // add terminating NULL *AppNameLength -= sizeof(WCHAR); Length = (ExeNameLength*sizeof(WCHAR)) > *AppNameLength ? *AppNameLength : (ExeNameLength*sizeof(WCHAR)); RtlCopyMemory(AppName,ExeNameBuffer,Length+sizeof(WCHAR)); *AppNameLength = Length + sizeof(WCHAR); // add terminating NULL }

VOID SetUpConsoleInfo (  IN BOOL  DllInit, OUT LPDWORD  TitleLength, OUT LPWSTR Title  OPTIONAL, OUT LPDWORD  DesktopLength, OUT LPWSTR *Desktop  OPTIONAL, OUT PCONSOLE_INFO  ConsoleInfo )

Definition at line 141 of file dllinit.c. References BOOL, DEFAULT_WINDOW_TITLE, DllInit(), ghInstance, L, MAX_TITLE_LENGTH, min, NULL, ParseReserved(), and USHORT. Referenced by AllocConsole(), and ConDllInitialize(). : ConsoleInfo - pointer to structure to fill in. Return Value: none. --*/ { STARTUPINFOW StartupInfo; HANDLE h; int id; HANDLE ghInstance; BOOL Success; GetStartupInfoW(&StartupInfo); ghInstance = (HANDLE)((PVOID)NtCurrentPeb()->ImageBaseAddress ); // these will eventually be filled in using menu input ConsoleInfo->nFont = 0; ConsoleInfo->nInputBufferSize = 0; ConsoleInfo->hIcon = NULL; ConsoleInfo->hSmIcon = NULL; ConsoleInfo->iIconId = 0; ConsoleInfo->dwStartupFlags = StartupInfo.dwFlags; #if defined(FE_SB) ConsoleInfo->uCodePage = GetOEMCP(); #endif if (StartupInfo.lpTitle == NULL) { StartupInfo.lpTitle = DEFAULT_WINDOW_TITLE; } // // if the desktop name was specified, set up the pointers. // if (DllInit && Desktop != NULL && StartupInfo.lpDesktop != NULL && *StartupInfo.lpDesktop != 0) { *DesktopLength = (lstrlenW(StartupInfo.lpDesktop) + 1) * sizeof(WCHAR); *Desktop = StartupInfo.lpDesktop; } else { *DesktopLength = 0; if (Desktop != NULL) *Desktop = NULL; } // Nope, do normal initialization (TitleLength is in BYTES, not CHARS!) *TitleLength = (USHORT)((lstrlenW(StartupInfo.lpTitle)+1)*sizeof(WCHAR)); *TitleLength = (USHORT)(min(*TitleLength,MAX_TITLE_LENGTH)); if (DllInit) { RtlCopyMemory(Title,StartupInfo.lpTitle,*TitleLength); // ensure the title is NULL terminated if (*TitleLength == MAX_TITLE_LENGTH) Title[ (MAX_TITLE_LENGTH/sizeof(WCHAR)) - 1 ] = L'\0'; } if (StartupInfo.dwFlags & STARTF_USESHOWWINDOW) { ConsoleInfo->wShowWindow = StartupInfo.wShowWindow; } if (StartupInfo.dwFlags & STARTF_USEFILLATTRIBUTE) { ConsoleInfo->wFillAttribute = (WORD)StartupInfo.dwFillAttribute; } if (StartupInfo.dwFlags & STARTF_USECOUNTCHARS) { ConsoleInfo->dwScreenBufferSize.X = (WORD)(StartupInfo.dwXCountChars); ConsoleInfo->dwScreenBufferSize.Y = (WORD)(StartupInfo.dwYCountChars); } if (StartupInfo.dwFlags & STARTF_USESIZE) { ConsoleInfo->dwWindowSize.X = (WORD)(StartupInfo.dwXSize); ConsoleInfo->dwWindowSize.Y = (WORD)(StartupInfo.dwYSize); } if (StartupInfo.dwFlags & STARTF_USEPOSITION) { ConsoleInfo->dwWindowOrigin.X = (WORD)(StartupInfo.dwX); ConsoleInfo->dwWindowOrigin.Y = (WORD)(StartupInfo.dwY); } // // Grab information passed on lpReserved line... // if (StartupInfo.lpReserved != 0) { // // the program manager has an icon for the exe. store the // index in the iIconId field. // ConsoleInfo->iIconId = ParseReserved(StartupInfo.lpReserved, L"dde."); // // The new "Chicago" way of doing things is to pass the hotkey in the // hStdInput field and set the STARTF_USEHOTKEY flag. So, if this is // specified, we get the hotkey from there instead // if (StartupInfo.dwFlags & STARTF_USEHOTKEY) { ConsoleInfo->dwHotKey = HandleToUlong(StartupInfo.hStdInput); } else { ConsoleInfo->dwHotKey = ParseReserved(StartupInfo.lpReserved, L"hotkey."); } } }

VOID SetUpHandles (  IN PCONSOLE_INFO  ConsoleInfo  )

Definition at line 263 of file dllinit.c. References SET_CONSOLE_HANDLE, STD_ERROR_HANDLE, STD_INPUT_HANDLE, and STD_OUTPUT_HANDLE. Referenced by AllocConsole(), and ConDllInitialize(). : ConsoleInfo - pointer to structure containing handles. Return Value: none. --*/ { SET_CONSOLE_HANDLE(ConsoleInfo->ConsoleHandle); if (!(ConsoleInfo->dwStartupFlags & STARTF_USESTDHANDLES)) { SetStdHandle(STD_INPUT_HANDLE,ConsoleInfo->StdIn); SetStdHandle(STD_OUTPUT_HANDLE,ConsoleInfo->StdOut); SetStdHandle(STD_ERROR_HANDLE,ConsoleInfo->StdErr); } }

---

Variable Documentation

WCHAR ExeNameBuffer[]

Definition at line 31 of file dllinit.c. Referenced by GetConsoleAliasExesA(), GetConsoleAliasExesInternal(), GetConsoleAliasExesW(), GetConsoleInputExeNameW(), GetCurrentExeName(), InitExeName(), SetConsoleInputExeNameW(), and SetUpAppName().

USHORT ExeNameLength

Definition at line 32 of file dllinit.c. Referenced by GetConsoleInputExeNameW(), GetCurrentExeName(), InitExeName(), ReadChars(), ReadConsoleA(), ReadConsoleInternal(), ReadConsoleW(), SetConsoleInputExeNameW(), and SetUpAppName().

HANDLE InputWaitHandle

Definition at line 30 of file dllinit.c. Referenced by AllocConsole(), ConDllInitialize(), FreeConsole(), and GetConsoleInputWaitHandle().

WCHAR StartDirBuffer[]

Definition at line 33 of file dllinit.c. Referenced by InitExeName(), and SetUpAppName().

USHORT StartDirLength

Definition at line 34 of file dllinit.c. Referenced by InitExeName(), and SetUpAppName().

---