srvinit.c File Reference

#include "precomp.h"

Go to the source code of this file.

Defines
#define	SYSTEM_ROOT   (L"%SystemRoot%")
#define	SYSTEM_ROOT_LENGTH   (sizeof(SYSTEM_ROOT) - sizeof(WCHAR))
Functions
VOID	UnregisterVDM (IN PCONSOLE_INFORMATION Console)
ULONG	NonConsoleProcessShutdown (PCSR_PROCESS Process, DWORD dwFlags)
ULONG	ConsoleClientShutdown (PCSR_PROCESS Process, ULONG Flags, BOOLEAN fFirstPass)
NTSTATUS	ConsoleClientConnectRoutine (IN PCSR_PROCESS Process, IN OUT PVOID ConnectionInfo, IN OUT PULONG ConnectionInfoLength)
VOID	ConsoleClientDisconnectRoutine (IN PCSR_PROCESS Process)
VOID	ConsolePlaySound (VOID)
VOID	LoadLinkInfo (PCONSOLE_INFO ConsoleInfo, LPWSTR Title, LPDWORD TitleLength, LPWSTR CurDir, LPWSTR AppName)
BOOL	InitWindowClass (VOID)
NTSTATUS	InitWindowsStuff (HDESK hdesk, LPDWORD lpdwThreadId)
NTSTATUS APIPRIVATE	ConServerDllInitialization (PCSR_SERVER_DLL LoadedServerDll)
BOOL	MapHandle (IN HANDLE ClientProcessHandle, IN HANDLE ServerHandle, OUT PHANDLE ClientHandle)
VOID	AddProcessToList (IN OUT PCONSOLE_INFORMATION Console, IN OUT PCONSOLE_PROCESS_HANDLE ProcessHandleRecord, IN HANDLE ProcessHandle)
PCONSOLE_PROCESS_HANDLE	FindProcessInList (IN PCONSOLE_INFORMATION Console, IN HANDLE ProcessHandle)
VOID	RemoveProcessFromList (IN OUT PCONSOLE_INFORMATION Console, IN HANDLE ProcessHandle)
NTSTATUS	SetUpConsole (IN OUT PCONSOLE_INFO ConsoleInfo, IN DWORD TitleLength, IN LPWSTR Title, IN LPWSTR CurDir, IN LPWSTR AppName, IN PCONSOLE_PER_PROCESS_DATA ProcessData, IN BOOLEAN WindowVisible, IN PUNICODE_STRING pstrDesktopName)
NTSTATUS	RemoveConsole (IN PCONSOLE_PER_PROCESS_DATA ProcessData, IN HANDLE ProcessHandle, IN HANDLE ProcessId)
ULONG	SrvAllocConsole (IN OUT PCSR_API_MSG m, IN OUT PCSR_REPLY_STATUS ReplyStatus)
ULONG	SrvFreeConsole (IN OUT PCSR_API_MSG m, IN OUT PCSR_REPLY_STATUS ReplyStatus)
NTSTATUS	MyRegOpenKey (IN HANDLE hKey, IN LPWSTR lpSubKey, OUT PHANDLE phResult)
NTSTATUS	MyRegQueryValue (IN HANDLE hKey, IN LPWSTR lpValueName, IN DWORD dwValueLength, OUT LPBYTE lpData)
LPWSTR	TranslateConsoleTitle (LPWSTR ConsoleTitle, PUSHORT pcbTranslatedTitle, BOOL Unexpand, BOOL Substitute)
VOID	InitializeConsoleAttributes (VOID)
VOID	GetRegistryValues (IN LPWSTR ConsoleTitle, OUT PCONSOLE_REGISTRY_INFO RegInfo)
NTSTATUS	GetConsoleLangId (IN UINT OutputCP, OUT LANGID *pLangId)
ULONG	SrvGetConsoleLangId (IN OUT PCSR_API_MSG m, IN OUT PCSR_REPLY_STATUS ReplyStatus)
Variables
CONST PCSR_API_ROUTINE	ConsoleServerApiDispatchTable [ConsolepMaxApiNumber-ConsolepOpenConsole]
CONST BOOLEAN	ConsoleServerApiServerValidTable [ConsolepMaxApiNumber-ConsolepOpenConsole]
BOOL	FullScreenInitialized
CRITICAL_SECTION	ConsoleVDMCriticalSection
PCONSOLE_INFORMATION	ConsoleVDMOnSwitching
CRITICAL_SECTION	ConsoleInitWindowsLock
BOOL	fOneTimeInitialized
UINT	OEMCP
UINT	WINDOWSCP
UINT	ConsoleOutputCP
CONSOLE_REGISTRY_INFO	DefaultRegInfo
HANDLE	ghInstance
HICON	ghDefaultIcon
HICON	ghDefaultSmIcon
HCURSOR	ghNormalCursor
PWIN32HEAP	pConHeap
DWORD	dwConBaseTag
DWORD	gExtendedEditKey
BOOL	gfTrimLeadingZeros
BOOL	gfLoadConIme

---

Define Documentation

#define SYSTEM_ROOT   (L"%SystemRoot%")

Definition at line 1827 of file srvinit.c. Referenced by TranslateConsoleTitle().

#define SYSTEM_ROOT_LENGTH   (sizeof(SYSTEM_ROOT) - sizeof(WCHAR))

Definition at line 1828 of file srvinit.c. Referenced by TranslateConsoleTitle().

---

Function Documentation

VOID AddProcessToList (  IN OUT PCONSOLE_INFORMATION  Console, IN OUT PCONSOLE_PROCESS_HANDLE  ProcessHandleRecord, IN HANDLE  ProcessHandle )

Definition at line 895 of file srvinit.c. References ASSERT, CONSOLE_HAS_FOCUS, CONSOLE_SHUTTING_DOWN, CONSOLE_TERMINATING, and SetProcessFocus(). Referenced by ConsoleAddProcessRoutine(), ConsoleClientConnectRoutine(), and SrvAllocConsole(). { ASSERT(!(Console->Flags & (CONSOLE_TERMINATING | CONSOLE_SHUTTING_DOWN))); ProcessHandleRecord->ProcessHandle = ProcessHandle; ProcessHandleRecord->TerminateCount = 0; InsertHeadList(&Console->ProcessHandleList,&ProcessHandleRecord->ListLink); SetProcessFocus(ProcessHandleRecord->Process, Console->Flags & CONSOLE_HAS_FOCUS); }

NTSTATUS APIPRIVATE ConServerDllInitialization (  PCSR_SERVER_DLL  LoadedServerDll  )

Definition at line 737 of file srvinit.c. References ConsoleAddProcessRoutine(), ConsoleClientConnectRoutine(), ConsoleClientDisconnectRoutine(), ConsoleClientShutdown(), ConsoleInitWindowsLock, ConsoleOutputCP, ConsolepMaxApiNumber, ConsoleServerApiDispatchTable, ConsoleServerApiServerValidTable, ConsoleVDMCriticalSection, ConsoleVDMOnSwitching, DBG, dwConBaseTag, ghInstance, gInputThreadMsgLock, InitializeConsoleHandleTable(), InitializeFonts(), InitializeThreadMessages(), InputThreadTlsIndex, IsAvailableFarEastCodePage(), L, NT_SUCCESS, NTSTATUS(), NULL, OEMCP, pConHeap, RtlInitializeCriticalSectionAndSpinCount(), Status, and WINDOWSCP. : This routine is called to initialize the server dll. It initializes the console handle table. Arguments: LoadedServerDll - Pointer to console server dll data Return Value: --*/ { NTSTATUS Status; LoadedServerDll->ApiNumberBase = CONSRV_FIRST_API_NUMBER; LoadedServerDll->MaxApiNumber = ConsolepMaxApiNumber; LoadedServerDll->ApiDispatchTable = (PCSR_API_ROUTINE *)ConsoleServerApiDispatchTable; LoadedServerDll->ApiServerValidTable = (PBOOLEAN)ConsoleServerApiServerValidTable; #if DBG LoadedServerDll->ApiNameTable = ConsoleServerApiNameTable; #else LoadedServerDll->ApiNameTable = NULL; #endif LoadedServerDll->PerProcessDataLength = sizeof(CONSOLE_PER_PROCESS_DATA); LoadedServerDll->ConnectRoutine = ConsoleClientConnectRoutine; LoadedServerDll->DisconnectRoutine = ConsoleClientDisconnectRoutine; LoadedServerDll->AddProcessRoutine = ConsoleAddProcessRoutine; LoadedServerDll->ShutdownProcessRoutine = ConsoleClientShutdown; ghInstance = LoadedServerDll->ModuleHandle; // initialize data structures InitWin32HeapStubs(); pConHeap = Win32HeapCreate( "CH_Head", "CH_Tail", HEAP_GROWABLE | HEAP_CLASS_5 | #if DBG HEAP_TAIL_CHECKING_ENABLED, #else 0, #endif NULL, // HeapBase 64 * 1024, // ReserveSize 4096, // CommitSize NULL, // Lock to use for serialization NULL); // GrowthThreshold // pConHeap = RtlProcessHeap(); if (pConHeap == NULL) { return STATUS_NO_MEMORY; } dwConBaseTag = Win32HeapCreateTag( pConHeap, 0, L"CON!", L"TMP\0" L"BMP\0" L"ALIAS\0" L"HISTORY\0" L"TITLE\0" L"HANDLE\0" L"CONSOLE\0" L"ICON\0" L"BUFFER\0" L"WAIT\0" L"FONT\0" L"SCREEN\0" #if defined(FE_SB) L"TMP DBCS\0" L"SCREEN DBCS\0" L"EUDC\0" L"CONVAREA\0" L"IME\0" #endif ); Status = InitializeConsoleHandleTable(); if (!NT_SUCCESS(Status)) { return Status; } Status = RtlInitializeCriticalSectionAndSpinCount(&ConsoleInitWindowsLock, 0x80000000); if (!NT_SUCCESS(Status)) { return Status; } // // Initialize Input thread local message queue // Status = RtlInitializeCriticalSectionAndSpinCount(&gInputThreadMsgLock, 0x80000000); if (!NT_SUCCESS(Status)) { return Status; } InitializeThreadMessages(); #ifdef i386 Status = RtlInitializeCriticalSectionAndSpinCount(&ConsoleVDMCriticalSection, 0x80000000); if (!NT_SUCCESS(Status)) { return Status; } ConsoleVDMOnSwitching = NULL; #endif OEMCP = GetOEMCP(); WINDOWSCP = GetACP(); #if !defined(FE_SB) ConsoleOutputCP = OEMCP; #endif InitializeFonts(); InputThreadTlsIndex = TlsAlloc(); if (InputThreadTlsIndex == 0xFFFFFFFF) return STATUS_UNSUCCESSFUL; #if defined(FE_SB) gfIsDBCSACP = !!IsAvailableFarEastCodePage(WINDOWSCP); #endif return( STATUS_SUCCESS ); }

NTSTATUS ConsoleClientConnectRoutine (  IN PCSR_PROCESS  Process, IN OUT PVOID  ConnectionInfo, IN OUT PULONG  ConnectionInfoLength )

Definition at line 1091 of file srvinit.c. References AddProcessToList(), AllocateCommandHistory(), _CONSOLE_API_CONNECTINFO::AppName, _CONSOLE_API_CONNECTINFO::AppNameLength, ASSERT, CONSOLE_CLIENTPROCESSHANDLE, CONSOLE_CLIENTPROCESSID, CONSOLE_FROMPROCESSPERPROCESSDATA, CONSOLE_GETCONSOLEAPPFROMPROCESSDATA, CONSOLE_HAS_FOCUS, CONSOLE_SETCONSOLEAPPFROMPROCESSDATA, CONSOLE_SHUTTING_DOWN, _CONSOLE_API_CONNECTINFO::ConsoleApp, _CONSOLE_PER_PROCESS_DATA::ConsoleHandle, _CONSOLE_INFO::ConsoleHandle, ConsoleHeapAlloc, ConsoleHeapFree, ConsoleIMERoutine, _CONSOLE_API_CONNECTINFO::ConsoleInfo, ConsolePlaySound(), _CONSOLE_PROCESS_HANDLE::CtrlRoutine, _CONSOLE_API_CONNECTINFO::CtrlRoutine, CtrlRoutine, _CONSOLE_API_CONNECTINFO::CurDir, _CONSOLE_API_CONNECTINFO::CurDirLength, _CONSOLE_API_CONNECTINFO::Desktop, _CONSOLE_API_CONNECTINFO::DesktopLength, ErrorExit(), FALSE, FindProcessInList(), _CONSOLE_INFORMATION::Flags, HANDLE_TAG, _CONSOLE_INFORMATION::hWinSta, _CONSOLE_INFO::InitEvents, _CONSOLE_INFORMATION::InitEvents, INITIALIZATION_FAILED, INITIALIZATION_SUCCEEDED, _CONSOLE_INFORMATION::InputBuffer, _INPUT_INFORMATION::InputWaitEvent, _CONSOLE_INFO::InputWaitHandle, L, MAKE_TAG, MapHandle(), NELEM, NT_SUCCESS, NtReadVirtualMemory(), NTSTATUS(), NtUserConsoleControl(), NULL, PCONSOLE_API_CONNECTINFO, _CONSOLE_PROCESS_HANDLE::Process, _CONSOLE_API_CONNECTINFO::PropRoutine, _CONSOLE_PROCESS_HANDLE::PropRoutine, RemoveConsole(), RevalidateConsole(), _CONSOLE_PER_PROCESS_DATA::RootProcess, RtlInitUnicodeString(), SetProcessForegroundRights(), SetUpConsole(), Status, _CONSOLE_API_CONNECTINFO::Title, _CONSOLE_API_CONNECTINFO::TitleLength, TMP_TAG, TRUE, UnlockConsole(), USHORT, and _CONSOLE_API_CONNECTINFO::WindowVisible. Referenced by ConServerDllInitialization(). : This routine is called when a new process is created. For processes without parents, it creates the console. For processes with parents, it duplicates the handle table. Arguments: Process - Pointer to process structure. ConnectionInfo - Pointer to connection info. ConnectionInfoLength - Connection info length. Return Value: --*/ { NTSTATUS Status; PCONSOLE_API_CONNECTINFO p = (PCONSOLE_API_CONNECTINFO)ConnectionInfo; PCONSOLE_INFORMATION Console; PCONSOLE_PER_PROCESS_DATA ProcessData; PCONSOLE_PROCESS_HANDLE ProcessHandleRecord; CONSOLEWINDOWSTATIONPROCESS ConsoleWindowStationInfo; UNICODE_STRING strDesktopName; CONSOLE_PROCESS_INFO cpi; if (p == NULL || *ConnectionInfoLength != sizeof( *p ) || p->AppNameLength > sizeof(p->AppName) || p->CurDirLength > sizeof(p->CurDir) || p->TitleLength > sizeof(p->Title)) { KdPrint(("CONSRV: bad connection info\n")); ASSERT(FALSE); return( STATUS_UNSUCCESSFUL ); } // // Make sure the strings are NULL terminated. // p->AppName[NELEM(p->AppName) - 1] = 0; p->CurDir[NELEM(p->CurDir) - 1] = 0; p->Title[NELEM(p->Title) - 1] = 0; if (CtrlRoutine == NULL) { CtrlRoutine = p->CtrlRoutine; } #if defined(FE_IME) if (ConsoleIMERoutine == NULL) { ConsoleIMERoutine = p->ConsoleIMERoutine; } #endif ProcessData = CONSOLE_FROMPROCESSPERPROCESSDATA(Process); Console = NULL; // // If this process is not a console app, stop right here - no // initialization is needed. Just need to remember that this // is not a console app so that we do no work during // ClientDisconnectRoutine(). // Status = STATUS_SUCCESS; if ((CONSOLE_GETCONSOLEAPPFROMPROCESSDATA(ProcessData) = p->ConsoleApp)) { // // First call off to USER so it unblocks any app waiting on a call // to WaitForInputIdle. This way apps calling WinExec() to exec console // apps will return right away. // /* * Bug 273518 - joejo * * Adding optimization to bug fix */ cpi.dwProcessID = HandleToUlong(CONSOLE_CLIENTPROCESSID()); cpi.dwFlags = (p->ConsoleInfo.ConsoleHandle != NULL) ? 0 : CPI_NEWPROCESSWINDOW; NtUserConsoleControl(ConsoleNotifyConsoleApplication, &cpi, sizeof(CONSOLE_PROCESS_INFO)); // // create console // if (p->ConsoleInfo.ConsoleHandle == NULL) { ProcessHandleRecord = ConsoleHeapAlloc(MAKE_TAG( HANDLE_TAG ),sizeof(CONSOLE_PROCESS_HANDLE)); if (ProcessHandleRecord == NULL) { Status = STATUS_NO_MEMORY; goto ErrorExit; } // // We are creating a new console, so derereference // the parent's console, if any. // if (ProcessData->ConsoleHandle != NULL) { RemoveConsole(ProcessData, Process->ProcessHandle, 0); } // // Get the desktop name. // if (p->DesktopLength) { strDesktopName.Buffer = ConsoleHeapAlloc( MAKE_TAG( TMP_TAG ), p->DesktopLength); if (strDesktopName.Buffer == NULL) { Status = STATUS_NO_MEMORY; goto ErrorExit; } Status = NtReadVirtualMemory(Process->ProcessHandle, (PVOID)p->Desktop, strDesktopName.Buffer, p->DesktopLength, NULL ); if (!NT_SUCCESS(Status)) { ConsoleHeapFree(strDesktopName.Buffer); goto ErrorExit; } strDesktopName.MaximumLength = (USHORT)p->DesktopLength; strDesktopName.Length = (USHORT)(p->DesktopLength - sizeof(WCHAR)); } else { RtlInitUnicodeString(&strDesktopName, L"Default"); } ProcessData->RootProcess = TRUE; Status = SetUpConsole(&p->ConsoleInfo, p->TitleLength, p->Title, p->CurDir, p->AppName, ProcessData, p->WindowVisible, &strDesktopName); if (p->DesktopLength) ConsoleHeapFree(strDesktopName.Buffer); if (!NT_SUCCESS(Status)) { goto ErrorExit; } // Play the Open sound for console apps ConsolePlaySound(); Status = RevalidateConsole(p->ConsoleInfo.ConsoleHandle,&Console); ASSERT (NT_SUCCESS(Status)); } else { ProcessHandleRecord = NULL; ProcessData->RootProcess = FALSE; Status = STATUS_SUCCESS; if (!(NT_SUCCESS(RevalidateConsole(p->ConsoleInfo.ConsoleHandle,&Console))) ) { Status = STATUS_PROCESS_IS_TERMINATING; goto ErrorExit; } if (Console->Flags & CONSOLE_SHUTTING_DOWN) { Status = STATUS_PROCESS_IS_TERMINATING; goto ErrorExit; } if (!MapHandle(CONSOLE_CLIENTPROCESSHANDLE(), Console->InitEvents[INITIALIZATION_SUCCEEDED], &p->ConsoleInfo.InitEvents[INITIALIZATION_SUCCEEDED] ) || !MapHandle(CONSOLE_CLIENTPROCESSHANDLE(), Console->InitEvents[INITIALIZATION_FAILED], &p->ConsoleInfo.InitEvents[INITIALIZATION_FAILED] ) || !MapHandle(CONSOLE_CLIENTPROCESSHANDLE(), Console->InputBuffer.InputWaitEvent, &p->ConsoleInfo.InputWaitHandle )) { Status = STATUS_NO_MEMORY; goto ErrorExit; } ProcessHandleRecord = FindProcessInList(Console,CONSOLE_CLIENTPROCESSHANDLE()); if (ProcessHandleRecord) { ProcessHandleRecord->CtrlRoutine = p->CtrlRoutine; ProcessHandleRecord->PropRoutine = p->PropRoutine; ProcessHandleRecord = NULL; } } if (NT_SUCCESS(Status)) { // // Associate the correct window station with client process // so they can do Global atom calls. // if (DuplicateHandle( NtCurrentProcess(), Console->hWinSta, Process->ProcessHandle, &ConsoleWindowStationInfo.hwinsta, 0, FALSE, DUPLICATE_SAME_ACCESS ) ) { ConsoleWindowStationInfo.dwProcessId = HandleToUlong(CONSOLE_CLIENTPROCESSID()); NtUserConsoleControl(ConsoleWindowStationProcess, &ConsoleWindowStationInfo, sizeof(ConsoleWindowStationInfo)); } if (ProcessHandleRecord) { ProcessHandleRecord->Process = Process; ProcessHandleRecord->CtrlRoutine = p->CtrlRoutine; ProcessHandleRecord->PropRoutine = p->PropRoutine; AddProcessToList(Console,ProcessHandleRecord,CONSOLE_CLIENTPROCESSHANDLE()); } SetProcessForegroundRights(Process, Console->Flags & CONSOLE_HAS_FOCUS); AllocateCommandHistory(Console, p->AppNameLength, p->AppName, CONSOLE_CLIENTPROCESSHANDLE()); UnlockConsole(Console); } else { ErrorExit: CONSOLE_SETCONSOLEAPPFROMPROCESSDATA(ProcessData,FALSE); if (ProcessHandleRecord) ConsoleHeapFree(ProcessHandleRecord); if (Console) { UnlockConsole(Console); } if (ProcessData->ConsoleHandle != NULL) { RemoveConsole(ProcessData, Process->ProcessHandle, 0); } } } else if (ProcessData->ConsoleHandle != NULL) { // // This is a non-console app with a reference to a // reference to a parent console. Dereference the // console. // RemoveConsole(ProcessData, Process->ProcessHandle, 0); } return( Status ); }

VOID ConsoleClientDisconnectRoutine (  IN PCSR_PROCESS  Process  )

Definition at line 1482 of file srvinit.c. References CONSOLE_FROMPROCESSPERPROCESSDATA, CONSOLE_FROMPROCESSPROCESSHANDLE, CONSOLE_SETCONSOLEAPPFROMPROCESSDATA, _CONSOLE_PER_PROCESS_DATA::ConsoleHandle, FALSE, NULL, and RemoveConsole(). Referenced by ConServerDllInitialization(). : This routine is called when a process is destroyed. It closes the process's handles and frees the console if it's the last reference. Arguments: Process - Pointer to process structure. Return Value: --*/ { PCONSOLE_PER_PROCESS_DATA ProcessData; #if 0 OutputDebugString("entering ConsoleClientDisconnectRoutine\n"); #endif ProcessData = CONSOLE_FROMPROCESSPERPROCESSDATA(Process); // // If this process is not a console app, stop right here - no // disconnect processing is needed, because this app didn't create // or connect to an existing console. // if ( ProcessData->ConsoleHandle == NULL ) { #if defined(FE_IME) if (ProcessData->hDesk ) { // // If this process is a Console IME, // should unregister console IME on this desktop. // RemoveConsoleIME(Process, HandleToUlong(Process->ClientId.UniqueThread)); } #endif return; } RemoveConsole(ProcessData, CONSOLE_FROMPROCESSPROCESSHANDLE(Process), Process->ClientId.UniqueProcess); CONSOLE_SETCONSOLEAPPFROMPROCESSDATA(ProcessData,FALSE); return; }

ULONG ConsoleClientShutdown (  PCSR_PROCESS  Process, ULONG  Flags, BOOLEAN  fFirstPass )

Definition at line 1912 of file srvinit.c. References CONSOLE_FROMPROCESSPERPROCESSDATA, CONSOLE_GETCONSOLEAPPFROMPROCESSDATA, CONSOLE_GETCONSOLEHANDLEFROMPROCESSDATA, CONSOLE_NO_WINDOW, CONSOLE_WOW_REGISTERED, _CONSOLE_PER_PROCESS_DATA::ConsoleHandle, FALSE, _CONSOLE_INFORMATION::Flags, _CONSOLE_INFORMATION::hWnd, hWnd, _CONSOLE_INFORMATION::InputThreadInfo, InternalWaitCancel(), IsWindow(), NonConsoleProcessShutdown(), NT_SUCCESS, NtClose(), NtDuplicateObject(), NTSTATUS(), NtUserSetInformationThread(), NULL, _CONSOLE_PROCESS_HANDLE::Process, _CONSOLE_INFORMATION::ProcessHandleList, _CONSOLE_INFORMATION::RefCount, RevalidateConsole(), SHUTDOWN_CANCEL, SHUTDOWN_KNOWN_PROCESS, SHUTDOWN_UNKNOWN_PROCESS, ShutdownConsole(), Status, _CONSOLE_INFORMATION::TerminationEvent, _INPUT_THREAD_INFO::ThreadHandle, and UnlockConsole(). Referenced by ConServerDllInitialization(). { PCONSOLE_INFORMATION Console; PCONSOLE_PER_PROCESS_DATA ProcessData; NTSTATUS Status; HWND hWnd; HANDLE TerminationEvent; HANDLE ConsoleHandle; NTSTATUS WaitStatus; USERTHREAD_USEDESKTOPINFO utudi; // // Find the console associated with this process // ProcessData = CONSOLE_FROMPROCESSPERPROCESSDATA(Process); // // If this process is not a console app, stop right here unless // this is the second pass of shutdown, in which case we'll take // it. // if (!ProcessData || !CONSOLE_GETCONSOLEAPPFROMPROCESSDATA(ProcessData)) { #if defined(FE_IME) if (fFirstPass && (ProcessData->ConsoleHandle == NULL) && (ProcessData->hDesk != NULL)) { // // If this process is a Console IME, // should unregister console IME on this desktop. // RemoveConsoleIME(Process, HandleToUlong(Process->ClientId.UniqueThread)); } #endif if (fFirstPass) { return SHUTDOWN_UNKNOWN_PROCESS; } return NonConsoleProcessShutdown(Process, Flags); } // // Find the console structure pointer. // ConsoleHandle = CONSOLE_GETCONSOLEHANDLEFROMPROCESSDATA(ProcessData); Status = RevalidateConsole( ConsoleHandle, &Console); if (!NT_SUCCESS(Status)) { return SHUTDOWN_UNKNOWN_PROCESS; } // // If this is the invisible WOW console, return UNKNOWN so USER // enumerates 16-bit gui apps. // if ((Console->Flags & CONSOLE_NO_WINDOW) && (Console->Flags & CONSOLE_WOW_REGISTERED)) { UnlockConsole(Console); return SHUTDOWN_UNKNOWN_PROCESS; } // // Sometimes the console structure is around even though the // hWnd has been NULLed out. In this case, go to non-console // process shutdown. // hWnd = Console->hWnd; if (hWnd == NULL || !IsWindow(hWnd)) { UnlockConsole(Console); return NonConsoleProcessShutdown(Process, Flags); } // // Make a copy of the console termination event // Status = NtDuplicateObject(NtCurrentProcess(), Console->TerminationEvent, NtCurrentProcess(), &TerminationEvent, 0, FALSE, DUPLICATE_SAME_ACCESS ); if (!NT_SUCCESS(Status)) { UnlockConsole(Console); return NonConsoleProcessShutdown(Process, Flags); } // // Attach to the desktop. // utudi.hThread = Console->InputThreadInfo->ThreadHandle; utudi.drdRestore.pdeskRestore = NULL; Status = NtUserSetInformationThread(NtCurrentThread(), UserThreadUseDesktop, &utudi, sizeof(utudi)); UnlockConsole(Console); if (!NT_SUCCESS(Status)) { return NonConsoleProcessShutdown(Process, Flags); } // // We're done looking at this process structure, so dereference it. // CsrDereferenceProcess(Process); // // Synchronously talk to this console. // Status = ShutdownConsole(ConsoleHandle, Flags); // // Detach from the desktop. // utudi.hThread = NULL; NtUserSetInformationThread(NtCurrentThread(), UserThreadUseDesktop, &utudi, sizeof(utudi)); // // If Status == STATUS_PROCESS_IS_TERMINATING, then we should wait // for the console to exit. // if (Status == STATUS_PROCESS_IS_TERMINATING) { WaitStatus = InternalWaitCancel(TerminationEvent, 500000); if (WaitStatus == STATUS_WAIT_1) { Status = SHUTDOWN_CANCEL; } else if (WaitStatus != STATUS_TIMEOUT) { Status = SHUTDOWN_KNOWN_PROCESS; } else { #if DBG PLIST_ENTRY ListHead, ListNext; PCONSOLE_PROCESS_HANDLE ProcessHandleRecord; PCSR_PROCESS Process; RIPMSG0(RIP_ERROR | RIP_THERESMORE, "********************************************"); RIPMSG1(RIP_ERROR | RIP_THERESMORE, "Shutdown wait timed out on console %p", Console); RIPMSG1(RIP_ERROR | RIP_THERESMORE, "Reference count is %d", Console->RefCount); RIPMSG0(RIP_ERROR | RIP_THERESMORE, "Dump these processes and see if they're hung"); ListHead = &Console->ProcessHandleList; ListNext = ListHead->Flink; while (ListNext != ListHead) { ProcessHandleRecord = CONTAINING_RECORD(ListNext, CONSOLE_PROCESS_HANDLE, ListLink); Process = ProcessHandleRecord->Process; RIPMSG2(RIP_ERROR | RIP_THERESMORE, "CsrProcess = %p ProcessId = %x", Process, Process->ClientId.UniqueProcess); ListNext = ListNext->Flink; } RIPMSG0(RIP_ERROR, "********************************************"); #endif Status = SHUTDOWN_CANCEL; } } NtClose(TerminationEvent); return Status; }

VOID ConsolePlaySound (  VOID   )

Definition at line 25 of file server/msgbeep.c. References NtUserCallOneParam(), USER_SOUND_OPEN, and VOID(). Referenced by ConsoleClientConnectRoutine(). { NtUserCallOneParam(USER_SOUND_OPEN, SFI_PLAYEVENTSOUND); }

PCONSOLE_PROCESS_HANDLE FindProcessInList (  IN PCONSOLE_INFORMATION  Console, IN HANDLE  ProcessHandle )

Definition at line 911 of file srvinit.c. References NULL, and _CONSOLE_PROCESS_HANDLE::ProcessHandle. Referenced by ConsoleClientConnectRoutine(). { PCONSOLE_PROCESS_HANDLE ProcessHandleRecord; PLIST_ENTRY ListHead, ListNext; ListHead = &Console->ProcessHandleList; ListNext = ListHead->Flink; while (ListNext != ListHead) { ProcessHandleRecord = CONTAINING_RECORD( ListNext, CONSOLE_PROCESS_HANDLE, ListLink ); if (ProcessHandleRecord->ProcessHandle == ProcessHandle) { return ProcessHandleRecord; } ListNext = ListNext->Flink; } return NULL; }

NTSTATUS GetConsoleLangId (  IN UINT  OutputCP, OUT LANGID *  pLangId )

Definition at line 2643 of file srvinit.c. References CONSOLE_IS_DBCS_ENABLED, NTSTATUS(), NULL, and Status. Referenced by CommandNumberPopup(), CopyFromCharPopup(), CopyToCharPopup(), SetTEBLangID(), and SrvGetConsoleLangId(). { NTSTATUS Status; if (CONSOLE_IS_DBCS_ENABLED()){ if (pLangId != NULL) { switch (OutputCP) { case 932: *pLangId = MAKELANGID( LANG_JAPANESE, SUBLANG_DEFAULT ); break; case 949: *pLangId = MAKELANGID( LANG_KOREAN, SUBLANG_KOREAN ); break; case 936: *pLangId = MAKELANGID( LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED ); break; case 950: *pLangId = MAKELANGID( LANG_CHINESE, SUBLANG_CHINESE_TRADITIONAL ); break; default: *pLangId = MAKELANGID( LANG_ENGLISH, SUBLANG_ENGLISH_US ); break; } } Status = STATUS_SUCCESS; } else { Status = STATUS_NOT_SUPPORTED; } return Status; }

VOID GetRegistryValues (  IN LPWSTR  ConsoleTitle, OUT PCONSOLE_REGISTRY_INFO  RegInfo )

Definition at line 2210 of file srvinit.c. References ConsoleHeapFree, DBGPRINT, DbgPrint, DefaultRegInfo, DWORD, FALSE, gaWordDelimChars, gaWordDelimCharsDefault, gExtendedEditKey, gfLoadConIme, gfTrimLeadingZeros, InitExtendedEditKeys(), IsAvailableFarEastCodePage(), L, _CONSOLE_REGISTRY_INFO::LastWriteTime, MyRegOpenKey(), MyRegQueryValue(), NELEM, NT_ERROR, NT_SUCCESS, NtClose(), NtQueryKey(), NTSTATUS(), NULL, OEMCP, PBYTE, RtlOpenCurrentUser(), Status, TranslateConsoleTitle(), TRUE, UINT, and WORD_DELIM_MAX. Referenced by InitWindowsStuff(), and LoadLinkInfo(). : This routine reads in values from the registry and places them in the supplied structure. Arguments: ConsoleTitle - name of subkey to open RegInfo - pointer to structure to receive information Return Value: none --*/ { HANDLE hCurrentUserKey; HANDLE hConsoleKey; HANDLE hTitleKey; NTSTATUS Status; LPWSTR TranslatedConsoleTitle; DWORD dwValue; DWORD i; WCHAR awchFaceName[LF_FACESIZE]; WCHAR awchBuffer[64]; KEY_BASIC_INFORMATION KeyInfo; ULONG ResultLength; // // Impersonate the client process // if (!CsrImpersonateClient(NULL)) { KdPrint(("CONSRV: GetRegistryValues Impersonate failed\n")); return; } // // Open the current user registry key // Status = RtlOpenCurrentUser(MAXIMUM_ALLOWED, &hCurrentUserKey); if (!NT_SUCCESS(Status)) { CsrRevertToSelf(); return; } // // Open the console registry key // Status = MyRegOpenKey(hCurrentUserKey, CONSOLE_REGISTRY_STRING, &hConsoleKey); if (!NT_SUCCESS(Status)) { NtClose(hCurrentUserKey); CsrRevertToSelf(); return; } // // If we're not reading the default key, check if the default values // need to be updated // Status = NtQueryKey(hConsoleKey, KeyBasicInformation, &KeyInfo, sizeof(KeyInfo), &ResultLength); if (!NT_ERROR(Status)) { if (DefaultRegInfo.LastWriteTime != KeyInfo.LastWriteTime.QuadPart) { DefaultRegInfo.LastWriteTime = KeyInfo.LastWriteTime.QuadPart; if (RegInfo != &DefaultRegInfo) { GetRegistryValues(L"", &DefaultRegInfo); *RegInfo = DefaultRegInfo; } } } // // Open the console title subkey // TranslatedConsoleTitle = TranslateConsoleTitle(ConsoleTitle, NULL, TRUE, TRUE); if (TranslatedConsoleTitle == NULL) { NtClose(hConsoleKey); NtClose(hCurrentUserKey); CsrRevertToSelf(); return; } Status = MyRegOpenKey(hConsoleKey, TranslatedConsoleTitle, &hTitleKey); ConsoleHeapFree(TranslatedConsoleTitle); if (!NT_SUCCESS(Status)) { TranslatedConsoleTitle = TranslateConsoleTitle(ConsoleTitle, NULL, FALSE, TRUE); if (TranslatedConsoleTitle) { Status = MyRegOpenKey(hConsoleKey, TranslatedConsoleTitle, &hTitleKey); ConsoleHeapFree(TranslatedConsoleTitle); } } if (!NT_SUCCESS(Status)) { NtClose(hConsoleKey); NtClose(hCurrentUserKey); CsrRevertToSelf(); return; } // // Initial screen fill // if (NT_SUCCESS(MyRegQueryValue(hTitleKey, CONSOLE_REGISTRY_FILLATTR, sizeof(dwValue), (PBYTE)&dwValue))) { RegInfo->ScreenFill.Attributes = (WORD)dwValue; } // // Initial popup fill // if (NT_SUCCESS(MyRegQueryValue(hTitleKey, CONSOLE_REGISTRY_POPUPATTR, sizeof(dwValue), (PBYTE)&dwValue))) { RegInfo->PopupFill.Attributes = (WORD)dwValue; } // // Initial insert mode // if (NT_SUCCESS(MyRegQueryValue(hTitleKey, CONSOLE_REGISTRY_INSERTMODE, sizeof(dwValue), (PBYTE)&dwValue))) { RegInfo->InsertMode = !!dwValue; } // // Initial quick edit mode // if (NT_SUCCESS(MyRegQueryValue(hTitleKey, CONSOLE_REGISTRY_QUICKEDIT, sizeof(dwValue), (PBYTE)&dwValue))) { RegInfo->QuickEdit = !!dwValue; } #ifdef i386 // // Initial full screen mode // if (NT_SUCCESS(MyRegQueryValue(hTitleKey, CONSOLE_REGISTRY_FULLSCR, sizeof(dwValue), (PBYTE)&dwValue))) { RegInfo->FullScreen = !!dwValue; } #endif #if defined(FE_SB) // scotthsu // // Code Page // if (NT_SUCCESS(MyRegQueryValue(hTitleKey, CONSOLE_REGISTRY_CODEPAGE, sizeof(dwValue), (PBYTE)&dwValue))) { RegInfo->CodePage = (UINT)dwValue; // If this routine specified default settings for console property, // then make sure code page value when Fae East environment. // If code page value does not the same to OEMCP and any FE's code page then // we are override code page value to OEMCP on default console property. // Because, Far East environment has limitation that doesn not switch to // another FE's code page by the SetConsoleCP/SetConsoleOutputCP. // // Compare of ConsoleTitle and L"" has limit to default property of console. // It means, this code doesn't care user defined property. // Content of user defined property has responsibility to themselves. if ( wcscmp(ConsoleTitle,L"") == 0 && IsAvailableFarEastCodePage( RegInfo->CodePage ) && OEMCP != RegInfo->CodePage ) { RegInfo->CodePage = OEMCP; } } #endif // // Initial screen buffer size // if (NT_SUCCESS(MyRegQueryValue(hTitleKey, CONSOLE_REGISTRY_BUFFERSIZE, sizeof(dwValue), (PBYTE)&dwValue))) { RegInfo->ScreenBufferSize.X = LOWORD(dwValue); RegInfo->ScreenBufferSize.Y = HIWORD(dwValue); if (RegInfo->ScreenBufferSize.X <= 0) RegInfo->ScreenBufferSize.X = 1; if (RegInfo->ScreenBufferSize.Y <= 0) RegInfo->ScreenBufferSize.Y = 1; } // // Initial window size // if (NT_SUCCESS(MyRegQueryValue(hTitleKey, CONSOLE_REGISTRY_WINDOWSIZE, sizeof(dwValue), (PBYTE)&dwValue))) { RegInfo->WindowSize.X = LOWORD(dwValue); RegInfo->WindowSize.Y = HIWORD(dwValue); if (RegInfo->WindowSize.X <= 0) RegInfo->WindowSize.X = 1; else if (RegInfo->WindowSize.X > RegInfo->ScreenBufferSize.X) RegInfo->WindowSize.X = RegInfo->ScreenBufferSize.X; if (RegInfo->WindowSize.Y <= 0) RegInfo->WindowSize.Y = 1; else if (RegInfo->WindowSize.Y > RegInfo->ScreenBufferSize.Y) RegInfo->WindowSize.Y = RegInfo->ScreenBufferSize.Y; } // // Initial window position // if (NT_SUCCESS(MyRegQueryValue(hTitleKey, CONSOLE_REGISTRY_WINDOWPOS, sizeof(dwValue), (PBYTE)&dwValue))) { RegInfo->WindowOrigin.X = LOWORD(dwValue); RegInfo->WindowOrigin.Y = HIWORD(dwValue); RegInfo->AutoPosition = FALSE; } // // Initial font size // if (NT_SUCCESS(MyRegQueryValue(hTitleKey, CONSOLE_REGISTRY_FONTSIZE, sizeof(dwValue), (PBYTE)&dwValue))) { RegInfo->FontSize.X = LOWORD(dwValue); RegInfo->FontSize.Y = HIWORD(dwValue); } // // Initial font family // if (NT_SUCCESS(MyRegQueryValue(hTitleKey, CONSOLE_REGISTRY_FONTFAMILY, sizeof(dwValue), (PBYTE)&dwValue))) { RegInfo->FontFamily = dwValue; } // // Initial font weight // if (NT_SUCCESS(MyRegQueryValue(hTitleKey, CONSOLE_REGISTRY_FONTWEIGHT, sizeof(dwValue), (PBYTE)&dwValue))) { RegInfo->FontWeight = dwValue; } // // Initial font face name // if (NT_SUCCESS(MyRegQueryValue(hTitleKey, CONSOLE_REGISTRY_FACENAME, sizeof(awchFaceName), (PBYTE)awchFaceName))) { RtlCopyMemory(RegInfo->FaceName, awchFaceName, sizeof(awchFaceName)); RegInfo->FaceName[NELEM(RegInfo->FaceName) - 1] = 0; } // // Initial cursor size // if (NT_SUCCESS(MyRegQueryValue(hTitleKey, CONSOLE_REGISTRY_CURSORSIZE, sizeof(dwValue), (PBYTE)&dwValue))) { RegInfo->CursorSize = dwValue; } // // Initial history buffer size // if (NT_SUCCESS(MyRegQueryValue(hTitleKey, CONSOLE_REGISTRY_HISTORYSIZE, sizeof(dwValue), (PBYTE)&dwValue))) { RegInfo->HistoryBufferSize = dwValue; } // // Initial number of history buffers // if (NT_SUCCESS(MyRegQueryValue(hTitleKey, CONSOLE_REGISTRY_HISTORYBUFS, sizeof(dwValue), (PBYTE)&dwValue))) { RegInfo->NumberOfHistoryBuffers = dwValue; } // // Initial history duplication mode // if (NT_SUCCESS(MyRegQueryValue(hTitleKey, CONSOLE_REGISTRY_HISTORYNODUP, sizeof(dwValue), (PBYTE)&dwValue))) { RegInfo->HistoryNoDup = dwValue; } for (i=0; i<16; i++) { wsprintf(awchBuffer, CONSOLE_REGISTRY_COLORTABLE, i); if (NT_SUCCESS(MyRegQueryValue(hTitleKey, awchBuffer, sizeof(dwValue), (PBYTE)&dwValue))) { RegInfo->ColorTable[ i ] = dwValue; } } if (RegInfo == &DefaultRegInfo) { // // If the common (default) setting has been changed, // // // Get registry for conime flag // if (NT_SUCCESS(MyRegQueryValue(hConsoleKey, CONSOLE_REGISTRY_LOAD_CONIME, sizeof dwValue, (PBYTE)&dwValue))) { gfLoadConIme = (dwValue != 0); } else { gfLoadConIme = TRUE; } // // get extended edit mode and keys from registry. // if (NT_SUCCESS(MyRegQueryValue(hConsoleKey, CONSOLE_REGISTRY_EXTENDEDEDITKEY, sizeof dwValue, (PBYTE)&dwValue)) && dwValue <= 1) { ExtKeyDefBuf buf; gExtendedEditKey = dwValue; // // Initialize Extended Edit keys // InitExtendedEditKeys(NULL); if (NT_SUCCESS(MyRegQueryValue(hConsoleKey, CONSOLE_REGISTRY_EXTENDEDEDITKEY_CUSTOM, sizeof buf, (PBYTE)&buf))) { InitExtendedEditKeys(&buf); } #if DBG else { DbgPrint("Error reading ExtendedEditkeyCustom.\n"); } #endif } else { gExtendedEditKey = 0; DBGPRINT(("Error reading ExtendedEditkey.\n")); } // // Word delimiters // if (gExtendedEditKey) { // If extended edit key is given, provide extended word delimiters // by default. memcpy((LPBYTE)gaWordDelimChars, (LPBYTE)gaWordDelimCharsDefault, sizeof gaWordDelimChars[0] * WORD_DELIM_MAX); } else { // Otherwise, stick to the original word delimiter. gaWordDelimChars[0] = L'\0'; } // Read word delimiters from registry if (NT_SUCCESS(MyRegQueryValue(hConsoleKey, CONSOLE_REGISTRY_WORD_DELIM, sizeof awchBuffer, (PBYTE)awchBuffer))) { // OK, copy it to the word delimiter array. wcsncpy(gaWordDelimChars, awchBuffer, WORD_DELIM_MAX); gaWordDelimChars[WORD_DELIM_MAX - 1] = 0; } // // Read Trim Zero Heading flag // if (NT_SUCCESS(MyRegQueryValue(hTitleKey, CONSOLE_REGISTRY_TRIMZEROHEADINGS, sizeof(dwValue), (PBYTE)&dwValue))) { gfTrimLeadingZeros = dwValue; } else { gfTrimLeadingZeros = FALSE; } } // // Close the registry keys // NtClose(hTitleKey); NtClose(hConsoleKey); NtClose(hCurrentUserKey); CsrRevertToSelf(); }

VOID InitializeConsoleAttributes (  VOID   )

Definition at line 2132 of file srvinit.c. References _CONSOLE_REGISTRY_INFO::AutoPosition, _CONSOLE_REGISTRY_INFO::ColorTable, CURSOR_SMALL_SIZE, _CONSOLE_REGISTRY_INFO::CursorSize, DEFAULT_NUMBER_OF_BUFFERS, DEFAULT_NUMBER_OF_COMMANDS, DefaultRegInfo, _CONSOLE_REGISTRY_INFO::FaceName, FALSE, _CONSOLE_REGISTRY_INFO::FontFamily, _CONSOLE_REGISTRY_INFO::FontSize, _CONSOLE_REGISTRY_INFO::FontWeight, _CONSOLE_REGISTRY_INFO::FullScreen, _CONSOLE_REGISTRY_INFO::HistoryBufferSize, _CONSOLE_REGISTRY_INFO::HistoryNoDup, InitializeSystemMetrics(), _CONSOLE_REGISTRY_INFO::InsertMode, L, _CONSOLE_REGISTRY_INFO::LastWriteTime, _CONSOLE_REGISTRY_INFO::NumberOfHistoryBuffers, OEMCP, _CONSOLE_REGISTRY_INFO::PopupFill, _CONSOLE_REGISTRY_INFO::QuickEdit, _CONSOLE_REGISTRY_INFO::ScreenBufferSize, _CONSOLE_REGISTRY_INFO::ScreenFill, TRUE, _CONSOLE_REGISTRY_INFO::WindowOrigin, and _CONSOLE_REGISTRY_INFO::WindowSize. Referenced by SrvLogon(). : This routine initializes default attributes from the current user's registry values. It gets called during logon/logoff. Arguments: none Return Value: none --*/ { // // Store default values in structure and mark it // as invalid (by resetting LastWriteTime). // DefaultRegInfo.ScreenFill.Attributes = 0x07; // white on black DefaultRegInfo.ScreenFill.Char.UnicodeChar = (WCHAR)' '; DefaultRegInfo.PopupFill.Attributes = 0xf5; // purple on white DefaultRegInfo.PopupFill.Char.UnicodeChar = (WCHAR)' '; DefaultRegInfo.InsertMode = FALSE; DefaultRegInfo.QuickEdit = FALSE; DefaultRegInfo.AutoPosition = TRUE; DefaultRegInfo.FullScreen = FALSE; DefaultRegInfo.ScreenBufferSize.X = 80; DefaultRegInfo.ScreenBufferSize.Y = 25; DefaultRegInfo.WindowSize.X = 80; DefaultRegInfo.WindowSize.Y = 25; DefaultRegInfo.WindowOrigin.X = 0; DefaultRegInfo.WindowOrigin.Y = 0; DefaultRegInfo.FontSize.X = 0; DefaultRegInfo.FontSize.Y = 0; DefaultRegInfo.FontFamily = 0; DefaultRegInfo.FontWeight = 0; DefaultRegInfo.FaceName[0] = L'\0'; DefaultRegInfo.CursorSize = CURSOR_SMALL_SIZE; DefaultRegInfo.HistoryBufferSize = DEFAULT_NUMBER_OF_COMMANDS; DefaultRegInfo.NumberOfHistoryBuffers = DEFAULT_NUMBER_OF_BUFFERS; DefaultRegInfo.HistoryNoDup = FALSE; DefaultRegInfo.ColorTable[ 0] = RGB(0, 0, 0 ); DefaultRegInfo.ColorTable[ 1] = RGB(0, 0, 0x80); DefaultRegInfo.ColorTable[ 2] = RGB(0, 0x80,0 ); DefaultRegInfo.ColorTable[ 3] = RGB(0, 0x80,0x80); DefaultRegInfo.ColorTable[ 4] = RGB(0x80,0, 0 ); DefaultRegInfo.ColorTable[ 5] = RGB(0x80,0, 0x80); DefaultRegInfo.ColorTable[ 6] = RGB(0x80,0x80,0 ); DefaultRegInfo.ColorTable[ 7] = RGB(0xC0,0xC0,0xC0); DefaultRegInfo.ColorTable[ 8] = RGB(0x80,0x80,0x80); DefaultRegInfo.ColorTable[ 9] = RGB(0, 0, 0xFF); DefaultRegInfo.ColorTable[10] = RGB(0, 0xFF,0 ); DefaultRegInfo.ColorTable[11] = RGB(0, 0xFF,0xFF); DefaultRegInfo.ColorTable[12] = RGB(0xFF,0, 0 ); DefaultRegInfo.ColorTable[13] = RGB(0xFF,0, 0xFF); DefaultRegInfo.ColorTable[14] = RGB(0xFF,0xFF,0 ); DefaultRegInfo.ColorTable[15] = RGB(0xFF,0xFF,0xFF); #if defined(FE_SB) // scotthsu DefaultRegInfo.CodePage = OEMCP; #endif DefaultRegInfo.LastWriteTime = 0; // // Get system metrics for this user // InitializeSystemMetrics(); }

BOOL InitWindowClass (  VOID   )

Definition at line 590 of file srvinit.c. References ASSERT, BOOL, _CONSOLE_REGISTRY_INFO::ColorTable, CONSOLE_WINDOW_CLASS, ConsoleWindowProc(), DefaultRegInfo, GetSystemMetrics(), ghDefaultIcon, ghDefaultSmIcon, ghInstance, ghModuleWin, ghNormalCursor, IDI_CONSOLE, LOBYTE, NtUserConsoleControl(), NULL, RegisterClassEx, and _CONSOLE_REGISTRY_INFO::ScreenFill. Referenced by ConsoleInputThread(). { WNDCLASSEX wc; BOOL retval; ATOM atomConsoleClass; ghNormalCursor = LoadCursor(NULL, IDC_ARROW); ASSERT(ghModuleWin != NULL); ghDefaultIcon = LoadIcon(ghModuleWin, MAKEINTRESOURCE(IDI_CONSOLE)); ghDefaultSmIcon = LoadImage(ghModuleWin, MAKEINTRESOURCE(IDI_CONSOLE), IMAGE_ICON, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), LR_SHARED); wc.hIcon = ghDefaultIcon; wc.cbSize = sizeof(WNDCLASSEX); wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC | CS_DBLCLKS; wc.lpfnWndProc = ConsoleWindowProc; wc.cbClsExtra = 0; wc.cbWndExtra = GWL_CONSOLE_WNDALLOC; wc.hInstance = ghInstance; wc.hCursor = ghNormalCursor; wc.hbrBackground = CreateSolidBrush(DefaultRegInfo.ColorTable[LOBYTE(DefaultRegInfo.ScreenFill.Attributes >> 4) & 0xF]); wc.lpszMenuName = NULL; wc.lpszClassName = CONSOLE_WINDOW_CLASS; wc.hIconSm = ghDefaultSmIcon; atomConsoleClass = RegisterClassEx(&wc); retval = (atomConsoleClass != 0); if (retval) NtUserConsoleControl(ConsoleClassAtom, &atomConsoleClass, sizeof(ATOM)); return retval; }

NTSTATUS InitWindowsStuff (  HDESK  hdesk, LPDWORD  lpdwThreadId )

Definition at line 626 of file srvinit.c. References ASSERT, ConsoleInitWindowsLock, ConsoleInputThread(), DefaultRegInfo, _INPUT_THREAD_INIT_INFO::DesktopHandle, DWORD, ErrorExit(), FALSE, fOneTimeInitialized, FullScreenInitialized, GetRegistryValues(), _INPUT_THREAD_INIT_INFO::InitCompleteEventHandle, InitializeDbcsMisc(), InitializeFullScreen(), InitializeScrollBuffer(), _INPUT_THREAD_INIT_INFO::InitStatus, L, NT_SUCCESS, NtClose(), NtCreateEvent(), NtDuplicateObject(), NtResumeThread(), NTSTATUS(), NtUserConsoleControl(), NtWaitForSingleObject(), NULL, RtlCreateUserThread(), Status, _INPUT_THREAD_INIT_INFO::ThreadHandle, and TRUE. Referenced by SetUpConsole(). { NTSTATUS Status = STATUS_SUCCESS; CLIENT_ID ClientId; CONSOLEDESKTOPCONSOLETHREAD ConsoleDesktopInfo; INPUT_THREAD_INIT_INFO InputThreadInitInfo; // // This routine must be done within a critical section to ensure that // only one thread can initialize at a time. We need a special critical // section here because Csr calls into ConsoleAddProcessRoutine with // it's own critical section locked and then tries to grab the // ConsoleHandleTableLock. If we call CsrAddStaticServerThread here // with the ConsoleHandleTableLock locked we could get into a deadlock // situation. This critical section should not be used anywhere else. // RtlEnterCriticalSection(&ConsoleInitWindowsLock); ConsoleDesktopInfo.hdesk = hdesk; ConsoleDesktopInfo.dwThreadId = (DWORD)-1; NtUserConsoleControl(ConsoleDesktopConsoleThread, &ConsoleDesktopInfo, sizeof(ConsoleDesktopInfo)); if (ConsoleDesktopInfo.dwThreadId == 0) { if (!fOneTimeInitialized) { #if defined(FE_SB) InitializeDbcsMisc(); #endif FullScreenInitialized = InitializeFullScreen(); // // read the registry values // GetRegistryValues(L"", &DefaultRegInfo); // // allocate buffer for scrolling // Status = InitializeScrollBuffer(); ASSERT (NT_SUCCESS(Status)); if (!NT_SUCCESS(Status)) goto ErrorExit; } // // create GetMessage thread // Status = NtCreateEvent(&InputThreadInitInfo.InitCompleteEventHandle, EVENT_ALL_ACCESS, NULL, NotificationEvent, FALSE); if (!NT_SUCCESS(Status)) { goto ErrorExit; } Status = NtDuplicateObject(NtCurrentProcess(), hdesk, NtCurrentProcess(), &InputThreadInitInfo.DesktopHandle, 0, 0, DUPLICATE_SAME_ACCESS); if (!NT_SUCCESS(Status)) { NtClose(InputThreadInitInfo.InitCompleteEventHandle); goto ErrorExit; } // can't call CreateThread from server Status = RtlCreateUserThread(NtCurrentProcess(), (PSECURITY_DESCRIPTOR) NULL, TRUE, 0, 0, 0, (PUSER_THREAD_START_ROUTINE)ConsoleInputThread, &InputThreadInitInfo, &InputThreadInitInfo.ThreadHandle, &ClientId ); if (!NT_SUCCESS(Status)) { NtClose(InputThreadInitInfo.InitCompleteEventHandle); CloseDesktop(InputThreadInitInfo.DesktopHandle); goto ErrorExit; } CsrAddStaticServerThread(InputThreadInitInfo.ThreadHandle,&ClientId,0); NtResumeThread(InputThreadInitInfo.ThreadHandle, NULL); NtWaitForSingleObject(InputThreadInitInfo.InitCompleteEventHandle, FALSE, NULL); NtClose(InputThreadInitInfo.InitCompleteEventHandle); if (!NT_SUCCESS(InputThreadInitInfo.InitStatus)) { goto ErrorExit; } *lpdwThreadId = HandleToUlong(ClientId.UniqueThread); fOneTimeInitialized=TRUE; } else { *lpdwThreadId = ConsoleDesktopInfo.dwThreadId; } ErrorExit: RtlLeaveCriticalSection(&ConsoleInitWindowsLock); return Status; }

VOID LoadLinkInfo (  PCONSOLE_INFO  ConsoleInfo, LPWSTR  Title, LPDWORD  TitleLength, LPWSTR  CurDir, LPWSTR  AppName )

Definition at line 360 of file srvinit.c. References _CONSOLE_REGISTRY_INFO::AutoPosition, _CONSOLE_REGISTRY_INFO::ColorTable, _CONSOLE_REGISTRY_INFO::CursorSize, DbgPrint, DefaultRegInfo, _CONSOLE_INFO::dwHotKey, DWORD, _CONSOLE_INFO::dwStartupFlags, _CONSOLE_REGISTRY_INFO::FaceName, _CONSOLE_INFO::FaceName, FALSE, _CONSOLE_REGISTRY_INFO::FontFamily, _CONSOLE_REGISTRY_INFO::FontSize, _CONSOLE_REGISTRY_INFO::FontWeight, _CONSOLE_REGISTRY_INFO::FullScreen, GetLinkProperties(), GetRegistryValues(), GetTitleFromLinkName(), ghDefaultIcon, ghDefaultSmIcon, _CONSOLE_INFO::hIcon, _CONSOLE_REGISTRY_INFO::HistoryBufferSize, _CONSOLE_REGISTRY_INFO::HistoryNoDup, _CONSOLE_INFO::hSmIcon, _CONSOLE_INFO::iIconId, _CONSOLE_REGISTRY_INFO::InsertMode, INT, L, LINK_NOINFO, LINK_SIMPLEINFO, MAX_PATH, min, NULL, _CONSOLE_REGISTRY_INFO::NumberOfHistoryBuffers, OEMCP, _CONSOLE_REGISTRY_INFO::PopupFill, PrivateExtractIconExW(), _CONSOLE_REGISTRY_INFO::QuickEdit, RtlDosSearchPath_U(), _CONSOLE_REGISTRY_INFO::ScreenBufferSize, _CONSOLE_REGISTRY_INFO::ScreenFill, TRUE, VOID(), _CONSOLE_REGISTRY_INFO::WindowOrigin, and _CONSOLE_REGISTRY_INFO::WindowSize. Referenced by SetUpConsole(). { DWORD dwLinkLen; WCHAR LinkName[ MAX_PATH+1 ]; LNKPROPNTCONSOLE linkprops; LPWSTR pszIconLocation; int nIconIndex; ConsoleInfo->uCodePage = OEMCP; // Do some initialization ConsoleInfo->hIcon = ghDefaultIcon; ConsoleInfo->hSmIcon = ghDefaultSmIcon; pszIconLocation = NULL; nIconIndex = 0; // Try to impersonate the client-side thread if (!CsrImpersonateClient(NULL)) { ConsoleInfo->dwStartupFlags &= (~STARTF_TITLEISLINKNAME); goto DefaultInit; } // Did we get started from a link? if (ConsoleInfo->dwStartupFlags & STARTF_TITLEISLINKNAME) { DWORD Success; DWORD oldLen; // Get the filename of the link (TitleLength is BYTES, not CHARS) dwLinkLen = (DWORD)(min(*TitleLength,(MAX_PATH+1)*sizeof(WCHAR))); RtlCopyMemory(LinkName,Title,dwLinkLen); LinkName[ MAX_PATH ] = (WCHAR)0; // Get the title for the window, which is effectively the link file name oldLen = *TitleLength; *TitleLength = GetTitleFromLinkName( LinkName, Title ); if (*TitleLength < oldLen) Title[ *TitleLength / sizeof(WCHAR) ] = L'\0'; // try to get console properties from the link Success = GetLinkProperties( LinkName, &linkprops, sizeof(linkprops) ); if (Success == LINK_NOINFO) { ConsoleInfo->dwStartupFlags &= (~STARTF_TITLEISLINKNAME); goto NormalInit; } if (linkprops.pszIconLocation && *linkprops.pszIconLocation) { pszIconLocation = linkprops.pszIconLocation; nIconIndex = linkprops.uIcon; ConsoleInfo->iIconId = 0; } // Transfer link settings ConsoleInfo->dwHotKey = linkprops.uHotKey; ConsoleInfo->wShowWindow = (WORD)linkprops.uShowCmd; if (Success == LINK_SIMPLEINFO) { ConsoleInfo->dwStartupFlags &= (~STARTF_TITLEISLINKNAME); goto NormalInit; } // Transfer console link settings ConsoleInfo->wFillAttribute = linkprops.console_props.wFillAttribute; ConsoleInfo->wPopupFillAttribute = linkprops.console_props.wPopupFillAttribute; RtlCopyMemory( &ConsoleInfo->dwScreenBufferSize, &linkprops.console_props.dwScreenBufferSize, sizeof(NT_CONSOLE_PROPS) - FIELD_OFFSET(NT_CONSOLE_PROPS, dwScreenBufferSize) ); ConsoleInfo->uCodePage = linkprops.fe_console_props.uCodePage; #if 0 { INT i; DbgPrint("[LoadLinkInfo Properties for %ws]\n", Title ); DbgPrint(" wFillAttribute = 0x%04X\n", ConsoleInfo->wFillAttribute ); DbgPrint(" wPopupFillAttribute = 0x%04X\n", ConsoleInfo->wPopupFillAttribute ); DbgPrint(" dwScreenBufferSize = (%d , %d)\n", ConsoleInfo->dwScreenBufferSize.X, ConsoleInfo->dwScreenBufferSize.Y ); DbgPrint(" dwWindowSize = (%d , %d)\n", ConsoleInfo->dwWindowSize.X, ConsoleInfo->dwWindowSize.Y ); DbgPrint(" dwWindowOrigin = (%d , %d)\n", ConsoleInfo->dwWindowOrigin.X, ConsoleInfo->dwWindowOrigin.Y ); DbgPrint(" nFont = 0x%X\n", ConsoleInfo->nFont ); DbgPrint(" nInputBufferSize = 0x%X\n", ConsoleInfo->nInputBufferSize ); DbgPrint(" dwFontSize = (%d , %d)\n", ConsoleInfo->dwFontSize.X, ConsoleInfo->dwFontSize.Y ); DbgPrint(" uFontFamily = 0x%08X\n", ConsoleInfo->uFontFamily ); DbgPrint(" uFontWeight = 0x%08X\n", ConsoleInfo->uFontWeight ); DbgPrint(" FaceName = %ws\n", ConsoleInfo->FaceName ); DbgPrint(" uCursorSize = %d\n", ConsoleInfo->uCursorSize ); DbgPrint(" bFullScreen = %s\n", ConsoleInfo->bFullScreen ? "TRUE" : "FALSE" ); DbgPrint(" bQuickEdit = %s\n", ConsoleInfo->bQuickEdit ? "TRUE" : "FALSE" ); DbgPrint(" bInsertMode = %s\n", ConsoleInfo->bInsertMode ? "TRUE" : "FALSE" ); DbgPrint(" bAutoPosition = %s\n", ConsoleInfo->bAutoPosition ? "TRUE" : "FALSE" ); DbgPrint(" uHistoryBufferSize = %d\n", ConsoleInfo->uHistoryBufferSize ); DbgPrint(" uNumHistoryBuffers = %d\n", ConsoleInfo->uNumberOfHistoryBuffers ); DbgPrint(" bHistoryNoDup = %s\n", ConsoleInfo->bHistoryNoDup ? "TRUE" : "FALSE" ); DbgPrint(" ColorTable = [" ); i=0; while( i < 16 ) { DbgPrint("\n "); DbgPrint("0x%08X ", ConsoleInfo->ColorTable[i++]); DbgPrint("0x%08X ", ConsoleInfo->ColorTable[i++]); DbgPrint("0x%08X ", ConsoleInfo->ColorTable[i++]); DbgPrint("0x%08X ", ConsoleInfo->ColorTable[i++]); } DbgPrint( "]\n\n" ); } #endif ConsoleInfo->dwStartupFlags &= ~(STARTF_USESIZE | STARTF_USECOUNTCHARS); } NormalInit: // // Go get the icon // if (pszIconLocation == NULL) { dwLinkLen = RtlDosSearchPath_U(CurDir, AppName, NULL, sizeof(LinkName), LinkName, NULL); if (dwLinkLen > 0 && dwLinkLen < sizeof(LinkName)) { pszIconLocation = LinkName; } else { pszIconLocation = AppName; } } if (pszIconLocation != NULL) { HICON hIcon, hSmIcon; hIcon = hSmIcon = NULL; PrivateExtractIconExW(pszIconLocation, nIconIndex, &hIcon, &hSmIcon, 1); /* * If there is no large icon, use the default ones * If there is only a large icon in the resource, do not use * the default small one but let it be NULL so we'll stretch the large one */ if (hIcon != NULL) { ConsoleInfo->hIcon = hIcon; ConsoleInfo->hSmIcon = hSmIcon; } } CsrRevertToSelf(); if (! IsValidCodePage(ConsoleInfo->uCodePage)) { // fail safe ConsoleInfo->uCodePage = OEMCP; } if (!(ConsoleInfo->dwStartupFlags & STARTF_TITLEISLINKNAME)) { CONSOLE_REGISTRY_INFO RegInfo; DefaultInit: // // read values from the registry // RegInfo = DefaultRegInfo; GetRegistryValues(Title, &RegInfo); // // if a value isn't specified in STARTUPINFO, then use the one // from the registry. // if (!(ConsoleInfo->dwStartupFlags & STARTF_USEFILLATTRIBUTE)) { ConsoleInfo->wFillAttribute = RegInfo.ScreenFill.Attributes; } ConsoleInfo->wPopupFillAttribute = RegInfo.PopupFill.Attributes; if (!(ConsoleInfo->dwStartupFlags & STARTF_USECOUNTCHARS)) { ConsoleInfo->dwScreenBufferSize = RegInfo.ScreenBufferSize; } if (!(ConsoleInfo->dwStartupFlags & STARTF_USESIZE)) { ConsoleInfo->dwWindowSize = RegInfo.WindowSize; } if (!(ConsoleInfo->dwStartupFlags & STARTF_USEPOSITION)) { ConsoleInfo->dwWindowOrigin = RegInfo.WindowOrigin; ConsoleInfo->bAutoPosition = RegInfo.AutoPosition; } else { ConsoleInfo->bAutoPosition = FALSE; } if (!(ConsoleInfo->dwStartupFlags & STARTF_RUNFULLSCREEN)) { ConsoleInfo->bFullScreen = RegInfo.FullScreen; } else { ConsoleInfo->bFullScreen = TRUE; } ConsoleInfo->uFontFamily = RegInfo.FontFamily; ConsoleInfo->uFontWeight = RegInfo.FontWeight; ConsoleInfo->dwFontSize = RegInfo.FontSize; RtlCopyMemory(ConsoleInfo->FaceName, RegInfo.FaceName, sizeof(RegInfo.FaceName)); ConsoleInfo->bQuickEdit = RegInfo.QuickEdit; ConsoleInfo->bInsertMode = RegInfo.InsertMode; ConsoleInfo->uCursorSize = RegInfo.CursorSize; ConsoleInfo->uHistoryBufferSize = RegInfo.HistoryBufferSize; ConsoleInfo->uNumberOfHistoryBuffers = RegInfo.NumberOfHistoryBuffers; ConsoleInfo->bHistoryNoDup = RegInfo.HistoryNoDup; RtlCopyMemory(ConsoleInfo->ColorTable, RegInfo.ColorTable, sizeof(RegInfo.ColorTable)); #ifdef FE_SB ConsoleInfo->uCodePage = RegInfo.CodePage; #endif } }

BOOL MapHandle (  IN HANDLE  ClientProcessHandle, IN HANDLE  ServerHandle, OUT PHANDLE  ClientHandle )

Definition at line 874 of file srvinit.c. References FALSE. Referenced by AllocateConsole(), ConsoleClientConnectRoutine(), and CreateConsoleBitmap(). { // // map event handle into dll's handle space. // return DuplicateHandle(NtCurrentProcess(), ServerHandle, ClientProcessHandle, ClientHandle, 0, FALSE, DUPLICATE_SAME_ACCESS ); }

NTSTATUS MyRegOpenKey (  IN HANDLE  hKey, IN LPWSTR  lpSubKey, OUT PHANDLE  phResult )

Definition at line 1635 of file srvinit.c. References NtOpenKey(), NULL, and RtlInitUnicodeString(). Referenced by GetRegistryValues(), and GetTimeouts(). { OBJECT_ATTRIBUTES Obja; UNICODE_STRING SubKey; // // Convert the subkey to a counted Unicode string. // RtlInitUnicodeString( &SubKey, lpSubKey ); // // Initialize the OBJECT_ATTRIBUTES structure and open the key. // InitializeObjectAttributes( &Obja, &SubKey, OBJ_CASE_INSENSITIVE, hKey, NULL ); return NtOpenKey( phResult, KEY_READ, &Obja ); }

NTSTATUS MyRegQueryValue (  IN HANDLE  hKey, IN LPWSTR  lpValueName, IN DWORD  dwValueLength, OUT LPBYTE  lpData )

Definition at line 1670 of file srvinit.c. References ASSERT, ConsoleHeapAlloc, ConsoleHeapFree, MAKE_TAG, NT_SUCCESS, NtQueryValueKey(), NTSTATUS(), NULL, RtlInitUnicodeString(), Status, TMP_TAG, and ValueName. Referenced by GetRegistryValues(). { UNICODE_STRING ValueName; ULONG BufferLength; ULONG ResultLength; PKEY_VALUE_PARTIAL_INFORMATION KeyValueInformation; NTSTATUS Status; // // Convert the subkey to a counted Unicode string. // RtlInitUnicodeString( &ValueName, lpValueName ); BufferLength = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data) + dwValueLength; KeyValueInformation = ConsoleHeapAlloc(MAKE_TAG( TMP_TAG ),BufferLength); if (KeyValueInformation == NULL) return STATUS_NO_MEMORY; Status = NtQueryValueKey( hKey, &ValueName, KeyValuePartialInformation, KeyValueInformation, BufferLength, &ResultLength ); if (NT_SUCCESS(Status)) { ASSERT(KeyValueInformation->DataLength <= dwValueLength); RtlCopyMemory(lpData, KeyValueInformation->Data, KeyValueInformation->DataLength); if (KeyValueInformation->Type == REG_SZ || KeyValueInformation->Type == REG_MULTI_SZ ) { if (KeyValueInformation->DataLength + sizeof(WCHAR) > dwValueLength) { KeyValueInformation->DataLength -= sizeof(WCHAR); } lpData[KeyValueInformation->DataLength++] = 0; lpData[KeyValueInformation->DataLength] = 0; } } ConsoleHeapFree(KeyValueInformation); return Status; }

ULONG NonConsoleProcessShutdown (  PCSR_PROCESS  Process, DWORD  dwFlags )

Definition at line 2088 of file srvinit.c. References BOOL, CreateCtrlThread(), CtrlRoutine, _CONSOLE_PROCESS_TERMINATION_RECORD::CtrlRoutine, dwFlags, DWORD, FALSE, NULL, _CONSOLE_PROCESS_TERMINATION_RECORD::ProcessHandle, SHUTDOWN_KNOWN_PROCESS, _CONSOLE_PROCESS_TERMINATION_RECORD::TerminateCount, and TRUE. Referenced by ConsoleClientShutdown(). { CONSOLE_PROCESS_TERMINATION_RECORD TerminateRecord; DWORD EventType; BOOL Success; HANDLE ProcessHandle; Success = DuplicateHandle(NtCurrentProcess(), Process->ProcessHandle, NtCurrentProcess(), &ProcessHandle, 0, FALSE, DUPLICATE_SAME_ACCESS); if (!Success) ProcessHandle = Process->ProcessHandle; TerminateRecord.ProcessHandle = ProcessHandle; TerminateRecord.TerminateCount = 0; TerminateRecord.CtrlRoutine = CtrlRoutine; CsrDereferenceProcess(Process); EventType = CTRL_LOGOFF_EVENT; if (dwFlags & EWX_SHUTDOWN) EventType = CTRL_SHUTDOWN_EVENT; CreateCtrlThread(&TerminateRecord, 1, NULL, EventType, TRUE); if (Success) CloseHandle(ProcessHandle); return SHUTDOWN_KNOWN_PROCESS; }

NTSTATUS RemoveConsole (  IN PCONSOLE_PER_PROCESS_DATA  ProcessData, IN HANDLE  ProcessHandle, IN HANDLE  ProcessId )

Definition at line 1355 of file srvinit.c. References ASSERT, CloseInputHandle(), CloseOutputHandle(), CONSOLE_FREE_HANDLE, CONSOLE_FULLSCREEN_NOPAINT, CONSOLE_INPUT_HANDLE, CONSOLE_NOTIFY_LAST_CLOSE, CONSOLE_VDM_REGISTERED, _CONSOLE_INFORMATION::ConsoleHandle, ConsoleHeapFree, CreateCtrlThread(), CtrlRoutine, _CONSOLE_PROCESS_TERMINATION_RECORD::CtrlRoutine, DereferenceIoHandleNoCheck(), FALSE, _CONSOLE_INFORMATION::Flags, FreeCommandHistory(), FreeCon(), FreeProcessData(), _HANDLE_DATA::HandleType, _CONSOLE_INFORMATION::hProcessLastNotifyClose, NT_SUCCESS, NtClose(), NTSTATUS(), NULL, _CONSOLE_PROCESS_TERMINATION_RECORD::ProcessHandle, _CONSOLE_INFORMATION::ProcessIdLastNotifyClose, _CONSOLE_INFORMATION::RefCount, RemoveProcessFromList(), RevalidateConsole(), Status, _CONSOLE_PROCESS_TERMINATION_RECORD::TerminateCount, TRUE, UnlockConsole(), UnregisterVDM(), and _CONSOLE_INFORMATION::VDMProcessId. Referenced by ConsoleClientConnectRoutine(), ConsoleClientDisconnectRoutine(), SrvFreeConsole(), and WndProc(). { ULONG i; PHANDLE_DATA HandleData; NTSTATUS Status; PCONSOLE_INFORMATION Console; Status = RevalidateConsole(ProcessData->ConsoleHandle, &Console); // // If this process isn't using the console, error. // if (!NT_SUCCESS(Status)) { ASSERT(FALSE); return Status; } if (Console->Flags & CONSOLE_NOTIFY_LAST_CLOSE) { if (Console->ProcessIdLastNotifyClose == ProcessId) { // if this process is the one who wants last close notification, // remove it. Console->Flags &= ~CONSOLE_NOTIFY_LAST_CLOSE; NtClose(Console->hProcessLastNotifyClose); } else if (ProcessData->RootProcess) { // notify the ntvdm process to terminate if the console root // process is going away. HANDLE ConsoleHandle; CONSOLE_PROCESS_TERMINATION_RECORD ProcessHandleList; Console->Flags &= ~CONSOLE_NOTIFY_LAST_CLOSE; ConsoleHandle = Console->ConsoleHandle; ProcessHandleList.ProcessHandle = Console->hProcessLastNotifyClose; ProcessHandleList.TerminateCount = 0; ProcessHandleList.CtrlRoutine = CtrlRoutine; UnlockConsole(Console); CreateCtrlThread(&ProcessHandleList, 1, NULL, SYSTEM_ROOT_CONSOLE_EVENT, TRUE); NtClose(ProcessHandleList.ProcessHandle); Status = RevalidateConsole(ConsoleHandle, &Console); ASSERT(NT_SUCCESS(Status)); if (!NT_SUCCESS(Status)) { return STATUS_SUCCESS; } } } if (Console->VDMProcessId == ProcessId && (Console->Flags & CONSOLE_VDM_REGISTERED)) { Console->Flags &= ~CONSOLE_FULLSCREEN_NOPAINT; UnregisterVDM(Console); } if (ProcessHandle != NULL) { RemoveProcessFromList(Console,ProcessHandle); FreeCommandHistory(Console,ProcessHandle); } ASSERT(Console->RefCount); // // close the process's handles. // for (i=0;i<ProcessData->HandleTableSize;i++) { if (ProcessData->HandleTablePtr[i].HandleType != CONSOLE_FREE_HANDLE) { Status = DereferenceIoHandleNoCheck(ProcessData, (HANDLE) i, &HandleData ); ASSERT (NT_SUCCESS(Status)); if (HandleData->HandleType & CONSOLE_INPUT_HANDLE) { Status = CloseInputHandle(ProcessData,Console,HandleData,(HANDLE) i); } else { Status = CloseOutputHandle(ProcessData,Console,HandleData,(HANDLE) i,FALSE); } } } FreeProcessData(ProcessData); ProcessData->ConsoleHandle = NULL; // // decrement the console reference count. free the console if it goes to // zero. // Console->RefCount--; if (Console->RefCount == 0) { #if defined(FE_IME) PCONVERSIONAREA_INFORMATION ConvAreaInfo; PCONVERSIONAREA_INFORMATION ConvAreaInfoNext; ConvAreaInfo = Console->ConsoleIme.ConvAreaRoot; while(ConvAreaInfo) { ConvAreaInfoNext = ConvAreaInfo->ConvAreaNext; FreeConvAreaScreenBuffer(ConvAreaInfo->ScreenBuffer); ConsoleHeapFree(ConvAreaInfo); ConvAreaInfo = ConvAreaInfoNext; } if (Console->ConsoleIme.NumberOfConvAreaCompStr) { ConsoleHeapFree(Console->ConsoleIme.ConvAreaCompStr); } if (Console->ConsoleIme.CompStrData) { ConsoleHeapFree(Console->ConsoleIme.CompStrData); } #endif FreeCon(Console); } else { UnlockConsole(Console); } return( STATUS_SUCCESS ); }

VOID RemoveProcessFromList (  IN OUT PCONSOLE_INFORMATION  Console, IN HANDLE  ProcessHandle )

Definition at line 932 of file srvinit.c. References ASSERT, ConsoleHeapFree, FALSE, _CONSOLE_PROCESS_HANDLE::ListLink, and _CONSOLE_PROCESS_HANDLE::ProcessHandle. Referenced by RemoveConsole(). { PCONSOLE_PROCESS_HANDLE ProcessHandleRecord; PLIST_ENTRY ListHead, ListNext; ListHead = &Console->ProcessHandleList; ListNext = ListHead->Flink; while (ListNext != ListHead) { ProcessHandleRecord = CONTAINING_RECORD( ListNext, CONSOLE_PROCESS_HANDLE, ListLink ); ListNext = ListNext->Flink; if (ProcessHandleRecord->ProcessHandle == ProcessHandle) { RemoveEntryList(&ProcessHandleRecord->ListLink); ConsoleHeapFree(ProcessHandleRecord); return; } } ASSERT (FALSE); }

NTSTATUS SetUpConsole (  IN OUT PCONSOLE_INFO  ConsoleInfo, IN DWORD  TitleLength, IN LPWSTR  Title, IN LPWSTR  CurDir, IN LPWSTR  AppName, IN PCONSOLE_PER_PROCESS_DATA  ProcessData, IN BOOLEAN  WindowVisible, IN PUNICODE_STRING  pstrDesktopName )

Definition at line 955 of file srvinit.c. References AllocateConsole(), AllocateConsoleHandle(), ASSERT, CloseWindowStation, CONSOLE_CLIENTPROCESSHANDLE, CONSOLE_IS_IME_ENABLED, CONSOLE_SETCONSOLEHANDLE, DereferenceConsoleHandle(), DWORD, FALSE, FreeConsoleHandle(), _CONSOLE_INFORMATION::hDesk, _CONSOLE_INFORMATION::hWinSta, InitWindowsStuff(), LoadLinkInfo(), LockConsoleHandleTable, NT_SUCCESS, NTSTATUS(), NtUserResolveDesktop(), NULL, _CONSOLE_INFORMATION::RefCount, Status, UnlockConsoleHandleTable, and USHORT. Referenced by ConsoleClientConnectRoutine(), and SrvAllocConsole(). { NTSTATUS Status; PCONSOLE_INFORMATION Console; DWORD ConsoleThreadId; HWINSTA hwinsta; HDESK hdesk; USEROBJECTFLAGS UserObjectFlags; DWORD Length; // // Connect to the windowstation and desktop. // if (!CsrImpersonateClient(NULL)) { return STATUS_BAD_IMPERSONATION_LEVEL; } hdesk = NtUserResolveDesktop(CONSOLE_CLIENTPROCESSHANDLE(), pstrDesktopName, FALSE, &hwinsta); CsrRevertToSelf(); if (hdesk == NULL) { return STATUS_UNSUCCESSFUL; } // // Need to initialize windows stuff once real console app starts. // This is because for the time being windows expects the first // app to be a windows app. // Status = InitWindowsStuff(hdesk, &ConsoleThreadId); if (!NT_SUCCESS(Status)) { CloseDesktop(hdesk); CloseWindowStation(hwinsta); return Status; } // // If the windowstation isn't visible, then neither is the window. // if (WindowVisible) { if (GetUserObjectInformation(hwinsta, UOI_FLAGS, &UserObjectFlags, sizeof(UserObjectFlags), &Length)) { if (!(UserObjectFlags.dwFlags & WSF_VISIBLE)) { WindowVisible = FALSE; } } } // // We need to see if we were spawned from a link. If we were, we // need to call back into the shell to try to get all the console // information from the link. // LoadLinkInfo( ConsoleInfo, Title, &TitleLength, CurDir, AppName ); LockConsoleHandleTable(); Status = AllocateConsoleHandle(&ConsoleInfo->ConsoleHandle); if (!NT_SUCCESS(Status)) { UnlockConsoleHandleTable(); CloseDesktop(hdesk); CloseWindowStation(hwinsta); return Status; } Status = AllocateConsole(ConsoleInfo->ConsoleHandle, Title, (USHORT)TitleLength, CONSOLE_CLIENTPROCESSHANDLE(), &ConsoleInfo->StdIn, &ConsoleInfo->StdOut, &ConsoleInfo->StdErr, ProcessData, ConsoleInfo, WindowVisible, ConsoleThreadId ); if (!NT_SUCCESS(Status)) { FreeConsoleHandle(ConsoleInfo->ConsoleHandle); UnlockConsoleHandleTable(); CloseDesktop(hdesk); CloseWindowStation(hwinsta); return Status; } CONSOLE_SETCONSOLEHANDLE(ConsoleInfo->ConsoleHandle); Status = DereferenceConsoleHandle(ConsoleInfo->ConsoleHandle,&Console); ASSERT (NT_SUCCESS(Status)); // // increment console reference count // Console->RefCount++; // // Save the windowstation and desktop handles so they // can be used later // Console->hWinSta = hwinsta; Console->hDesk = hdesk; UnlockConsoleHandleTable(); #if defined(FE_IME) if (CONSOLE_IS_IME_ENABLED()) { if (WindowVisible) { InitConsoleIMEStuff(Console->hDesk, ConsoleThreadId, Console); } } #endif return Status; }

ULONG SrvAllocConsole (  IN OUT PCSR_API_MSG  m, IN OUT PCSR_REPLY_STATUS  ReplyStatus )

Definition at line 1537 of file srvinit.c. References AddProcessToList(), AllocateCommandHistory(), _CONSOLE_ALLOC_MSG::AppName, _CONSOLE_ALLOC_MSG::AppNameLength, ASSERT, BYTE, CONSOLE_CLIENTPROCESSHANDLE, CONSOLE_GETCONSOLEAPPFROMPROCESSDATA, CONSOLE_HAS_FOCUS, CONSOLE_PERPROCESSDATA, CONSOLE_SETCONSOLEAPP, CONSOLE_SHUTTING_DOWN, _CONSOLE_INFO::ConsoleHandle, ConsoleHeapAlloc, ConsoleHeapFree, _CONSOLE_ALLOC_MSG::ConsoleInfo, _CONSOLE_ALLOC_MSG::CtrlRoutine, _CONSOLE_PROCESS_HANDLE::CtrlRoutine, _CONSOLE_ALLOC_MSG::CurDir, _CONSOLE_ALLOC_MSG::CurDirLength, _CONSOLE_ALLOC_MSG::Desktop, _CONSOLE_ALLOC_MSG::DesktopLength, _CONSOLE_INFORMATION::Flags, HANDLE_TAG, L, MAKE_TAG, NT_SUCCESS, NTSTATUS(), NULL, PCONSOLE_ALLOC_MSG, _CONSOLE_PROCESS_HANDLE::Process, _CONSOLE_ALLOC_MSG::PropRoutine, _CONSOLE_PROCESS_HANDLE::PropRoutine, RevalidateConsole(), RtlInitUnicodeString(), SetProcessForegroundRights(), SetUpConsole(), Status, _CONSOLE_ALLOC_MSG::Title, _CONSOLE_ALLOC_MSG::TitleLength, TRUE, and UnlockConsole(). { PCONSOLE_ALLOC_MSG a = (PCONSOLE_ALLOC_MSG)&m->u.ApiMessageData; PCONSOLE_PER_PROCESS_DATA ProcessData; NTSTATUS Status; PCONSOLE_INFORMATION Console; PCONSOLE_PROCESS_HANDLE ProcessHandleRecord; PCSR_PROCESS Process; UNICODE_STRING strDesktopName; ProcessData = CONSOLE_PERPROCESSDATA(); ASSERT(!CONSOLE_GETCONSOLEAPPFROMPROCESSDATA(ProcessData)); if (!CsrValidateMessageBuffer(m, &a->Title, a->TitleLength, sizeof(BYTE)) || !CsrValidateMessageBuffer(m, &a->Desktop, a->DesktopLength, sizeof(BYTE)) || !CsrValidateMessageBuffer(m, &a->CurDir, a->CurDirLength, sizeof(BYTE)) || !CsrValidateMessageBuffer(m, &a->AppName, a->AppNameLength, sizeof(BYTE)) || !CsrValidateMessageBuffer(m, &a->ConsoleInfo, sizeof(*a->ConsoleInfo), sizeof(BYTE))) { return STATUS_INVALID_PARAMETER; } Process = (PCSR_PROCESS)(CSR_SERVER_QUERYCLIENTTHREAD()->Process); if (a->DesktopLength) RtlInitUnicodeString(&strDesktopName, a->Desktop); else RtlInitUnicodeString(&strDesktopName, L"Default"); ProcessHandleRecord = ConsoleHeapAlloc(MAKE_TAG( HANDLE_TAG ),sizeof(CONSOLE_PROCESS_HANDLE)); if (ProcessHandleRecord == NULL) { return (ULONG)STATUS_NO_MEMORY; } Status = SetUpConsole(a->ConsoleInfo, a->TitleLength, a->Title, a->CurDir, a->AppName, ProcessData, TRUE, &strDesktopName); if (!NT_SUCCESS(Status)) { ConsoleHeapFree(ProcessHandleRecord); return Status; } CONSOLE_SETCONSOLEAPP(TRUE); Process->Flags |= CSR_PROCESS_CONSOLEAPP; Status = RevalidateConsole(a->ConsoleInfo->ConsoleHandle,&Console); ASSERT (NT_SUCCESS(Status)); ProcessHandleRecord->Process = CSR_SERVER_QUERYCLIENTTHREAD()->Process; ProcessHandleRecord->CtrlRoutine = a->CtrlRoutine; ProcessHandleRecord->PropRoutine = a->PropRoutine; ASSERT (!(Console->Flags & CONSOLE_SHUTTING_DOWN)); AddProcessToList(Console,ProcessHandleRecord,CONSOLE_CLIENTPROCESSHANDLE()); SetProcessForegroundRights(Process, Console->Flags & CONSOLE_HAS_FOCUS); (HANDLE) AllocateCommandHistory(Console, a->AppNameLength, a->AppName, CONSOLE_CLIENTPROCESSHANDLE()); UnlockConsole(Console); return STATUS_SUCCESS; UNREFERENCED_PARAMETER(ReplyStatus); // get rid of unreferenced parameter warning message }

ULONG SrvFreeConsole (  IN OUT PCSR_API_MSG  m, IN OUT PCSR_REPLY_STATUS  ReplyStatus )

Definition at line 1608 of file srvinit.c. References ASSERT, CONSOLE_CLIENTPROCESSHANDLE, CONSOLE_CLIENTPROCESSID, CONSOLE_GETCONSOLEAPPFROMPROCESSDATA, CONSOLE_GETCONSOLEHANDLEFROMPROCESSDATA, CONSOLE_PERPROCESSDATA, CONSOLE_SETCONSOLEAPP, _CONSOLE_FREE_MSG::ConsoleHandle, FALSE, NT_SUCCESS, NTSTATUS(), PCONSOLE_FREE_MSG, RemoveConsole(), and Status. { PCONSOLE_FREE_MSG a = (PCONSOLE_FREE_MSG)&m->u.ApiMessageData; PCONSOLE_PER_PROCESS_DATA ProcessData; NTSTATUS Status; ProcessData = CONSOLE_PERPROCESSDATA(); ASSERT (CONSOLE_GETCONSOLEAPPFROMPROCESSDATA(ProcessData)); ASSERT(CONSOLE_GETCONSOLEHANDLEFROMPROCESSDATA(ProcessData)==a->ConsoleHandle); Status = RemoveConsole(ProcessData, CONSOLE_CLIENTPROCESSHANDLE(), CONSOLE_CLIENTPROCESSID()); if (NT_SUCCESS(Status)) { CONSOLE_SETCONSOLEAPP(FALSE); } return Status; UNREFERENCED_PARAMETER(ReplyStatus); // get rid of unreferenced parameter warning message }

ULONG SrvGetConsoleLangId (  IN OUT PCSR_API_MSG  m, IN OUT PCSR_REPLY_STATUS  ReplyStatus )

Definition at line 2680 of file srvinit.c. References ApiPreamble(), _CONSOLE_LANGID_MSG::ConsoleHandle, GetConsoleLangId(), _CONSOLE_LANGID_MSG::LangId, NT_SUCCESS, NTSTATUS(), _CONSOLE_INFORMATION::OutputCP, PCONSOLE_LANGID_MSG, Status, and UnlockConsole(). { PCONSOLE_LANGID_MSG a = (PCONSOLE_LANGID_MSG)&m->u.ApiMessageData; NTSTATUS Status; PCONSOLE_INFORMATION Console; Status = ApiPreamble(a->ConsoleHandle, &Console ); if (!NT_SUCCESS(Status)) { return Status; } Status = GetConsoleLangId(Console->OutputCP, &a->LangId); UnlockConsole(Console); return((ULONG) Status); UNREFERENCED_PARAMETER(ReplyStatus); // get rid of unreferenced parameter warning message }

LPWSTR TranslateConsoleTitle (  LPWSTR  ConsoleTitle, PUSHORT  pcbTranslatedTitle, BOOL  Unexpand, BOOL  Substitute )

Definition at line 1831 of file srvinit.c. References ConsoleHeapAlloc, MAKE_TAG, MyStringCompareW(), NULL, PBYTE, SYSTEM_ROOT, SYSTEM_ROOT_LENGTH, TITLE_TAG, TRUE, and USHORT. Referenced by AllocateConsole(), and GetRegistryValues(). : This routine translates path characters into '_' characters because the NT registry apis do not allow the creation of keys with names that contain path characters. It also converts absolute paths into %SystemRoot% relative ones. As an example, if both behaviors were specified it would convert a title like C:\WINNT\System32\cmd.exe to %SystemRoot%_System32_cmd.exe. Arguments: ConsoleTitle - Pointer to string to translate. pcbTranslatedTitle - On return, contains size of translated title. Unexpand - Convert absolute path to %SystemRoot% relative one. Substitute - Replace '\' with '_' in path. Return Value: Pointer to translated title or NULL. Note: This routine allocates a buffer that must be freed. --*/ { USHORT cbConsoleTitle,i; USHORT cbSystemRoot; LPWSTR TranslatedConsoleTitle,Tmp; cbConsoleTitle = (USHORT)((lstrlenW(ConsoleTitle) + 1) * sizeof(WCHAR)); cbSystemRoot = (USHORT)(lstrlenW(USER_SHARED_DATA->NtSystemRoot) * sizeof(WCHAR)); if (Unexpand && !MyStringCompareW(ConsoleTitle, USER_SHARED_DATA->NtSystemRoot, cbSystemRoot, TRUE)) { cbConsoleTitle -= cbSystemRoot; (PBYTE)ConsoleTitle += cbSystemRoot; cbSystemRoot = SYSTEM_ROOT_LENGTH; } else { cbSystemRoot = 0; } Tmp = TranslatedConsoleTitle = ConsoleHeapAlloc(MAKE_TAG( TITLE_TAG ),cbSystemRoot + cbConsoleTitle); if (TranslatedConsoleTitle == NULL) { return NULL; } RtlCopyMemory(TranslatedConsoleTitle, SYSTEM_ROOT, cbSystemRoot); (PBYTE)TranslatedConsoleTitle += cbSystemRoot; for (i=0;i<cbConsoleTitle;i+=sizeof(WCHAR)) { if (Substitute && *ConsoleTitle == '\\') { *TranslatedConsoleTitle++ = (WCHAR)'_'; } else { *TranslatedConsoleTitle++ = *ConsoleTitle; } ConsoleTitle++; } if (pcbTranslatedTitle) { *pcbTranslatedTitle = cbSystemRoot + cbConsoleTitle; } return Tmp; }

VOID UnregisterVDM (  IN PCONSOLE_INFORMATION  Console  )

Definition at line 980 of file server/private.c. References AdjustCursorPosition, ASSERT, BOOL, ConnectToEmulator(), CONSOLE_CONNECTED_TO_EMULATOR, CONSOLE_HAS_FOCUS, CONSOLE_TEXTMODE_BUFFER, CONSOLE_VDM_REGISTERED, CONSOLE_WOW_REGISTERED, FALSE, FS_MODE_GRAPHICS, FullScreenInitialized, Index, IsAvailableFsCodePage(), JAPAN_CP, KOREAN_CP, _MODE_FONT_PAIR::Mode, NtClose(), NtUnmapViewOfSection(), NtUserConsoleControl(), NtUserSetInformationThread(), NULL, RegModeFontPairs, _MODE_FONT_PAIR::Resolution, TIF_DOSEMULATOR, TIF_VDMAPP, and TRUE. Referenced by DisplayModeTransition(), RemoveConsole(), and SrvRegisterConsoleVDM(). { // williamh, Feb 2 1994. // catch multiple calls to unregister vdm. Believe it or not, this could // happen ASSERT(Console->Flags & CONSOLE_VDM_REGISTERED); if (!(Console->Flags & CONSOLE_VDM_REGISTERED)) return; #if defined(FE_SB) && defined(i386) // When HDOS apps exit, console screen resolution is changed to 640*400. Because HBIOS set // Screen resolution to 640*400. So, we should replace current screen resoultion(640*480). // 09/11/96 bklee { if ((Console->FullScreenFlags & CONSOLE_FULLSCREEN_HARDWARE) && ( Console->OutputCP == KOREAN_CP || (Console->OutputCP == JAPAN_CP && ISNECPC98(gdwMachineId) ) )) { ULONG Index; DEVMODEW Devmode; BOOL fGraphics = fFullScreenGraphics ? IsAvailableFsCodePage(Console->OutputCP) : FALSE; Index = Console->CurrentScreenBuffer->BufferInfo.TextInfo.ModeIndex; ZeroMemory(&Devmode, sizeof(Devmode)); Devmode.dmSize = sizeof(Devmode); Devmode.dmDriverExtra = 0; Devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFLAGS; Devmode.dmBitsPerPel = 4; Devmode.dmPelsWidth = RegModeFontPairs[Index].Resolution.X; Devmode.dmPelsHeight = RegModeFontPairs[Index].Resolution.Y; Devmode.dmDisplayFlags = (fGraphics && (RegModeFontPairs[Index].Mode & FS_MODE_GRAPHICS)) ? 0 : DMDISPLAYFLAGS_TEXTMODE; GdiFullscreenControl(FullscreenControlSetMode, &Devmode, sizeof(Devmode), NULL, NULL); } } #endif #ifdef i386 if (Console->FullScreenFlags & CONSOLE_FULLSCREEN_HARDWARE && Console->Flags & CONSOLE_CONNECTED_TO_EMULATOR) { NtUserConsoleControl(ConsoleSetVDMCursorBounds, NULL, 0); // connect emulator ConnectToEmulator(FALSE, Console); } if (FullScreenInitialized) { CloseHandle(Console->VDMStartHardwareEvent); CloseHandle(Console->VDMEndHardwareEvent); NtUnmapViewOfSection(NtCurrentProcess(),Console->StateBuffer); NtUnmapViewOfSection(Console->VDMProcessHandle,Console->StateBufferClient); NtClose(Console->StateSectionHandle); Console->StateLength = 0; } #endif Console->Flags &= ~CONSOLE_VDM_REGISTERED; if (Console->Flags & CONSOLE_HAS_FOCUS) { USERTHREAD_FLAGS Flags; Flags.dwFlags = 0; Flags.dwMask = (TIF_VDMAPP | TIF_DOSEMULATOR); NtUserSetInformationThread(Console->InputThreadInfo->ThreadHandle, UserThreadFlags, &Flags, sizeof(Flags)); } Console->Flags &= ~CONSOLE_WOW_REGISTERED; ASSERT(Console->VDMBuffer != NULL); if (Console->VDMBuffer != NULL) { NtUnmapViewOfSection(Console->VDMProcessHandle,Console->VDMBufferClient); NtUnmapViewOfSection(NtCurrentProcess(),Console->VDMBuffer); NtClose(Console->VDMBufferSectionHandle); Console->VDMBuffer = NULL; } #ifdef i386 if (Console->CurrentScreenBuffer && Console->CurrentScreenBuffer->Flags & CONSOLE_TEXTMODE_BUFFER) { Console->CurrentScreenBuffer->BufferInfo.TextInfo.MousePosition.X = 0; Console->CurrentScreenBuffer->BufferInfo.TextInfo.MousePosition.Y = 0; } #endif ASSERT(Console->VDMProcessHandle); CloseHandle(Console->VDMProcessHandle); Console->VDMProcessHandle = NULL; #if defined(FE_SB) && defined(FE_IME) && defined(i386) { if (Console->FullScreenFlags & CONSOLE_FULLSCREEN) { Console->Flags |= CONSOLE_JUST_VDM_UNREGISTERED ; } else if (Console->CurrentScreenBuffer->Flags & CONSOLE_TEXTMODE_BUFFER) { AdjustCursorPosition(Console->CurrentScreenBuffer, Console->CurrentScreenBuffer->BufferInfo.TextInfo.CursorPosition, TRUE, NULL); } } #endif }

---

Variable Documentation

CRITICAL_SECTION ConsoleInitWindowsLock

Definition at line 300 of file srvinit.c. Referenced by ConServerDllInitialization(), and InitWindowsStuff().

UINT ConsoleOutputCP

Definition at line 305 of file srvinit.c. Referenced by AllocateConsole(), and ConServerDllInitialization().

CONST PCSR_API_ROUTINE ConsoleServerApiDispatchTable[ConsolepMaxApiNumber-ConsolepOpenConsole]

Definition at line 26 of file srvinit.c. Referenced by ConServerDllInitialization().

CONST BOOLEAN ConsoleServerApiServerValidTable[ConsolepMaxApiNumber-ConsolepOpenConsole]

Definition at line 115 of file srvinit.c. Referenced by ConServerDllInitialization().

CRITICAL_SECTION ConsoleVDMCriticalSection

Definition at line 296 of file srvinit.c. Referenced by ApiPreamble(), ConServerDllInitialization(), DisplayModeTransition(), and UnlockConsole().

PCONSOLE_INFORMATION ConsoleVDMOnSwitching

Definition at line 297 of file srvinit.c. Referenced by ApiPreamble(), ConServerDllInitialization(), DisplayModeTransition(), and UnlockConsole().

CONSOLE_REGISTRY_INFO DefaultRegInfo

Definition at line 306 of file srvinit.c. Referenced by GetRegistryValues(), InitializeConsoleAttributes(), InitializeScrollBuffer(), InitWindowClass(), InitWindowsStuff(), and LoadLinkInfo().

DWORD dwConBaseTag

Definition at line 353 of file srvinit.c. Referenced by ConServerDllInitialization().

BOOL fOneTimeInitialized

Definition at line 301 of file srvinit.c. Referenced by ConsoleInputThread(), and InitWindowsStuff().

BOOL FullScreenInitialized

Definition at line 295 of file srvinit.c. Referenced by DisplayModeTransition(), DoCreateScreenBuffer(), HandleSysKeyEvent(), InitWindowsStuff(), PropertiesUpdate(), SrvRegisterConsoleVDM(), SrvSetConsoleDisplayMode(), and UnregisterVDM().

DWORD gExtendedEditKey

Definition at line 355 of file srvinit.c. Referenced by GetRegistryValues(), IsCommandLineEditingKey(), IsCommandLinePopupKey(), IsPauseKey(), ParseEditKeyInfo(), and ProcessCookedReadInput().

BOOL gfLoadConIme

Definition at line 358 of file srvinit.c. Referenced by GetRegistryValues().

BOOL gfTrimLeadingZeros

Definition at line 356 of file srvinit.c. Referenced by GetRegistryValues(), and HandleMouseEvent().

HICON ghDefaultIcon

Definition at line 348 of file srvinit.c. Referenced by ConsoleWindowProc(), CreateWindowsWindow(), DestroyWindowsWindow(), InitWindowClass(), LoadLinkInfo(), and SrvSetConsoleIcon().

HICON ghDefaultSmIcon

Definition at line 349 of file srvinit.c. Referenced by ConsoleWindowProc(), CreateWindowsWindow(), DestroyWindowsWindow(), InitWindowClass(), LoadLinkInfo(), and SrvSetConsoleIcon().

HANDLE ghInstance

Definition at line 347 of file srvinit.c. Referenced by CommandNumberPopup(), ConServerDllInitialization(), CopyFromCharPopup(), CopyToCharPopup(), CreateWindowsWindow(), DoFind(), HandleSysKeyEvent(), InitSystemMenu(), InitWindowClass(), MyModifyMenuItem(), ProcessCreateConsoleWindow(), SetUpConsoleInfo(), and SetWinText().

HCURSOR ghNormalCursor

Definition at line 350 of file srvinit.c. Referenced by CreateScreenBuffer(), InitWindowClass(), and SrvSetConsoleCursor().

UINT OEMCP

Definition at line 303 of file srvinit.c. Referenced by AllocateConsole(), CharToWchar(), CharToWcharGlyph(), ConServerDllInitialization(), ConvertInputToUnicode(), ConvertOutputToOem(), ConvertOutputToUnicode(), ConvertToOem(), FalseUnicodeToRealUnicode(), GetRegistryValues(), InitializeConsoleAttributes(), LoadLinkInfo(), RealUnicodeToFalseUnicode(), SetRAMFontCodePage(), SrvGetConsoleTitle(), SrvSetConsoleCP(), SrvSetConsoleTitle(), WcharToChar(), and WWSB_DoSrvWriteConsole().

PWIN32HEAP pConHeap

Definition at line 352 of file srvinit.c. Referenced by ConServerDllInitialization().

UINT WINDOWSCP

Definition at line 304 of file srvinit.c. Referenced by ConServerDllInitialization(), FalseUnicodeToRealUnicode(), ReadOutputString(), RealUnicodeToFalseUnicode(), SB_TranslateOutputToOem(), SB_TranslateOutputToUnicode(), SrvInvalidateBitMapRect(), WWSB_DoSrvWriteConsole(), WWSB_FillOutput(), and WWSB_WriteOutputString().

---