ReactOS 0.4.15-dev-7906-g1b85a5f
console.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

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

Functions

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

Macro Definition Documentation

◆ HANDLE_CREATE_NEW_CONSOLE

#define HANDLE_CREATE_NEW_CONSOLE   (HANDLE)-2

Definition at line 14 of file console.h.

◆ HANDLE_CREATE_NO_WINDOW

#define HANDLE_CREATE_NO_WINDOW   (HANDLE)-3

Definition at line 15 of file console.h.

◆ HANDLE_DETACHED_PROCESS

#define HANDLE_DETACHED_PROCESS   (HANDLE)-1

Definition at line 13 of file console.h.

Function Documentation

◆ CloseConsoleHandle()

BOOL WINAPI CloseConsoleHandle ( HANDLE  Handle)

Definition at line 1142 of file console.c.

1143{
1144 CONSOLE_API_MESSAGE ApiMessage;
1145 PCONSOLE_CLOSEHANDLE CloseHandleRequest = &ApiMessage.Data.CloseHandleRequest;
1146
1147 CloseHandleRequest->ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
1148 CloseHandleRequest->Handle = hHandle;
1149
1151 NULL,
1153 sizeof(*CloseHandleRequest));
1154 if (!NT_SUCCESS(ApiMessage.Status))
1155 {
1156 BaseSetLastNTError(ApiMessage.Status);
1157 return FALSE;
1158 }
1159
1160 return TRUE;
1161}
#define NtCurrentPeb()
Definition: FLS.c:22
@ ConsolepCloseHandle
Definition: conmsg.h:55
#define CONSRV_SERVERDLL_INDEX
Definition: conmsg.h:15
#define CSR_CREATE_API_NUMBER(ServerId, ApiId)
Definition: csrmsg.h:37
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
DWORD BaseSetLastNTError(IN NTSTATUS Status)
Definition: reactos.cpp:166
NTSTATUS NTAPI CsrClientCallServer(_Inout_ PCSR_API_MESSAGE ApiMessage, _Inout_opt_ PCSR_CAPTURE_BUFFER CaptureBuffer, _In_ CSR_API_NUMBER ApiNumber, _In_ ULONG DataLength)
Definition: connect.c:366
CONSOLE_CLOSEHANDLE CloseHandleRequest
Definition: conmsg.h:935
union _CONSOLE_API_MESSAGE::@3540 Data
HANDLE ConsoleHandle
Definition: conmsg.h:626
NTSTATUS Status
Definition: csrmsg.h:110

Referenced by CloseHandle().

◆ ConDllInitialize()

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

Definition at line 338 of file init.c.

340{
343 BOOLEAN InServerProcess = FALSE;
344 CONSRV_API_CONNECTINFO ConnectInfo;
345
347 {
349 {
350 /* Sync the new thread's LangId with the console's one */
351 SetTEBLangID();
352 }
353 else if (Reason == DLL_PROCESS_DETACH)
354 {
355 /* Free our resources */
357 {
360 }
361 }
362
363 return TRUE;
364 }
365
366 DPRINT("ConDllInitialize for: %wZ\n"
367 "Our current console handles are: 0x%p, 0x%p, 0x%p 0x%p\n",
368 &Parameters->ImagePathName,
369 Parameters->ConsoleHandle,
370 Parameters->StandardInput,
371 Parameters->StandardOutput,
372 Parameters->StandardError);
373
374 /* Initialize our global console DLL lock */
376 if (!NT_SUCCESS(Status)) return FALSE;
378
379 /* Show by default the console window when applicable */
380 ConnectInfo.IsWindowVisible = TRUE;
381 /* If this is a console app, a console will be created/opened */
382 ConnectInfo.IsConsoleApp = IsConsoleApp();
383
384 /* Do nothing if this is not a console app... */
385 if (!ConnectInfo.IsConsoleApp)
386 {
387 DPRINT("Image is not a console application\n");
388 }
389
390 /*
391 * Handle the special flags given to us by BasePushProcessParameters.
392 */
393 if (Parameters->ConsoleHandle == HANDLE_DETACHED_PROCESS)
394 {
395 /* No console to create */
396 DPRINT("No console to create\n");
397 /*
398 * The new process does not inherit its parent's console and cannot
399 * attach to the console of its parent. The new process can call the
400 * AllocConsole function at a later time to create a console.
401 */
402 Parameters->ConsoleHandle = NULL; // Do not inherit the parent's console.
403 ConnectInfo.IsConsoleApp = FALSE; // Do not create any console.
404 }
405 else if (Parameters->ConsoleHandle == HANDLE_CREATE_NEW_CONSOLE)
406 {
407 /* We'll get the real one soon */
408 DPRINT("Creating a new separate console\n");
409 /*
410 * The new process has a new console, instead of inheriting
411 * its parent's console.
412 */
413 Parameters->ConsoleHandle = NULL; // Do not inherit the parent's console.
414 }
415 else if (Parameters->ConsoleHandle == HANDLE_CREATE_NO_WINDOW)
416 {
417 /* We'll get the real one soon */
418 DPRINT("Creating a new invisible console\n");
419 /*
420 * The process is a console application that is being run
421 * without a console window. Therefore, the console handle
422 * for the application is not set.
423 */
424 Parameters->ConsoleHandle = NULL; // Do not inherit the parent's console.
425 ConnectInfo.IsWindowVisible = FALSE; // A console is created but is not shown to the user.
426 }
427 else
428 {
429 DPRINT("Using existing console: 0x%p\n", Parameters->ConsoleHandle);
430 }
431
432 /* Do nothing if this is not a console app... */
433 if (!ConnectInfo.IsConsoleApp)
434 {
435 /* Do not inherit the parent's console if we are not a console app */
436 Parameters->ConsoleHandle = NULL;
437 }
438
439 /* Now use the proper console handle */
440 ConnectInfo.ConsoleStartInfo.ConsoleHandle = Parameters->ConsoleHandle;
441
442 /* Initialize the console dispatchers */
444 ConnectInfo.PropRoutine = PropDialogHandler;
445 // ConnectInfo.ImeRoutine = ImeRoutine;
446
447 /* Set up the console properties */
448 if (ConnectInfo.IsConsoleApp && Parameters->ConsoleHandle == NULL)
449 {
450 /*
451 * We can set up the console properties only if we create a new one
452 * (we do not inherit it from our parent).
453 */
454
455 LPWSTR ConsoleTitle = ConnectInfo.ConsoleTitle;
456
457 ConnectInfo.TitleLength = sizeof(ConnectInfo.ConsoleTitle);
458 ConnectInfo.DesktopLength = 0; // SetUpConsoleInfo will give us the real length.
459
461 &ConnectInfo.TitleLength,
462 &ConsoleTitle,
463 &ConnectInfo.DesktopLength,
464 &ConnectInfo.Desktop,
465 &ConnectInfo.ConsoleStartInfo);
466 DPRINT("ConsoleTitle = '%S' - Desktop = '%S'\n",
467 ConsoleTitle, ConnectInfo.Desktop);
468 }
469 else
470 {
471 ConnectInfo.TitleLength = 0;
472 ConnectInfo.DesktopLength = 0;
473 }
474
475 /* Initialize the Input EXE name */
476 if (ConnectInfo.IsConsoleApp)
477 {
478 LPWSTR CurDir = ConnectInfo.CurDir;
479 LPWSTR AppName = ConnectInfo.AppName;
480
481 InitExeName();
482
483 ConnectInfo.CurDirLength = sizeof(ConnectInfo.CurDir);
484 ConnectInfo.AppNameLength = sizeof(ConnectInfo.AppName);
485
487 &ConnectInfo.CurDirLength,
488 &CurDir,
489 &ConnectInfo.AppNameLength,
490 &AppName);
491 DPRINT("CurDir = '%S' - AppName = '%S'\n",
492 CurDir, AppName);
493 }
494 else
495 {
496 ConnectInfo.CurDirLength = 0;
497 ConnectInfo.AppNameLength = 0;
498 }
499
500 /*
501 * Initialize Console Ctrl Handling, that needs to be supported by
502 * all applications, especially because it is used at shutdown.
503 */
505
506 /* Connect to the Console Server */
507 if (!ConnectConsole(SessionDir,
508 &ConnectInfo,
509 &InServerProcess))
510 {
511 // DPRINT1("Failed to connect to the Console Server (Status %lx)\n", Status);
512 return FALSE;
513 }
514
515 /* If we are not doing server-to-server init and if this is a console app... */
516 if (!InServerProcess && ConnectInfo.IsConsoleApp)
517 {
518 /* ... set the handles that we got */
519 if (Parameters->ConsoleHandle == NULL)
520 SetUpHandles(&ConnectInfo.ConsoleStartInfo);
521
523
524 /* Sync the current thread's LangId with the console's one */
525 SetTEBLangID();
526 }
527
528 DPRINT("Console setup: 0x%p, 0x%p, 0x%p, 0x%p\n",
529 Parameters->ConsoleHandle,
530 Parameters->StandardInput,
531 Parameters->StandardOutput,
532 Parameters->StandardError);
533
534 return TRUE;
535}
unsigned char BOOLEAN
LONG NTSTATUS
Definition: precomp.h:26
static CHAR AppName[MAX_PATH]
Definition: dem.c:252
#define DLL_PROCESS_ATTACH
Definition: compat.h:131
#define DLL_PROCESS_DETACH
Definition: compat.h:130
#define DLL_THREAD_ATTACH
Definition: compat.h:132
VOID InitExeName(VOID)
Definition: console.c:216
DWORD WINAPI ConsoleControlDispatcher(IN LPVOID lpThreadParameter)
Definition: console.c:89
VOID SetTEBLangID(VOID)
Internal helper function used to synchronize the current thread's language ID with the one from the c...
Definition: console.c:3171
VOID InitializeCtrlHandling(VOID)
Definition: console.c:204
VOID SetUpAppName(IN BOOLEAN CaptureStrings, IN OUT LPDWORD CurDirLength, IN OUT LPWSTR *CurDir, IN OUT LPDWORD AppNameLength, IN OUT LPWSTR *AppName)
Definition: console.c:264
DWORD WINAPI PropDialogHandler(IN LPVOID lpThreadParameter)
Definition: init.c:34
VOID SetUpConsoleInfo(IN BOOLEAN CaptureTitle, IN OUT LPDWORD pTitleLength, IN OUT LPWSTR *lpTitle OPTIONAL, IN OUT LPDWORD pDesktopLength, IN OUT LPWSTR *lpDesktop OPTIONAL, IN OUT PCONSOLE_START_INFO ConsoleStartInfo)
Definition: init.c:134
RTL_CRITICAL_SECTION ConsoleLock
Definition: init.c:24
static BOOLEAN ConnectConsole(IN PWSTR SessionDir, IN PCONSRV_API_CONNECTINFO ConnectInfo, OUT PBOOLEAN InServerProcess)
Definition: init.c:285
HANDLE InputWaitHandle
Definition: console.c:38
VOID SetUpHandles(IN PCONSOLE_START_INFO ConsoleStartInfo)
Definition: init.c:250
static BOOLEAN IsConsoleApp(VOID)
Definition: init.c:276
BOOLEAN ConsoleInitialized
Definition: init.c:25
#define HANDLE_CREATE_NEW_CONSOLE
Definition: console.h:14
#define HANDLE_CREATE_NO_WINDOW
Definition: console.h:15
#define HANDLE_DETACHED_PROCESS
Definition: console.h:13
Status
Definition: gdiplustypes.h:25
PVOID PVOID PWCHAR PVOID USHORT PULONG Reason
Definition: env.c:47
NTSYSAPI NTSTATUS NTAPI RtlDeleteCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
NTSYSAPI NTSTATUS NTAPI RtlInitializeCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
#define DPRINT
Definition: sndvol32.h:71
HANDLE InputWaitHandle
Definition: conmsg.h:171
HANDLE ConsoleHandle
Definition: conmsg.h:170
BOOLEAN IsWindowVisible
Definition: conmsg.h:189
WCHAR ConsoleTitle[MAX_PATH+1]
Definition: conmsg.h:198
LPTHREAD_START_ROUTINE PropRoutine
Definition: conmsg.h:194
WCHAR AppName[128]
Definition: conmsg.h:204
WCHAR CurDir[MAX_PATH+1]
Definition: conmsg.h:206
CONSOLE_START_INFO ConsoleStartInfo
Definition: conmsg.h:186
LPTHREAD_START_ROUTINE CtrlRoutine
Definition: conmsg.h:193
_Must_inspect_result_ _In_ WDFQUEUE _In_opt_ WDFREQUEST _In_opt_ WDFFILEOBJECT _Inout_opt_ PWDF_REQUEST_PARAMETERS Parameters
Definition: wdfio.h:869
WCHAR * LPWSTR
Definition: xmlstorage.h:184

Referenced by DllMain().

◆ ConsoleControlDispatcher()

DWORD WINAPI ConsoleControlDispatcher ( IN LPVOID  lpThreadParameter)

Definition at line 89 of file console.c.

90{
91 DWORD nExitCode = 0;
92 DWORD CodeAndFlag = PtrToUlong(lpThreadParameter);
93 DWORD nCode = CodeAndFlag & MAXLONG;
94 UINT i;
95 EXCEPTION_RECORD erException;
96
97 DPRINT1("Console Dispatcher Active: %lx %lx\n", CodeAndFlag, nCode);
99
100 switch(nCode)
101 {
102 case CTRL_C_EVENT:
103 case CTRL_BREAK_EVENT:
104 {
105 if (IsDebuggerPresent())
106 {
107 erException.ExceptionCode = (nCode == CTRL_C_EVENT ?
109 erException.ExceptionFlags = 0;
110 erException.ExceptionRecord = NULL;
112 erException.NumberParameters = 0;
113
115 {
116 RtlRaiseException(&erException);
117 }
119 {
121
122 if ((nCode != CTRL_C_EVENT) ||
123 (NtCurrentPeb()->ProcessParameters->ConsoleFlags != 1))
124 {
125 for (i = NrCtrlHandlers; i > 0; i--)
126 {
127 if (CtrlHandlers[i - 1](nCode)) break;
128 }
129 }
130
132 }
133 _SEH2_END;
134
135 ExitThread(0);
136 }
137 break;
138 }
139
140 case CTRL_CLOSE_EVENT:
143 break;
144
146 /*
147 * In case the console app hasn't register for last close notification,
148 * just kill this console handler thread. We don't want that such apps
149 * get killed for unexpected reasons. On the contrary apps that registered
150 * can be killed because they expect to be.
151 */
153 break;
154
155 case 4:
157 break;
158
159 default:
160 ASSERT(FALSE);
161 break;
162 }
163
165
167
168 nExitCode = 0;
169 if ((nCode != CTRL_C_EVENT) || (NtCurrentPeb()->ProcessParameters->ConsoleFlags != 1))
170 {
171 for (i = NrCtrlHandlers; i > 0; i--)
172 {
173 if ((i == 1) &&
174 (CodeAndFlag & MINLONG) &&
175 ((nCode == CTRL_LOGOFF_EVENT) || (nCode == CTRL_SHUTDOWN_EVENT)))
176 {
177 DPRINT("Skipping system/service apps\n");
178 break;
179 }
180
181 if (CtrlHandlers[i - 1](nCode))
182 {
183 switch(nCode)
184 {
185 case CTRL_CLOSE_EVENT:
189 nExitCode = CodeAndFlag;
190 break;
191 }
192 break;
193 }
194 }
195 }
196
198
199 ExitThread(nExitCode);
200 return STATUS_SUCCESS;
201}
#define DPRINT1
Definition: precomp.h:8
static ULONG NrCtrlHandlers
Definition: console.c:31
static PHANDLER_ROUTINE * CtrlHandlers
Definition: console.c:30
RTL_CRITICAL_SECTION ConsoleLock
Definition: init.c:24
static BOOL WINAPI DefaultConsoleCtrlHandler(DWORD Event)
Definition: console.c:53
static BOOLEAN LastCloseNotify
Definition: console.c:33
BOOLEAN ConsoleInitialized
Definition: init.c:25
VOID WINAPI ExitProcess(IN UINT uExitCode)
Definition: proc.c:1487
BOOL WINAPI SetThreadPriority(IN HANDLE hThread, IN int nPriority)
Definition: thread.c:700
VOID WINAPI ExitThread(IN DWORD uExitCode)
Definition: thread.c:365
#define PtrToUlong(u)
Definition: config.h:107
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
unsigned long DWORD
Definition: ntddk_ex.h:95
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define ASSERT(a)
Definition: mode.c:44
unsigned int UINT
Definition: ndis.h:50
NTSYSAPI NTSTATUS NTAPI RtlEnterCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
NTSYSAPI NTSTATUS NTAPI RtlLeaveCriticalSection(_In_ PRTL_CRITICAL_SECTION CriticalSection)
NTSYSAPI VOID NTAPI RtlRaiseException(_In_ PEXCEPTION_RECORD ExceptionRecord)
#define DBG_CONTROL_BREAK
Definition: ntstatus.h:55
#define DBG_CONTROL_C
Definition: ntstatus.h:52
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:34
#define STATUS_SUCCESS
Definition: shellext.h:65
struct _EXCEPTION_RECORD * ExceptionRecord
Definition: compat.h:210
DWORD ExceptionCode
Definition: compat.h:208
DWORD NumberParameters
Definition: compat.h:212
DWORD ExceptionFlags
Definition: compat.h:209
PVOID ExceptionAddress
Definition: compat.h:211
#define MAXLONG
Definition: umtypes.h:116
#define MINLONG
Definition: umtypes.h:115
#define CONTROL_C_EXIT
Definition: winbase.h:333
HANDLE WINAPI GetCurrentThread(void)
Definition: proc.c:1148
#define THREAD_PRIORITY_HIGHEST
Definition: winbase.h:277
BOOL WINAPI IsDebuggerPresent(void)
Definition: debugger.c:580
#define CTRL_C_EVENT
Definition: wincon.h:68
#define CTRL_SHUTDOWN_EVENT
Definition: wincon.h:73
#define CTRL_BREAK_EVENT
Definition: wincon.h:69
#define CTRL_LOGOFF_EVENT
Definition: wincon.h:72
#define CTRL_LAST_CLOSE_EVENT
Definition: wincon.h:71
#define CTRL_CLOSE_EVENT
Definition: wincon.h:70

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

◆ DuplicateConsoleHandle()

HANDLE WINAPI DuplicateConsoleHandle ( HANDLE  hConsole,
DWORD  dwDesiredAccess,
BOOL  bInheritHandle,
DWORD  dwOptions 
)

Definition at line 424 of file console.c.

428{
429 CONSOLE_API_MESSAGE ApiMessage;
430 PCONSOLE_DUPLICATEHANDLE DuplicateHandleRequest = &ApiMessage.Data.DuplicateHandleRequest;
431
434 (dwDesiredAccess & ~(GENERIC_READ | GENERIC_WRITE))) )
435 {
438 }
439
440 DuplicateHandleRequest->ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
441 DuplicateHandleRequest->SourceHandle = hConsole;
442 DuplicateHandleRequest->DesiredAccess = dwDesiredAccess;
443 DuplicateHandleRequest->InheritHandle = bInheritHandle;
444 DuplicateHandleRequest->Options = dwOptions;
445
447 NULL,
449 sizeof(*DuplicateHandleRequest));
450 if (!NT_SUCCESS(ApiMessage.Status))
451 {
452 BaseSetLastNTError(ApiMessage.Status);
454 }
455
456 return DuplicateHandleRequest->TargetHandle;
457}
@ ConsolepDuplicateHandle
Definition: conmsg.h:52
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define SetLastError(x)
Definition: compat.h:752
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
#define GENERIC_READ
Definition: compat.h:135
static BOOL bInheritHandle
Definition: pipe.c:82
#define GENERIC_WRITE
Definition: nt_native.h:90
DWORD dwOptions
Definition: solitaire.cpp:25
CONSOLE_DUPLICATEHANDLE DuplicateHandleRequest
Definition: conmsg.h:937
#define DUPLICATE_SAME_ACCESS
#define DUPLICATE_CLOSE_SOURCE

Referenced by DuplicateHandle().

◆ GetConsoleHandleInformation()

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

Definition at line 465 of file console.c.

467{
468 CONSOLE_API_MESSAGE ApiMessage;
469 PCONSOLE_GETHANDLEINFO GetHandleInfoRequest = &ApiMessage.Data.GetHandleInfoRequest;
470
471 GetHandleInfoRequest->ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
472 GetHandleInfoRequest->Handle = hHandle;
473
475 NULL,
477 sizeof(*GetHandleInfoRequest));
478 if (!NT_SUCCESS(ApiMessage.Status))
479 {
480 BaseSetLastNTError(ApiMessage.Status);
481 return FALSE;
482 }
483
484 *lpdwFlags = GetHandleInfoRequest->Flags;
485
486 return TRUE;
487}
@ ConsolepGetHandleInformation
Definition: conmsg.h:53
CONSOLE_GETHANDLEINFO GetHandleInfoRequest
Definition: conmsg.h:938

Referenced by GetHandleInformation().

◆ GetConsoleInputWaitHandle()

HANDLE WINAPI GetConsoleInputWaitHandle ( VOID  )

Definition at line 683 of file console.c.

684{
685 return InputWaitHandle;
686}
HANDLE InputWaitHandle
Definition: console.c:38

◆ GetCurrentExeName()

USHORT GetCurrentExeName ( OUT PWCHAR  ExeName,
IN USHORT  BufferSize 
)

Definition at line 316 of file console.c.

318{
319 USHORT ExeLength;
320
322 {
324
325 if (BufferSize > ExeNameLength * sizeof(WCHAR))
326 BufferSize = ExeNameLength * sizeof(WCHAR);
327
329
331 ExeLength = BufferSize;
332 }
333 else
334 {
335 *ExeName = UNICODE_NULL;
336 ExeLength = 0;
337 }
338
339 return ExeLength;
340}
#define BufferSize
Definition: mmc.h:75
static WCHAR ExeNameBuffer[EXENAME_LENGTH]
Definition: console.c:43
static BOOLEAN ExeNameInitialized
Definition: console.c:42
static RTL_CRITICAL_SECTION ExeNameLock
Definition: console.c:41
static USHORT ExeNameLength
Definition: console.c:44
#define UNICODE_NULL
unsigned short USHORT
Definition: pedump.c:61
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
_In_ WDFMEMORY _Out_opt_ size_t * BufferSize
Definition: wdfmemory.h:254
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by IntReadConsole().

◆ InitExeName()

VOID InitExeName ( VOID  )

Definition at line 216 of file console.c.

217{
221 PLDR_DATA_TABLE_ENTRY ImageEntry;
222
223 if (ExeNameInitialized) return;
224
225 /* Initialize the EXE name lock */
227 if (!NT_SUCCESS(Status)) return;
229
232 InLoadOrderLinks);
233
234 /* Retrieve the EXE name, NULL-terminate it... */
235 ExeNameLength = min(sizeof(ExeNameBuffer)/sizeof(ExeNameBuffer[0]),
236 ImageEntry->BaseDllName.Length / sizeof(WCHAR));
238 ImageEntry->BaseDllName.Buffer,
239 ImageEntry->BaseDllName.Length);
241
242 /* ... and retrieve the current directory path and NULL-terminate it. */
243 StartDirLength = min(sizeof(StartDirBuffer)/sizeof(StartDirBuffer[0]),
244 CurrentDirectory->DosPath.Length / sizeof(WCHAR));
246 CurrentDirectory->DosPath.Buffer,
247 CurrentDirectory->DosPath.Length);
249}
WCHAR CurrentDirectory[1024]
Definition: chkdsk.c:74
static WCHAR StartDirBuffer[MAX_PATH+1]
Definition: console.c:45
static USHORT StartDirLength
Definition: console.c:46
PPEB Peb
Definition: dllmain.c:27
#define min(a, b)
Definition: monoChain.cc:55
Definition: btrfs_drv.h:1876
UNICODE_STRING BaseDllName
Definition: ldrtypes.h:145
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
LIST_ENTRY InLoadOrderModuleList
Definition: ldrtypes.h:120
PPEB_LDR_DATA Ldr
Definition: btrfs_drv.h:1912
PRTL_USER_PROCESS_PARAMETERS ProcessParameters
Definition: btrfs_drv.h:1913
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260

Referenced by AllocConsole(), and ConDllInitialize().

◆ InitializeCtrlHandling()

VOID InitializeCtrlHandling ( VOID  )

Definition at line 204 of file console.c.

205{
206 /* Initialize Console Ctrl Handler */
210}
static ULONG NrAllocatedHandlers
Definition: console.c:32
static PHANDLER_ROUTINE InitialHandler[1]
Definition: console.c:29

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

◆ IntCheckForConsoleFileName()

LPCWSTR IntCheckForConsoleFileName ( IN LPCWSTR  pszName,
IN DWORD  dwDesiredAccess 
)

Definition at line 345 of file console.c.

347{
348 LPCWSTR ConsoleName = pszName;
349 ULONG DeviceNameInfo;
350
351 /*
352 * Check whether we deal with a DOS device, and if so,
353 * strip the path till the file name.
354 * Therefore, things like \\.\CON or C:\some_path\CONIN$
355 * are transformed into CON or CONIN$, for example.
356 */
357 DeviceNameInfo = RtlIsDosDeviceName_U(pszName);
358 if (DeviceNameInfo != 0)
359 {
360 ConsoleName = (LPCWSTR)((ULONG_PTR)ConsoleName + ((DeviceNameInfo >> 16) & 0xFFFF));
361 }
362
363 /* Return a standard console "file" name according to what we passed in parameters */
364 if (_wcsicmp(ConsoleName, BaseConInputFileName) == 0)
365 {
367 }
368 else if (_wcsicmp(ConsoleName, BaseConOutputFileName) == 0)
369 {
371 }
372 else if (_wcsicmp(ConsoleName, BaseConFileName) == 0)
373 {
374 if ((dwDesiredAccess & (GENERIC_READ | GENERIC_WRITE)) == GENERIC_READ)
375 {
377 }
378 else if ((dwDesiredAccess & (GENERIC_READ | GENERIC_WRITE)) == GENERIC_WRITE)
379 {
381 }
382 }
383
384 /* If we are there, that means that either the file name or the desired access are wrong */
385 return NULL;
386}
static LPCWSTR BaseConInputFileName
Definition: console.c:25
static LPCWSTR BaseConFileName
Definition: console.c:24
static LPCWSTR BaseConOutputFileName
Definition: console.c:26
NTSYSAPI ULONG NTAPI RtlIsDosDeviceName_U(_In_ PCWSTR Name)
_Check_return_ _CRTIMP int __cdecl _wcsicmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
uint32_t ULONG_PTR
Definition: typedefs.h:65
uint32_t ULONG
Definition: typedefs.h:59
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185

Referenced by CreateFileW().

◆ OpenConsoleW()

HANDLE WINAPI OpenConsoleW ( LPCWSTR  wsName,
DWORD  dwDesiredAccess,
BOOL  bInheritHandle,
DWORD  dwShareMode 
)

Definition at line 791 of file console.c.

795{
796 CONSOLE_API_MESSAGE ApiMessage;
797 PCONSOLE_OPENCONSOLE OpenConsoleRequest = &ApiMessage.Data.OpenConsoleRequest;
798 CONSOLE_HANDLE_TYPE HandleType;
799
800 if (wsName && (_wcsicmp(wsName, BaseConInputFileName) == 0))
801 {
802 HandleType = HANDLE_INPUT;
803 }
804 else if (wsName && (_wcsicmp(wsName, BaseConOutputFileName) == 0))
805 {
806 HandleType = HANDLE_OUTPUT;
807 }
808 else
809 {
812 }
813
814 if ( (dwDesiredAccess & ~(GENERIC_READ | GENERIC_WRITE)) ||
815 (dwShareMode & ~(FILE_SHARE_READ | FILE_SHARE_WRITE)) )
816 {
819 }
820
821 OpenConsoleRequest->ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
822 OpenConsoleRequest->HandleType = HandleType;
823 OpenConsoleRequest->DesiredAccess = dwDesiredAccess;
824 OpenConsoleRequest->InheritHandle = bInheritHandle;
825 OpenConsoleRequest->ShareMode = dwShareMode;
826
828 NULL,
830 sizeof(*OpenConsoleRequest));
831 if (!NT_SUCCESS(ApiMessage.Status))
832 {
833 BaseSetLastNTError(ApiMessage.Status);
835 }
836
837 return OpenConsoleRequest->Handle;
838}
@ HANDLE_INPUT
Definition: conmsg.h:667
@ HANDLE_OUTPUT
Definition: conmsg.h:668
@ ConsolepOpenConsole
Definition: conmsg.h:21
enum _CONSOLE_HANDLE_TYPE CONSOLE_HANDLE_TYPE
#define FILE_SHARE_READ
Definition: compat.h:136
#define FILE_SHARE_WRITE
Definition: nt_native.h:681
CONSOLE_OPENCONSOLE OpenConsoleRequest
Definition: conmsg.h:934
CONSOLE_HANDLE_TYPE HandleType
Definition: conmsg.h:674
HANDLE ConsoleHandle
Definition: conmsg.h:673

Referenced by CreateFileW(), and init_function_pointers().

◆ PropDialogHandler()

DWORD WINAPI PropDialogHandler ( IN LPVOID  lpThreadParameter)

Definition at line 34 of file init.c.

35{
36 // NOTE: lpThreadParameter corresponds to the client shared section handle.
37
39 HMODULE hConsoleApplet = NULL;
41 static BOOL AlreadyDisplayingProps = FALSE;
42 WCHAR szBuffer[MAX_PATH];
43
44 /*
45 * Do not launch more than once the console property dialog applet,
46 * or (albeit less probable), if we are not initialized.
47 */
48 if (!ConsoleInitialized || AlreadyDisplayingProps)
49 {
50 /* Close the associated client shared section handle if needed */
51 if (lpThreadParameter)
52 CloseHandle((HANDLE)lpThreadParameter);
53
55 }
56
57 AlreadyDisplayingProps = TRUE;
58
59 /* Load the control applet */
61 wcscat(szBuffer, L"\\console.dll");
62 hConsoleApplet = LoadLibraryW(szBuffer);
63 if (hConsoleApplet == NULL)
64 {
65 DPRINT1("Failed to load console.dll\n");
67 goto Quit;
68 }
69
70 /* Load its main function */
71 CPlApplet = (APPLET_PROC)GetProcAddress(hConsoleApplet, "CPlApplet");
72 if (CPlApplet == NULL)
73 {
74 DPRINT1("Error: console.dll misses CPlApplet export\n");
76 goto Quit;
77 }
78
79 /* Initialize the applet */
80 if (CPlApplet(NULL, CPL_INIT, 0, 0) == FALSE)
81 {
82 DPRINT1("Error: failed to initialize console.dll\n");
84 goto Quit;
85 }
86
87 /* Check the count */
88 if (CPlApplet(NULL, CPL_GETCOUNT, 0, 0) != 1)
89 {
90 DPRINT1("Error: console.dll returned unexpected CPL count\n");
92 goto Quit;
93 }
94
95 /*
96 * Start the applet. For Windows compatibility purposes we need
97 * to pass the client shared section handle (lpThreadParameter)
98 * via the hWnd parameter of the CPlApplet function.
99 */
100 CPlApplet((HWND)lpThreadParameter, CPL_DBLCLK, 0, 0);
101
102 /* We have finished */
103 CPlApplet(NULL, CPL_EXIT, 0, 0);
104
105Quit:
106 if (hConsoleApplet) FreeLibrary(hConsoleApplet);
107 AlreadyDisplayingProps = FALSE;
108 return Status;
109}
LONG(APIENTRY * APPLET_PROC)(HWND, UINT, LPARAM, LPARAM)
Definition: cpl.h:23
#define CPL_DBLCLK
Definition: cpl.h:16
#define CPL_INIT
Definition: cpl.h:12
#define CPL_EXIT
Definition: cpl.h:18
#define CPL_GETCOUNT
Definition: cpl.h:13
#define CloseHandle
Definition: compat.h:739
#define GetProcAddress(x, y)
Definition: compat.h:753
#define FreeLibrary(x)
Definition: compat.h:748
#define MAX_PATH
Definition: compat.h:34
#define LoadLibraryW(x)
Definition: compat.h:747
UINT WINAPI GetSystemDirectoryW(OUT LPWSTR lpBuffer, IN UINT uSize)
Definition: path.c:2313
unsigned int BOOL
Definition: ntddk_ex.h:94
#define L(x)
Definition: ntvdm.h:50
_CRTIMP wchar_t *__cdecl wcscat(_Inout_updates_z_(_String_length_(_Dest)+_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132

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

◆ SetConsoleHandleInformation()

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

Definition at line 495 of file console.c.

498{
499 CONSOLE_API_MESSAGE ApiMessage;
500 PCONSOLE_SETHANDLEINFO SetHandleInfoRequest = &ApiMessage.Data.SetHandleInfoRequest;
501
502 SetHandleInfoRequest->ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
503 SetHandleInfoRequest->Handle = hHandle;
504 SetHandleInfoRequest->Mask = dwMask;
505 SetHandleInfoRequest->Flags = dwFlags;
506
508 NULL,
510 sizeof(*SetHandleInfoRequest));
511 if (!NT_SUCCESS(ApiMessage.Status))
512 {
513 BaseSetLastNTError(ApiMessage.Status);
514 return FALSE;
515 }
516
517 return TRUE;
518}
@ ConsolepSetHandleInformation
Definition: conmsg.h:54
CONSOLE_SETHANDLEINFO SetHandleInfoRequest
Definition: conmsg.h:939
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176

Referenced by SetHandleInformation().

◆ SetTEBLangID()

VOID SetTEBLangID ( VOID  )

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

Definition at line 3171 of file console.c.

3172{
3173 CONSOLE_API_MESSAGE ApiMessage;
3174 PCONSOLE_GETLANGID LangIdRequest = &ApiMessage.Data.LangIdRequest;
3175
3176 /* Retrieve the "best-suited" language ID corresponding
3177 * to the active console output code page. */
3178 LangIdRequest->ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
3179
3181 NULL,
3183 sizeof(*LangIdRequest));
3184 if (!NT_SUCCESS(ApiMessage.Status))
3185 {
3186 /*
3187 * No best console language ID: keep the current thread's one.
3188 * Since this internal function only modifies an optional setting,
3189 * don't set any last error, as it could otherwise mess with the
3190 * main last error set by the caller.
3191 */
3192 return;
3193 }
3194
3195 /*
3196 * We succeeded, set the current thread's language ID by
3197 * modifying its locale -- Windows <= 2003 does not have
3198 * the concept of a separate thread UI language.
3199 * Ignore the returned value.
3200 */
3201 if (!SetThreadLocale(MAKELCID(LangIdRequest->LangId, SORT_DEFAULT)))
3202 {
3203 DPRINT1("SetTEBLangID: Could not set thread locale to console lang ID %lu\n",
3204 LangIdRequest->LangId);
3205 }
3206}
@ ConsolepGetLangId
Definition: conmsg.h:103
BOOL WINAPI SetThreadLocale(LCID lcid)
Definition: lang.c:1478
#define SORT_DEFAULT
#define MAKELCID(lgid, srtid)
CONSOLE_GETLANGID LangIdRequest
Definition: conmsg.h:1016
HANDLE ConsoleHandle
Definition: conmsg.h:864

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

◆ SetUpAppName()

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

Definition at line 264 of file console.c.

269{
271
272 /* Retrieve the needed buffer size */
273 Length = (StartDirLength + 1) * sizeof(WCHAR);
274 if (*CurDirLength > 0) Length = min(Length, *CurDirLength);
275 *CurDirLength = Length;
276
277 /* Capture the data if needed, or, return a pointer to it */
278 if (CaptureStrings)
279 {
280 /*
281 * Length is always >= sizeof(WCHAR). Copy everything but the
282 * possible trailing NULL character, and then NULL-terminate.
283 */
284 Length -= sizeof(WCHAR);
286 (*CurDir)[Length / sizeof(WCHAR)] = UNICODE_NULL;
287 }
288 else
289 {
290 *CurDir = StartDirBuffer;
291 }
292
293 /* Retrieve the needed buffer size */
294 Length = (ExeNameLength + 1) * sizeof(WCHAR);
295 if (*AppNameLength > 0) Length = min(Length, *AppNameLength);
296 *AppNameLength = Length;
297
298 /* Capture the data if needed, or, return a pointer to it */
299 if (CaptureStrings)
300 {
301 /*
302 * Length is always >= sizeof(WCHAR). Copy everything but the
303 * possible trailing NULL character, and then NULL-terminate.
304 */
305 Length -= sizeof(WCHAR);
307 (*AppName)[Length / sizeof(WCHAR)] = UNICODE_NULL;
308 }
309 else
310 {
312 }
313}
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102

Referenced by AllocConsole(), and ConDllInitialize().

◆ SetUpConsoleInfo()

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

Definition at line 134 of file init.c.

140{
143
144 /* Initialize the fields */
145
146 ConsoleStartInfo->IconIndex = 0;
147 ConsoleStartInfo->hIcon = NULL;
148 ConsoleStartInfo->hIconSm = NULL;
149 ConsoleStartInfo->dwStartupFlags = Parameters->WindowFlags;
150 ConsoleStartInfo->nFont = 0;
151 ConsoleStartInfo->nInputBufferSize = 0;
152 ConsoleStartInfo->uCodePage = GetOEMCP();
153
154 if (lpTitle)
155 {
157
158 /* If we don't have any title, use the default one */
159 if (Parameters->WindowTitle.Buffer == NULL)
160 {
162 Length = lstrlenW(DefaultConsoleTitle) * sizeof(WCHAR); // sizeof(DefaultConsoleTitle);
163 }
164 else
165 {
166 Title = Parameters->WindowTitle.Buffer;
167 Length = Parameters->WindowTitle.Length;
168 }
169
170 /* Retrieve the needed buffer size */
171 Length += sizeof(WCHAR);
172 if (*pTitleLength > 0) Length = min(Length, *pTitleLength);
173 *pTitleLength = Length;
174
175 /* Capture the data if needed, or, return a pointer to it */
176 if (CaptureTitle)
177 {
178 /*
179 * Length is always >= sizeof(WCHAR). Copy everything but the
180 * possible trailing NULL character, and then NULL-terminate.
181 */
182 Length -= sizeof(WCHAR);
184 (*lpTitle)[Length / sizeof(WCHAR)] = UNICODE_NULL;
185 }
186 else
187 {
188 *lpTitle = Title;
189 }
190 }
191 else
192 {
193 *pTitleLength = 0;
194 }
195
196 if (lpDesktop && Parameters->DesktopInfo.Buffer && *Parameters->DesktopInfo.Buffer)
197 {
198 /* Retrieve the needed buffer size */
199 Length = Parameters->DesktopInfo.Length + sizeof(WCHAR);
200 if (*pDesktopLength > 0) Length = min(Length, *pDesktopLength);
201 *pDesktopLength = Length;
202
203 /* Return a pointer to the data */
204 *lpDesktop = Parameters->DesktopInfo.Buffer;
205 }
206 else
207 {
208 *pDesktopLength = 0;
209 if (lpDesktop) *lpDesktop = NULL;
210 }
211
212 if (Parameters->WindowFlags & STARTF_USEFILLATTRIBUTE)
213 {
214 ConsoleStartInfo->wFillAttribute = (WORD)Parameters->FillAttribute;
215 }
216 if (Parameters->WindowFlags & STARTF_USECOUNTCHARS)
217 {
218 ConsoleStartInfo->dwScreenBufferSize.X = (SHORT)Parameters->CountCharsX;
219 ConsoleStartInfo->dwScreenBufferSize.Y = (SHORT)Parameters->CountCharsY;
220 }
221 if (Parameters->WindowFlags & STARTF_USESHOWWINDOW)
222 {
223 ConsoleStartInfo->wShowWindow = (WORD)Parameters->ShowWindowFlags;
224 }
225 if (Parameters->WindowFlags & STARTF_USEPOSITION)
226 {
227 ConsoleStartInfo->dwWindowOrigin.X = (SHORT)Parameters->StartingX;
228 ConsoleStartInfo->dwWindowOrigin.Y = (SHORT)Parameters->StartingY;
229 }
230 if (Parameters->WindowFlags & STARTF_USESIZE)
231 {
232 ConsoleStartInfo->dwWindowSize.X = (SHORT)Parameters->CountX;
233 ConsoleStartInfo->dwWindowSize.Y = (SHORT)Parameters->CountY;
234 }
235
236 /* Get shell information (ShellInfo.Buffer is NULL-terminated) */
237 if (Parameters->ShellInfo.Buffer != NULL)
238 {
239 ConsoleStartInfo->IconIndex = ParseShellInfo(Parameters->ShellInfo.Buffer, L"dde.");
240
241 if ((Parameters->WindowFlags & STARTF_USEHOTKEY) == 0)
242 ConsoleStartInfo->dwHotKey = ParseShellInfo(Parameters->ShellInfo.Buffer, L"hotkey.");
243 else
244 ConsoleStartInfo->dwHotKey = HandleToUlong(Parameters->StandardInput);
245 }
246}
#define HandleToUlong(h)
Definition: basetsd.h:79
TCHAR lpTitle[80]
Definition: ctm.c:69
static const WCHAR Title[]
Definition: oid.c:1259
#define lstrlenW
Definition: compat.h:750
static INT ParseShellInfo(LPCWSTR lpszShellInfo, LPCWSTR lpszKeyword)
Definition: init.c:113
static const PWSTR DefaultConsoleTitle
Definition: init.c:28
unsigned short WORD
Definition: ntddk_ex.h:93
short SHORT
Definition: pedump.c:59
#define STARTF_USEPOSITION
Definition: winbase.h:493
#define STARTF_USESHOWWINDOW
Definition: winbase.h:491
#define STARTF_USECOUNTCHARS
Definition: winbase.h:494
#define STARTF_USEFILLATTRIBUTE
Definition: winbase.h:495
#define STARTF_USESIZE
Definition: winbase.h:492
UINT WINAPI GetOEMCP(void)
Definition: nls.c:2322

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

◆ SetUpHandles()

VOID SetUpHandles ( IN PCONSOLE_START_INFO  ConsoleStartInfo)

Definition at line 250 of file init.c.

251{
253
254 if (ConsoleStartInfo->dwStartupFlags & STARTF_USEHOTKEY)
255 {
256 Parameters->WindowFlags &= ~STARTF_USEHOTKEY;
257 }
258 if (ConsoleStartInfo->dwStartupFlags & STARTF_SHELLPRIVATE)
259 {
260 Parameters->WindowFlags &= ~STARTF_SHELLPRIVATE;
261 }
262
263 /* We got the handles, let's set them */
264 Parameters->ConsoleHandle = ConsoleStartInfo->ConsoleHandle;
265
266 if ((ConsoleStartInfo->dwStartupFlags & STARTF_USESTDHANDLES) == 0)
267 {
268 Parameters->StandardInput = ConsoleStartInfo->InputHandle;
269 Parameters->StandardOutput = ConsoleStartInfo->OutputHandle;
270 Parameters->StandardError = ConsoleStartInfo->ErrorHandle;
271 }
272}
#define STARTF_SHELLPRIVATE
Definition: kernel32.h:60
#define STARTF_USESTDHANDLES
Definition: winbase.h:499

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

◆ TranslateStdHandle()

HANDLE TranslateStdHandle ( HANDLE  hHandle)

◆ VerifyConsoleIoHandle()

BOOL WINAPI VerifyConsoleIoHandle ( HANDLE  Handle)

Definition at line 1110 of file console.c.

1111{
1112 CONSOLE_API_MESSAGE ApiMessage;
1113 PCONSOLE_VERIFYHANDLE VerifyHandleRequest = &ApiMessage.Data.VerifyHandleRequest;
1114
1115 VerifyHandleRequest->ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
1116 VerifyHandleRequest->Handle = hIoHandle;
1117 VerifyHandleRequest->IsValid = FALSE;
1118
1119 /* If the process is not attached to a console, return invalid handle */
1120 if (VerifyHandleRequest->ConsoleHandle == NULL) return FALSE;
1121
1123 NULL,
1125 sizeof(*VerifyHandleRequest));
1126 if (!NT_SUCCESS(ApiMessage.Status))
1127 {
1128 BaseSetLastNTError(ApiMessage.Status);
1129 return FALSE;
1130 }
1131
1132 return VerifyHandleRequest->IsValid;
1133}
@ ConsolepVerifyIoHandle
Definition: conmsg.h:56
CONSOLE_VERIFYHANDLE VerifyHandleRequest
Definition: conmsg.h:936
HANDLE ConsoleHandle
Definition: conmsg.h:633

Referenced by GetFileType(), init_function_pointers(), RegisterWaitForSingleObject(), RegisterWaitForSingleObjectEx(), SignalObjectAndWait(), WaitForMultipleObjectsEx(), and WaitForSingleObjectEx().