projects / reactos.git / blob
? search:


19e053aeb72a83b9c79141c89850859bb12d3115
[reactos.git] / dll / win32 / kernel32 / client / console / console.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS system libraries
4 * FILE: dll/win32/kernel32/client/console/console.c
5 * PURPOSE: Win32 server console functions
6 * PROGRAMMER: James Tabor
7 * <jimtabor@adsl-64-217-116-74.dsl.hstntx.swbell.net>
8 * UPDATE HISTORY:
9 * 199901?? ?? Created
10 * 19990204 EA SetConsoleTitleA
11 * 19990306 EA Stubs
12 */
13
14 /* INCLUDES *******************************************************************/
15
16 #include <k32.h>
17
18 #define NDEBUG
19 #include <debug.h>
20
21 extern RTL_CRITICAL_SECTION ConsoleLock;
22 extern BOOL ConsoleInitialized;
23 extern BOOL WINAPI IsDebuggerPresent(VOID);
24
25 /* GLOBALS ********************************************************************/
26
27 PHANDLER_ROUTINE InitialHandler[1];
28 PHANDLER_ROUTINE* CtrlHandlers;
29 ULONG NrCtrlHandlers;
30 ULONG NrAllocatedHandlers;
31
32 #define INPUTEXENAME_BUFLEN 256
33 static WCHAR InputExeName[INPUTEXENAME_BUFLEN];
34
35 /* Default Console Control Handler ********************************************/
36
37 BOOL
38 WINAPI
39 DefaultConsoleCtrlHandler(DWORD Event)
40 {
41 DPRINT("Default handler called: %lx\n", Event);
42 switch(Event)
43 {
44 case CTRL_C_EVENT:
45 DPRINT("Ctrl-C Event\n");
46 break;
47
48 case CTRL_BREAK_EVENT:
49 DPRINT("Ctrl-Break Event\n");
50 break;
51
52 case CTRL_SHUTDOWN_EVENT:
53 DPRINT("Ctrl Shutdown Event\n");
54 break;
55
56 case CTRL_CLOSE_EVENT:
57 DPRINT("Ctrl Close Event\n");
58 break;
59
60 case CTRL_LOGOFF_EVENT:
61 DPRINT("Ctrl Logoff Event\n");
62 break;
63 }
64
65 ExitProcess(CONTROL_C_EXIT);
66 return TRUE;
67 }
68
69 DWORD
70 WINAPI
71 ConsoleControlDispatcher(IN LPVOID lpThreadParameter)
72 {
73 DWORD nExitCode = 0;
74 DWORD CodeAndFlag = PtrToUlong(lpThreadParameter);
75 DWORD nCode = CodeAndFlag & MAXLONG;
76 UINT i;
77 EXCEPTION_RECORD erException;
78
79 DPRINT("Console Dispatcher Active: %lx %lx\n", CodeAndFlag, nCode);
80 SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);
81
82 switch(nCode)
83 {
84 case CTRL_C_EVENT:
85 case CTRL_BREAK_EVENT:
86 {
87 if (IsDebuggerPresent())
88 {
89 erException.ExceptionCode = (nCode == CTRL_C_EVENT ?
90 DBG_CONTROL_C : DBG_CONTROL_BREAK);
91 erException.ExceptionFlags = 0;
92 erException.ExceptionRecord = NULL;
93 erException.ExceptionAddress = DefaultConsoleCtrlHandler;
94 erException.NumberParameters = 0;
95
96 _SEH2_TRY
97 {
98 RtlRaiseException(&erException);
99 }
100 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
101 {
102 RtlEnterCriticalSection(&ConsoleLock);
103
104 if ((nCode != CTRL_C_EVENT) ||
105 (NtCurrentPeb()->ProcessParameters->ConsoleFlags != 1))
106 {
107 for (i = NrCtrlHandlers; i > 0; i--)
108 {
109 if (CtrlHandlers[i - 1](nCode)) break;
110 }
111 }
112
113 RtlLeaveCriticalSection(&ConsoleLock);
114 }
115 _SEH2_END;
116
117 ExitThread(0);
118 }
119 break;
120 }
121
122 case CTRL_CLOSE_EVENT:
123 case CTRL_LOGOFF_EVENT:
124 case CTRL_SHUTDOWN_EVENT:
125 break;
126
127 case 3:
128 ExitThread(0);
129 break;
130
131 case 4:
132 ExitProcess(CONTROL_C_EXIT);
133 break;
134
135 default:
136 ASSERT(FALSE);
137 break;
138 }
139
140 ASSERT(ConsoleInitialized);
141
142 RtlEnterCriticalSection(&ConsoleLock);
143 nExitCode = 0;
144 if ((nCode != CTRL_C_EVENT) || (NtCurrentPeb()->ProcessParameters->ConsoleFlags != 1))
145 {
146 for (i = NrCtrlHandlers; i > 0; i--)
147 {
148 if ((i == 1) &&
149 (CodeAndFlag & MINLONG) &&
150 ((nCode == CTRL_LOGOFF_EVENT) || (nCode == CTRL_SHUTDOWN_EVENT)))
151 {
152 DPRINT("Skipping system/service apps\n");
153 break;
154 }
155
156 if (CtrlHandlers[i - 1](nCode))
157 {
158 switch(nCode)
159 {
160 case CTRL_CLOSE_EVENT:
161 case CTRL_LOGOFF_EVENT:
162 case CTRL_SHUTDOWN_EVENT:
163 case 3:
164 nExitCode = CodeAndFlag;
165 break;
166 }
167 break;
168 }
169 }
170 }
171
172 RtlLeaveCriticalSection(&ConsoleLock);
173 ExitThread(nExitCode);
174 return STATUS_SUCCESS;
175 }
176
177
178 /* FUNCTIONS ******************************************************************/
179
180 /*
181 * @unimplemented (Undocumented)
182 */
183 BOOL
184 WINAPI
185 ConsoleMenuControl(HANDLE hConsole,
186 DWORD Unknown1,
187 DWORD Unknown2)
188 {
189 DPRINT1("ConsoleMenuControl(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", hConsole, Unknown1, Unknown2);
190 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
191 return FALSE;
192 }
193
194
195 /*
196 * @implemented
197 */
198 HANDLE
199 WINAPI
200 DuplicateConsoleHandle(HANDLE hConsole,
201 DWORD dwDesiredAccess,
202 BOOL bInheritHandle,
203 DWORD dwOptions)
204 {
205 NTSTATUS Status;
206 CONSOLE_API_MESSAGE ApiMessage;
207 PCSRSS_DUPLICATE_HANDLE DuplicateHandleRequest = &ApiMessage.Data.DuplicateHandleRequest;
208
209 if ( (dwOptions & ~(DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS)) ||
210 (!(dwOptions & DUPLICATE_SAME_ACCESS) &&
211 (dwDesiredAccess & ~(GENERIC_READ | GENERIC_WRITE))) )
212 {
213 SetLastError (ERROR_INVALID_PARAMETER);
214 return INVALID_HANDLE_VALUE;
215 }
216
217 DuplicateHandleRequest->Handle = hConsole;
218 DuplicateHandleRequest->Access = dwDesiredAccess;
219 DuplicateHandleRequest->Inheritable = bInheritHandle;
220 DuplicateHandleRequest->Options = dwOptions;
221
222 Status = CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
223 NULL,
224 CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepDuplicateHandle),
225 sizeof(CSRSS_DUPLICATE_HANDLE));
226 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = ApiMessage.Status))
227 {
228 BaseSetLastNTError(Status);
229 return INVALID_HANDLE_VALUE;
230 }
231
232 return DuplicateHandleRequest->Handle;
233 }
234
235
236 /*
237 * @unimplemented
238 */
239 INT
240 WINAPI
241 GetConsoleDisplayMode(LPDWORD lpdwMode)
242 /*
243 * FUNCTION: Get the console display mode
244 * ARGUMENTS:
245 * lpdwMode - Address of variable that receives the current value
246 * of display mode
247 * STATUS: Undocumented
248 */
249 {
250 DPRINT1("GetConsoleDisplayMode(0x%x) UNIMPLEMENTED!\n", lpdwMode);
251 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
252 return 0;
253 }
254
255
256 /*
257 * @unimplemented (Undocumented)
258 */
259 DWORD
260 WINAPI
261 GetConsoleFontInfo(DWORD Unknown0,
262 DWORD Unknown1,
263 DWORD Unknown2,
264 DWORD Unknown3)
265 {
266 DPRINT1("GetConsoleFontInfo(0x%x, 0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1, Unknown2, Unknown3);
267 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
268 return 0;
269 }
270
271
272 /*
273 * @unimplemented
274 */
275 COORD
276 WINAPI
277 GetConsoleFontSize(HANDLE hConsoleOutput,
278 DWORD nFont)
279 {
280 COORD Empty = {0, 0};
281 DPRINT1("GetConsoleFontSize(0x%x, 0x%x) UNIMPLEMENTED!\n", hConsoleOutput, nFont);
282 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
283 return Empty;
284 }
285
286
287 /*
288 * @implemented (Undocumented)
289 */
290 DWORD
291 WINAPI
292 GetConsoleHardwareState(HANDLE hConsole,
293 DWORD Flags,
294 PDWORD State)
295 {
296 NTSTATUS Status;
297 CONSOLE_API_MESSAGE ApiMessage;
298 PCSRSS_CONSOLE_HW_STATE ConsoleHardwareStateRequest = &ApiMessage.Data.ConsoleHardwareStateRequest;
299
300 ConsoleHardwareStateRequest->ConsoleHandle = hConsole;
301
302 Status = CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
303 NULL,
304 CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepGetHardwareState),
305 sizeof(CSRSS_CONSOLE_HW_STATE));
306 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = ApiMessage.Status))
307 {
308 BaseSetLastNTError(Status);
309 return FALSE;
310 }
311
312 *State = ConsoleHardwareStateRequest->State;
313 return TRUE;
314 }
315
316
317 /*
318 * @implemented (Undocumented)
319 */
320 HANDLE
321 WINAPI
322 GetConsoleInputWaitHandle(VOID)
323 {
324 CSR_API_MESSAGE Request;
325 NTSTATUS Status;
326
327 Status = CsrClientCallServer(&Request,
328 NULL,
329 CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_INPUT_WAIT_HANDLE),
330 sizeof(CSR_API_MESSAGE));
331 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
332 {
333 BaseSetLastNTError(Status);
334 return 0;
335 }
336
337 return Request.Data.GetConsoleInputWaitHandle.InputWaitHandle;
338 }
339
340
341 /*
342 * @unimplemented
343 */
344 INT
345 WINAPI
346 GetCurrentConsoleFont(HANDLE hConsoleOutput,
347 BOOL bMaximumWindow,
348 PCONSOLE_FONT_INFO lpConsoleCurrentFont)
349 {
350 DPRINT1("GetCurrentConsoleFont(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", hConsoleOutput, bMaximumWindow, lpConsoleCurrentFont);
351 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
352 return 0;
353 }
354
355
356 /*
357 * @unimplemented (Undocumented)
358 */
359 ULONG
360 WINAPI
361 GetNumberOfConsoleFonts(VOID)
362 {
363 DPRINT1("GetNumberOfConsoleFonts() UNIMPLEMENTED!\n");
364 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
365 return 1;
366 }
367
368
369 /*
370 * @unimplemented (Undocumented)
371 */
372 DWORD
373 WINAPI
374 InvalidateConsoleDIBits(DWORD Unknown0,
375 DWORD Unknown1)
376 {
377 DPRINT1("InvalidateConsoleDIBits(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1);
378 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
379 return 0;
380 }
381
382
383 /*
384 * @unimplemented (Undocumented)
385 */
386 HANDLE
387 WINAPI
388 OpenConsoleW(LPCWSTR wsName,
389 DWORD dwDesiredAccess,
390 BOOL bInheritHandle,
391 DWORD dwShareMode)
392 {
393 NTSTATUS Status = STATUS_SUCCESS;
394 CONSOLE_API_MESSAGE ApiMessage;
395 PCSRSS_OPEN_CONSOLE OpenConsoleRequest = &ApiMessage.Data.OpenConsoleRequest;
396 HANDLE_TYPE HandleType;
397
398 if (wsName && 0 == _wcsicmp(wsName, L"CONIN$"))
399 {
400 HandleType = HANDLE_INPUT;
401 }
402 else if (wsName && 0 == _wcsicmp(wsName, L"CONOUT$"))
403 {
404 HandleType = HANDLE_OUTPUT;
405 }
406 else
407 {
408 SetLastError(ERROR_INVALID_PARAMETER);
409 return INVALID_HANDLE_VALUE;
410 }
411
412 if (dwDesiredAccess & ~(GENERIC_READ | GENERIC_WRITE))
413 {
414 SetLastError(ERROR_INVALID_PARAMETER);
415 return INVALID_HANDLE_VALUE;
416 }
417
418 if (dwShareMode & ~(FILE_SHARE_READ | FILE_SHARE_WRITE))
419 {
420 SetLastError(ERROR_INVALID_PARAMETER);
421 return INVALID_HANDLE_VALUE;
422 }
423
424 OpenConsoleRequest->HandleType = HandleType;
425 OpenConsoleRequest->Access = dwDesiredAccess;
426 OpenConsoleRequest->Inheritable = bInheritHandle;
427 OpenConsoleRequest->ShareMode = dwShareMode;
428
429 Status = CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
430 NULL,
431 CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepOpenConsole),
432 sizeof(CSRSS_OPEN_CONSOLE));
433 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = ApiMessage.Status))
434 {
435 BaseSetLastNTError(Status);
436 return INVALID_HANDLE_VALUE;
437 }
438
439 return OpenConsoleRequest->Handle;
440 }
441
442
443 /*
444 * @unimplemented (Undocumented)
445 */
446 BOOL
447 WINAPI
448 SetConsoleCursor(DWORD Unknown0,
449 DWORD Unknown1)
450 {
451 DPRINT1("SetConsoleCursor(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1);
452 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
453 return FALSE;
454 }
455
456
457 /*
458 * @unimplemented
459 */
460 BOOL
461 WINAPI
462 SetConsoleDisplayMode(HANDLE hOut,
463 DWORD dwNewMode,
464 PCOORD lpdwOldMode)
465 /*
466 * FUNCTION: Set the console display mode.
467 * ARGUMENTS:
468 * hOut - Standard output handle.
469 * dwNewMode - New mode.
470 * lpdwOldMode - Address of a variable that receives the old mode.
471 */
472 {
473 DPRINT1("SetConsoleDisplayMode(0x%x, 0x%x, 0x%p) UNIMPLEMENTED!\n", hOut, dwNewMode, lpdwOldMode);
474 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
475 return FALSE;
476 }
477
478
479 /*
480 * @unimplemented (Undocumented)
481 */
482 BOOL
483 WINAPI
484 SetConsoleFont(DWORD Unknown0,
485 DWORD Unknown1)
486 {
487 DPRINT1("SetConsoleFont(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1);
488 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
489 return FALSE;
490 }
491
492
493 /*
494 * @implemented (Undocumented)
495 */
496 BOOL
497 WINAPI
498 SetConsoleHardwareState(HANDLE hConsole,
499 DWORD Flags,
500 DWORD State)
501 {
502 NTSTATUS Status;
503 CONSOLE_API_MESSAGE ApiMessage;
504 PCSRSS_CONSOLE_HW_STATE ConsoleHardwareStateRequest = &ApiMessage.Data.ConsoleHardwareStateRequest;
505
506 ConsoleHardwareStateRequest->ConsoleHandle = hConsole;
507 ConsoleHardwareStateRequest->State = State;
508
509 Status = CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
510 NULL,
511 CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepSetHardwareState),
512 sizeof(CSRSS_CONSOLE_HW_STATE));
513 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = ApiMessage.Status))
514 {
515 BaseSetLastNTError(Status);
516 return FALSE;
517 }
518
519 return TRUE;
520 }
521
522
523 /*
524 * @unimplemented (Undocumented)
525 */
526 BOOL
527 WINAPI
528 SetConsoleKeyShortcuts(DWORD Unknown0,
529 DWORD Unknown1,
530 DWORD Unknown2,
531 DWORD Unknown3)
532 {
533 DPRINT1("SetConsoleKeyShortcuts(0x%x, 0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1, Unknown2, Unknown3);
534 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
535 return FALSE;
536 }
537
538
539 /*
540 * @unimplemented (Undocumented)
541 */
542 BOOL
543 WINAPI
544 SetConsoleMaximumWindowSize(DWORD Unknown0,
545 DWORD Unknown1)
546 {
547 DPRINT1("SetConsoleMaximumWindowSize(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1);
548 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
549 return FALSE;
550 }
551
552
553 /*
554 * @unimplemented (Undocumented)
555 */
556 BOOL
557 WINAPI
558 SetConsoleMenuClose(DWORD Unknown0)
559 {
560 DPRINT1("SetConsoleMenuClose(0x%x) UNIMPLEMENTED!\n", Unknown0);
561 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
562 return FALSE;
563 }
564
565
566 /*
567 * @unimplemented (Undocumented)
568 */
569 BOOL
570 WINAPI
571 SetConsolePalette(DWORD Unknown0,
572 DWORD Unknown1,
573 DWORD Unknown2)
574 {
575 DPRINT1("SetConsolePalette(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1, Unknown2);
576 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
577 return FALSE;
578 }
579
580 /*
581 * @unimplemented (Undocumented)
582 */
583 DWORD
584 WINAPI
585 ShowConsoleCursor(DWORD Unknown0,
586 DWORD Unknown1)
587 {
588 DPRINT1("ShowConsoleCursor(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1);
589 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
590 return 0;
591 }
592
593
594 /*
595 * FUNCTION: Checks whether the given handle is a valid console handle.
596 *
597 * ARGUMENTS:
598 * Handle - Handle to be checked
599 *
600 * RETURNS:
601 * TRUE: Handle is a valid console handle
602 * FALSE: Handle is not a valid console handle.
603 *
604 * STATUS: Officially undocumented
605 *
606 * @implemented
607 */
608 BOOL
609 WINAPI
610 VerifyConsoleIoHandle(HANDLE Handle)
611 {
612 NTSTATUS Status;
613 CONSOLE_API_MESSAGE ApiMessage;
614
615 ApiMessage.Data.VerifyHandleRequest.Handle = Handle;
616
617 Status = CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
618 NULL,
619 CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepVerifyIoHandle),
620 sizeof(CSRSS_VERIFY_HANDLE));
621 if (!NT_SUCCESS(Status))
622 {
623 BaseSetLastNTError(Status);
624 return FALSE;
625 }
626
627 return (BOOL)NT_SUCCESS(ApiMessage.Status);
628 }
629
630
631 /*
632 * @unimplemented
633 */
634 DWORD
635 WINAPI
636 WriteConsoleInputVDMA(DWORD Unknown0,
637 DWORD Unknown1,
638 DWORD Unknown2,
639 DWORD Unknown3)
640 {
641 DPRINT1("WriteConsoleInputVDMA(0x%x, 0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1, Unknown2, Unknown3);
642 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
643 return 0;
644 }
645
646
647 /*
648 * @unimplemented
649 */
650 DWORD
651 WINAPI
652 WriteConsoleInputVDMW(DWORD Unknown0,
653 DWORD Unknown1,
654 DWORD Unknown2,
655 DWORD Unknown3)
656 {
657 DPRINT1("WriteConsoleInputVDMW(0x%x, 0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1, Unknown2, Unknown3);
658 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
659 return 0;
660 }
661
662
663 /*
664 * @implemented (Undocumented)
665 */
666 BOOL
667 WINAPI
668 CloseConsoleHandle(HANDLE Handle)
669 {
670 NTSTATUS Status;
671 CONSOLE_API_MESSAGE ApiMessage;
672
673 ApiMessage.Data.CloseHandleRequest.Handle = Handle;
674
675 Status = CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
676 NULL,
677 CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepCloseHandle),
678 sizeof(CSRSS_CLOSE_HANDLE));
679 if (!NT_SUCCESS(Status))
680 {
681 BaseSetLastNTError(Status);
682 return FALSE;
683 }
684
685 return TRUE;
686 }
687
688
689 /*
690 * @implemented
691 */
692 HANDLE
693 WINAPI
694 GetStdHandle(DWORD nStdHandle)
695 /*
696 * FUNCTION: Get a handle for the standard input, standard output
697 * and a standard error device.
698 *
699 * ARGUMENTS:
700 * nStdHandle - Specifies the device for which to return the handle.
701 *
702 * RETURNS: If the function succeeds, the return value is the handle
703 * of the specified device. Otherwise the value is INVALID_HANDLE_VALUE.
704 */
705 {
706 PRTL_USER_PROCESS_PARAMETERS Ppb;
707
708 Ppb = NtCurrentPeb()->ProcessParameters;
709 switch (nStdHandle)
710 {
711 case STD_INPUT_HANDLE:
712 return Ppb->StandardInput;
713
714 case STD_OUTPUT_HANDLE:
715 return Ppb->StandardOutput;
716
717 case STD_ERROR_HANDLE:
718 return Ppb->StandardError;
719 }
720
721 SetLastError(ERROR_INVALID_PARAMETER);
722 return INVALID_HANDLE_VALUE;
723 }
724
725
726 /*
727 * @implemented
728 */
729 BOOL
730 WINAPI
731 SetStdHandle(DWORD nStdHandle,
732 HANDLE hHandle)
733 /*
734 * FUNCTION: Set the handle for the standard input, standard output or
735 * the standard error device.
736 *
737 * ARGUMENTS:
738 * nStdHandle - Specifies the handle to be set.
739 * hHandle - The handle to set.
740 *
741 * RETURNS: TRUE if the function succeeds, FALSE otherwise.
742 */
743 {
744 PRTL_USER_PROCESS_PARAMETERS Ppb;
745
746 /* no need to check if hHandle == INVALID_HANDLE_VALUE */
747
748 Ppb = NtCurrentPeb()->ProcessParameters;
749
750 switch (nStdHandle)
751 {
752 case STD_INPUT_HANDLE:
753 Ppb->StandardInput = hHandle;
754 return TRUE;
755
756 case STD_OUTPUT_HANDLE:
757 Ppb->StandardOutput = hHandle;
758 return TRUE;
759
760 case STD_ERROR_HANDLE:
761 Ppb->StandardError = hHandle;
762 return TRUE;
763 }
764
765 /* windows for whatever reason sets the last error to ERROR_INVALID_HANDLE here */
766 SetLastError(ERROR_INVALID_HANDLE);
767 return FALSE;
768 }
769
770
771 /*--------------------------------------------------------------
772 * AllocConsole
773 *
774 * @implemented
775 */
776 BOOL
777 WINAPI
778 AllocConsole(VOID)
779 {
780 NTSTATUS Status;
781 CONSOLE_API_MESSAGE ApiMessage;
782 PCSRSS_ALLOC_CONSOLE AllocConsoleRequest = &ApiMessage.Data.AllocConsoleRequest;
783 HANDLE hStdError;
784 STARTUPINFO si;
785
786 if (NtCurrentPeb()->ProcessParameters->ConsoleHandle)
787 {
788 DPRINT("AllocConsole: Allocate duplicate console to the same Process\n");
789 BaseSetLastNTError (STATUS_OBJECT_NAME_EXISTS);
790 return FALSE;
791 }
792
793 GetStartupInfo(&si);
794
795 AllocConsoleRequest->CtrlDispatcher = ConsoleControlDispatcher;
796 AllocConsoleRequest->ConsoleNeeded = TRUE;
797 AllocConsoleRequest->ShowCmd = si.wShowWindow;
798
799 Status = CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
800 NULL,
801 CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepAlloc),
802 sizeof(CSRSS_ALLOC_CONSOLE));
803 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = ApiMessage.Status))
804 {
805 BaseSetLastNTError(Status);
806 return FALSE;
807 }
808
809 NtCurrentPeb()->ProcessParameters->ConsoleHandle = AllocConsoleRequest->Console;
810
811 SetStdHandle(STD_INPUT_HANDLE, AllocConsoleRequest->InputHandle);
812 SetStdHandle(STD_OUTPUT_HANDLE, AllocConsoleRequest->OutputHandle);
813
814 hStdError = DuplicateConsoleHandle(AllocConsoleRequest->OutputHandle,
815 0,
816 TRUE,
817 DUPLICATE_SAME_ACCESS);
818
819 SetStdHandle(STD_ERROR_HANDLE, hStdError);
820 return TRUE;
821 }
822
823
824 /*--------------------------------------------------------------
825 * FreeConsole
826 *
827 * @implemented
828 */
829 BOOL
830 WINAPI
831 FreeConsole(VOID)
832 {
833 // AG: I'm not sure if this is correct (what happens to std handles?)
834 // but I just tried to reverse what AllocConsole() does...
835
836 NTSTATUS Status;
837 CONSOLE_API_MESSAGE ApiMessage;
838
839 Status = CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
840 NULL,
841 CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepFree),
842 sizeof(CSRSS_FREE_CONSOLE));
843 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = ApiMessage.Status))
844 {
845 BaseSetLastNTError(Status);
846 return FALSE;
847 }
848
849 NtCurrentPeb()->ProcessParameters->ConsoleHandle = NULL;
850 return TRUE;
851 }
852
853
854 /*--------------------------------------------------------------
855 * GetConsoleScreenBufferInfo
856 *
857 * @implemented
858 */
859 BOOL
860 WINAPI
861 GetConsoleScreenBufferInfo(HANDLE hConsoleOutput,
862 PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo)
863 {
864 NTSTATUS Status;
865 CONSOLE_API_MESSAGE ApiMessage;
866
867 ApiMessage.Data.ScreenBufferInfoRequest.ConsoleHandle = hConsoleOutput;
868
869 Status = CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
870 NULL,
871 CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepGetScreenBufferInfo),
872 sizeof(CSRSS_SCREEN_BUFFER_INFO));
873 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = ApiMessage.Status))
874 {
875 BaseSetLastNTError(Status);
876 return FALSE;
877 }
878
879 *lpConsoleScreenBufferInfo = ApiMessage.Data.ScreenBufferInfoRequest.Info;
880
881 return TRUE;
882 }
883
884
885 /*--------------------------------------------------------------
886 * SetConsoleCursorPosition
887 *
888 * @implemented
889 */
890 BOOL
891 WINAPI
892 SetConsoleCursorPosition(HANDLE hConsoleOutput,
893 COORD dwCursorPosition)
894 {
895 NTSTATUS Status;
896 CONSOLE_API_MESSAGE ApiMessage;
897
898 ApiMessage.Data.SetCursorPositionRequest.ConsoleHandle = hConsoleOutput;
899 ApiMessage.Data.SetCursorPositionRequest.Position = dwCursorPosition;
900
901 Status = CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
902 NULL,
903 CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepSetCursorPosition),
904 sizeof(CSRSS_SET_CURSOR_POSITION));
905 if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = ApiMessage.Status))
906 {
907 BaseSetLastNTError(Status);
908 return FALSE;
909 }
910
911 return TRUE;
912 }
913
914
915 /*--------------------------------------------------------------
916 * GetConsoleMode
917 *
918 * @implemented
919 */
920 BOOL
921 WINAPI
922 GetConsoleMode(HANDLE hConsoleHandle,
923 LPDWORD lpMode)
924 {
925 NTSTATUS Status;
926 CONSOLE_API_MESSAGE ApiMessage;
927 PCSRSS_CONSOLE_MODE ConsoleModeRequest = &ApiMessage.Data.ConsoleModeRequest;
928
929 ConsoleModeRequest->ConsoleHandle = hConsoleHandle;
930
931 Status = CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
932 NULL,
933 CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepGetMode),
934 sizeof(CSRSS_CONSOLE_MODE));
935 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = ApiMessage.Status))
936 {
937 BaseSetLastNTError(Status);
938 return FALSE;
939 }
940
941 *lpMode = ConsoleModeRequest->ConsoleMode;
942
943 return TRUE;
944 }
945
946
947 /*--------------------------------------------------------------
948 * GetNumberOfConsoleInputEvents
949 *
950 * @implemented
951 */
952 BOOL
953 WINAPI
954 GetNumberOfConsoleInputEvents(HANDLE hConsoleInput,
955 LPDWORD lpNumberOfEvents)
956 {
957 CSR_API_MESSAGE Request;
958 NTSTATUS Status;
959
960 if (lpNumberOfEvents == NULL)
961 {
962 SetLastError(ERROR_INVALID_PARAMETER);
963 return FALSE;
964 }
965
966 Request.Data.GetNumInputEventsRequest.ConsoleHandle = hConsoleInput;
967
968 Status = CsrClientCallServer(&Request,
969 NULL,
970 CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_NUM_INPUT_EVENTS),
971 sizeof(CSR_API_MESSAGE));
972 if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
973 {
974 BaseSetLastNTError(Status);
975 return FALSE;
976 }
977
978 *lpNumberOfEvents = Request.Data.GetNumInputEventsRequest.NumInputEvents;
979
980 return TRUE;
981 }
982
983
984 /*--------------------------------------------------------------
985 * GetLargestConsoleWindowSize
986 *
987 * @unimplemented
988 */
989 COORD
990 WINAPI
991 GetLargestConsoleWindowSize(HANDLE hConsoleOutput)
992 {
993 COORD Coord = {80,25};
994 DPRINT1("GetLargestConsoleWindowSize(0x%x) UNIMPLEMENTED!\n", hConsoleOutput);
995 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
996 return Coord;
997 }
998
999
1000 /*--------------------------------------------------------------
1001 * GetConsoleCursorInfo
1002 *
1003 * @implemented
1004 */
1005 BOOL
1006 WINAPI
1007 GetConsoleCursorInfo(HANDLE hConsoleOutput,
1008 PCONSOLE_CURSOR_INFO lpConsoleCursorInfo)
1009 {
1010 NTSTATUS Status;
1011 CONSOLE_API_MESSAGE ApiMessage;
1012
1013 if (!lpConsoleCursorInfo)
1014 {
1015 if (!hConsoleOutput)
1016 SetLastError(ERROR_INVALID_HANDLE);
1017 else
1018 SetLastError(ERROR_INVALID_ACCESS);
1019
1020 return FALSE;
1021 }
1022
1023 ApiMessage.Data.CursorInfoRequest.ConsoleHandle = hConsoleOutput;
1024
1025 Status = CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
1026 NULL,
1027 CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepGetCursorInfo),
1028 sizeof(CSRSS_CURSOR_INFO));
1029 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = ApiMessage.Status))
1030 {
1031 BaseSetLastNTError(Status);
1032 return FALSE;
1033 }
1034
1035 *lpConsoleCursorInfo = ApiMessage.Data.CursorInfoRequest.Info;
1036
1037 return TRUE;
1038 }
1039
1040
1041 /*--------------------------------------------------------------
1042 * GetNumberOfConsoleMouseButtons
1043 *
1044 * @unimplemented
1045 */
1046 BOOL
1047 WINAPI
1048 GetNumberOfConsoleMouseButtons(LPDWORD lpNumberOfMouseButtons)
1049 {
1050 DPRINT1("GetNumberOfConsoleMouseButtons(0x%x) UNIMPLEMENTED!\n", lpNumberOfMouseButtons);
1051 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1052 return FALSE;
1053 }
1054
1055
1056 /*--------------------------------------------------------------
1057 * SetConsoleMode
1058 *
1059 * @implemented
1060 */
1061 BOOL
1062 WINAPI
1063 SetConsoleMode(HANDLE hConsoleHandle,
1064 DWORD dwMode)
1065 {
1066 NTSTATUS Status;
1067 CONSOLE_API_MESSAGE ApiMessage;
1068 PCSRSS_CONSOLE_MODE ConsoleModeRequest = &ApiMessage.Data.ConsoleModeRequest;
1069
1070 ConsoleModeRequest->ConsoleHandle = hConsoleHandle;
1071 ConsoleModeRequest->ConsoleMode = dwMode;
1072
1073 Status = CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
1074 NULL,
1075 CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepSetMode),
1076 sizeof(CSRSS_CONSOLE_MODE));
1077 if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = ApiMessage.Status))
1078 {
1079 BaseSetLastNTError(Status);
1080 return FALSE;
1081 }
1082
1083 return TRUE;
1084 }
1085
1086
1087 /*--------------------------------------------------------------
1088 * SetConsoleActiveScreenBuffer
1089 *
1090 * @implemented
1091 */
1092 BOOL
1093 WINAPI
1094 SetConsoleActiveScreenBuffer(HANDLE hConsoleOutput)
1095 {
1096 CSR_API_MESSAGE Request;
1097 NTSTATUS Status;
1098
1099 Request.Data.SetScreenBufferRequest.OutputHandle = hConsoleOutput;
1100
1101 Status = CsrClientCallServer(&Request,
1102 NULL,
1103 CSR_CREATE_API_NUMBER(CSR_CONSOLE, SET_SCREEN_BUFFER),
1104 sizeof(CSR_API_MESSAGE));
1105 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
1106 {
1107 BaseSetLastNTError(Status);
1108 return FALSE;
1109 }
1110
1111 return TRUE;
1112 }
1113
1114
1115 /*--------------------------------------------------------------
1116 * FlushConsoleInputBuffer
1117 *
1118 * @implemented
1119 */
1120 BOOL
1121 WINAPI
1122 FlushConsoleInputBuffer(HANDLE hConsoleInput)
1123 {
1124 CSR_API_MESSAGE Request;
1125 NTSTATUS Status;
1126
1127 Request.Data.FlushInputBufferRequest.ConsoleInput = hConsoleInput;
1128
1129 Status = CsrClientCallServer(&Request,
1130 NULL,
1131 CSR_CREATE_API_NUMBER(CSR_CONSOLE, FLUSH_INPUT_BUFFER),
1132 sizeof(CSR_API_MESSAGE));
1133 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
1134 {
1135 BaseSetLastNTError(Status);
1136 return FALSE;
1137 }
1138
1139 return TRUE;
1140 }
1141
1142
1143 /*--------------------------------------------------------------
1144 * SetConsoleScreenBufferSize
1145 *
1146 * @implemented
1147 */
1148 BOOL
1149 WINAPI
1150 SetConsoleScreenBufferSize(HANDLE hConsoleOutput,
1151 COORD dwSize)
1152 {
1153 CSR_API_MESSAGE Request;
1154 NTSTATUS Status;
1155
1156 Request.Data.SetScreenBufferSize.OutputHandle = hConsoleOutput;
1157 Request.Data.SetScreenBufferSize.Size = dwSize;
1158
1159 Status = CsrClientCallServer(&Request,
1160 NULL,
1161 CSR_CREATE_API_NUMBER(CSR_CONSOLE, SET_SCREEN_BUFFER_SIZE),
1162 sizeof(CSR_API_MESSAGE));
1163 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
1164 {
1165 BaseSetLastNTError(Status);
1166 return FALSE;
1167 }
1168
1169 return TRUE;
1170 }
1171
1172
1173 /*--------------------------------------------------------------
1174 * SetConsoleCursorInfo
1175 *
1176 * @implemented
1177 */
1178 BOOL
1179 WINAPI
1180 SetConsoleCursorInfo(HANDLE hConsoleOutput,
1181 CONST CONSOLE_CURSOR_INFO *lpConsoleCursorInfo)
1182 {
1183 NTSTATUS Status;
1184 CONSOLE_API_MESSAGE ApiMessage;
1185
1186 ApiMessage.Data.CursorInfoRequest.ConsoleHandle = hConsoleOutput;
1187 ApiMessage.Data.CursorInfoRequest.Info = *lpConsoleCursorInfo;
1188
1189 Status = CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
1190 NULL,
1191 CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepSetCursorInfo),
1192 sizeof(CSRSS_CURSOR_INFO));
1193 if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = ApiMessage.Status))
1194 {
1195 BaseSetLastNTError(Status);
1196 return FALSE;
1197 }
1198
1199 return TRUE;
1200 }
1201
1202
1203 static
1204 BOOL
1205 IntScrollConsoleScreenBuffer(HANDLE hConsoleOutput,
1206 const SMALL_RECT *lpScrollRectangle,
1207 const SMALL_RECT *lpClipRectangle,
1208 COORD dwDestinationOrigin,
1209 const CHAR_INFO *lpFill,
1210 BOOL bUnicode)
1211 {
1212 CSR_API_MESSAGE Request;
1213 NTSTATUS Status;
1214
1215 Request.Data.ScrollConsoleScreenBufferRequest.ConsoleHandle = hConsoleOutput;
1216 Request.Data.ScrollConsoleScreenBufferRequest.Unicode = bUnicode;
1217 Request.Data.ScrollConsoleScreenBufferRequest.ScrollRectangle = *lpScrollRectangle;
1218
1219 if (lpClipRectangle != NULL)
1220 {
1221 Request.Data.ScrollConsoleScreenBufferRequest.UseClipRectangle = TRUE;
1222 Request.Data.ScrollConsoleScreenBufferRequest.ClipRectangle = *lpClipRectangle;
1223 }
1224 else
1225 {
1226 Request.Data.ScrollConsoleScreenBufferRequest.UseClipRectangle = FALSE;
1227 }
1228
1229 Request.Data.ScrollConsoleScreenBufferRequest.DestinationOrigin = dwDestinationOrigin;
1230 Request.Data.ScrollConsoleScreenBufferRequest.Fill = *lpFill;
1231
1232 Status = CsrClientCallServer(&Request,
1233 NULL,
1234 CSR_CREATE_API_NUMBER(CSR_CONSOLE, SCROLL_CONSOLE_SCREEN_BUFFER),
1235 sizeof(CSR_API_MESSAGE));
1236
1237 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
1238 {
1239 BaseSetLastNTError(Status);
1240 return FALSE;
1241 }
1242
1243 return TRUE;
1244 }
1245
1246
1247 /*--------------------------------------------------------------
1248 * ScrollConsoleScreenBufferA
1249 *
1250 * @implemented
1251 */
1252 BOOL
1253 WINAPI
1254 ScrollConsoleScreenBufferA(HANDLE hConsoleOutput,
1255 CONST SMALL_RECT *lpScrollRectangle,
1256 CONST SMALL_RECT *lpClipRectangle,
1257 COORD dwDestinationOrigin,
1258 CONST CHAR_INFO *lpFill)
1259 {
1260 return IntScrollConsoleScreenBuffer(hConsoleOutput,
1261 (PSMALL_RECT)lpScrollRectangle,
1262 (PSMALL_RECT)lpClipRectangle,
1263 dwDestinationOrigin,
1264 (PCHAR_INFO)lpFill,
1265 FALSE);
1266 }
1267
1268
1269 /*--------------------------------------------------------------
1270 * ScrollConsoleScreenBufferW
1271 *
1272 * @implemented
1273 */
1274 BOOL
1275 WINAPI
1276 ScrollConsoleScreenBufferW(HANDLE hConsoleOutput,
1277 CONST SMALL_RECT *lpScrollRectangle,
1278 CONST SMALL_RECT *lpClipRectangle,
1279 COORD dwDestinationOrigin,
1280 CONST CHAR_INFO *lpFill)
1281 {
1282 return IntScrollConsoleScreenBuffer(hConsoleOutput,
1283 lpScrollRectangle,
1284 lpClipRectangle,
1285 dwDestinationOrigin,
1286 lpFill,
1287 TRUE);
1288 }
1289
1290
1291 /*--------------------------------------------------------------
1292 * SetConsoleWindowInfo
1293 *
1294 * @unimplemented
1295 */
1296 BOOL
1297 WINAPI
1298 SetConsoleWindowInfo(HANDLE hConsoleOutput,
1299 BOOL bAbsolute,
1300 CONST SMALL_RECT *lpConsoleWindow)
1301 {
1302 DPRINT1("SetConsoleWindowInfo(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", hConsoleOutput, bAbsolute, lpConsoleWindow);
1303 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1304 return FALSE;
1305 }
1306
1307
1308 /*--------------------------------------------------------------
1309 * SetConsoleTextAttribute
1310 *
1311 * @implemented
1312 */
1313 BOOL
1314 WINAPI
1315 SetConsoleTextAttribute(HANDLE hConsoleOutput,
1316 WORD wAttributes)
1317 {
1318 CSR_API_MESSAGE Request;
1319 NTSTATUS Status;
1320
1321 Request.Data.SetAttribRequest.ConsoleHandle = hConsoleOutput;
1322 Request.Data.SetAttribRequest.Attrib = wAttributes;
1323
1324 Status = CsrClientCallServer(&Request,
1325 NULL,
1326 CSR_CREATE_API_NUMBER(CSR_CONSOLE, SET_ATTRIB),
1327 sizeof(CSR_API_MESSAGE));
1328 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
1329 {
1330 BaseSetLastNTError(Status);
1331 return FALSE;
1332 }
1333
1334 return TRUE;
1335 }
1336
1337
1338 static
1339 BOOL
1340 AddConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine)
1341 {
1342 PHANDLER_ROUTINE* NewCtrlHandlers = NULL;
1343
1344 if (HandlerRoutine == NULL)
1345 {
1346 NtCurrentPeb()->ProcessParameters->ConsoleFlags = TRUE;
1347 return TRUE;
1348 }
1349
1350 if (NrCtrlHandlers == NrAllocatedHandlers)
1351 {
1352 NewCtrlHandlers = RtlAllocateHeap(RtlGetProcessHeap(),
1353 0,
1354 (NrCtrlHandlers + 4) * sizeof(PHANDLER_ROUTINE));
1355 if (NewCtrlHandlers == NULL)
1356 {
1357 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1358 return FALSE;
1359 }
1360
1361 memmove(NewCtrlHandlers, CtrlHandlers, sizeof(PHANDLER_ROUTINE) * NrCtrlHandlers);
1362
1363 if (NrAllocatedHandlers > 1) RtlFreeHeap(RtlGetProcessHeap(), 0, CtrlHandlers);
1364
1365 CtrlHandlers = NewCtrlHandlers;
1366 NrAllocatedHandlers += 4;
1367 }
1368
1369 ASSERT(NrCtrlHandlers < NrAllocatedHandlers);
1370
1371 CtrlHandlers[NrCtrlHandlers++] = HandlerRoutine;
1372 return TRUE;
1373 }
1374
1375
1376 static
1377 BOOL
1378 RemoveConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine)
1379 {
1380 ULONG i;
1381
1382 if (HandlerRoutine == NULL)
1383 {
1384 NtCurrentPeb()->ProcessParameters->ConsoleFlags = FALSE;
1385 return TRUE;
1386 }
1387
1388 for (i = 0; i < NrCtrlHandlers; i++)
1389 {
1390 if (CtrlHandlers[i] == HandlerRoutine)
1391 {
1392 if (i < (NrCtrlHandlers - 1))
1393 {
1394 memmove(&CtrlHandlers[i],
1395 &CtrlHandlers[i+1],
1396 (NrCtrlHandlers - i + 1) * sizeof(PHANDLER_ROUTINE));
1397 }
1398
1399 NrCtrlHandlers--;
1400 return TRUE;
1401 }
1402 }
1403
1404 SetLastError(ERROR_INVALID_PARAMETER);
1405 return FALSE;
1406 }
1407
1408
1409 /*
1410 * @implemented
1411 */
1412 BOOL
1413 WINAPI
1414 SetConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine,
1415 BOOL Add)
1416 {
1417 BOOL Ret;
1418
1419 RtlEnterCriticalSection(&BaseDllDirectoryLock);
1420 if (Add)
1421 {
1422 Ret = AddConsoleCtrlHandler(HandlerRoutine);
1423 }
1424 else
1425 {
1426 Ret = RemoveConsoleCtrlHandler(HandlerRoutine);
1427 }
1428
1429 RtlLeaveCriticalSection(&BaseDllDirectoryLock);
1430 return(Ret);
1431 }
1432
1433
1434 /*--------------------------------------------------------------
1435 * GenerateConsoleCtrlEvent
1436 *
1437 * @implemented
1438 */
1439 BOOL
1440 WINAPI
1441 GenerateConsoleCtrlEvent(DWORD dwCtrlEvent,
1442 DWORD dwProcessGroupId)
1443 {
1444 CSR_API_MESSAGE Request;
1445 NTSTATUS Status;
1446
1447 if (dwCtrlEvent != CTRL_C_EVENT && dwCtrlEvent != CTRL_BREAK_EVENT)
1448 {
1449 SetLastError(ERROR_INVALID_PARAMETER);
1450 return FALSE;
1451 }
1452
1453 Request.Data.GenerateCtrlEvent.Event = dwCtrlEvent;
1454 Request.Data.GenerateCtrlEvent.ProcessGroup = dwProcessGroupId;
1455
1456 Status = CsrClientCallServer(&Request,
1457 NULL,
1458 CSR_CREATE_API_NUMBER(CSR_CONSOLE, GENERATE_CTRL_EVENT),
1459 sizeof(CSR_API_MESSAGE));
1460 if(!NT_SUCCESS(Status) || !(NT_SUCCESS(Status = Request.Status)))
1461 {
1462 BaseSetLastNTError(Status);
1463 return FALSE;
1464 }
1465
1466 return TRUE;
1467 }
1468
1469
1470 static DWORD
1471 IntGetConsoleTitle(LPVOID lpConsoleTitle, DWORD nSize, BOOL bUnicode)
1472 {
1473 CSR_API_MESSAGE Request;
1474 PCSR_CAPTURE_BUFFER CaptureBuffer;
1475 NTSTATUS Status;
1476
1477 if (nSize == 0)
1478 return 0;
1479
1480 Request.Data.GetTitleRequest.Length = nSize * (bUnicode ? 1 : sizeof(WCHAR));
1481 CaptureBuffer = CsrAllocateCaptureBuffer(1, Request.Data.GetTitleRequest.Length);
1482 if (CaptureBuffer == NULL)
1483 {
1484 DPRINT1("CsrAllocateCaptureBuffer failed!\n");
1485 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1486 return 0;
1487 }
1488
1489 CsrAllocateMessagePointer(CaptureBuffer,
1490 Request.Data.GetTitleRequest.Length,
1491 (PVOID*)&Request.Data.GetTitleRequest.Title);
1492
1493 Status = CsrClientCallServer(&Request,
1494 CaptureBuffer,
1495 CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_TITLE),
1496 sizeof(CSR_API_MESSAGE));
1497 if (!NT_SUCCESS(Status) || !(NT_SUCCESS(Status = Request.Status)))
1498 {
1499 CsrFreeCaptureBuffer(CaptureBuffer);
1500 BaseSetLastNTError(Status);
1501 return 0;
1502 }
1503
1504 if (bUnicode)
1505 {
1506 if (nSize >= sizeof(WCHAR))
1507 wcscpy((LPWSTR)lpConsoleTitle, Request.Data.GetTitleRequest.Title);
1508 }
1509 else
1510 {
1511 if (nSize < Request.Data.GetTitleRequest.Length / sizeof(WCHAR) ||
1512 !WideCharToMultiByte(CP_ACP, // ANSI code page
1513 0, // performance and mapping flags
1514 Request.Data.GetTitleRequest.Title, // address of wide-character string
1515 -1, // number of characters in string
1516 (LPSTR)lpConsoleTitle, // address of buffer for new string
1517 nSize, // size of buffer
1518 NULL, // FAST
1519 NULL))
1520 {
1521 /* Yes, if the buffer isn't big enough, it returns 0... Bad API */
1522 *(LPSTR)lpConsoleTitle = '\0';
1523 Request.Data.GetTitleRequest.Length = 0;
1524 }
1525 }
1526 CsrFreeCaptureBuffer(CaptureBuffer);
1527
1528 return Request.Data.GetTitleRequest.Length / sizeof(WCHAR);
1529 }
1530
1531 /*--------------------------------------------------------------
1532 * GetConsoleTitleW
1533 *
1534 * @implemented
1535 */
1536 DWORD
1537 WINAPI
1538 GetConsoleTitleW(LPWSTR lpConsoleTitle,
1539 DWORD nSize)
1540 {
1541 return IntGetConsoleTitle(lpConsoleTitle, nSize, TRUE);
1542 }
1543
1544 /*--------------------------------------------------------------
1545 * GetConsoleTitleA
1546 *
1547 * 19990306 EA
1548 *
1549 * @implemented
1550 */
1551 DWORD
1552 WINAPI
1553 GetConsoleTitleA(LPSTR lpConsoleTitle,
1554 DWORD nSize)
1555 {
1556 return IntGetConsoleTitle(lpConsoleTitle, nSize, FALSE);
1557 }
1558
1559
1560 /*--------------------------------------------------------------
1561 * SetConsoleTitleW
1562 *
1563 * @implemented
1564 */
1565 BOOL
1566 WINAPI
1567 SetConsoleTitleW(LPCWSTR lpConsoleTitle)
1568 {
1569 CSR_API_MESSAGE Request;
1570 PCSR_CAPTURE_BUFFER CaptureBuffer;
1571 NTSTATUS Status;
1572
1573 Request.Data.SetTitleRequest.Length = wcslen(lpConsoleTitle) * sizeof(WCHAR);
1574
1575 CaptureBuffer = CsrAllocateCaptureBuffer(1, Request.Data.SetTitleRequest.Length);
1576 if (CaptureBuffer == NULL)
1577 {
1578 DPRINT1("CsrAllocateCaptureBuffer failed!\n");
1579 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1580 return FALSE;
1581 }
1582
1583 CsrCaptureMessageBuffer(CaptureBuffer,
1584 (PVOID)lpConsoleTitle,
1585 Request.Data.SetTitleRequest.Length,
1586 (PVOID*)&Request.Data.SetTitleRequest.Title);
1587
1588 Status = CsrClientCallServer(&Request,
1589 CaptureBuffer,
1590 CSR_CREATE_API_NUMBER(CSR_CONSOLE, SET_TITLE),
1591 sizeof(CSR_API_MESSAGE));
1592
1593 CsrFreeCaptureBuffer(CaptureBuffer);
1594
1595 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
1596 {
1597 BaseSetLastNTError(Status);
1598 return FALSE;
1599 }
1600
1601 return TRUE;
1602 }
1603
1604
1605 /*--------------------------------------------------------------
1606 * SetConsoleTitleA
1607 *
1608 * 19990204 EA Added
1609 *
1610 * @implemented
1611 */
1612 BOOL
1613 WINAPI
1614 SetConsoleTitleA(LPCSTR lpConsoleTitle)
1615 {
1616 ULONG Length = strlen(lpConsoleTitle) + 1;
1617 LPWSTR WideTitle = HeapAlloc(GetProcessHeap(), 0, Length * sizeof(WCHAR));
1618 BOOL Ret;
1619 if (!WideTitle)
1620 {
1621 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1622 return FALSE;
1623 }
1624 MultiByteToWideChar(CP_ACP, 0, lpConsoleTitle, -1, WideTitle, Length);
1625 Ret = SetConsoleTitleW(WideTitle);
1626 HeapFree(GetProcessHeap(), 0, WideTitle);
1627 return Ret;
1628 }
1629
1630
1631 /*--------------------------------------------------------------
1632 * CreateConsoleScreenBuffer
1633 *
1634 * @implemented
1635 */
1636 HANDLE
1637 WINAPI
1638 CreateConsoleScreenBuffer(DWORD dwDesiredAccess,
1639 DWORD dwShareMode,
1640 CONST SECURITY_ATTRIBUTES *lpSecurityAttributes,
1641 DWORD dwFlags,
1642 LPVOID lpScreenBufferData)
1643 {
1644 CSR_API_MESSAGE Request;
1645 NTSTATUS Status;
1646
1647 if (dwDesiredAccess & ~(GENERIC_READ | GENERIC_WRITE)
1648 || dwShareMode & ~(FILE_SHARE_READ | FILE_SHARE_WRITE)
1649 || dwFlags != CONSOLE_TEXTMODE_BUFFER)
1650 {
1651 SetLastError(ERROR_INVALID_PARAMETER);
1652 return INVALID_HANDLE_VALUE;
1653 }
1654
1655 Request.Data.CreateScreenBufferRequest.Access = dwDesiredAccess;
1656 Request.Data.CreateScreenBufferRequest.ShareMode = dwShareMode;
1657 Request.Data.CreateScreenBufferRequest.Inheritable =
1658 lpSecurityAttributes ? lpSecurityAttributes->bInheritHandle : FALSE;
1659
1660 Status = CsrClientCallServer(&Request,
1661 NULL,
1662 CSR_CREATE_API_NUMBER(CSR_CONSOLE, CREATE_SCREEN_BUFFER),
1663 sizeof(CSR_API_MESSAGE));
1664 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
1665 {
1666 BaseSetLastNTError(Status);
1667 return INVALID_HANDLE_VALUE;
1668 }
1669 return Request.Data.CreateScreenBufferRequest.OutputHandle;
1670 }
1671
1672
1673 /*--------------------------------------------------------------
1674 * GetConsoleCP
1675 *
1676 * @implemented
1677 */
1678 UINT
1679 WINAPI
1680 GetConsoleCP(VOID)
1681 {
1682 CSR_API_MESSAGE Request;
1683 NTSTATUS Status;
1684
1685 Status = CsrClientCallServer(&Request,
1686 NULL,
1687 CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_CONSOLE_CP),
1688 sizeof(CSR_API_MESSAGE));
1689 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
1690 {
1691 BaseSetLastNTError (Status);
1692 return 0;
1693 }
1694
1695 return Request.Data.GetConsoleCodePage.CodePage;
1696 }
1697
1698
1699 /*--------------------------------------------------------------
1700 * SetConsoleCP
1701 *
1702 * @implemented
1703 */
1704 BOOL
1705 WINAPI
1706 SetConsoleCP(UINT wCodePageID)
1707 {
1708 CSR_API_MESSAGE Request;
1709 NTSTATUS Status;
1710
1711 Request.Data.SetConsoleCodePage.CodePage = wCodePageID;
1712
1713 Status = CsrClientCallServer(&Request,
1714 NULL,
1715 CSR_CREATE_API_NUMBER(CSR_CONSOLE, SET_CONSOLE_CP),
1716 sizeof(CSR_API_MESSAGE));
1717 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
1718 {
1719 BaseSetLastNTError(Status);
1720 }
1721
1722 return NT_SUCCESS(Status);
1723 }
1724
1725
1726 /*--------------------------------------------------------------
1727 * GetConsoleOutputCP
1728 *
1729 * @implemented
1730 */
1731 UINT
1732 WINAPI
1733 GetConsoleOutputCP(VOID)
1734 {
1735 CSR_API_MESSAGE Request;
1736 NTSTATUS Status;
1737
1738 Status = CsrClientCallServer(&Request,
1739 NULL,
1740 CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_CONSOLE_OUTPUT_CP),
1741 sizeof(CSR_API_MESSAGE));
1742 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
1743 {
1744 BaseSetLastNTError (Status);
1745 return 0;
1746 }
1747
1748 return Request.Data.GetConsoleOutputCodePage.CodePage;
1749 }
1750
1751
1752 /*--------------------------------------------------------------
1753 * SetConsoleOutputCP
1754 *
1755 * @implemented
1756 */
1757 BOOL
1758 WINAPI
1759 SetConsoleOutputCP(UINT wCodePageID)
1760 {
1761 CSR_API_MESSAGE Request;
1762 NTSTATUS Status;
1763
1764 Request.Data.SetConsoleOutputCodePage.CodePage = wCodePageID;
1765
1766 Status = CsrClientCallServer(&Request,
1767 NULL,
1768 CSR_CREATE_API_NUMBER(CSR_CONSOLE, SET_CONSOLE_OUTPUT_CP),
1769 sizeof(CSR_API_MESSAGE));
1770 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
1771 {
1772 BaseSetLastNTError(Status);
1773 }
1774
1775 return NT_SUCCESS(Status);
1776 }
1777
1778
1779 /*--------------------------------------------------------------
1780 * GetConsoleProcessList
1781 *
1782 * @implemented
1783 */
1784 DWORD
1785 WINAPI
1786 GetConsoleProcessList(LPDWORD lpdwProcessList,
1787 DWORD dwProcessCount)
1788 {
1789 PCSR_CAPTURE_BUFFER CaptureBuffer;
1790 CSR_API_MESSAGE Request;
1791 ULONG nProcesses;
1792 NTSTATUS Status;
1793
1794 if (lpdwProcessList == NULL || dwProcessCount == 0)
1795 {
1796 SetLastError(ERROR_INVALID_PARAMETER);
1797 return 0;
1798 }
1799
1800 CaptureBuffer = CsrAllocateCaptureBuffer(1, dwProcessCount * sizeof(DWORD));
1801 if (CaptureBuffer == NULL)
1802 {
1803 DPRINT1("CsrAllocateCaptureBuffer failed!\n");
1804 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1805 return FALSE;
1806 }
1807
1808 Request.Data.GetProcessListRequest.nMaxIds = dwProcessCount;
1809 CsrAllocateMessagePointer(CaptureBuffer,
1810 dwProcessCount * sizeof(DWORD),
1811 (PVOID*)&Request.Data.GetProcessListRequest.ProcessId);
1812
1813 Status = CsrClientCallServer(&Request,
1814 CaptureBuffer,
1815 CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_PROCESS_LIST),
1816 sizeof(CSR_API_MESSAGE));
1817 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
1818 {
1819 BaseSetLastNTError (Status);
1820 nProcesses = 0;
1821 }
1822 else
1823 {
1824 nProcesses = Request.Data.GetProcessListRequest.nProcessIdsTotal;
1825 if (dwProcessCount >= nProcesses)
1826 {
1827 memcpy(lpdwProcessList, Request.Data.GetProcessListRequest.ProcessId, nProcesses * sizeof(DWORD));
1828 }
1829 }
1830
1831 CsrFreeCaptureBuffer(CaptureBuffer);
1832 return nProcesses;
1833 }
1834
1835
1836 /*--------------------------------------------------------------
1837 * GetConsoleSelectionInfo
1838 *
1839 * @implemented
1840 */
1841 BOOL
1842 WINAPI
1843 GetConsoleSelectionInfo(PCONSOLE_SELECTION_INFO lpConsoleSelectionInfo)
1844 {
1845 CSR_API_MESSAGE Request;
1846 NTSTATUS Status = CsrClientCallServer(&Request,
1847 NULL,
1848 CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_CONSOLE_SELECTION_INFO),
1849 sizeof(CSR_API_MESSAGE));
1850 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
1851 {
1852 BaseSetLastNTError(Status);
1853 return FALSE;
1854 }
1855
1856 *lpConsoleSelectionInfo = Request.Data.GetConsoleSelectionInfo.Info;
1857 return TRUE;
1858 }
1859
1860
1861 /*--------------------------------------------------------------
1862 * AttachConsole
1863 *
1864 * @unimplemented
1865 */
1866 BOOL
1867 WINAPI
1868 AttachConsole(DWORD dwProcessId)
1869 {
1870 DPRINT1("AttachConsole(0x%x) UNIMPLEMENTED!\n", dwProcessId);
1871 return TRUE;
1872 }
1873
1874 /*--------------------------------------------------------------
1875 * GetConsoleWindow
1876 *
1877 * @implemented
1878 */
1879 HWND
1880 WINAPI
1881 GetConsoleWindow(VOID)
1882 {
1883 CSR_API_MESSAGE Request;
1884 NTSTATUS Status;
1885
1886 Status = CsrClientCallServer(&Request,
1887 NULL,
1888 CSR_CREATE_API_NUMBER(CSR_CONSOLE, GET_CONSOLE_WINDOW),
1889 sizeof(CSR_API_MESSAGE));
1890 if (!NT_SUCCESS(Status ) || !NT_SUCCESS(Status = Request.Status))
1891 {
1892 BaseSetLastNTError(Status);
1893 return (HWND) NULL;
1894 }
1895
1896 return Request.Data.GetConsoleWindowRequest.WindowHandle;
1897 }
1898
1899
1900 /*--------------------------------------------------------------
1901 * SetConsoleIcon
1902 *
1903 * @implemented
1904 */
1905 BOOL
1906 WINAPI
1907 SetConsoleIcon(HICON hicon)
1908 {
1909 CSR_API_MESSAGE Request;
1910 NTSTATUS Status;
1911
1912 Request.Data.SetConsoleIconRequest.WindowIcon = hicon;
1913
1914 Status = CsrClientCallServer(&Request,
1915 NULL,
1916 CSR_CREATE_API_NUMBER(CSR_CONSOLE, SET_CONSOLE_ICON),
1917 sizeof(CSR_API_MESSAGE));
1918 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
1919 {
1920 BaseSetLastNTError(Status);
1921 return FALSE;
1922 }
1923
1924 return NT_SUCCESS(Status);
1925 }
1926
1927
1928 /******************************************************************************
1929 * \name SetConsoleInputExeNameW
1930 * \brief Sets the console input file name from a unicode string.
1931 * \param lpInputExeName Pointer to a unicode string with the name.
1932 * \return TRUE if successful, FALSE if unsuccsedful.
1933 * \remarks If lpInputExeName is 0 or the string length is 0 or greater than 255,
1934 * the function fails and sets last error to ERROR_INVALID_PARAMETER.
1935 */
1936 BOOL
1937 WINAPI
1938 SetConsoleInputExeNameW(LPCWSTR lpInputExeName)
1939 {
1940 int lenName;
1941
1942 if (!lpInputExeName
1943 || (lenName = lstrlenW(lpInputExeName)) == 0
1944 || lenName > INPUTEXENAME_BUFLEN - 1)
1945 {
1946 /* Fail if string is empty or too long */
1947 SetLastError(ERROR_INVALID_PARAMETER);
1948 return FALSE;
1949 }
1950
1951 RtlEnterCriticalSection(&ConsoleLock);
1952 _SEH2_TRY
1953 {
1954 RtlCopyMemory(InputExeName, lpInputExeName, lenName * sizeof(WCHAR));
1955 InputExeName[lenName] = L'\0';
1956 }
1957 _SEH2_FINALLY
1958 {
1959 RtlLeaveCriticalSection(&ConsoleLock);
1960 }
1961 _SEH2_END;
1962
1963 return TRUE;
1964 }
1965
1966
1967 /******************************************************************************
1968 * \name SetConsoleInputExeNameA
1969 * \brief Sets the console input file name from an ansi string.
1970 * \param lpInputExeName Pointer to an ansi string with the name.
1971 * \return TRUE if successful, FALSE if unsuccsedful.
1972 * \remarks If lpInputExeName is 0 or the string length is 0 or greater than 255,
1973 * the function fails and sets last error to ERROR_INVALID_PARAMETER.
1974 */
1975 BOOL
1976 WINAPI
1977 SetConsoleInputExeNameA(LPCSTR lpInputExeName)
1978 {
1979 WCHAR Buffer[INPUTEXENAME_BUFLEN];
1980 ANSI_STRING InputExeNameA;
1981 UNICODE_STRING InputExeNameU;
1982 NTSTATUS Status;
1983 BOOL Ret;
1984
1985 RtlInitAnsiString(&InputExeNameA, lpInputExeName);
1986
1987 if(InputExeNameA.Length == 0 ||
1988 InputExeNameA.Length > INPUTEXENAME_BUFLEN - 1)
1989 {
1990 /* Fail if string is empty or too long */
1991 SetLastError(ERROR_INVALID_PARAMETER);
1992 return FALSE;
1993 }
1994
1995 InputExeNameU.Buffer = Buffer;
1996 InputExeNameU.MaximumLength = sizeof(Buffer);
1997 InputExeNameU.Length = 0;
1998 Status = RtlAnsiStringToUnicodeString(&InputExeNameU, &InputExeNameA, FALSE);
1999 if(NT_SUCCESS(Status))
2000 {
2001 Ret = SetConsoleInputExeNameW(InputExeNameU.Buffer);
2002 }
2003 else
2004 {
2005 BaseSetLastNTError(Status);
2006 Ret = FALSE;
2007 }
2008
2009 return Ret;
2010 }
2011
2012
2013 /******************************************************************************
2014 * \name GetConsoleInputExeNameW
2015 * \brief Retrieves the console input file name as unicode string.
2016 * \param nBufferLength Length of the buffer in WCHARs.
2017 * Specify 0 to recieve the needed buffer length.
2018 * \param lpBuffer Pointer to a buffer that recieves the string.
2019 * \return Needed buffer size if \p nBufferLength is 0.
2020 * Otherwise 1 if successful, 2 if buffer is too small.
2021 * \remarks Sets last error value to ERROR_BUFFER_OVERFLOW if the buffer
2022 * is not big enough.
2023 */
2024 DWORD
2025 WINAPI
2026 GetConsoleInputExeNameW(DWORD nBufferLength, LPWSTR lpBuffer)
2027 {
2028 int lenName = lstrlenW(InputExeName);
2029
2030 if (nBufferLength == 0)
2031 {
2032 /* Buffer size is requested, return it */
2033 return lenName + 1;
2034 }
2035
2036 if(lenName + 1 > nBufferLength)
2037 {
2038 /* Buffer is not large enough! */
2039 SetLastError(ERROR_BUFFER_OVERFLOW);
2040 return 2;
2041 }
2042
2043 RtlEnterCriticalSection(&ConsoleLock);
2044 _SEH2_TRY
2045 {
2046 RtlCopyMemory(lpBuffer, InputExeName, lenName * sizeof(WCHAR));
2047 lpBuffer[lenName] = '\0';
2048 }
2049 _SEH2_FINALLY
2050 {
2051 RtlLeaveCriticalSection(&ConsoleLock);
2052 }
2053 _SEH2_END;
2054
2055 /* Success, return 1 */
2056 return 1;
2057 }
2058
2059
2060 /******************************************************************************
2061 * \name GetConsoleInputExeNameA
2062 * \brief Retrieves the console input file name as ansi string.
2063 * \param nBufferLength Length of the buffer in CHARs.
2064 * \param lpBuffer Pointer to a buffer that recieves the string.
2065 * \return 1 if successful, 2 if buffer is too small.
2066 * \remarks Sets last error value to ERROR_BUFFER_OVERFLOW if the buffer
2067 * is not big enough. The buffer recieves as much characters as fit.
2068 */
2069 DWORD
2070 WINAPI
2071 GetConsoleInputExeNameA(DWORD nBufferLength, LPSTR lpBuffer)
2072 {
2073 WCHAR Buffer[INPUTEXENAME_BUFLEN];
2074 DWORD Ret;
2075 UNICODE_STRING BufferU;
2076 ANSI_STRING BufferA;
2077
2078 /* Get the unicode name */
2079 Ret = GetConsoleInputExeNameW(sizeof(Buffer) / sizeof(Buffer[0]), Buffer);
2080
2081 /* Initialize strings for conversion */
2082 RtlInitUnicodeString(&BufferU, Buffer);
2083 BufferA.Length = 0;
2084 BufferA.MaximumLength = nBufferLength;
2085 BufferA.Buffer = lpBuffer;
2086
2087 /* Convert unicode name to ansi, copying as much chars as fit */
2088 RtlUnicodeStringToAnsiString(&BufferA, &BufferU, FALSE);
2089
2090 /* Error handling */
2091 if(nBufferLength <= BufferU.Length / sizeof(WCHAR))
2092 {
2093 SetLastError(ERROR_BUFFER_OVERFLOW);
2094 return 2;
2095 }
2096
2097 return Ret;
2098 }
2099
2100 BOOL
2101 WINAPI
2102 GetConsoleCharType(HANDLE hConsole, COORD Coord, PDWORD Type)
2103 {
2104 STUB;
2105 return FALSE;
2106 }
2107
2108 BOOL
2109 WINAPI
2110 GetConsoleCursorMode(HANDLE hConsole, PBOOL pUnknown1, PBOOL pUnknown2)
2111 {
2112 STUB;
2113 return FALSE;
2114 }
2115
2116 BOOL
2117 WINAPI
2118 GetConsoleNlsMode(HANDLE hConsole, LPDWORD lpMode)
2119 {
2120 STUB;
2121 return FALSE;
2122 }
2123
2124 BOOL
2125 WINAPI
2126 RegisterConsoleIME(HWND hWnd, LPDWORD ThreadId)
2127 {
2128 STUB;
2129 return FALSE;
2130 }
2131
2132 BOOL
2133 WINAPI
2134 RegisterConsoleOS2(BOOL bUnknown)
2135 {
2136 STUB;
2137 return FALSE;
2138 }
2139
2140 BOOL
2141 WINAPI
2142 SetConsoleCursorMode(HANDLE hConsole, BOOL Unknown1, BOOL Unknown2)
2143 {
2144 STUB;
2145 return FALSE;
2146 }
2147
2148 BOOL
2149 WINAPI
2150 SetConsoleLocalEUDC(DWORD Unknown1, DWORD Unknown2, DWORD Unknown3, DWORD Unknown4)
2151 {
2152 STUB;
2153 return FALSE;
2154 }
2155
2156 BOOL
2157 WINAPI
2158 SetConsoleNlsMode(HANDLE hConsole, DWORD dwMode)
2159 {
2160 STUB;
2161 return FALSE;
2162 }
2163
2164 BOOL
2165 WINAPI
2166 SetConsoleOS2OemFormat(BOOL bUnknown)
2167 {
2168 STUB;
2169 return FALSE;
2170 }
2171
2172 BOOL
2173 WINAPI
2174 UnregisterConsoleIME(VOID)
2175 {
2176 STUB;
2177 return FALSE;
2178 }
2179
2180
2181 /*
2182 * @unimplemented
2183 */
2184 BOOL WINAPI GetConsoleKeyboardLayoutNameA(LPSTR name)
2185 {
2186 STUB;
2187 return 0;
2188 }
2189
2190 /*
2191 * @unimplemented
2192 */
2193 BOOL WINAPI GetConsoleKeyboardLayoutNameW(LPWSTR name)
2194 {
2195 STUB;
2196 return 0;
2197 }
2198
2199 /*
2200 * @unimplemented
2201 */
2202 BOOL
2203 WINAPI
2204 SetLastConsoleEventActive(VOID)
2205 {
2206 STUB;
2207 return FALSE;
2208 }
2209
2210 /* EOF */
A free Windows-compatible Operating System