projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
- Moved all members with variable length in CSRSS_XXX structures to the end.
[reactos.git] / reactos / lib / kernel32 / misc / console.c
1 /* $Id$
2 *
3 * COPYRIGHT: See COPYING in the top level directory
4 * PROJECT: ReactOS system libraries
5 * FILE: lib/kernel32/misc/console.c
6 * PURPOSE: Win32 server console functions
7 * PROGRAMMER: James Tabor
8 * <jimtabor@adsl-64-217-116-74.dsl.hstntx.swbell.net>
9 * UPDATE HISTORY:
10 * 199901?? ?? Created
11 * 19990204 EA SetConsoleTitleA
12 * 19990306 EA Stubs
13 */
14
15 /* INCLUDES ******************************************************************/
16
17 #include <k32.h>
18
19 #define NDEBUG
20 #include "../include/debug.h"
21
22 extern BOOL WINAPI DefaultConsoleCtrlHandler(DWORD Event);
23 extern __declspec(noreturn) VOID CALLBACK ConsoleControlDispatcher(DWORD CodeAndFlag);
24 extern RTL_CRITICAL_SECTION ConsoleLock;
25 extern BOOL WINAPI IsDebuggerPresent(VOID);
26
27
28 /* GLOBALS *******************************************************************/
29
30 static BOOL IgnoreCtrlEvents = FALSE;
31
32 static PHANDLER_ROUTINE* CtrlHandlers = NULL;
33 static ULONG NrCtrlHandlers = 0;
34 static WCHAR InputExeName[MAX_PATH + 1] = L"";
35
36 /* Default Console Control Handler *******************************************/
37
38 BOOL WINAPI DefaultConsoleCtrlHandler(DWORD Event)
39 {
40 switch(Event)
41 {
42 case CTRL_C_EVENT:
43 DPRINT("Ctrl-C Event\n");
44 break;
45
46 case CTRL_BREAK_EVENT:
47 DPRINT("Ctrl-Break Event\n");
48 break;
49
50 case CTRL_SHUTDOWN_EVENT:
51 DPRINT("Ctrl Shutdown Event\n");
52 break;
53
54 case CTRL_CLOSE_EVENT:
55 DPRINT("Ctrl Close Event\n");
56 break;
57
58 case CTRL_LOGOFF_EVENT:
59 DPRINT("Ctrl Logoff Event\n");
60 break;
61 }
62 ExitProcess(0);
63 return TRUE;
64 }
65
66
67 __declspec(noreturn) VOID CALLBACK ConsoleControlDispatcher(DWORD CodeAndFlag)
68 {
69 DWORD nExitCode = 0;
70 DWORD nCode = CodeAndFlag & MAXLONG;
71 UINT i;
72
73 SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);
74
75 switch(nCode)
76 {
77 case CTRL_C_EVENT:
78 case CTRL_BREAK_EVENT:
79 {
80 if(IsDebuggerPresent())
81 {
82 EXCEPTION_RECORD erException;
83 erException.ExceptionCode =
84 (nCode == CTRL_C_EVENT ? DBG_CONTROL_C : DBG_CONTROL_BREAK);
85 erException.ExceptionFlags = 0;
86 erException.ExceptionRecord = NULL;
87 erException.ExceptionAddress = &DefaultConsoleCtrlHandler;
88 erException.NumberParameters = 0;
89 RtlRaiseException(&erException);
90 }
91 RtlEnterCriticalSection(&ConsoleLock);
92
93 if(!(nCode == CTRL_C_EVENT &&
94 NtCurrentPeb()->ProcessParameters->ConsoleFlags & 1))
95 {
96 for(i = NrCtrlHandlers; i > 0; -- i)
97 if(CtrlHandlers[i - 1](nCode)) break;
98 }
99 RtlLeaveCriticalSection(&ConsoleLock);
100 ExitThread(0);
101 }
102 case CTRL_CLOSE_EVENT:
103 case CTRL_LOGOFF_EVENT:
104 case CTRL_SHUTDOWN_EVENT:
105 break;
106
107 default: ExitThread(0);
108 }
109
110 RtlEnterCriticalSection(&ConsoleLock);
111
112 if(!(nCode == CTRL_C_EVENT &&
113 NtCurrentPeb()->ProcessParameters->ConsoleFlags & 1))
114 {
115 i = NrCtrlHandlers;
116 while(i > 0)
117 {
118 if (i == 1 && (CodeAndFlag & MINLONG) &&
119 (nCode == CTRL_LOGOFF_EVENT || nCode == CTRL_SHUTDOWN_EVENT))
120 break;
121
122 if(CtrlHandlers[i - 1](nCode))
123 {
124 switch(nCode)
125 {
126 case CTRL_CLOSE_EVENT:
127 case CTRL_LOGOFF_EVENT:
128 case CTRL_SHUTDOWN_EVENT:
129 nExitCode = CodeAndFlag;
130 }
131 break;
132 }
133 --i;
134 }
135 }
136 RtlLeaveCriticalSection(&ConsoleLock);
137 ExitThread(nExitCode);
138 }
139
140
141 /* FUNCTIONS *****************************************************************/
142
143 /*
144 * @unimplemented
145 */
146 BOOL STDCALL
147 AddConsoleAliasA (LPSTR Source,
148 LPSTR Target,
149 LPSTR ExeName)
150 {
151 DPRINT1("AddConsoleAliasA(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Source, Target, ExeName);
152 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
153 return FALSE;
154 }
155
156
157 /*
158 * @unimplemented
159 */
160 BOOL STDCALL
161 AddConsoleAliasW (LPWSTR Source,
162 LPWSTR Target,
163 LPWSTR ExeName)
164 {
165 DPRINT1("AddConsoleAliasW(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Source, Target, ExeName);
166 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
167 return FALSE;
168 }
169
170
171 /*
172 * @unimplemented
173 */
174 BOOL STDCALL
175 ConsoleMenuControl (HANDLE hConsole,
176 DWORD Unknown1,
177 DWORD Unknown2)
178 /*
179 * Undocumented
180 */
181 {
182 DPRINT1("ConsoleMenuControl(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", hConsole, Unknown1, Unknown2);
183 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
184 return FALSE;
185 }
186
187
188 /*
189 * @implemented
190 */
191 HANDLE STDCALL
192 DuplicateConsoleHandle (HANDLE hConsole,
193 DWORD dwDesiredAccess,
194 BOOL bInheritHandle,
195 DWORD dwOptions)
196 {
197 CSR_API_MESSAGE Request;
198 ULONG CsrRequest;
199 NTSTATUS Status;
200
201 if (IsConsoleHandle (hConsole) == FALSE)
202 {
203 SetLastError (ERROR_INVALID_PARAMETER);
204 return INVALID_HANDLE_VALUE;
205 }
206
207 CsrRequest = MAKE_CSR_API(DUPLICATE_HANDLE, CSR_NATIVE);
208 Request.Data.DuplicateHandleRequest.Handle = hConsole;
209 Request.Data.DuplicateHandleRequest.ProcessId = GetTeb()->Cid.UniqueProcess;
210 Status = CsrClientCallServer(&Request,
211 NULL,
212 CsrRequest,
213 sizeof(CSR_API_MESSAGE));
214 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status=Request.Status))
215 {
216 SetLastErrorByStatus(Status);
217 return INVALID_HANDLE_VALUE;
218 }
219 return Request.Data.DuplicateHandleRequest.Handle;
220 }
221
222
223 /*
224 * @unimplemented
225 */
226 DWORD STDCALL
227 ExpungeConsoleCommandHistoryW (DWORD Unknown0)
228 /*
229 * Undocumented
230 */
231 {
232 DPRINT1("ExpungeConsoleCommandHistoryW(0x%x) UNIMPLEMENTED!\n", Unknown0);
233 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
234 return 0;
235 }
236
237
238 /*
239 * @unimplemented
240 */
241 DWORD STDCALL
242 ExpungeConsoleCommandHistoryA (DWORD Unknown0)
243 /*
244 * Undocumented
245 */
246 {
247
248 DPRINT1("ExpungeConsoleCommandHistoryW(0x%x) UNIMPLEMENTED!\n", Unknown0);
249 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
250 return 0;
251 }
252
253
254 /*
255 * @unimplemented
256 */
257 DWORD STDCALL
258 GetConsoleAliasW (LPWSTR lpSource,
259 LPWSTR lpTargetBuffer,
260 DWORD TargetBufferLength,
261 LPWSTR lpExeName)
262 /*
263 * Undocumented
264 */
265 {
266 DPRINT1("GetConsoleAliasW(0x%p, 0x%p, 0x%x, 0x%p) UNIMPLEMENTED!\n", lpSource, lpTargetBuffer, TargetBufferLength, lpExeName);
267 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
268 return 0;
269 }
270
271
272 /*
273 * @unimplemented
274 */
275 DWORD STDCALL
276 GetConsoleAliasA (LPSTR lpSource,
277 LPSTR lpTargetBuffer,
278 DWORD TargetBufferLength,
279 LPSTR lpExeName)
280 /*
281 * Undocumented
282 */
283 {
284 DPRINT1("GetConsoleAliasA(0x%p, 0x%p, 0x%x, 0x%p) UNIMPLEMENTED!\n", lpSource, lpTargetBuffer, TargetBufferLength, lpExeName);
285 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
286 return 0;
287 }
288
289
290 /*
291 * @unimplemented
292 */
293 DWORD STDCALL
294 GetConsoleAliasExesW (LPWSTR lpExeNameBuffer,
295 DWORD ExeNameBufferLength)
296 /*
297 * Undocumented
298 */
299 {
300 DPRINT1("GetConsoleAliasExesW(0x%p, 0x%x) UNIMPLEMENTED!\n", lpExeNameBuffer, ExeNameBufferLength);
301 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
302 return 0;
303 }
304
305
306 /*
307 * @unimplemented
308 */
309 DWORD STDCALL
310 GetConsoleAliasExesA (LPSTR lpExeNameBuffer,
311 DWORD ExeNameBufferLength)
312 /*
313 * Undocumented
314 */
315 {
316 DPRINT1("GetConsoleAliasExesA(0x%p, 0x%x) UNIMPLEMENTED!\n", lpExeNameBuffer, ExeNameBufferLength);
317 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
318 return 0;
319 }
320
321
322 /*
323 * @unimplemented
324 */
325 DWORD STDCALL
326 GetConsoleAliasExesLengthA (VOID)
327 /*
328 * Undocumented
329 */
330 {
331 DPRINT1("GetConsoleAliasExesLengthA() UNIMPLEMENTED!\n");
332 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
333 return 0;
334 }
335
336
337 /*
338 * @unimplemented
339 */
340 DWORD STDCALL
341 GetConsoleAliasExesLengthW (VOID)
342 /*
343 * Undocumented
344 */
345 {
346 DPRINT1("GetConsoleAliasExesLengthW() UNIMPLEMENTED!\n");
347 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
348 return 0;
349 }
350
351
352 /*
353 * @unimplemented
354 */
355 DWORD STDCALL
356 GetConsoleAliasesW (DWORD Unknown0,
357 DWORD Unknown1,
358 DWORD Unknown2)
359 /*
360 * Undocumented
361 */
362 {
363 DPRINT1("GetConsoleAliasesW(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1, Unknown2);
364 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
365 return 0;
366 }
367
368
369 /*
370 * @unimplemented
371 */
372 DWORD STDCALL
373 GetConsoleAliasesA (DWORD Unknown0,
374 DWORD Unknown1,
375 DWORD Unknown2)
376 /*
377 * Undocumented
378 */
379 {
380 DPRINT1("GetConsoleAliasesA(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1, Unknown2);
381 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
382 return 0;
383 }
384
385
386 /*
387 * @unimplemented
388 */
389 DWORD STDCALL
390 GetConsoleAliasesLengthW (LPWSTR lpExeName)
391 /*
392 * Undocumented
393 */
394 {
395 DPRINT1("GetConsoleAliasesLengthW(0x%p) UNIMPLEMENTED!\n", lpExeName);
396 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
397 return 0;
398 }
399
400
401 /*
402 * @unimplemented
403 */
404 DWORD STDCALL
405 GetConsoleAliasesLengthA (LPSTR lpExeName)
406 /*
407 * Undocumented
408 */
409 {
410 DPRINT1("GetConsoleAliasesLengthA(0x%p) UNIMPLEMENTED!\n", lpExeName);
411 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
412 return 0;
413 }
414
415
416 /*
417 * @unimplemented
418 */
419 DWORD STDCALL
420 GetConsoleCommandHistoryW (DWORD Unknown0,
421 DWORD Unknown1,
422 DWORD Unknown2)
423 /*
424 * Undocumented
425 */
426 {
427 DPRINT1("GetConsoleCommandHistoryW(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1, Unknown2);
428 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
429 return 0;
430 }
431
432
433 /*
434 * @unimplemented
435 */
436 DWORD STDCALL
437 GetConsoleCommandHistoryA (DWORD Unknown0,
438 DWORD Unknown1,
439 DWORD Unknown2)
440 /*
441 * Undocumented
442 */
443 {
444 DPRINT1("GetConsoleCommandHistoryA(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1, Unknown2);
445 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
446 return 0;
447 }
448
449
450 /*
451 * @unimplemented
452 */
453 DWORD STDCALL
454 GetConsoleCommandHistoryLengthW (DWORD Unknown0)
455 /*
456 * Undocumented
457 */
458 {
459 DPRINT1("GetConsoleCommandHistoryLengthW(0x%x) UNIMPLEMENTED!\n", Unknown0);
460 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
461 return 0;
462 }
463
464
465 /*
466 * @unimplemented
467 */
468 DWORD STDCALL
469 GetConsoleCommandHistoryLengthA (DWORD Unknown0)
470 /*
471 * Undocumented
472 */
473 {
474 DPRINT1("GetConsoleCommandHistoryLengthA(0x%x) UNIMPLEMENTED!\n", Unknown0);
475 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
476 return 0;
477 }
478
479 /*
480 * @unimplemented
481 */
482 DWORD STDCALL
483 GetConsoleDisplayMode (LPDWORD lpdwMode)
484 /*
485 * FUNCTION: Get the console display mode
486 * ARGUMENTS:
487 * lpdwMode - Address of variable that receives the current value
488 * of display mode
489 * STATUS: Undocumented
490 */
491 {
492 DPRINT1("GetConsoleDisplayMode(0x%x) UNIMPLEMENTED!\n", lpdwMode);
493 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
494 return 0;
495 }
496
497
498 /*
499 * @unimplemented
500 */
501 DWORD STDCALL
502 GetConsoleFontInfo (DWORD Unknown0,
503 DWORD Unknown1,
504 DWORD Unknown2,
505 DWORD Unknown3)
506 /*
507 * Undocumented
508 */
509 {
510 DPRINT1("GetConsoleFontInfo(0x%x, 0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1, Unknown2, Unknown3);
511 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
512 return 0;
513 }
514
515
516 /*
517 * @unimplemented
518 */
519 COORD STDCALL
520 GetConsoleFontSize(HANDLE hConsoleOutput,
521 DWORD nFont)
522 {
523 COORD Empty = {0, 0};
524 DPRINT1("GetConsoleFontSize(0x%x, 0x%x) UNIMPLEMENTED!\n", hConsoleOutput, nFont);
525 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
526 return Empty ;
527 }
528
529
530 /*
531 * @implemented
532 */
533 DWORD STDCALL
534 GetConsoleHardwareState (HANDLE hConsole,
535 DWORD Flags,
536 PDWORD State)
537 /*
538 * Undocumented
539 */
540 {
541 CSR_API_MESSAGE Request; ULONG CsrRequest;
542
543 NTSTATUS Status;
544
545 CsrRequest = MAKE_CSR_API(SETGET_CONSOLE_HW_STATE, CSR_CONSOLE);
546 Request.Data.ConsoleHardwareStateRequest.ConsoleHandle = hConsole;
547 Request.Data.ConsoleHardwareStateRequest.SetGet = CONSOLE_HARDWARE_STATE_GET;
548
549 Status = CsrClientCallServer(& Request,
550 NULL,
551 CsrRequest,
552 sizeof(CSR_API_MESSAGE));
553 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
554 {
555 SetLastErrorByStatus(Status);
556 return FALSE;
557 }
558 *State = Request.Data.ConsoleHardwareStateRequest.State;
559 return TRUE;
560 }
561
562
563 /*
564 * @implemented
565 */
566 DWORD STDCALL
567 GetConsoleInputWaitHandle (VOID)
568 /*
569 * Undocumented
570 */
571 {
572 CSR_API_MESSAGE Request; ULONG CsrRequest;
573
574 NTSTATUS Status;
575
576 CsrRequest = MAKE_CSR_API(GET_INPUT_WAIT_HANDLE, CSR_CONSOLE);
577 Status = CsrClientCallServer(&Request, NULL, CsrRequest,
578 sizeof(CSR_API_MESSAGE));
579 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
580 {
581 SetLastErrorByStatus(Status);
582 return 0;
583 }
584 return (DWORD) Request.Data.GetConsoleInputWaitHandle.InputWaitHandle;
585 }
586
587
588 /*
589 * @unimplemented
590 */
591 DWORD STDCALL
592 GetCurrentConsoleFont(HANDLE hConsoleOutput,
593 BOOL bMaximumWindow,
594 PCONSOLE_FONT_INFO lpConsoleCurrentFont)
595 {
596 DPRINT1("GetCurrentConsoleFont(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", hConsoleOutput, bMaximumWindow, lpConsoleCurrentFont);
597 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
598 return 0;
599 }
600
601
602 /*
603 * @unimplemented
604 */
605 ULONG STDCALL
606 GetNumberOfConsoleFonts (VOID)
607 /*
608 * Undocumented
609 */
610 {
611 DPRINT1("GetNumberOfConsoleFonts() UNIMPLEMENTED!\n");
612 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
613 return 1; /* FIXME: call csrss.exe */
614 }
615
616
617 /*
618 * @unimplemented
619 */
620 DWORD STDCALL
621 InvalidateConsoleDIBits (DWORD Unknown0,
622 DWORD Unknown1)
623 /*
624 * Undocumented
625 */
626 {
627 DPRINT1("InvalidateConsoleDIBits(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1);
628 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
629 return 0;
630 }
631
632
633 /*
634 * @unimplemented
635 */
636 HANDLE STDCALL
637 OpenConsoleW (LPWSTR wsName,
638 DWORD dwDesiredAccess,
639 BOOL bInheritHandle,
640 DWORD dwCreationDistribution)
641 /*
642 * Undocumented
643 */
644 {
645 CSR_API_MESSAGE Request; ULONG CsrRequest;
646
647 PHANDLE phConsole = NULL;
648 NTSTATUS Status = STATUS_SUCCESS;
649
650 if(0 == _wcsicmp(wsName, L"CONIN$"))
651 {
652 CsrRequest = MAKE_CSR_API(GET_INPUT_HANDLE, CSR_NATIVE);
653 phConsole = & Request.Data.GetInputHandleRequest.InputHandle;
654 }
655 else if (0 == _wcsicmp(wsName, L"CONOUT$"))
656 {
657 CsrRequest = MAKE_CSR_API(GET_OUTPUT_HANDLE, CSR_NATIVE);
658 phConsole = & Request.Data.GetOutputHandleRequest.OutputHandle;
659 }
660 else
661 {
662 SetLastError(ERROR_INVALID_PARAMETER);
663 return(INVALID_HANDLE_VALUE);
664 }
665 if ((GENERIC_READ|GENERIC_WRITE) != dwDesiredAccess)
666 {
667 SetLastError(ERROR_INVALID_PARAMETER);
668 return(INVALID_HANDLE_VALUE);
669 }
670 if (OPEN_EXISTING != dwCreationDistribution)
671 {
672 SetLastError(ERROR_INVALID_PARAMETER);
673 return(INVALID_HANDLE_VALUE);
674 }
675 Status = CsrClientCallServer(& Request,
676 NULL,
677 CsrRequest,
678 sizeof(CSR_API_MESSAGE));
679 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
680 {
681 SetLastErrorByStatus(Status);
682 return INVALID_HANDLE_VALUE;
683 }
684 return(*phConsole);
685 }
686
687
688 /*
689 * @unimplemented
690 */
691 BOOL STDCALL
692 SetConsoleCommandHistoryMode (DWORD dwMode)
693 /*
694 * Undocumented
695 */
696 {
697 DPRINT1("SetConsoleCommandHistoryMode(0x%x) UNIMPLEMENTED!\n", dwMode);
698 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
699 return FALSE;
700 }
701
702
703 /*
704 * @unimplemented
705 */
706 BOOL STDCALL
707 SetConsoleCursor (DWORD Unknown0,
708 DWORD Unknown1)
709 /*
710 * Undocumented
711 */
712 {
713 DPRINT1("SetConsoleCursor(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1);
714 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
715 return FALSE;
716 }
717
718
719 /*
720 * @unimplemented
721 */
722 BOOL STDCALL
723 SetConsoleDisplayMode (HANDLE hOut,
724 DWORD dwNewMode,
725 LPDWORD lpdwOldMode)
726 /*
727 * FUNCTION: Set the console display mode.
728 * ARGUMENTS:
729 * hOut - Standard output handle.
730 * dwNewMode - New mode.
731 * lpdwOldMode - Address of a variable that receives the old mode.
732 */
733 {
734 DPRINT1("SetConsoleDisplayMode(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", hOut, dwNewMode, lpdwOldMode);
735 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
736 return FALSE;
737 }
738
739
740 /*
741 * @unimplemented
742 */
743 BOOL STDCALL
744 SetConsoleFont (DWORD Unknown0,
745 DWORD Unknown1)
746 /*
747 * Undocumented
748 */
749 {
750 DPRINT1("SetConsoleFont(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1);
751 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
752 return FALSE;
753 }
754
755
756 /*
757 * @implemented
758 */
759 BOOL STDCALL
760 SetConsoleHardwareState (HANDLE hConsole,
761 DWORD Flags,
762 DWORD State)
763 /*
764 * Undocumented
765 */
766 {
767 CSR_API_MESSAGE Request; ULONG CsrRequest;
768
769 NTSTATUS Status;
770
771 CsrRequest = MAKE_CSR_API(SETGET_CONSOLE_HW_STATE, CSR_CONSOLE);
772 Request.Data.ConsoleHardwareStateRequest.ConsoleHandle = hConsole;
773 Request.Data.ConsoleHardwareStateRequest.SetGet = CONSOLE_HARDWARE_STATE_SET;
774 Request.Data.ConsoleHardwareStateRequest.State = State;
775
776 Status = CsrClientCallServer(& Request,
777 NULL,
778 CsrRequest,
779 sizeof(CSR_API_MESSAGE));
780 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
781 {
782 SetLastErrorByStatus(Status);
783 return FALSE;
784 }
785 return TRUE;
786 }
787
788
789 /*
790 * @unimplemented
791 */
792 BOOL STDCALL
793 SetConsoleKeyShortcuts (DWORD Unknown0,
794 DWORD Unknown1,
795 DWORD Unknown2,
796 DWORD Unknown3)
797 /*
798 * Undocumented
799 */
800 {
801 DPRINT1("SetConsoleKeyShortcuts(0x%x, 0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1, Unknown2, Unknown3);
802 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
803 return FALSE;
804 }
805
806
807 /*
808 * @unimplemented
809 */
810 BOOL STDCALL
811 SetConsoleMaximumWindowSize (DWORD Unknown0,
812 DWORD Unknown1)
813 /*
814 * Undocumented
815 */
816 {
817 DPRINT1("SetConsoleMaximumWindowSize(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1);
818 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
819 return FALSE;
820 }
821
822
823 /*
824 * @unimplemented
825 */
826 BOOL STDCALL
827 SetConsoleMenuClose (DWORD Unknown0)
828 /*
829 * Undocumented
830 */
831 {
832 DPRINT1("SetConsoleMenuClose(0x%x) UNIMPLEMENTED!\n", Unknown0);
833 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
834 return FALSE;
835 }
836
837
838 /*
839 * @unimplemented
840 */
841 BOOL STDCALL
842 SetConsoleNumberOfCommandsA (DWORD Unknown0,
843 DWORD Unknown1)
844 /*
845 * Undocumented
846 */
847 {
848 DPRINT1("SetConsoleNumberOfCommandsA(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1);
849 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
850 return FALSE;
851 }
852
853
854 /*
855 * @unimplemented
856 */
857 BOOL STDCALL
858 SetConsoleNumberOfCommandsW (DWORD Unknown0,
859 DWORD Unknown1)
860 /*
861 * Undocumented
862 */
863 {
864 DPRINT1("SetConsoleNumberOfCommandsW(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1);
865 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
866 return FALSE;
867 }
868
869
870 /*
871 * @unimplemented
872 */
873 BOOL STDCALL
874 SetConsolePalette (DWORD Unknown0,
875 DWORD Unknown1,
876 DWORD Unknown2)
877 /*
878 * Undocumented
879 */
880 {
881 DPRINT1("SetConsolePalette(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1, Unknown2);
882 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
883 return FALSE;
884 }
885
886
887 /*
888 * @unimplemented
889 */
890 BOOL STDCALL
891 SetLastConsoleEventActive (VOID)
892 /*
893 * Undocumented
894 */
895 {
896 DPRINT1("SetLastConsoleEventActive() UNIMPLEMENTED!\n");
897 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
898 return FALSE;
899 }
900
901
902 /*
903 * @unimplemented
904 */
905 DWORD STDCALL
906 ShowConsoleCursor (DWORD Unknown0,
907 DWORD Unknown1)
908 /*
909 * Undocumented
910 */
911 {
912 DPRINT1("ShowConsoleCursor(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1);
913 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
914 return 0;
915 }
916
917
918 /*
919 * FUNCTION: Checks whether the given handle is a valid console handle.
920 * ARGUMENTS:
921 * Handle - Handle to be checked
922 * RETURNS:
923 * TRUE: Handle is a valid console handle
924 * FALSE: Handle is not a valid console handle.
925 * STATUS: Officially undocumented
926 *
927 * @implemented
928 */
929 BOOL STDCALL
930 VerifyConsoleIoHandle(HANDLE Handle)
931 {
932 CSR_API_MESSAGE Request; ULONG CsrRequest;
933
934 NTSTATUS Status;
935
936 CsrRequest = MAKE_CSR_API(VERIFY_HANDLE, CSR_NATIVE);
937 Request.Data.VerifyHandleRequest.Handle = Handle;
938 Status = CsrClientCallServer(&Request,
939 NULL,
940 CsrRequest,
941 sizeof(CSR_API_MESSAGE));
942 if (!NT_SUCCESS(Status))
943 {
944 SetLastErrorByStatus(Status);
945 return FALSE;
946 }
947
948 return (BOOL)NT_SUCCESS(Request.Status);
949 }
950
951
952 /*
953 * @unimplemented
954 */
955 DWORD STDCALL
956 WriteConsoleInputVDMA (DWORD Unknown0,
957 DWORD Unknown1,
958 DWORD Unknown2,
959 DWORD Unknown3)
960 {
961 DPRINT1("WriteConsoleInputVDMA(0x%x, 0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1, Unknown2, Unknown3);
962 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
963 return 0;
964 }
965
966
967 /*
968 * @unimplemented
969 */
970 DWORD STDCALL
971 WriteConsoleInputVDMW (DWORD Unknown0,
972 DWORD Unknown1,
973 DWORD Unknown2,
974 DWORD Unknown3)
975 {
976 DPRINT1("WriteConsoleInputVDMW(0x%x, 0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0, Unknown1, Unknown2, Unknown3);
977 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
978 return 0;
979 }
980
981
982 /*
983 * @implemented
984 */
985 BOOL STDCALL
986 CloseConsoleHandle(HANDLE Handle)
987 /*
988 * Undocumented
989 */
990 {
991 CSR_API_MESSAGE Request; ULONG CsrRequest;
992
993 NTSTATUS Status;
994
995 if (IsConsoleHandle (Handle) == FALSE)
996 {
997 SetLastError (ERROR_INVALID_PARAMETER);
998 return FALSE;
999 }
1000
1001 CsrRequest = MAKE_CSR_API(CLOSE_HANDLE, CSR_NATIVE);
1002 Request.Data.CloseHandleRequest.Handle = Handle;
1003 Status = CsrClientCallServer(&Request,
1004 NULL,
1005 CsrRequest,
1006 sizeof(CSR_API_MESSAGE));
1007 if (!NT_SUCCESS(Status))
1008 {
1009 SetLastErrorByStatus(Status);
1010 return FALSE;
1011 }
1012
1013 return TRUE;
1014 }
1015
1016 /*
1017 * @implemented
1018 */
1019 HANDLE STDCALL
1020 GetStdHandle(DWORD nStdHandle)
1021 /*
1022 * FUNCTION: Get a handle for the standard input, standard output
1023 * and a standard error device.
1024 * ARGUMENTS:
1025 * nStdHandle - Specifies the device for which to return the handle.
1026 * RETURNS: If the function succeeds, the return value is the handle
1027 * of the specified device. Otherwise the value is INVALID_HANDLE_VALUE.
1028 */
1029 {
1030 PRTL_USER_PROCESS_PARAMETERS Ppb;
1031
1032 Ppb = NtCurrentPeb()->ProcessParameters;
1033 switch (nStdHandle)
1034 {
1035 case STD_INPUT_HANDLE:
1036 return Ppb->StandardInput;
1037
1038 case STD_OUTPUT_HANDLE:
1039 return Ppb->StandardOutput;
1040
1041 case STD_ERROR_HANDLE:
1042 return Ppb->StandardError;
1043 }
1044
1045 SetLastError (ERROR_INVALID_PARAMETER);
1046 return INVALID_HANDLE_VALUE;
1047 }
1048
1049
1050 /*
1051 * @implemented
1052 */
1053 BOOL WINAPI
1054 SetStdHandle(DWORD nStdHandle,
1055 HANDLE hHandle)
1056 /*
1057 * FUNCTION: Set the handle for the standard input, standard output or
1058 * the standard error device.
1059 * ARGUMENTS:
1060 * nStdHandle - Specifies the handle to be set.
1061 * hHandle - The handle to set.
1062 * RETURNS: TRUE if the function succeeds, FALSE otherwise.
1063 */
1064 {
1065 PRTL_USER_PROCESS_PARAMETERS Ppb;
1066
1067 /* no need to check if hHandle == INVALID_HANDLE_VALUE */
1068
1069 Ppb = NtCurrentPeb()->ProcessParameters;
1070
1071 switch (nStdHandle)
1072 {
1073 case STD_INPUT_HANDLE:
1074 Ppb->StandardInput = hHandle;
1075 return TRUE;
1076
1077 case STD_OUTPUT_HANDLE:
1078 Ppb->StandardOutput = hHandle;
1079 return TRUE;
1080
1081 case STD_ERROR_HANDLE:
1082 Ppb->StandardError = hHandle;
1083 return TRUE;
1084 }
1085
1086 /* windows for whatever reason sets the last error to ERROR_INVALID_HANDLE here */
1087 SetLastError (ERROR_INVALID_HANDLE);
1088 return FALSE;
1089 }
1090
1091
1092 static BOOL
1093 IntWriteConsole(HANDLE hConsoleOutput,
1094 PVOID lpBuffer,
1095 DWORD nNumberOfCharsToWrite,
1096 LPDWORD lpNumberOfCharsWritten,
1097 LPVOID lpReserved,
1098 BOOL bUnicode)
1099 {
1100 CSR_API_MESSAGE Request;
1101 ULONG CsrRequest;
1102 NTSTATUS Status;
1103 USHORT nChars;
1104 ULONG SizeBytes, CharSize;
1105 DWORD Written = 0;
1106
1107 CharSize = (bUnicode ? sizeof(WCHAR) : sizeof(CHAR));
1108
1109 CsrRequest = MAKE_CSR_API(WRITE_CONSOLE, CSR_CONSOLE);
1110 Request.Data.WriteConsoleRequest.ConsoleHandle = hConsoleOutput;
1111 Request.Data.WriteConsoleRequest.Unicode = bUnicode;
1112
1113 while(nNumberOfCharsToWrite > 0)
1114 {
1115 nChars = min(nNumberOfCharsToWrite, CSRSS_MAX_WRITE_CONSOLE) / CharSize;
1116 Request.Data.WriteConsoleRequest.NrCharactersToWrite = nChars;
1117
1118 SizeBytes = nChars * CharSize;
1119
1120 memcpy(Request.Data.WriteConsoleRequest.Buffer, lpBuffer, SizeBytes);
1121
1122 Status = CsrClientCallServer(&Request,
1123 NULL,
1124 CsrRequest,
1125 sizeof(CSR_API_MESSAGE));
1126
1127 if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
1128 {
1129 SetLastErrorByStatus(Status);
1130 return FALSE;
1131 }
1132
1133 nNumberOfCharsToWrite -= nChars;
1134 lpBuffer = (PVOID)((ULONG_PTR)lpBuffer + (ULONG_PTR)SizeBytes);
1135 Written += Request.Data.WriteConsoleRequest.NrCharactersWritten;
1136 }
1137
1138 if(lpNumberOfCharsWritten != NULL)
1139 {
1140 *lpNumberOfCharsWritten = Written;
1141 }
1142
1143 return TRUE;
1144 }
1145
1146
1147 /*--------------------------------------------------------------
1148 * WriteConsoleA
1149 *
1150 * @implemented
1151 */
1152 BOOL STDCALL
1153 WriteConsoleA(HANDLE hConsoleOutput,
1154 CONST VOID *lpBuffer,
1155 DWORD nNumberOfCharsToWrite,
1156 LPDWORD lpNumberOfCharsWritten,
1157 LPVOID lpReserved)
1158 {
1159 return IntWriteConsole(hConsoleOutput,
1160 (PVOID)lpBuffer,
1161 nNumberOfCharsToWrite,
1162 lpNumberOfCharsWritten,
1163 lpReserved,
1164 FALSE);
1165 }
1166
1167
1168 /*--------------------------------------------------------------
1169 * WriteConsoleW
1170 *
1171 * @implemented
1172 */
1173 BOOL STDCALL
1174 WriteConsoleW(
1175 HANDLE hConsoleOutput,
1176 CONST VOID *lpBuffer,
1177 DWORD nNumberOfCharsToWrite,
1178 LPDWORD lpNumberOfCharsWritten,
1179 LPVOID lpReserved
1180 )
1181 {
1182 return IntWriteConsole(hConsoleOutput,
1183 (PVOID)lpBuffer,
1184 nNumberOfCharsToWrite,
1185 lpNumberOfCharsWritten,
1186 lpReserved,
1187 TRUE);
1188 }
1189
1190
1191 static BOOL
1192 IntReadConsole(HANDLE hConsoleInput,
1193 PVOID lpBuffer,
1194 DWORD nNumberOfCharsToRead,
1195 LPDWORD lpNumberOfCharsRead,
1196 LPVOID lpReserved,
1197 BOOL bUnicode)
1198 {
1199 CSR_API_MESSAGE Request;
1200 ULONG CsrRequest;
1201 NTSTATUS Status;
1202 ULONG CharSize, CharsRead = 0;
1203
1204 CharSize = (bUnicode ? sizeof(WCHAR) : sizeof(CHAR));
1205
1206 Request.Status = STATUS_SUCCESS;
1207
1208 do
1209 {
1210 if(Request.Status == STATUS_PENDING)
1211 {
1212 Status = NtWaitForSingleObject(Request.Data.ReadConsoleRequest.EventHandle, FALSE, 0);
1213 if(!NT_SUCCESS(Status))
1214 {
1215 DPRINT1("Wait for console input failed!\n");
1216 break;
1217 }
1218 }
1219
1220 CsrRequest = MAKE_CSR_API(READ_CONSOLE, CSR_CONSOLE);
1221 Request.Data.ReadConsoleRequest.ConsoleHandle = hConsoleInput;
1222 Request.Data.ReadConsoleRequest.Unicode = bUnicode;
1223 Request.Data.ReadConsoleRequest.NrCharactersToRead = min(nNumberOfCharsToRead, CSRSS_MAX_READ_CONSOLE) / CharSize;
1224 Request.Data.ReadConsoleRequest.nCharsCanBeDeleted = CharsRead;
1225 Status = CsrClientCallServer(&Request,
1226 NULL,
1227 CsrRequest,
1228 sizeof(CSR_API_MESSAGE));
1229
1230 if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
1231 {
1232 DPRINT1("CSR returned error in ReadConsole\n");
1233 SetLastErrorByStatus(Status);
1234 return FALSE;
1235 }
1236
1237 nNumberOfCharsToRead -= Request.Data.ReadConsoleRequest.NrCharactersRead;
1238 memcpy((PVOID)((ULONG_PTR)lpBuffer + (ULONG_PTR)(CharsRead * CharSize)),
1239 Request.Data.ReadConsoleRequest.Buffer,
1240 Request.Data.ReadConsoleRequest.NrCharactersRead * CharSize);
1241 CharsRead += Request.Data.ReadConsoleRequest.NrCharactersRead;
1242
1243 if(Request.Status == STATUS_NOTIFY_CLEANUP)
1244 {
1245 if(CharsRead > 0)
1246 {
1247 CharsRead--;
1248 nNumberOfCharsToRead++;
1249 }
1250 Request.Status = STATUS_PENDING;
1251 }
1252 } while(Request.Status == STATUS_PENDING && nNumberOfCharsToRead > 0);
1253
1254 if(lpNumberOfCharsRead != NULL)
1255 {
1256 *lpNumberOfCharsRead = CharsRead;
1257 }
1258
1259 return TRUE;
1260 }
1261
1262
1263 /*--------------------------------------------------------------
1264 * ReadConsoleA
1265 *
1266 * @implemented
1267 */
1268 BOOL STDCALL
1269 ReadConsoleA(HANDLE hConsoleInput,
1270 LPVOID lpBuffer,
1271 DWORD nNumberOfCharsToRead,
1272 LPDWORD lpNumberOfCharsRead,
1273 LPVOID lpReserved)
1274 {
1275 return IntReadConsole(hConsoleInput,
1276 lpBuffer,
1277 nNumberOfCharsToRead,
1278 lpNumberOfCharsRead,
1279 lpReserved,
1280 FALSE);
1281 }
1282
1283
1284 /*--------------------------------------------------------------
1285 * ReadConsoleW
1286 *
1287 * @implemented
1288 */
1289 BOOL STDCALL
1290 ReadConsoleW(HANDLE hConsoleInput,
1291 LPVOID lpBuffer,
1292 DWORD nNumberOfCharsToRead,
1293 LPDWORD lpNumberOfCharsRead,
1294 LPVOID lpReserved)
1295 {
1296 return IntReadConsole(hConsoleInput,
1297 lpBuffer,
1298 nNumberOfCharsToRead,
1299 lpNumberOfCharsRead,
1300 lpReserved,
1301 TRUE);
1302 }
1303
1304
1305 /*--------------------------------------------------------------
1306 * AllocConsole
1307 *
1308 * @implemented
1309 */
1310 BOOL STDCALL AllocConsole(VOID)
1311 {
1312 CSR_API_MESSAGE Request; ULONG CsrRequest;
1313
1314 NTSTATUS Status;
1315 HANDLE hStdError;
1316
1317 if(NtCurrentPeb()->ProcessParameters->ConsoleHandle)
1318 {
1319 DPRINT("AllocConsole: Allocate duplicate console to the same Process\n");
1320 SetLastErrorByStatus (STATUS_OBJECT_NAME_EXISTS);
1321 return FALSE;
1322 }
1323
1324 Request.Data.AllocConsoleRequest.CtrlDispatcher = ConsoleControlDispatcher;
1325 Request.Data.AllocConsoleRequest.ConsoleNeeded = TRUE;
1326
1327 CsrRequest = MAKE_CSR_API(ALLOC_CONSOLE, CSR_CONSOLE);
1328 Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
1329 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
1330 {
1331 SetLastErrorByStatus ( Status );
1332 return FALSE;
1333 }
1334 NtCurrentPeb()->ProcessParameters->ConsoleHandle = Request.Data.AllocConsoleRequest.Console;
1335 SetStdHandle( STD_INPUT_HANDLE, Request.Data.AllocConsoleRequest.InputHandle );
1336 SetStdHandle( STD_OUTPUT_HANDLE, Request.Data.AllocConsoleRequest.OutputHandle );
1337 hStdError = DuplicateConsoleHandle(Request.Data.AllocConsoleRequest.OutputHandle,
1338 0,
1339 TRUE,
1340 DUPLICATE_SAME_ACCESS);
1341 SetStdHandle( STD_ERROR_HANDLE, hStdError );
1342 return TRUE;
1343 }
1344
1345
1346 /*--------------------------------------------------------------
1347 * FreeConsole
1348 *
1349 * @implemented
1350 */
1351 BOOL STDCALL FreeConsole(VOID)
1352 {
1353 // AG: I'm not sure if this is correct (what happens to std handles?)
1354 // but I just tried to reverse what AllocConsole() does...
1355
1356 CSR_API_MESSAGE Request; ULONG CsrRequest;
1357
1358 NTSTATUS Status;
1359
1360 CsrRequest = MAKE_CSR_API(FREE_CONSOLE, CSR_CONSOLE);
1361 Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
1362 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
1363 {
1364 SetLastErrorByStatus ( Status );
1365 return FALSE;
1366 }
1367
1368 return TRUE;
1369 }
1370
1371
1372 /*--------------------------------------------------------------
1373 * GetConsoleScreenBufferInfo
1374 *
1375 * @implemented
1376 */
1377 BOOL
1378 STDCALL
1379 GetConsoleScreenBufferInfo(
1380 HANDLE hConsoleOutput,
1381 PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo
1382 )
1383 {
1384 CSR_API_MESSAGE Request; ULONG CsrRequest;
1385
1386 NTSTATUS Status;
1387
1388 CsrRequest = MAKE_CSR_API(SCREEN_BUFFER_INFO, CSR_CONSOLE);
1389 Request.Data.ScreenBufferInfoRequest.ConsoleHandle = hConsoleOutput;
1390 Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
1391 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
1392 {
1393 SetLastErrorByStatus ( Status );
1394 return FALSE;
1395 }
1396 *lpConsoleScreenBufferInfo = Request.Data.ScreenBufferInfoRequest.Info;
1397 return TRUE;
1398 }
1399
1400
1401 /*--------------------------------------------------------------
1402 * SetConsoleCursorPosition
1403 *
1404 * @implemented
1405 */
1406 BOOL
1407 STDCALL
1408 SetConsoleCursorPosition(
1409 HANDLE hConsoleOutput,
1410 COORD dwCursorPosition
1411 )
1412 {
1413 CSR_API_MESSAGE Request; ULONG CsrRequest;
1414
1415 NTSTATUS Status;
1416
1417 CsrRequest = MAKE_CSR_API(SET_CURSOR, CSR_CONSOLE);
1418 Request.Data.SetCursorRequest.ConsoleHandle = hConsoleOutput;
1419 Request.Data.SetCursorRequest.Position = dwCursorPosition;
1420 Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
1421 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
1422 {
1423 SetLastErrorByStatus ( Status );
1424 return FALSE;
1425 }
1426 return TRUE;
1427 }
1428
1429
1430 static BOOL
1431 IntFillConsoleOutputCharacter(HANDLE hConsoleOutput,
1432 PVOID cCharacter,
1433 DWORD nLength,
1434 COORD dwWriteCoord,
1435 LPDWORD lpNumberOfCharsWritten,
1436 BOOL bUnicode)
1437 {
1438 CSR_API_MESSAGE Request; ULONG CsrRequest;
1439
1440 NTSTATUS Status;
1441
1442 CsrRequest = MAKE_CSR_API(FILL_OUTPUT, CSR_CONSOLE);
1443 Request.Data.FillOutputRequest.ConsoleHandle = hConsoleOutput;
1444 Request.Data.FillOutputRequest.Unicode = bUnicode;
1445 if(bUnicode)
1446 Request.Data.FillOutputRequest.Char.UnicodeChar = *((WCHAR*)cCharacter);
1447 else
1448 Request.Data.FillOutputRequest.Char.AsciiChar = *((CHAR*)cCharacter);
1449 Request.Data.FillOutputRequest.Position = dwWriteCoord;
1450 Request.Data.FillOutputRequest.Length = nLength;
1451 Status = CsrClientCallServer(&Request, NULL,
1452 CsrRequest,
1453 sizeof(CSR_API_MESSAGE));
1454
1455 if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
1456 {
1457 SetLastErrorByStatus(Status);
1458 return FALSE;
1459 }
1460
1461 if(lpNumberOfCharsWritten != NULL)
1462 {
1463 *lpNumberOfCharsWritten = Request.Data.FillOutputRequest.NrCharactersWritten;
1464 }
1465
1466 return TRUE;
1467 }
1468
1469 /*--------------------------------------------------------------
1470 * FillConsoleOutputCharacterA
1471 *
1472 * @implemented
1473 */
1474 BOOL STDCALL
1475 FillConsoleOutputCharacterA(
1476 HANDLE hConsoleOutput,
1477 CHAR cCharacter,
1478 DWORD nLength,
1479 COORD dwWriteCoord,
1480 LPDWORD lpNumberOfCharsWritten
1481 )
1482 {
1483 return IntFillConsoleOutputCharacter(hConsoleOutput,
1484 &cCharacter,
1485 nLength,
1486 dwWriteCoord,
1487 lpNumberOfCharsWritten,
1488 FALSE);
1489 }
1490
1491
1492 /*--------------------------------------------------------------
1493 * FillConsoleOutputCharacterW
1494 *
1495 * @implemented
1496 */
1497 BOOL
1498 STDCALL
1499 FillConsoleOutputCharacterW(
1500 HANDLE hConsoleOutput,
1501 WCHAR cCharacter,
1502 DWORD nLength,
1503 COORD dwWriteCoord,
1504 LPDWORD lpNumberOfCharsWritten
1505 )
1506 {
1507 return IntFillConsoleOutputCharacter(hConsoleOutput,
1508 &cCharacter,
1509 nLength,
1510 dwWriteCoord,
1511 lpNumberOfCharsWritten,
1512 TRUE);
1513 }
1514
1515
1516 static BOOL
1517 IntPeekConsoleInput(HANDLE hConsoleInput,
1518 PINPUT_RECORD lpBuffer,
1519 DWORD nLength,
1520 LPDWORD lpNumberOfEventsRead,
1521 BOOL bUnicode)
1522 {
1523 CSR_API_MESSAGE Request; ULONG CsrRequest;
1524 NTSTATUS Status;
1525 PVOID BufferBase;
1526 PVOID BufferTargetBase;
1527 ULONG Size;
1528
1529 if(lpBuffer == NULL)
1530 {
1531 SetLastError(ERROR_INVALID_PARAMETER);
1532 return FALSE;
1533 }
1534
1535 Size = nLength * sizeof(INPUT_RECORD);
1536
1537 Status = CsrCaptureParameterBuffer(NULL, Size, &BufferBase, &BufferTargetBase);
1538 if(!NT_SUCCESS(Status))
1539 {
1540 SetLastErrorByStatus(Status);
1541 return FALSE;
1542 }
1543
1544 CsrRequest = MAKE_CSR_API(PEEK_CONSOLE_INPUT, CSR_CONSOLE);
1545 Request.Data.PeekConsoleInputRequest.ConsoleHandle = hConsoleInput;
1546 Request.Data.PeekConsoleInputRequest.Unicode = bUnicode;
1547 Request.Data.PeekConsoleInputRequest.Length = nLength;
1548 Request.Data.PeekConsoleInputRequest.InputRecord = (INPUT_RECORD*)BufferTargetBase;
1549
1550 Status = CsrClientCallServer(&Request,
1551 NULL,
1552 CsrRequest,
1553 sizeof(CSR_API_MESSAGE));
1554
1555 if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
1556 {
1557 CsrReleaseParameterBuffer(BufferBase);
1558 return FALSE;
1559 }
1560
1561 memcpy(lpBuffer, BufferBase, sizeof(INPUT_RECORD) * Request.Data.PeekConsoleInputRequest.Length);
1562
1563 CsrReleaseParameterBuffer(BufferBase);
1564
1565 if(lpNumberOfEventsRead != NULL)
1566 {
1567 *lpNumberOfEventsRead = Request.Data.PeekConsoleInputRequest.Length;
1568 }
1569
1570 return TRUE;
1571 }
1572
1573 /*--------------------------------------------------------------
1574 * PeekConsoleInputA
1575 *
1576 * @implemented
1577 */
1578 BOOL
1579 WINAPI
1580 PeekConsoleInputA(
1581 HANDLE hConsoleInput,
1582 PINPUT_RECORD lpBuffer,
1583 DWORD nLength,
1584 LPDWORD lpNumberOfEventsRead
1585 )
1586 {
1587 return IntPeekConsoleInput(hConsoleInput, lpBuffer, nLength,
1588 lpNumberOfEventsRead, FALSE);
1589 }
1590
1591
1592 /*--------------------------------------------------------------
1593 * PeekConsoleInputW
1594 *
1595 * @implemented
1596 */
1597 BOOL
1598 WINAPI
1599 PeekConsoleInputW(
1600 HANDLE hConsoleInput,
1601 PINPUT_RECORD lpBuffer,
1602 DWORD nLength,
1603 LPDWORD lpNumberOfEventsRead
1604 )
1605 {
1606 return IntPeekConsoleInput(hConsoleInput, lpBuffer, nLength,
1607 lpNumberOfEventsRead, TRUE);
1608 }
1609
1610
1611 static BOOL
1612 IntReadConsoleInput(HANDLE hConsoleInput,
1613 PINPUT_RECORD lpBuffer,
1614 DWORD nLength,
1615 LPDWORD lpNumberOfEventsRead,
1616 BOOL bUnicode)
1617 {
1618 CSR_API_MESSAGE Request; ULONG CsrRequest;
1619
1620 ULONG Read;
1621 NTSTATUS Status;
1622
1623 CsrRequest = MAKE_CSR_API(READ_INPUT, CSR_CONSOLE);
1624 Request.Data.ReadInputRequest.ConsoleHandle = hConsoleInput;
1625 Request.Data.ReadInputRequest.Unicode = bUnicode;
1626
1627 Read = 0;
1628 while(nLength > 0)
1629 {
1630 Status = CsrClientCallServer(&Request, NULL,
1631 CsrRequest,
1632 sizeof(CSR_API_MESSAGE));
1633 if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
1634 {
1635 if(Read == 0)
1636 {
1637 /* we couldn't read a single record, fail */
1638 SetLastErrorByStatus(Status);
1639 return FALSE;
1640 }
1641 else
1642 {
1643 /* FIXME - fail gracefully in case we already read at least one record? */
1644 break;
1645 }
1646 }
1647 else if(Status == STATUS_PENDING)
1648 {
1649 if(Read == 0)
1650 {
1651 Status = NtWaitForSingleObject(Request.Data.ReadInputRequest.Event, FALSE, 0);
1652 if(!NT_SUCCESS(Status))
1653 {
1654 SetLastErrorByStatus(Status);
1655 break;
1656 }
1657 }
1658 else
1659 {
1660 /* nothing more to read (waiting for more input??), let's just bail */
1661 break;
1662 }
1663 }
1664 else
1665 {
1666 lpBuffer[Read++] = Request.Data.ReadInputRequest.Input;
1667 nLength--;
1668
1669 if(!Request.Data.ReadInputRequest.MoreEvents)
1670 {
1671 /* nothing more to read, bail */
1672 break;
1673 }
1674 }
1675 }
1676
1677 if(lpNumberOfEventsRead != NULL)
1678 {
1679 *lpNumberOfEventsRead = Read;
1680 }
1681
1682 return (Read > 0);
1683 }
1684
1685
1686 /*--------------------------------------------------------------
1687 * ReadConsoleInputA
1688 *
1689 * @implemented
1690 */
1691 BOOL WINAPI
1692 ReadConsoleInputA(HANDLE hConsoleInput,
1693 PINPUT_RECORD lpBuffer,
1694 DWORD nLength,
1695 LPDWORD lpNumberOfEventsRead)
1696 {
1697 return IntReadConsoleInput(hConsoleInput, lpBuffer, nLength,
1698 lpNumberOfEventsRead, FALSE);
1699 }
1700
1701
1702 /*--------------------------------------------------------------
1703 * ReadConsoleInputW
1704 *
1705 * @implemented
1706 */
1707 BOOL
1708 WINAPI
1709 ReadConsoleInputW(
1710 HANDLE hConsoleInput,
1711 PINPUT_RECORD lpBuffer,
1712 DWORD nLength,
1713 LPDWORD lpNumberOfEventsRead
1714 )
1715 {
1716 return IntReadConsoleInput(hConsoleInput, lpBuffer, nLength,
1717 lpNumberOfEventsRead, TRUE);
1718 }
1719
1720
1721 static BOOL
1722 IntWriteConsoleInput(HANDLE hConsoleInput,
1723 PINPUT_RECORD lpBuffer,
1724 DWORD nLength,
1725 LPDWORD lpNumberOfEventsWritten,
1726 BOOL bUnicode)
1727 {
1728 CSR_API_MESSAGE Request; ULONG CsrRequest;
1729
1730 PVOID BufferBase, BufferTargetBase;
1731 NTSTATUS Status;
1732 DWORD Size;
1733
1734 if(lpBuffer == NULL)
1735 {
1736 SetLastError(ERROR_INVALID_PARAMETER);
1737 return FALSE;
1738 }
1739
1740 Size = nLength * sizeof(INPUT_RECORD);
1741
1742 Status = CsrCaptureParameterBuffer((PVOID)lpBuffer, Size, &BufferBase, &BufferTargetBase);
1743 if(!NT_SUCCESS(Status))
1744 {
1745 SetLastErrorByStatus(Status);
1746 return FALSE;
1747 }
1748
1749 CsrRequest = MAKE_CSR_API(WRITE_CONSOLE_INPUT, CSR_CONSOLE);
1750 Request.Data.WriteConsoleInputRequest.ConsoleHandle = hConsoleInput;
1751 Request.Data.WriteConsoleInputRequest.Unicode = bUnicode;
1752 Request.Data.WriteConsoleInputRequest.Length = nLength;
1753 Request.Data.WriteConsoleInputRequest.InputRecord = (PINPUT_RECORD)BufferTargetBase;
1754
1755 Status = CsrClientCallServer(&Request, NULL,
1756 CsrRequest,
1757 sizeof(CSR_API_MESSAGE));
1758
1759 CsrReleaseParameterBuffer(BufferBase);
1760
1761 if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
1762 {
1763 SetLastErrorByStatus(Status);
1764 return FALSE;
1765 }
1766
1767 if(lpNumberOfEventsWritten != NULL)
1768 {
1769 *lpNumberOfEventsWritten = Request.Data.WriteConsoleInputRequest.Length;
1770 }
1771
1772 return TRUE;
1773 }
1774
1775
1776 /*--------------------------------------------------------------
1777 * WriteConsoleInputA
1778 *
1779 * @implemented
1780 */
1781 BOOL
1782 WINAPI
1783 WriteConsoleInputA(
1784 HANDLE hConsoleInput,
1785 CONST INPUT_RECORD *lpBuffer,
1786 DWORD nLength,
1787 LPDWORD lpNumberOfEventsWritten
1788 )
1789 {
1790 return IntWriteConsoleInput(hConsoleInput,
1791 (PINPUT_RECORD)lpBuffer,
1792 nLength,
1793 lpNumberOfEventsWritten,
1794 FALSE);
1795 }
1796
1797
1798 /*--------------------------------------------------------------
1799 * WriteConsoleInputW
1800 *
1801 * @implemented
1802 */
1803 BOOL
1804 WINAPI
1805 WriteConsoleInputW(
1806 HANDLE hConsoleInput,
1807 CONST INPUT_RECORD *lpBuffer,
1808 DWORD nLength,
1809 LPDWORD lpNumberOfEventsWritten
1810 )
1811 {
1812 return IntWriteConsoleInput(hConsoleInput,
1813 (PINPUT_RECORD)lpBuffer,
1814 nLength,
1815 lpNumberOfEventsWritten,
1816 TRUE);
1817 }
1818
1819
1820 static BOOL
1821 IntReadConsoleOutput(HANDLE hConsoleOutput,
1822 PCHAR_INFO lpBuffer,
1823 COORD dwBufferSize,
1824 COORD dwBufferCoord,
1825 PSMALL_RECT lpReadRegion,
1826 BOOL bUnicode)
1827 {
1828 CSR_API_MESSAGE Request; ULONG CsrRequest;
1829
1830 PVOID BufferBase;
1831 PVOID BufferTargetBase;
1832 NTSTATUS Status;
1833 DWORD Size, SizeX, SizeY;
1834
1835 if(lpBuffer == NULL)
1836 {
1837 SetLastError(ERROR_INVALID_PARAMETER);
1838 return FALSE;
1839 }
1840
1841 Size = dwBufferSize.X * dwBufferSize.Y * sizeof(CHAR_INFO);
1842
1843 Status = CsrCaptureParameterBuffer(NULL, Size, &BufferBase, &BufferTargetBase);
1844 if(!NT_SUCCESS(Status))
1845 {
1846 SetLastErrorByStatus(Status);
1847 return FALSE;
1848 }
1849
1850 CsrRequest = MAKE_CSR_API(READ_CONSOLE_OUTPUT, CSR_CONSOLE);
1851 Request.Data.ReadConsoleOutputRequest.ConsoleHandle = hConsoleOutput;
1852 Request.Data.ReadConsoleOutputRequest.Unicode = bUnicode;
1853 Request.Data.ReadConsoleOutputRequest.BufferSize = dwBufferSize;
1854 Request.Data.ReadConsoleOutputRequest.BufferCoord = dwBufferCoord;
1855 Request.Data.ReadConsoleOutputRequest.ReadRegion = *lpReadRegion;
1856 Request.Data.ReadConsoleOutputRequest.CharInfo = (PCHAR_INFO)BufferTargetBase;
1857
1858 Status = CsrClientCallServer(&Request,
1859 NULL,
1860 CsrRequest,
1861 sizeof(CSR_API_MESSAGE));
1862
1863 if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
1864 {
1865 SetLastErrorByStatus(Status);
1866 CsrReleaseParameterBuffer(BufferBase);
1867 return FALSE;
1868 }
1869
1870 SizeX = Request.Data.ReadConsoleOutputRequest.ReadRegion.Right - Request.Data.ReadConsoleOutputRequest.ReadRegion.Left + 1;
1871 SizeY = Request.Data.ReadConsoleOutputRequest.ReadRegion.Bottom - Request.Data.ReadConsoleOutputRequest.ReadRegion.Top + 1;
1872
1873 memcpy(lpBuffer, BufferBase, sizeof(CHAR_INFO) * SizeX * SizeY);
1874
1875 CsrReleaseParameterBuffer(BufferBase);
1876
1877 *lpReadRegion = Request.Data.ReadConsoleOutputRequest.ReadRegion;
1878
1879 return TRUE;
1880 }
1881
1882 /*--------------------------------------------------------------
1883 * ReadConsoleOutputA
1884 *
1885 * @implemented
1886 */
1887 BOOL
1888 WINAPI
1889 ReadConsoleOutputA(
1890 HANDLE hConsoleOutput,
1891 PCHAR_INFO lpBuffer,
1892 COORD dwBufferSize,
1893 COORD dwBufferCoord,
1894 PSMALL_RECT lpReadRegion
1895 )
1896 {
1897 return IntReadConsoleOutput(hConsoleOutput, lpBuffer, dwBufferSize,
1898 dwBufferCoord, lpReadRegion, FALSE);
1899 }
1900
1901
1902 /*--------------------------------------------------------------
1903 * ReadConsoleOutputW
1904 *
1905 * @implemented
1906 */
1907 BOOL
1908 WINAPI
1909 ReadConsoleOutputW(
1910 HANDLE hConsoleOutput,
1911 PCHAR_INFO lpBuffer,
1912 COORD dwBufferSize,
1913 COORD dwBufferCoord,
1914 PSMALL_RECT lpReadRegion
1915 )
1916 {
1917 return IntReadConsoleOutput(hConsoleOutput, lpBuffer, dwBufferSize,
1918 dwBufferCoord, lpReadRegion, TRUE);
1919 }
1920
1921
1922 static BOOL
1923 IntWriteConsoleOutput(HANDLE hConsoleOutput,
1924 CONST CHAR_INFO *lpBuffer,
1925 COORD dwBufferSize,
1926 COORD dwBufferCoord,
1927 PSMALL_RECT lpWriteRegion,
1928 BOOL bUnicode)
1929 {
1930 CSR_API_MESSAGE Request; ULONG CsrRequest;
1931 NTSTATUS Status;
1932 ULONG Size;
1933 PVOID BufferBase;
1934 PVOID BufferTargetBase;
1935
1936 Size = dwBufferSize.Y * dwBufferSize.X * sizeof(CHAR_INFO);
1937
1938 Status = CsrCaptureParameterBuffer((PVOID)lpBuffer,
1939 Size,
1940 &BufferBase,
1941 &BufferTargetBase);
1942 if (!NT_SUCCESS(Status))
1943 {
1944 SetLastErrorByStatus(Status);
1945 return(FALSE);
1946 }
1947
1948 CsrRequest = MAKE_CSR_API(WRITE_CONSOLE_OUTPUT, CSR_CONSOLE);
1949 Request.Data.WriteConsoleOutputRequest.ConsoleHandle = hConsoleOutput;
1950 Request.Data.WriteConsoleOutputRequest.Unicode = bUnicode;
1951 Request.Data.WriteConsoleOutputRequest.BufferSize = dwBufferSize;
1952 Request.Data.WriteConsoleOutputRequest.BufferCoord = dwBufferCoord;
1953 Request.Data.WriteConsoleOutputRequest.WriteRegion = *lpWriteRegion;
1954 Request.Data.WriteConsoleOutputRequest.CharInfo =
1955 (CHAR_INFO*)BufferTargetBase;
1956
1957 Status = CsrClientCallServer(&Request,
1958 NULL,
1959 CsrRequest,
1960 sizeof(CSR_API_MESSAGE));
1961
1962 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
1963 {
1964 CsrReleaseParameterBuffer(BufferBase);
1965 SetLastErrorByStatus(Status);
1966 return FALSE;
1967 }
1968
1969 CsrReleaseParameterBuffer(BufferBase);
1970
1971 *lpWriteRegion = Request.Data.WriteConsoleOutputRequest.WriteRegion;
1972
1973 return(TRUE);
1974 }
1975
1976 /*--------------------------------------------------------------
1977 * WriteConsoleOutputA
1978 *
1979 * @implemented
1980 */
1981 BOOL WINAPI
1982 WriteConsoleOutputA(HANDLE hConsoleOutput,
1983 CONST CHAR_INFO *lpBuffer,
1984 COORD dwBufferSize,
1985 COORD dwBufferCoord,
1986 PSMALL_RECT lpWriteRegion)
1987 {
1988 return IntWriteConsoleOutput(hConsoleOutput, lpBuffer, dwBufferSize,
1989 dwBufferCoord, lpWriteRegion, FALSE);
1990 }
1991
1992
1993 /*--------------------------------------------------------------
1994 * WriteConsoleOutputW
1995 *
1996 * @implemented
1997 */
1998 BOOL
1999 WINAPI
2000 WriteConsoleOutputW(
2001 HANDLE hConsoleOutput,
2002 CONST CHAR_INFO *lpBuffer,
2003 COORD dwBufferSize,
2004 COORD dwBufferCoord,
2005 PSMALL_RECT lpWriteRegion
2006 )
2007 {
2008 return IntWriteConsoleOutput(hConsoleOutput, lpBuffer, dwBufferSize,
2009 dwBufferCoord, lpWriteRegion, TRUE);
2010 }
2011
2012
2013 static BOOL
2014 IntReadConsoleOutputCharacter(HANDLE hConsoleOutput,
2015 PVOID lpCharacter,
2016 DWORD nLength,
2017 COORD dwReadCoord,
2018 LPDWORD lpNumberOfCharsRead,
2019 BOOL bUnicode)
2020 {
2021 CSR_API_MESSAGE Request; ULONG CsrRequest;
2022 NTSTATUS Status;
2023 ULONG nChars, SizeBytes, CharSize;
2024 DWORD CharsRead = 0;
2025
2026 CharSize = (bUnicode ? sizeof(WCHAR) : sizeof(CHAR));
2027
2028 nChars = min(nLength, CSRSS_MAX_READ_CONSOLE_OUTPUT_CHAR) / CharSize;
2029 SizeBytes = nChars * CharSize;
2030
2031 CsrRequest = MAKE_CSR_API(READ_CONSOLE_OUTPUT_CHAR, CSR_CONSOLE);
2032 Request.Data.ReadConsoleOutputCharRequest.ConsoleHandle = hConsoleOutput;
2033 Request.Data.ReadConsoleOutputCharRequest.Unicode = bUnicode;
2034 Request.Data.ReadConsoleOutputCharRequest.ReadCoord = dwReadCoord;
2035
2036 while(nLength > 0)
2037 {
2038 DWORD BytesRead;
2039
2040 Request.Data.ReadConsoleOutputCharRequest.NumCharsToRead = min(nLength, nChars);
2041 SizeBytes = Request.Data.ReadConsoleOutputCharRequest.NumCharsToRead * CharSize;
2042
2043 Status = CsrClientCallServer(&Request,
2044 NULL,
2045 CsrRequest,
2046 sizeof(CSR_API_MESSAGE));
2047 if(!NT_SUCCESS(Status) || !NT_SUCCESS(Request.Status))
2048 {
2049 SetLastErrorByStatus(Status);
2050 break;
2051 }
2052
2053 BytesRead = Request.Data.ReadConsoleOutputCharRequest.CharsRead * CharSize;
2054 memcpy(lpCharacter, Request.Data.ReadConsoleOutputCharRequest.String, BytesRead);
2055 lpCharacter = (PVOID)((ULONG_PTR)lpCharacter + (ULONG_PTR)BytesRead);
2056 CharsRead += Request.Data.ReadConsoleOutputCharRequest.CharsRead;
2057 nLength -= Request.Data.ReadConsoleOutputCharRequest.CharsRead;
2058
2059 Request.Data.ReadConsoleOutputCharRequest.ReadCoord = Request.Data.ReadConsoleOutputCharRequest.EndCoord;
2060 }
2061
2062 if(lpNumberOfCharsRead != NULL)
2063 {
2064 *lpNumberOfCharsRead = CharsRead;
2065 }
2066
2067 return TRUE;
2068 }
2069
2070
2071 /*--------------------------------------------------------------
2072 * ReadConsoleOutputCharacterA
2073 *
2074 * @implemented
2075 */
2076 BOOL
2077 WINAPI
2078 ReadConsoleOutputCharacterA(
2079 HANDLE hConsoleOutput,
2080 LPSTR lpCharacter,
2081 DWORD nLength,
2082 COORD dwReadCoord,
2083 LPDWORD lpNumberOfCharsRead
2084 )
2085 {
2086 return IntReadConsoleOutputCharacter(hConsoleOutput,
2087 (PVOID)lpCharacter,
2088 nLength,
2089 dwReadCoord,
2090 lpNumberOfCharsRead,
2091 FALSE);
2092 }
2093
2094
2095 /*--------------------------------------------------------------
2096 * ReadConsoleOutputCharacterW
2097 *
2098 * @implemented
2099 */
2100 BOOL
2101 WINAPI
2102 ReadConsoleOutputCharacterW(
2103 HANDLE hConsoleOutput,
2104 LPWSTR lpCharacter,
2105 DWORD nLength,
2106 COORD dwReadCoord,
2107 LPDWORD lpNumberOfCharsRead
2108 )
2109 {
2110 return IntReadConsoleOutputCharacter(hConsoleOutput,
2111 (PVOID)lpCharacter,
2112 nLength,
2113 dwReadCoord,
2114 lpNumberOfCharsRead,
2115 TRUE);
2116 }
2117
2118
2119 /*--------------------------------------------------------------
2120 * ReadConsoleOutputAttribute
2121 *
2122 * @implemented
2123 */
2124 BOOL
2125 WINAPI
2126 ReadConsoleOutputAttribute(
2127 HANDLE hConsoleOutput,
2128 LPWORD lpAttribute,
2129 DWORD nLength,
2130 COORD dwReadCoord,
2131 LPDWORD lpNumberOfAttrsRead
2132 )
2133 {
2134 CSR_API_MESSAGE Request; ULONG CsrRequest;
2135 NTSTATUS Status;
2136 DWORD Size;
2137
2138 if (lpNumberOfAttrsRead != NULL)
2139 *lpNumberOfAttrsRead = nLength;
2140
2141 CsrRequest = MAKE_CSR_API(READ_CONSOLE_OUTPUT_ATTRIB, CSR_CONSOLE);
2142 Request.Data.ReadConsoleOutputAttribRequest.ConsoleHandle = hConsoleOutput;
2143 Request.Data.ReadConsoleOutputAttribRequest.ReadCoord = dwReadCoord;
2144
2145 while (nLength != 0)
2146 {
2147 if (nLength > CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB / sizeof(WORD))
2148 Size = CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB / sizeof(WCHAR);
2149 else
2150 Size = nLength;
2151
2152 Request.Data.ReadConsoleOutputAttribRequest.NumAttrsToRead = Size;
2153
2154 Status = CsrClientCallServer(&Request,
2155 NULL,
2156 CsrRequest,
2157 sizeof(CSR_API_MESSAGE));
2158 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Request.Status))
2159 {
2160 SetLastErrorByStatus(Status);
2161 return(FALSE);
2162 }
2163
2164 memcpy(lpAttribute, Request.Data.ReadConsoleOutputAttribRequest.Attribute, Size * sizeof(WORD));
2165 lpAttribute += Size;
2166 nLength -= Size;
2167 Request.Data.ReadConsoleOutputAttribRequest.ReadCoord = Request.Data.ReadConsoleOutputAttribRequest.EndCoord;
2168 }
2169
2170 return(TRUE);
2171 }
2172
2173
2174 static BOOL
2175 IntWriteConsoleOutputCharacter(HANDLE hConsoleOutput,
2176 PVOID lpCharacter,
2177 DWORD nLength,
2178 COORD dwWriteCoord,
2179 LPDWORD lpNumberOfCharsWritten,
2180 BOOL bUnicode)
2181 {
2182 CSR_API_MESSAGE Request; ULONG CsrRequest;
2183 NTSTATUS Status;
2184 ULONG SizeBytes, CharSize, nChars;
2185 DWORD Written = 0;
2186
2187 CharSize = (bUnicode ? sizeof(WCHAR) : sizeof(CHAR));
2188
2189 nChars = min(nLength, CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR / CharSize);
2190 SizeBytes = nChars * CharSize;
2191
2192 CsrRequest = MAKE_CSR_API(WRITE_CONSOLE_OUTPUT_CHAR, CSR_CONSOLE);
2193 Request.Data.WriteConsoleOutputCharRequest.ConsoleHandle = hConsoleOutput;
2194 Request.Data.WriteConsoleOutputCharRequest.Unicode = bUnicode;
2195 Request.Data.WriteConsoleOutputCharRequest.Coord = dwWriteCoord;
2196
2197 while(nLength > 0)
2198 {
2199 DWORD BytesWrite;
2200
2201 Request.Data.WriteConsoleOutputCharRequest.Length = min(nLength, nChars);
2202 BytesWrite = Request.Data.WriteConsoleOutputCharRequest.Length * CharSize;
2203
2204 memcpy(Request.Data.WriteConsoleOutputCharRequest.String, lpCharacter, BytesWrite);
2205
2206 Status = CsrClientCallServer(&Request,
2207 NULL,
2208 CsrRequest,
2209 sizeof(CSR_API_MESSAGE));
2210
2211 if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
2212 {
2213 SetLastErrorByStatus(Status);
2214 return FALSE;
2215 }
2216
2217 nLength -= Request.Data.WriteConsoleOutputCharRequest.NrCharactersWritten;
2218 lpCharacter = (PVOID)((ULONG_PTR)lpCharacter + (ULONG_PTR)(Request.Data.WriteConsoleOutputCharRequest.NrCharactersWritten * CharSize));
2219 Written += Request.Data.WriteConsoleOutputCharRequest.NrCharactersWritten;
2220
2221 Request.Data.WriteConsoleOutputCharRequest.Coord = Request.Data.WriteConsoleOutputCharRequest.EndCoord;
2222 }
2223
2224 if(lpNumberOfCharsWritten != NULL)
2225 {
2226 *lpNumberOfCharsWritten = Written;
2227 }
2228
2229 return TRUE;
2230 }
2231
2232
2233 /*--------------------------------------------------------------
2234 * WriteConsoleOutputCharacterA
2235 *
2236 * @implemented
2237 */
2238 BOOL WINAPI
2239 WriteConsoleOutputCharacterA(HANDLE hConsoleOutput,
2240 LPCSTR lpCharacter,
2241 DWORD nLength,
2242 COORD dwWriteCoord,
2243 LPDWORD lpNumberOfCharsWritten)
2244 {
2245 return IntWriteConsoleOutputCharacter(hConsoleOutput,
2246 (PVOID)lpCharacter,
2247 nLength,
2248 dwWriteCoord,
2249 lpNumberOfCharsWritten,
2250 FALSE);
2251 }
2252
2253
2254 /*--------------------------------------------------------------
2255 * WriteConsoleOutputCharacterW
2256 *
2257 * @implemented
2258 */
2259 BOOL WINAPI
2260 WriteConsoleOutputCharacterW(HANDLE hConsoleOutput,
2261 LPCWSTR lpCharacter,
2262 DWORD nLength,
2263 COORD dwWriteCoord,
2264 LPDWORD lpNumberOfCharsWritten)
2265 {
2266 return IntWriteConsoleOutputCharacter(hConsoleOutput,
2267 (PVOID)lpCharacter,
2268 nLength,
2269 dwWriteCoord,
2270 lpNumberOfCharsWritten,
2271 TRUE);
2272 }
2273
2274
2275 /*--------------------------------------------------------------
2276 * WriteConsoleOutputAttribute
2277 *
2278 * @implemented
2279 */
2280 BOOL
2281 WINAPI
2282 WriteConsoleOutputAttribute(
2283 HANDLE hConsoleOutput,
2284 CONST WORD *lpAttribute,
2285 DWORD nLength,
2286 COORD dwWriteCoord,
2287 LPDWORD lpNumberOfAttrsWritten
2288 )
2289 {
2290 CSR_API_MESSAGE Request; ULONG CsrRequest;
2291 NTSTATUS Status;
2292 WORD Size;
2293
2294 CsrRequest = MAKE_CSR_API(WRITE_CONSOLE_OUTPUT_ATTRIB, CSR_CONSOLE);
2295 Request.Data.WriteConsoleOutputAttribRequest.ConsoleHandle = hConsoleOutput;
2296 Request.Data.WriteConsoleOutputAttribRequest.Coord = dwWriteCoord;
2297 if( lpNumberOfAttrsWritten )
2298 *lpNumberOfAttrsWritten = nLength;
2299 while( nLength )
2300 {
2301 Size = min(nLength, CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB / sizeof(WORD));
2302 Request.Data.WriteConsoleOutputAttribRequest.Length = Size;
2303 memcpy(Request.Data.WriteConsoleOutputAttribRequest.Attribute, lpAttribute, Size * sizeof(WORD));
2304
2305 Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof(CSR_API_MESSAGE));
2306 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
2307 {
2308 SetLastErrorByStatus ( Status );
2309 return FALSE;
2310 }
2311 nLength -= Size;
2312 lpAttribute += Size;
2313 Request.Data.WriteConsoleOutputAttribRequest.Coord = Request.Data.WriteConsoleOutputAttribRequest.EndCoord;
2314 }
2315
2316 return TRUE;
2317 }
2318
2319
2320 /*--------------------------------------------------------------
2321 * FillConsoleOutputAttribute
2322 *
2323 * @implemented
2324 */
2325 BOOL
2326 WINAPI
2327 FillConsoleOutputAttribute(
2328 HANDLE hConsoleOutput,
2329 WORD wAttribute,
2330 DWORD nLength,
2331 COORD dwWriteCoord,
2332 LPDWORD lpNumberOfAttrsWritten
2333 )
2334 {
2335 CSR_API_MESSAGE Request; ULONG CsrRequest;
2336
2337 NTSTATUS Status;
2338
2339 CsrRequest = MAKE_CSR_API(FILL_OUTPUT_ATTRIB, CSR_CONSOLE);
2340 Request.Data.FillOutputAttribRequest.ConsoleHandle = hConsoleOutput;
2341 Request.Data.FillOutputAttribRequest.Attribute = wAttribute;
2342 Request.Data.FillOutputAttribRequest.Coord = dwWriteCoord;
2343 Request.Data.FillOutputAttribRequest.Length = nLength;
2344 Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
2345 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
2346 {
2347 SetLastErrorByStatus ( Status );
2348 return FALSE;
2349 }
2350 if( lpNumberOfAttrsWritten )
2351 *lpNumberOfAttrsWritten = nLength;
2352 return TRUE;
2353 }
2354
2355
2356 /*--------------------------------------------------------------
2357 * GetConsoleMode
2358 *
2359 * @implemented
2360 */
2361 BOOL
2362 WINAPI
2363 GetConsoleMode(
2364 HANDLE hConsoleHandle,
2365 LPDWORD lpMode
2366 )
2367 {
2368 CSR_API_MESSAGE Request; ULONG CsrRequest;
2369
2370 NTSTATUS Status;
2371
2372 CsrRequest = MAKE_CSR_API(GET_CONSOLE_MODE, CSR_CONSOLE);
2373 Request.Data.GetConsoleModeRequest.ConsoleHandle = hConsoleHandle;
2374 Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
2375 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
2376 {
2377 SetLastErrorByStatus ( Status );
2378 return FALSE;
2379 }
2380 *lpMode = Request.Data.GetConsoleModeRequest.ConsoleMode;
2381 return TRUE;
2382 }
2383
2384
2385 /*--------------------------------------------------------------
2386 * GetNumberOfConsoleInputEvents
2387 *
2388 * @implemented
2389 */
2390 BOOL
2391 WINAPI
2392 GetNumberOfConsoleInputEvents(
2393 HANDLE hConsoleInput,
2394 LPDWORD lpNumberOfEvents
2395 )
2396 {
2397 CSR_API_MESSAGE Request; ULONG CsrRequest;
2398
2399 NTSTATUS Status;
2400
2401 if(lpNumberOfEvents == NULL)
2402 {
2403 SetLastError(ERROR_INVALID_PARAMETER);
2404 return FALSE;
2405 }
2406
2407 CsrRequest = MAKE_CSR_API(GET_NUM_INPUT_EVENTS, CSR_CONSOLE);
2408 Request.Data.GetNumInputEventsRequest.ConsoleHandle = hConsoleInput;
2409 Status = CsrClientCallServer(&Request, NULL, CsrRequest, sizeof(CSR_API_MESSAGE));
2410 if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
2411 {
2412 SetLastErrorByStatus(Status);
2413 return FALSE;
2414 }
2415
2416 *lpNumberOfEvents = Request.Data.GetNumInputEventsRequest.NumInputEvents;
2417
2418 return TRUE;
2419 }
2420
2421
2422 /*--------------------------------------------------------------
2423 * GetLargestConsoleWindowSize
2424 *
2425 * @unimplemented
2426 */
2427 COORD
2428 WINAPI
2429 GetLargestConsoleWindowSize(
2430 HANDLE hConsoleOutput
2431 )
2432 {
2433 COORD Coord = {80,25};
2434 DPRINT1("GetLargestConsoleWindowSize(0x%x) UNIMPLEMENTED!\n", hConsoleOutput);
2435 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2436 return Coord;
2437 }
2438
2439
2440 /*--------------------------------------------------------------
2441 * GetConsoleCursorInfo
2442 *
2443 * @implemented
2444 */
2445 BOOL
2446 WINAPI
2447 GetConsoleCursorInfo(
2448 HANDLE hConsoleOutput,
2449 PCONSOLE_CURSOR_INFO lpConsoleCursorInfo
2450 )
2451 {
2452 CSR_API_MESSAGE Request; ULONG CsrRequest;
2453
2454 NTSTATUS Status;
2455
2456 CsrRequest = MAKE_CSR_API(GET_CURSOR_INFO, CSR_CONSOLE);
2457 Request.Data.GetCursorInfoRequest.ConsoleHandle = hConsoleOutput;
2458 Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
2459
2460 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
2461 {
2462 SetLastErrorByStatus ( Status );
2463 return FALSE;
2464 }
2465 *lpConsoleCursorInfo = Request.Data.GetCursorInfoRequest.Info;
2466 return TRUE;
2467 }
2468
2469
2470 /*--------------------------------------------------------------
2471 * GetNumberOfConsoleMouseButtons
2472 *
2473 * @unimplemented
2474 */
2475 BOOL
2476 WINAPI
2477 GetNumberOfConsoleMouseButtons(
2478 LPDWORD lpNumberOfMouseButtons
2479 )
2480 {
2481 DPRINT1("GetNumberOfConsoleMouseButtons(0x%x) UNIMPLEMENTED!\n", lpNumberOfMouseButtons);
2482 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2483 return FALSE;
2484 }
2485
2486
2487 /*--------------------------------------------------------------
2488 * SetConsoleMode
2489 *
2490 * @implemented
2491 */
2492 BOOL
2493 WINAPI
2494 SetConsoleMode(
2495 HANDLE hConsoleHandle,
2496 DWORD dwMode
2497 )
2498 {
2499 CSR_API_MESSAGE Request; ULONG CsrRequest;
2500
2501 NTSTATUS Status;
2502
2503 if (!IsConsoleHandle (hConsoleHandle))
2504 {
2505 DPRINT("SetConsoleMode was called with a non console handle\n");
2506 SetLastError (ERROR_INVALID_PARAMETER);
2507 return FALSE;
2508 }
2509
2510
2511 CsrRequest = MAKE_CSR_API(SET_CONSOLE_MODE, CSR_CONSOLE);
2512 Request.Data.SetConsoleModeRequest.ConsoleHandle = hConsoleHandle;
2513 Request.Data.SetConsoleModeRequest.Mode = dwMode;
2514 Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
2515 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
2516 {
2517 SetLastErrorByStatus ( Status );
2518 return FALSE;
2519 }
2520 return TRUE;
2521 }
2522
2523
2524 /*--------------------------------------------------------------
2525 * SetConsoleActiveScreenBuffer
2526 *
2527 * @implemented
2528 */
2529 BOOL
2530 WINAPI
2531 SetConsoleActiveScreenBuffer(
2532 HANDLE hConsoleOutput
2533 )
2534 {
2535 CSR_API_MESSAGE Request; ULONG CsrRequest;
2536
2537 NTSTATUS Status;
2538
2539 CsrRequest = MAKE_CSR_API(SET_SCREEN_BUFFER, CSR_CONSOLE);
2540 Request.Data.SetScreenBufferRequest.OutputHandle = hConsoleOutput;
2541 Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
2542 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
2543 {
2544 SetLastErrorByStatus ( Status );
2545 return FALSE;
2546 }
2547 return TRUE;
2548 }
2549
2550
2551 /*--------------------------------------------------------------
2552 * FlushConsoleInputBuffer
2553 *
2554 * @implemented
2555 */
2556 BOOL
2557 WINAPI
2558 FlushConsoleInputBuffer(
2559 HANDLE hConsoleInput
2560 )
2561 {
2562 CSR_API_MESSAGE Request; ULONG CsrRequest;
2563
2564 NTSTATUS Status;
2565
2566 CsrRequest = MAKE_CSR_API(FLUSH_INPUT_BUFFER, CSR_CONSOLE);
2567 Request.Data.FlushInputBufferRequest.ConsoleInput = hConsoleInput;
2568 Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
2569 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
2570 {
2571 SetLastErrorByStatus ( Status );
2572 return FALSE;
2573 }
2574 return TRUE;
2575 }
2576
2577
2578 /*--------------------------------------------------------------
2579 * SetConsoleScreenBufferSize
2580 *
2581 * @unimplemented
2582 */
2583 BOOL
2584 WINAPI
2585 SetConsoleScreenBufferSize(
2586 HANDLE hConsoleOutput,
2587 COORD dwSize
2588 )
2589 {
2590 DPRINT1("SetConsoleScreenBufferSize(0x%x, 0x%x) UNIMPLEMENTED!\n", hConsoleOutput, dwSize);
2591 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2592 return FALSE;
2593 }
2594
2595 /*--------------------------------------------------------------
2596 * SetConsoleCursorInfo
2597 *
2598 * @implemented
2599 */
2600 BOOL
2601 WINAPI
2602 SetConsoleCursorInfo(
2603 HANDLE hConsoleOutput,
2604 CONST CONSOLE_CURSOR_INFO *lpConsoleCursorInfo
2605 )
2606 {
2607 CSR_API_MESSAGE Request; ULONG CsrRequest;
2608
2609 NTSTATUS Status;
2610
2611 CsrRequest = MAKE_CSR_API(SET_CURSOR_INFO, CSR_CONSOLE);
2612 Request.Data.SetCursorInfoRequest.ConsoleHandle = hConsoleOutput;
2613 Request.Data.SetCursorInfoRequest.Info = *lpConsoleCursorInfo;
2614 Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
2615
2616 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
2617 {
2618 SetLastErrorByStatus ( Status );
2619 return FALSE;
2620 }
2621 return TRUE;
2622 }
2623
2624
2625 static BOOL
2626 IntScrollConsoleScreenBuffer(HANDLE hConsoleOutput,
2627 PSMALL_RECT lpScrollRectangle,
2628 PSMALL_RECT lpClipRectangle,
2629 COORD dwDestinationOrigin,
2630 PCHAR_INFO lpFill,
2631 BOOL bUnicode)
2632 {
2633 CSR_API_MESSAGE Request; ULONG CsrRequest;
2634
2635 NTSTATUS Status;
2636
2637 CsrRequest = MAKE_CSR_API(SCROLL_CONSOLE_SCREEN_BUFFER, CSR_CONSOLE);
2638 Request.Data.ScrollConsoleScreenBufferRequest.ConsoleHandle = hConsoleOutput;
2639 Request.Data.ScrollConsoleScreenBufferRequest.Unicode = bUnicode;
2640 Request.Data.ScrollConsoleScreenBufferRequest.ScrollRectangle = *lpScrollRectangle;
2641
2642 if(lpClipRectangle != NULL)
2643 {
2644 Request.Data.ScrollConsoleScreenBufferRequest.UseClipRectangle = TRUE;
2645 Request.Data.ScrollConsoleScreenBufferRequest.ClipRectangle = *lpClipRectangle;
2646 }
2647 else
2648 {
2649 Request.Data.ScrollConsoleScreenBufferRequest.UseClipRectangle = FALSE;
2650 }
2651
2652 Request.Data.ScrollConsoleScreenBufferRequest.DestinationOrigin = dwDestinationOrigin;
2653 Request.Data.ScrollConsoleScreenBufferRequest.Fill = *lpFill;
2654 Status = CsrClientCallServer(&Request, NULL,
2655 CsrRequest,
2656 sizeof(CSR_API_MESSAGE));
2657
2658 if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
2659 {
2660 SetLastErrorByStatus(Status);
2661 return FALSE;
2662 }
2663
2664 return TRUE;
2665 }
2666
2667
2668 /*--------------------------------------------------------------
2669 * ScrollConsoleScreenBufferA
2670 *
2671 * @implemented
2672 */
2673 BOOL
2674 WINAPI
2675 ScrollConsoleScreenBufferA(
2676 HANDLE hConsoleOutput,
2677 CONST SMALL_RECT *lpScrollRectangle,
2678 CONST SMALL_RECT *lpClipRectangle,
2679 COORD dwDestinationOrigin,
2680 CONST CHAR_INFO *lpFill
2681 )
2682 {
2683 return IntScrollConsoleScreenBuffer(hConsoleOutput,
2684 (PSMALL_RECT)lpScrollRectangle,
2685 (PSMALL_RECT)lpClipRectangle,
2686 dwDestinationOrigin,
2687 (PCHAR_INFO)lpFill,
2688 FALSE);
2689 }
2690
2691
2692 /*--------------------------------------------------------------
2693 * ScrollConsoleScreenBufferW
2694 *
2695 * @implemented
2696 */
2697 BOOL
2698 WINAPI
2699 ScrollConsoleScreenBufferW(
2700 HANDLE hConsoleOutput,
2701 CONST SMALL_RECT *lpScrollRectangle,
2702 CONST SMALL_RECT *lpClipRectangle,
2703 COORD dwDestinationOrigin,
2704 CONST CHAR_INFO *lpFill
2705 )
2706 {
2707 return IntScrollConsoleScreenBuffer(hConsoleOutput,
2708 (PSMALL_RECT)lpScrollRectangle,
2709 (PSMALL_RECT)lpClipRectangle,
2710 dwDestinationOrigin,
2711 (PCHAR_INFO)lpFill,
2712 TRUE);
2713 }
2714
2715
2716 /*--------------------------------------------------------------
2717 * SetConsoleWindowInfo
2718 *
2719 * @unimplemented
2720 */
2721 BOOL
2722 WINAPI
2723 SetConsoleWindowInfo(
2724 HANDLE hConsoleOutput,
2725 BOOL bAbsolute,
2726 CONST SMALL_RECT *lpConsoleWindow
2727 )
2728 {
2729 DPRINT1("SetConsoleWindowInfo(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", hConsoleOutput, bAbsolute, lpConsoleWindow);
2730 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2731 return FALSE;
2732 }
2733
2734
2735 /*--------------------------------------------------------------
2736 * SetConsoleTextAttribute
2737 *
2738 * @implemented
2739 */
2740 BOOL
2741 WINAPI
2742 SetConsoleTextAttribute(
2743 HANDLE hConsoleOutput,
2744 WORD wAttributes
2745 )
2746 {
2747 CSR_API_MESSAGE Request; ULONG CsrRequest;
2748
2749 NTSTATUS Status;
2750
2751 CsrRequest = MAKE_CSR_API(SET_ATTRIB, CSR_CONSOLE);
2752 Request.Data.SetAttribRequest.ConsoleHandle = hConsoleOutput;
2753 Request.Data.SetAttribRequest.Attrib = wAttributes;
2754 Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
2755 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
2756 {
2757 SetLastErrorByStatus ( Status );
2758 return FALSE;
2759 }
2760 return TRUE;
2761 }
2762
2763
2764 BOOL STATIC
2765 AddConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine)
2766 {
2767 if (HandlerRoutine == NULL)
2768 {
2769 IgnoreCtrlEvents = TRUE;
2770 return(TRUE);
2771 }
2772 else
2773 {
2774 NrCtrlHandlers++;
2775 if (CtrlHandlers == NULL)
2776 {
2777 CtrlHandlers = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY,
2778 NrCtrlHandlers * sizeof(PHANDLER_ROUTINE));
2779 }
2780 else
2781 {
2782 CtrlHandlers = RtlReAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY,
2783 (PVOID)CtrlHandlers,
2784 NrCtrlHandlers * sizeof(PHANDLER_ROUTINE));
2785 }
2786 if (CtrlHandlers == NULL)
2787 {
2788 NrCtrlHandlers = 0;
2789 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2790 return(FALSE);
2791 }
2792 CtrlHandlers[NrCtrlHandlers - 1] = HandlerRoutine;
2793 return(TRUE);
2794 }
2795 }
2796
2797
2798 BOOL STATIC
2799 RemoveConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine)
2800 {
2801 ULONG i;
2802
2803 if (HandlerRoutine == NULL)
2804 {
2805 IgnoreCtrlEvents = FALSE;
2806 return(TRUE);
2807 }
2808 else
2809 {
2810 for (i = 0; i < NrCtrlHandlers; i++)
2811 {
2812 if ( ((void*)(CtrlHandlers[i])) == (void*)HandlerRoutine)
2813 {
2814 NrCtrlHandlers--;
2815 memmove(CtrlHandlers + i, CtrlHandlers + i + 1,
2816 (NrCtrlHandlers - i) * sizeof(PHANDLER_ROUTINE));
2817 CtrlHandlers =
2818 RtlReAllocateHeap(RtlGetProcessHeap(),
2819 HEAP_ZERO_MEMORY,
2820 (PVOID)CtrlHandlers,
2821 NrCtrlHandlers * sizeof(PHANDLER_ROUTINE));
2822 return(TRUE);
2823 }
2824 }
2825 }
2826 return(FALSE);
2827 }
2828
2829
2830 /*
2831 * @implemented
2832 */
2833 BOOL WINAPI
2834 SetConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine,
2835 BOOL Add)
2836 {
2837 BOOLEAN Ret;
2838
2839 RtlEnterCriticalSection(&DllLock);
2840 if (Add)
2841 {
2842 Ret = AddConsoleCtrlHandler(HandlerRoutine);
2843 }
2844 else
2845 {
2846 Ret = RemoveConsoleCtrlHandler(HandlerRoutine);
2847 }
2848 RtlLeaveCriticalSection(&DllLock);
2849 return(Ret);
2850 }
2851
2852
2853 /*--------------------------------------------------------------
2854 * GenerateConsoleCtrlEvent
2855 *
2856 * @unimplemented
2857 */
2858 BOOL WINAPI
2859 GenerateConsoleCtrlEvent(
2860 DWORD dwCtrlEvent,
2861 DWORD dwProcessGroupId
2862 )
2863 {
2864 DPRINT1("GenerateConsoleCtrlEvent(0x%x, 0x%x) UNIMPLEMENTED!\n", dwCtrlEvent, dwProcessGroupId);
2865 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2866 return FALSE;
2867 }
2868
2869
2870 /*--------------------------------------------------------------
2871 * GetConsoleTitleW
2872 *
2873 * @implemented
2874 */
2875 DWORD
2876 WINAPI
2877 GetConsoleTitleW(
2878 LPWSTR lpConsoleTitle,
2879 DWORD nSize
2880 )
2881 {
2882 CSR_API_MESSAGE Request; ULONG CsrRequest;
2883 NTSTATUS Status;
2884 HANDLE hConsole;
2885
2886 hConsole = CreateFileW(L"CONIN$", GENERIC_READ, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
2887 if (hConsole == INVALID_HANDLE_VALUE)
2888 {
2889 return 0;
2890 }
2891
2892 CsrRequest = MAKE_CSR_API(GET_TITLE, CSR_CONSOLE);
2893 Request.Data.GetTitleRequest.ConsoleHandle = hConsole;
2894
2895 Status = CsrClientCallServer(&Request,
2896 NULL,
2897 CsrRequest,
2898 sizeof(CSR_API_MESSAGE));
2899 CloseHandle(hConsole);
2900 if(!NT_SUCCESS(Status) || !(NT_SUCCESS(Status = Request.Status)))
2901 {
2902 SetLastErrorByStatus(Status);
2903 return 0;
2904 }
2905
2906 if(nSize * sizeof(WCHAR) < Request.Data.GetTitleRequest.Length)
2907 {
2908 wcsncpy(lpConsoleTitle, Request.Data.GetTitleRequest.Title, nSize - 1);
2909 lpConsoleTitle[nSize--] = L'\0';
2910 }
2911 else
2912 {
2913 nSize = Request.Data.GetTitleRequest.Length / sizeof (WCHAR);
2914 wcscpy(lpConsoleTitle, Request.Data.GetTitleRequest.Title);
2915 lpConsoleTitle[nSize] = L'\0';
2916 }
2917
2918 return nSize;
2919 }
2920
2921
2922 /*--------------------------------------------------------------
2923 * GetConsoleTitleA
2924 *
2925 * 19990306 EA
2926 *
2927 * @implemented
2928 */
2929 DWORD
2930 WINAPI
2931 GetConsoleTitleA(
2932 LPSTR lpConsoleTitle,
2933 DWORD nSize
2934 )
2935 {
2936 wchar_t WideTitle [CSRSS_MAX_TITLE_LENGTH];
2937 DWORD nWideTitle = sizeof WideTitle;
2938 DWORD nWritten;
2939
2940 if (!lpConsoleTitle || !nSize) return 0;
2941 nWideTitle = GetConsoleTitleW( (LPWSTR) WideTitle, nWideTitle );
2942 if (!nWideTitle) return 0;
2943
2944 if ( (nWritten = WideCharToMultiByte(
2945 CP_ACP, // ANSI code page
2946 0, // performance and mapping flags
2947 (LPWSTR) WideTitle, // address of wide-character string
2948 nWideTitle, // number of characters in string
2949 lpConsoleTitle, // address of buffer for new string
2950 nSize, // size of buffer
2951 NULL, // FAST
2952 NULL // FAST
2953 )))
2954 {
2955 lpConsoleTitle[nWritten] = '\0';
2956 return nWritten;
2957 }
2958
2959 return 0;
2960 }
2961
2962
2963 /*--------------------------------------------------------------
2964 * SetConsoleTitleW
2965 *
2966 * @implemented
2967 */
2968 BOOL
2969 WINAPI
2970 SetConsoleTitleW(
2971 LPCWSTR lpConsoleTitle
2972 )
2973 {
2974 CSR_API_MESSAGE Request; ULONG CsrRequest;
2975 NTSTATUS Status;
2976 unsigned int c;
2977 HANDLE hConsole;
2978
2979 hConsole = CreateFileW(L"CONIN$", GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
2980 if (hConsole == INVALID_HANDLE_VALUE)
2981 {
2982 return FALSE;
2983 }
2984
2985 CsrRequest = MAKE_CSR_API(SET_TITLE, CSR_CONSOLE);
2986 Request.Data.SetTitleRequest.Console = hConsole;
2987
2988 for( c = 0; lpConsoleTitle[c] && c < CSRSS_MAX_TITLE_LENGTH; c++ )
2989 Request.Data.SetTitleRequest.Title[c] = lpConsoleTitle[c];
2990 // add null
2991 Request.Data.SetTitleRequest.Title[c] = 0;
2992 Request.Data.SetTitleRequest.Length = c;
2993 Status = CsrClientCallServer(&Request,
2994 NULL,
2995 CsrRequest,
2996 sizeof(CSR_API_MESSAGE));
2997 CloseHandle(hConsole);
2998 if (!NT_SUCCESS(Status) || !NT_SUCCESS( Status = Request.Status ) )
2999 {
3000 SetLastErrorByStatus (Status);
3001 return(FALSE);
3002 }
3003 return TRUE;
3004 }
3005
3006
3007 /*--------------------------------------------------------------
3008 * SetConsoleTitleA
3009 *
3010 * 19990204 EA Added
3011 *
3012 * @implemented
3013 */
3014 BOOL
3015 WINAPI
3016 SetConsoleTitleA(
3017 LPCSTR lpConsoleTitle
3018 )
3019 {
3020 CSR_API_MESSAGE Request; ULONG CsrRequest;
3021 NTSTATUS Status;
3022 unsigned int c;
3023 HANDLE hConsole;
3024
3025 hConsole = CreateFileW(L"CONIN$", GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
3026 if (hConsole == INVALID_HANDLE_VALUE)
3027 {
3028 return FALSE;
3029 }
3030
3031 CsrRequest = MAKE_CSR_API(SET_TITLE, CSR_CONSOLE);
3032 Request.Data.SetTitleRequest.Console = hConsole;
3033
3034 for( c = 0; lpConsoleTitle[c] && c < CSRSS_MAX_TITLE_LENGTH; c++ )
3035 Request.Data.SetTitleRequest.Title[c] = lpConsoleTitle[c];
3036 // add null
3037 Request.Data.SetTitleRequest.Title[c] = 0;
3038 Request.Data.SetTitleRequest.Length = c;
3039 Status = CsrClientCallServer(&Request,
3040 NULL,
3041 CsrRequest,
3042 sizeof(CSR_API_MESSAGE));
3043 CloseHandle(hConsole);
3044 if (!NT_SUCCESS(Status) || !NT_SUCCESS( Status = Request.Status ) )
3045 {
3046 SetLastErrorByStatus (Status);
3047 return(FALSE);
3048 }
3049 return TRUE;
3050 }
3051
3052
3053 /*--------------------------------------------------------------
3054 * CreateConsoleScreenBuffer
3055 *
3056 * @implemented
3057 */
3058 HANDLE
3059 WINAPI
3060 CreateConsoleScreenBuffer(
3061 DWORD dwDesiredAccess,
3062 DWORD dwShareMode,
3063 CONST SECURITY_ATTRIBUTES *lpSecurityAttributes,
3064 DWORD dwFlags,
3065 LPVOID lpScreenBufferData
3066 )
3067 {
3068 // FIXME: don't ignore access, share mode, and security
3069 CSR_API_MESSAGE Request; ULONG CsrRequest;
3070
3071 NTSTATUS Status;
3072
3073 CsrRequest = MAKE_CSR_API(CREATE_SCREEN_BUFFER, CSR_CONSOLE);
3074 Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
3075 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Request.Status ) )
3076 {
3077 SetLastErrorByStatus ( Status );
3078 return FALSE;
3079 }
3080 return Request.Data.CreateScreenBufferRequest.OutputHandle;
3081 }
3082
3083
3084 /*--------------------------------------------------------------
3085 * GetConsoleCP
3086 *
3087 * @implemented
3088 */
3089 UINT
3090 WINAPI
3091 GetConsoleCP( VOID )
3092 {
3093 CSR_API_MESSAGE Request; ULONG CsrRequest;
3094
3095 NTSTATUS Status;
3096
3097 CsrRequest = MAKE_CSR_API(GET_CONSOLE_CP, CSR_CONSOLE);
3098 Status = CsrClientCallServer(&Request, NULL, CsrRequest,
3099 sizeof(CSR_API_MESSAGE));
3100 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
3101 {
3102 SetLastErrorByStatus (Status);
3103 return 0;
3104 }
3105 return Request.Data.GetConsoleCodePage.CodePage;
3106 }
3107
3108
3109 /*--------------------------------------------------------------
3110 * SetConsoleCP
3111 *
3112 * @implemented
3113 */
3114 BOOL
3115 WINAPI
3116 SetConsoleCP(
3117 UINT wCodePageID
3118 )
3119 {
3120 CSR_API_MESSAGE Request; ULONG CsrRequest;
3121
3122 NTSTATUS Status;
3123
3124 CsrRequest = MAKE_CSR_API(SET_CONSOLE_CP, CSR_CONSOLE);
3125 Request.Data.SetConsoleCodePage.CodePage = wCodePageID;
3126 Status = CsrClientCallServer(&Request, NULL, CsrRequest,
3127 sizeof(CSR_API_MESSAGE));
3128 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
3129 {
3130 SetLastErrorByStatus (Status);
3131 }
3132 return NT_SUCCESS(Status);
3133 }
3134
3135
3136 /*--------------------------------------------------------------
3137 * GetConsoleOutputCP
3138 *
3139 * @implemented
3140 */
3141 UINT
3142 WINAPI
3143 GetConsoleOutputCP( VOID )
3144 {
3145 CSR_API_MESSAGE Request; ULONG CsrRequest;
3146
3147 NTSTATUS Status;
3148
3149 CsrRequest = MAKE_CSR_API(GET_CONSOLE_OUTPUT_CP, CSR_CONSOLE);
3150 Status = CsrClientCallServer(&Request, NULL, CsrRequest,
3151 sizeof(CSR_API_MESSAGE));
3152 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
3153 {
3154 SetLastErrorByStatus (Status);
3155 return 0;
3156 }
3157 return Request.Data.GetConsoleOutputCodePage.CodePage;
3158 }
3159
3160
3161 /*--------------------------------------------------------------
3162 * SetConsoleOutputCP
3163 *
3164 * @implemented
3165 */
3166 BOOL
3167 WINAPI
3168 SetConsoleOutputCP(
3169 UINT wCodePageID
3170 )
3171 {
3172 CSR_API_MESSAGE Request; ULONG CsrRequest;
3173
3174 NTSTATUS Status;
3175
3176 CsrRequest = MAKE_CSR_API(SET_CONSOLE_OUTPUT_CP, CSR_CONSOLE);
3177 Request.Data.SetConsoleOutputCodePage.CodePage = wCodePageID;
3178 Status = CsrClientCallServer(&Request, NULL, CsrRequest,
3179 sizeof(CSR_API_MESSAGE));
3180 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
3181 {
3182 SetLastErrorByStatus (Status);
3183 }
3184 return NT_SUCCESS(Status);
3185 }
3186
3187
3188 /*--------------------------------------------------------------
3189 * GetConsoleProcessList
3190 *
3191 * @implemented
3192 */
3193 DWORD STDCALL
3194 GetConsoleProcessList(LPDWORD lpdwProcessList,
3195 DWORD dwProcessCount)
3196 {
3197 CSR_API_MESSAGE Request; ULONG CsrRequest;
3198 ULONG nProcesses;
3199 NTSTATUS Status;
3200
3201 if(lpdwProcessList == NULL || dwProcessCount == 0)
3202 {
3203 SetLastError(ERROR_INVALID_PARAMETER);
3204 return 0;
3205 }
3206
3207 CsrRequest = MAKE_CSR_API(GET_PROCESS_LIST, CSR_CONSOLE);
3208 Request.Data.GetProcessListRequest.nMaxIds = dwProcessCount;
3209
3210 Status = CsrClientCallServer(&Request,
3211 NULL,
3212 CsrRequest,
3213 sizeof(CSR_API_MESSAGE));
3214 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
3215 {
3216 SetLastErrorByStatus (Status);
3217 nProcesses = 0;
3218 }
3219 else
3220 {
3221 if(dwProcessCount >= Request.Data.GetProcessListRequest.nProcessIdsTotal)
3222 {
3223 nProcesses = Request.Data.GetProcessListRequest.nProcessIdsCopied;
3224 for(nProcesses = 0; nProcesses < Request.Data.GetProcessListRequest.nProcessIdsCopied; nProcesses++)
3225 {
3226 *(lpdwProcessList++) = (DWORD)Request.Data.GetProcessListRequest.ProcessId[nProcesses];
3227 }
3228 }
3229 else
3230 {
3231 nProcesses = Request.Data.GetProcessListRequest.nProcessIdsTotal;
3232 }
3233 }
3234
3235 return nProcesses;
3236 }
3237
3238
3239
3240 /*--------------------------------------------------------------
3241 * GetConsoleSelectionInfo
3242 *
3243 * @unimplemented
3244 */
3245 BOOL STDCALL
3246 GetConsoleSelectionInfo(PCONSOLE_SELECTION_INFO lpConsoleSelectionInfo)
3247 {
3248 DPRINT1("GetConsoleSelectionInfo(0x%x) UNIMPLEMENTED!\n", lpConsoleSelectionInfo);
3249 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3250 return FALSE;
3251 }
3252
3253
3254
3255 /*--------------------------------------------------------------
3256 * AttachConsole
3257 *
3258 * @unimplemented
3259 */
3260 BOOL STDCALL
3261 AttachConsole(DWORD dwProcessId)
3262 {
3263 DPRINT1("AttachConsole(0x%x) UNIMPLEMENTED!\n", dwProcessId);
3264 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3265 return FALSE;
3266 }
3267
3268 /*--------------------------------------------------------------
3269 * GetConsoleWindow
3270 *
3271 * @implemented
3272 */
3273 HWND STDCALL
3274 GetConsoleWindow (VOID)
3275 {
3276 CSR_API_MESSAGE Request; ULONG CsrRequest;
3277
3278 NTSTATUS Status;
3279
3280 CsrRequest = MAKE_CSR_API(GET_CONSOLE_WINDOW, CSR_CONSOLE);
3281 Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
3282 if (!NT_SUCCESS(Status ) || !NT_SUCCESS(Status = Request.Status))
3283 {
3284 SetLastErrorByStatus (Status);
3285 return (HWND) NULL;
3286 }
3287 return Request.Data.GetConsoleWindowRequest.WindowHandle;
3288 }
3289
3290
3291 /*--------------------------------------------------------------
3292 * SetConsoleIcon
3293 *
3294 * @implemented
3295 */
3296 BOOL STDCALL SetConsoleIcon(HICON hicon)
3297 {
3298 CSR_API_MESSAGE Request; ULONG CsrRequest;
3299
3300 NTSTATUS Status;
3301
3302 CsrRequest = MAKE_CSR_API(SET_CONSOLE_ICON, CSR_CONSOLE);
3303 Request.Data.SetConsoleIconRequest.WindowIcon = hicon;
3304 Status = CsrClientCallServer( &Request, NULL, CsrRequest, sizeof( CSR_API_MESSAGE ) );
3305 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
3306 {
3307 SetLastErrorByStatus (Status);
3308 return FALSE;
3309 }
3310 return NT_SUCCESS(Status);
3311 }
3312
3313
3314 /*--------------------------------------------------------------
3315 * SetConsoleInputExeNameW
3316 *
3317 * @implemented
3318 */
3319 BOOL STDCALL
3320 SetConsoleInputExeNameW(LPCWSTR lpInputExeName)
3321 {
3322 BOOL Ret = FALSE;
3323 int lenName = lstrlenW(lpInputExeName);
3324
3325 if(lenName < 1 ||
3326 lenName > (int)(sizeof(InputExeName) / sizeof(InputExeName[0])) - 1)
3327 {
3328 /* Fail if string is empty or too long */
3329 SetLastError(ERROR_INVALID_PARAMETER);
3330 return FALSE;
3331 }
3332
3333 RtlEnterCriticalSection(&ConsoleLock);
3334 /* wrap copying into SEH as we may copy from invalid buffer and in case of an
3335 exception the console lock would've never been released, which would cause
3336 further calls (if the exception was handled by the caller) to recursively
3337 acquire the lock... */
3338 _SEH_TRY
3339 {
3340 RtlCopyMemory(InputExeName, lpInputExeName, lenName * sizeof(WCHAR));
3341 InputExeName[lenName] = L'\0';
3342 Ret = TRUE;
3343 }
3344 _SEH_HANDLE
3345 {
3346 lenName = 0;
3347 SetLastErrorByStatus(_SEH_GetExceptionCode());
3348 }
3349 _SEH_END;
3350 RtlLeaveCriticalSection(&ConsoleLock);
3351
3352 return Ret;
3353 }
3354
3355
3356 /*--------------------------------------------------------------
3357 * SetConsoleInputExeNameA
3358 *
3359 * @implemented
3360 */
3361 BOOL STDCALL
3362 SetConsoleInputExeNameA(LPCSTR lpInputExeName)
3363 {
3364 ANSI_STRING InputExeNameA;
3365 UNICODE_STRING InputExeNameU;
3366 NTSTATUS Status;
3367 BOOL Ret;
3368
3369 RtlInitAnsiString(&InputExeNameA, lpInputExeName);
3370
3371 if(InputExeNameA.Length < sizeof(InputExeNameA.Buffer[0]) ||
3372 InputExeNameA.Length >= (sizeof(InputExeName) / sizeof(InputExeName[0])) - 1)
3373 {
3374 /* Fail if string is empty or too long */
3375 SetLastError(ERROR_INVALID_PARAMETER);
3376 return FALSE;
3377 }
3378
3379 Status = RtlAnsiStringToUnicodeString(&InputExeNameU, &InputExeNameA, TRUE);
3380 if(NT_SUCCESS(Status))
3381 {
3382 Ret = SetConsoleInputExeNameW(InputExeNameU.Buffer);
3383 RtlFreeUnicodeString(&InputExeNameU);
3384 }
3385 else
3386 {
3387 SetLastErrorByStatus(Status);
3388 Ret = FALSE;
3389 }
3390
3391 return Ret;
3392 }
3393
3394
3395 /*--------------------------------------------------------------
3396 * GetConsoleInputExeNameW
3397 *
3398 * @implemented
3399 */
3400 DWORD STDCALL
3401 GetConsoleInputExeNameW(DWORD nBufferLength, LPWSTR lpBuffer)
3402 {
3403 int lenName;
3404
3405 RtlEnterCriticalSection(&ConsoleLock);
3406
3407 lenName = lstrlenW(InputExeName);
3408 if(lenName >= (int)nBufferLength)
3409 {
3410 /* buffer is not large enough, return the required size */
3411 RtlLeaveCriticalSection(&ConsoleLock);
3412 return lenName + 1;
3413 }
3414
3415 /* wrap copying into SEH as we may copy to invalid buffer and in case of an
3416 exception the console lock would've never been released, which would cause
3417 further calls (if the exception was handled by the caller) to recursively
3418 acquire the lock... */
3419 _SEH_TRY
3420 {
3421 RtlCopyMemory(lpBuffer, InputExeName, (lenName + 1) * sizeof(WCHAR));
3422 }
3423 _SEH_HANDLE
3424 {
3425 lenName = 0;
3426 SetLastErrorByStatus(_SEH_GetExceptionCode());
3427 }
3428 _SEH_END;
3429
3430 RtlLeaveCriticalSection(&ConsoleLock);
3431
3432 return lenName;
3433 }
3434
3435
3436 /*--------------------------------------------------------------
3437 * GetConsoleInputExeNameA
3438 *
3439 * @implemented
3440 */
3441 DWORD STDCALL
3442 GetConsoleInputExeNameA(DWORD nBufferLength, LPSTR lpBuffer)
3443 {
3444 WCHAR *Buffer;
3445 DWORD Ret;
3446
3447 if(nBufferLength > 0)
3448 {
3449 Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, nBufferLength * sizeof(WCHAR));
3450 if(Buffer == NULL)
3451 {
3452 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
3453 return 0;
3454 }
3455 }
3456 else
3457 {
3458 Buffer = NULL;
3459 }
3460
3461 Ret = GetConsoleInputExeNameW(nBufferLength, Buffer);
3462 if(nBufferLength > 0)
3463 {
3464 if(Ret > 0)
3465 {
3466 UNICODE_STRING BufferU;
3467 ANSI_STRING BufferA;
3468
3469 RtlInitUnicodeString(&BufferU, Buffer);
3470
3471 BufferA.Length = 0;
3472 BufferA.MaximumLength = nBufferLength;
3473 BufferA.Buffer = lpBuffer;
3474
3475 RtlUnicodeStringToAnsiString(&BufferA, &BufferU, FALSE);
3476 }
3477
3478 RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
3479 }
3480
3481 return Ret;
3482 }
3483
3484
3485 /*--------------------------------------------------------------
3486 * GetConsoleHistoryInfo
3487 *
3488 * @unimplemented
3489 */
3490 BOOL STDCALL
3491 GetConsoleHistoryInfo(PCONSOLE_HISTORY_INFO lpConsoleHistoryInfo)
3492 {
3493 DPRINT1("GetConsoleHistoryInfo(0x%p) UNIMPLEMENTED!\n", lpConsoleHistoryInfo);
3494 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3495 return FALSE;
3496 }
3497
3498
3499 /*--------------------------------------------------------------
3500 * SetConsoleHistoryInfo
3501 *
3502 * @unimplemented
3503 */
3504 BOOL STDCALL
3505 SetConsoleHistoryInfo(IN PCONSOLE_HISTORY_INFO lpConsoleHistoryInfo)
3506 {
3507 DPRINT1("SetConsoleHistoryInfo(0x%p) UNIMPLEMENTED!\n", lpConsoleHistoryInfo);
3508 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3509 return FALSE;
3510 }
3511
3512
3513 /*--------------------------------------------------------------
3514 * GetConsoleOriginalTitleW
3515 *
3516 * @unimplemented
3517 */
3518 DWORD STDCALL
3519 GetConsoleOriginalTitleW(OUT LPWSTR lpConsoleTitle,
3520 IN DWORD nSize)
3521 {
3522 DPRINT1("GetConsoleOriginalTitleW(0x%p, 0x%x) UNIMPLEMENTED!\n", lpConsoleTitle, nSize);
3523 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3524 return 0;
3525 }
3526
3527
3528 /*--------------------------------------------------------------
3529 * GetConsoleOriginalTitleA
3530 *
3531 * @unimplemented
3532 */
3533 DWORD STDCALL
3534 GetConsoleOriginalTitleA(OUT LPSTR lpConsoleTitle,
3535 IN DWORD nSize)
3536 {
3537 DPRINT1("GetConsoleOriginalTitleA(0x%p, 0x%x) UNIMPLEMENTED!\n", lpConsoleTitle, nSize);
3538 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3539 return 0;
3540 }
3541
3542
3543 /*--------------------------------------------------------------
3544 * GetConsoleScreenBufferInfoEx
3545 *
3546 * @unimplemented
3547 */
3548 BOOL STDCALL
3549 GetConsoleScreenBufferInfoEx(IN HANDLE hConsoleOutput,
3550 OUT PCONSOLE_SCREEN_BUFFER_INFOEX lpConsoleScreenBufferInfoEx)
3551 {
3552 DPRINT1("GetConsoleScreenBufferInfoEx(0x%p, 0x%p) UNIMPLEMENTED!\n", hConsoleOutput, lpConsoleScreenBufferInfoEx);
3553 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3554 return FALSE;
3555 }
3556
3557
3558 /*--------------------------------------------------------------
3559 * SetConsoleScreenBufferInfoEx
3560 *
3561 * @unimplemented
3562 */
3563 BOOL STDCALL
3564 SetConsoleScreenBufferInfoEx(IN HANDLE hConsoleOutput,
3565 IN PCONSOLE_SCREEN_BUFFER_INFOEX lpConsoleScreenBufferInfoEx)
3566 {
3567 DPRINT1("SetConsoleScreenBufferInfoEx(0x%p, 0x%p) UNIMPLEMENTED!\n", hConsoleOutput, lpConsoleScreenBufferInfoEx);
3568 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3569 return FALSE;
3570 }
3571
3572
3573 /*--------------------------------------------------------------
3574 * GetCurrentConsoleFontEx
3575 *
3576 * @unimplemented
3577 */
3578 BOOL STDCALL
3579 GetCurrentConsoleFontEx(IN HANDLE hConsoleOutput,
3580 IN BOOL bMaximumWindow,
3581 OUT PCONSOLE_FONT_INFOEX lpConsoleCurrentFontEx)
3582 {
3583 DPRINT1("GetCurrentConsoleFontEx(0x%p, 0x%x, 0x%p) UNIMPLEMENTED!\n", hConsoleOutput, bMaximumWindow, lpConsoleCurrentFontEx);
3584 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3585 return FALSE;
3586 }
3587
3588 /* EOF */
A free Windows-compatible Operating System