projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fixed zsh crash bug, it still doesn't work however
[reactos.git] / reactos / lib / kernel32 / misc / console.c
1 /* $Id: console.c,v 1.36 2001/11/20 02:29:44 dwelch Exp $
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: ???
8 * UPDATE HISTORY:
9 * 199901?? ?? Created
10 * 19990204 EA SetConsoleTitleA
11 * 19990306 EA Stubs
12 */
13
14 /* INCLUDES ******************************************************************/
15
16 #include <ddk/ntddk.h>
17 #include <ddk/ntddblue.h>
18 #include <windows.h>
19 #include <assert.h>
20 #include <wchar.h>
21
22 #include <csrss/csrss.h>
23 #include <ntdll/csr.h>
24
25 #define NDEBUG
26 #include <kernel32/kernel32.h>
27 #include <kernel32/error.h>
28
29 /* GLOBALS *******************************************************************/
30
31 static BOOL IgnoreCtrlEvents = FALSE;
32 static ULONG NrCtrlHandlers = 0;
33 static PHANDLER_ROUTINE* CtrlHandlers = NULL;
34
35 /* FUNCTIONS *****************************************************************/
36
37 BOOL STDCALL
38 AddConsoleAliasA (DWORD a0,
39 DWORD a1,
40 DWORD a2)
41 /*
42 * Undocumented
43 */
44 {
45 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
46 return FALSE;
47 }
48
49 BOOL STDCALL
50 AddConsoleAliasW (DWORD a0,
51 DWORD a1,
52 DWORD a2)
53 /*
54 * Undocumented
55 */
56 {
57 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
58 return FALSE;
59 }
60
61 BOOL STDCALL
62 ConsoleMenuControl (HANDLE hConsole,
63 DWORD Unknown1,
64 DWORD Unknown2)
65 /*
66 * Undocumented
67 */
68 {
69 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
70 return FALSE;
71 }
72
73 BOOL STDCALL
74 DuplicateConsoleHandle (HANDLE hConsole,
75 DWORD Unknown1,
76 DWORD Unknown2,
77 DWORD Unknown3)
78 /*
79 * Undocumented
80 */
81 {
82 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
83 return FALSE;
84 }
85
86 DWORD STDCALL
87 ExpungeConsoleCommandHistoryW (DWORD Unknown0)
88 /*
89 * Undocumented
90 */
91 {
92 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
93 return 0;
94 }
95
96
97 DWORD STDCALL
98 ExpungeConsoleCommandHistoryA (DWORD Unknown0)
99 /*
100 * Undocumented
101 */
102 {
103 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
104 return 0;
105 }
106
107 DWORD STDCALL
108 GetConsoleAliasW (DWORD Unknown0,
109 DWORD Unknown1,
110 DWORD Unknown2,
111 DWORD Unknown3)
112 /*
113 * Undocumented
114 */
115 {
116 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
117 return 0;
118 }
119
120
121 DWORD STDCALL
122 GetConsoleAliasA (DWORD Unknown0,
123 DWORD Unknown1,
124 DWORD Unknown2,
125 DWORD Unknown3)
126 /*
127 * Undocumented
128 */
129 {
130 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
131 return 0;
132 }
133
134 DWORD STDCALL
135 GetConsoleAliasExesW (DWORD Unknown0,
136 DWORD Unknown1)
137 /*
138 * Undocumented
139 */
140 {
141 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
142 return 0;
143 }
144
145
146
147 DWORD STDCALL
148 GetConsoleAliasExesA (DWORD Unknown0,
149 DWORD Unknown1)
150 /*
151 * Undocumented
152 */
153 {
154 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
155 return 0;
156 }
157
158
159
160 DWORD STDCALL
161 GetConsoleAliasExesLengthA (VOID)
162 /*
163 * Undocumented
164 */
165 {
166 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
167 return 0;
168 }
169
170 DWORD STDCALL
171 GetConsoleAliasExesLengthW (VOID)
172 /*
173 * Undocumented
174 */
175 {
176 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
177 return 0;
178 }
179
180 DWORD STDCALL
181 GetConsoleAliasesW (DWORD Unknown0,
182 DWORD Unknown1,
183 DWORD Unknown2)
184 /*
185 * Undocumented
186 */
187 {
188 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
189 return 0;
190 }
191
192 DWORD STDCALL
193 GetConsoleAliasesA (DWORD Unknown0,
194 DWORD Unknown1,
195 DWORD Unknown2)
196 /*
197 * Undocumented
198 */
199 {
200 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
201 return 0;
202 }
203
204 DWORD STDCALL
205 GetConsoleAliasesLengthW (DWORD Unknown0)
206 /*
207 * Undocumented
208 */
209 {
210 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
211 return 0;
212 }
213
214 DWORD STDCALL
215 GetConsoleAliasesLengthA (DWORD Unknown0)
216 /*
217 * Undocumented
218 */
219 {
220 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
221 return 0;
222 }
223
224 DWORD STDCALL
225 GetConsoleCommandHistoryW (DWORD Unknown0,
226 DWORD Unknown1,
227 DWORD Unknown2)
228 /*
229 * Undocumented
230 */
231 {
232 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
233 return 0;
234 }
235
236 DWORD STDCALL
237 GetConsoleCommandHistoryA (DWORD Unknown0,
238 DWORD Unknown1,
239 DWORD Unknown2)
240 /*
241 * Undocumented
242 */
243 {
244 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
245 return 0;
246 }
247
248 DWORD STDCALL
249 GetConsoleCommandHistoryLengthW (DWORD Unknown0)
250 /*
251 * Undocumented
252 */
253 {
254 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
255 return 0;
256 }
257
258 DWORD STDCALL
259 GetConsoleCommandHistoryLengthA (DWORD Unknown0)
260 /*
261 * Undocumented
262 */
263 {
264 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
265 return 0;
266 }
267
268 DWORD STDCALL
269 GetConsoleDisplayMode (LPDWORD lpdwMode)
270 /*
271 * FUNCTION: Get the console display mode
272 * ARGUMENTS:
273 * lpdwMode - Address of variable that receives the current value
274 * of display mode
275 * STATUS: Undocumented
276 */
277 {
278 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
279 return 0;
280 }
281
282 DWORD STDCALL
283 GetConsoleFontInfo (DWORD Unknown0,
284 DWORD Unknown1,
285 DWORD Unknown2,
286 DWORD Unknown3)
287 /*
288 * Undocumented
289 */
290 {
291 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
292 return 0;
293 }
294
295 DWORD STDCALL
296 GetConsoleFontSize (DWORD Unknown0,
297 DWORD Unknown1)
298 /*
299 * Undocumented
300 */
301 {
302 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
303 return 0;
304 }
305
306 DWORD STDCALL
307 GetConsoleHardwareState (DWORD Unknown0,
308 DWORD Unknown1,
309 DWORD Unknown2)
310 /*
311 * Undocumented
312 */
313 {
314 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
315 return 0;
316 }
317
318 DWORD STDCALL
319 GetConsoleInputWaitHandle (VOID)
320 /*
321 * Undocumented
322 */
323 {
324 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
325 return FALSE;
326 }
327
328 DWORD STDCALL
329 GetCurrentConsoleFont (DWORD Unknown0,
330 DWORD Unknown1,
331 DWORD Unknown2)
332 /*
333 * Undocumented
334 */
335 {
336 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
337 return 0;
338 }
339
340 ULONG STDCALL
341 GetNumberOfConsoleFonts (VOID)
342 /*
343 * Undocumented
344 */
345 {
346 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
347 return 1; /* FIXME: call csrss.exe */
348 }
349
350 DWORD STDCALL
351 InvalidateConsoleDIBits (DWORD Unknown0,
352 DWORD Unknown1)
353 /*
354 * Undocumented
355 */
356 {
357 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
358 return 0;
359 }
360
361 DWORD STDCALL
362 OpenConsoleW (DWORD Unknown0,
363 DWORD Unknown1,
364 DWORD Unknown2,
365 DWORD Unknown3)
366 /*
367 * Undocumented
368 */
369 {
370 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
371 return 0;
372 }
373
374 WINBOOL STDCALL
375 SetConsoleCommandHistoryMode (DWORD dwMode)
376 /*
377 * Undocumented
378 */
379 {
380 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
381 return FALSE;
382 }
383
384 WINBOOL STDCALL
385 SetConsoleCursor (DWORD Unknown0,
386 DWORD Unknown1)
387 /*
388 * Undocumented
389 */
390 {
391 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
392 return FALSE;
393 }
394
395 WINBOOL STDCALL
396 SetConsoleDisplayMode (HANDLE hOut,
397 DWORD dwNewMode,
398 LPDWORD lpdwOldMode)
399 /*
400 * FUNCTION: Set the console display mode.
401 * ARGUMENTS:
402 * hOut - Standard output handle.
403 * dwNewMode - New mode.
404 * lpdwOldMode - Address of a variable that receives the old mode.
405 */
406 {
407 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
408 return FALSE;
409 }
410
411 WINBOOL STDCALL
412 SetConsoleFont (DWORD Unknown0,
413 DWORD Unknown1)
414 /*
415 * Undocumented
416 */
417 {
418 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
419 return FALSE;
420 }
421
422 WINBOOL STDCALL
423 SetConsoleHardwareState (DWORD Unknown0,
424 DWORD Unknown1,
425 DWORD Unknown2)
426 /*
427 * Undocumented
428 */
429 {
430 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
431 return FALSE;
432 }
433
434 WINBOOL STDCALL
435 SetConsoleKeyShortcuts (DWORD Unknown0,
436 DWORD Unknown1,
437 DWORD Unknown2,
438 DWORD Unknown3)
439 /*
440 * Undocumented
441 */
442 {
443 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
444 return FALSE;
445 }
446
447 WINBOOL STDCALL
448 SetConsoleMaximumWindowSize (DWORD Unknown0,
449 DWORD Unknown1)
450 /*
451 * Undocumented
452 */
453 {
454 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
455 return FALSE;
456 }
457
458 WINBOOL STDCALL
459 SetConsoleMenuClose (DWORD Unknown0)
460 /*
461 * Undocumented
462 */
463 {
464 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
465 return FALSE;
466 }
467
468 WINBOOL STDCALL
469 SetConsoleNumberOfCommandsA (DWORD Unknown0,
470 DWORD Unknown1)
471 /*
472 * Undocumented
473 */
474 {
475 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
476 return FALSE;
477 }
478
479 WINBOOL STDCALL
480 SetConsoleNumberOfCommandsW (DWORD Unknown0,
481 DWORD Unknown1)
482 /*
483 * Undocumented
484 */
485 {
486 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
487 return FALSE;
488 }
489
490 WINBOOL STDCALL
491 SetConsolePalette (DWORD Unknown0,
492 DWORD Unknown1,
493 DWORD Unknown2)
494 /*
495 * Undocumented
496 */
497 {
498 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
499 return FALSE;
500 }
501
502 WINBOOL STDCALL
503 SetLastConsoleEventActive (VOID)
504 /*
505 * Undocumented
506 */
507 {
508 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
509 return FALSE;
510 }
511
512 DWORD STDCALL
513 ShowConsoleCursor (DWORD Unknown0,
514 DWORD Unknown1)
515 /*
516 * Undocumented
517 */
518 {
519 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
520 return 0;
521 }
522
523 DWORD STDCALL
524 VerifyConsoleIoHandle (DWORD Unknown0)
525 /*
526 * Undocumented
527 */
528 {
529 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
530 return 0;
531 }
532
533 DWORD STDCALL
534 WriteConsoleInputVDMA (DWORD Unknown0,
535 DWORD Unknown1,
536 DWORD Unknown2,
537 DWORD Unknown3)
538 {
539 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
540 return 0;
541 }
542
543 DWORD STDCALL
544 WriteConsoleInputVDMW (DWORD Unknown0,
545 DWORD Unknown1,
546 DWORD Unknown2,
547 DWORD Unknown3)
548 {
549 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
550 return 0;
551 }
552
553 WINBOOL STDCALL
554 CloseConsoleHandle(HANDLE Handle)
555 /*
556 * Undocumented
557 */
558 {
559 if (IsConsoleHandle (Handle) == FALSE)
560 {
561 SetLastError (ERROR_INVALID_PARAMETER);
562 return FALSE;
563 }
564 /* FIXME: call CSRSS */
565 return FALSE;
566 }
567
568 BOOLEAN STDCALL
569 IsConsoleHandle(HANDLE Handle)
570 {
571 if ((((ULONG)Handle) & 0x10000003) == 0x3)
572 {
573 return(TRUE);
574 }
575 return(FALSE);
576 }
577
578 HANDLE STDCALL
579 GetStdHandle(DWORD nStdHandle)
580 /*
581 * FUNCTION: Get a handle for the standard input, standard output
582 * and a standard error device.
583 * ARGUMENTS:
584 * nStdHandle - Specifies the device for which to return the handle.
585 * RETURNS: If the function succeeds, the return value is the handle
586 * of the specified device. Otherwise the value is INVALID_HANDLE_VALUE.
587 */
588 {
589 PRTL_USER_PROCESS_PARAMETERS Ppb;
590
591 Ppb = NtCurrentPeb()->ProcessParameters;
592 switch (nStdHandle)
593 {
594 case STD_INPUT_HANDLE: return Ppb->InputHandle;
595 case STD_OUTPUT_HANDLE: return Ppb->OutputHandle;
596 case STD_ERROR_HANDLE: return Ppb->ErrorHandle;
597 }
598 SetLastError (ERROR_INVALID_PARAMETER);
599 return INVALID_HANDLE_VALUE;
600 }
601
602 WINBASEAPI BOOL WINAPI
603 SetStdHandle(DWORD nStdHandle,
604 HANDLE hHandle)
605 /*
606 * FUNCTION: Set the handle for the standard input, standard output or
607 * the standard error device.
608 * ARGUMENTS:
609 * nStdHandle - Specifies the handle to be set.
610 * hHandle - The handle to set.
611 * RETURNS: TRUE if the function succeeds, FALSE otherwise.
612 */
613 {
614 PRTL_USER_PROCESS_PARAMETERS Ppb;
615
616 Ppb = NtCurrentPeb()->ProcessParameters;
617
618 /* More checking needed? */
619 if (hHandle == INVALID_HANDLE_VALUE)
620 {
621 SetLastError (ERROR_INVALID_HANDLE);
622 return FALSE;
623 }
624
625 SetLastError(ERROR_SUCCESS); /* OK */
626 switch (nStdHandle)
627 {
628 case STD_INPUT_HANDLE:
629 Ppb->InputHandle = hHandle;
630 return TRUE;
631 case STD_OUTPUT_HANDLE:
632 Ppb->OutputHandle = hHandle;
633 return TRUE;
634 case STD_ERROR_HANDLE:
635 Ppb->ErrorHandle = hHandle;
636 return TRUE;
637 }
638 SetLastError (ERROR_INVALID_PARAMETER);
639 return FALSE;
640 }
641
642
643 /*--------------------------------------------------------------
644 * WriteConsoleA
645 */
646 WINBOOL STDCALL WriteConsoleA(HANDLE hConsoleOutput,
647 CONST VOID *lpBuffer,
648 DWORD nNumberOfCharsToWrite,
649 LPDWORD lpNumberOfCharsWritten,
650 LPVOID lpReserved)
651 {
652 PCSRSS_API_REQUEST Request;
653 CSRSS_API_REPLY Reply;
654 NTSTATUS Status;
655 WORD Size;
656
657 Request = RtlAllocateHeap(GetProcessHeap(),
658 HEAP_ZERO_MEMORY,
659 sizeof(CSRSS_API_REQUEST) + CSRSS_MAX_WRITE_CONSOLE_REQUEST);
660 if (Request == NULL)
661 {
662 return(FALSE);
663 }
664
665 Request->Type = CSRSS_WRITE_CONSOLE;
666 Request->Data.WriteConsoleRequest.ConsoleHandle = hConsoleOutput;
667 if (lpNumberOfCharsWritten != NULL)
668 *lpNumberOfCharsWritten = nNumberOfCharsToWrite;
669 while( nNumberOfCharsToWrite )
670 {
671 Size = nNumberOfCharsToWrite > CSRSS_MAX_WRITE_CONSOLE_REQUEST ? CSRSS_MAX_WRITE_CONSOLE_REQUEST : nNumberOfCharsToWrite;
672
673 Request->Data.WriteConsoleRequest.NrCharactersToWrite = Size;
674
675 // DbgPrint("nNumberOfCharsToWrite %d\n", nNumberOfCharsToWrite);
676 // DbgPrint("Buffer %s\n", Request->Data.WriteConsoleRequest.Buffer);
677
678 memcpy( Request->Data.WriteConsoleRequest.Buffer, lpBuffer, Size );
679
680 Status = CsrClientCallServer(Request,
681 &Reply,
682 sizeof(CSRSS_WRITE_CONSOLE_REQUEST) +
683 Size,
684 sizeof(CSRSS_API_REPLY));
685
686 if (!NT_SUCCESS(Status) || !NT_SUCCESS( Status = Reply.Status ) )
687 {
688 RtlFreeHeap( GetProcessHeap(), 0, Request );
689 SetLastErrorByStatus (Status);
690 return(FALSE);
691 }
692 nNumberOfCharsToWrite -= Size;
693 lpBuffer += Size;
694 }
695 RtlFreeHeap( GetProcessHeap(), 0, Request );
696 return TRUE;
697 }
698
699
700 /*--------------------------------------------------------------
701 * ReadConsoleA
702 */
703 WINBOOL STDCALL ReadConsoleA(HANDLE hConsoleInput,
704 LPVOID lpBuffer,
705 DWORD nNumberOfCharsToRead,
706 LPDWORD lpNumberOfCharsRead,
707 LPVOID lpReserved)
708 {
709 CSRSS_API_REQUEST Request;
710 PCSRSS_API_REPLY Reply;
711 NTSTATUS Status;
712 ULONG CharsRead = 0;
713
714 Reply = RtlAllocateHeap(GetProcessHeap(),
715 HEAP_ZERO_MEMORY,
716 sizeof(CSRSS_API_REPLY) + nNumberOfCharsToRead);
717 if (Reply == NULL)
718 {
719 return(FALSE);
720 }
721
722 Request.Type = CSRSS_READ_CONSOLE;
723 Request.Data.ReadConsoleRequest.ConsoleHandle = hConsoleInput;
724 Request.Data.ReadConsoleRequest.NrCharactersToRead = nNumberOfCharsToRead > CSRSS_MAX_READ_CONSOLE_REQUEST ? CSRSS_MAX_READ_CONSOLE_REQUEST : nNumberOfCharsToRead;
725 Request.Data.ReadConsoleRequest.nCharsCanBeDeleted = 0;
726 Status = CsrClientCallServer(&Request,
727 Reply,
728 sizeof(CSRSS_API_REQUEST),
729 sizeof(CSRSS_API_REPLY) +
730 Request.Data.ReadConsoleRequest.NrCharactersToRead);
731 if (!NT_SUCCESS(Status) || !NT_SUCCESS( Status = Reply->Status ))
732 {
733 DbgPrint( "CSR returned error in ReadConsole\n" );
734 SetLastErrorByStatus ( Status );
735 RtlFreeHeap( GetProcessHeap(), 0, Reply );
736 return(FALSE);
737 }
738 if( Reply->Status == STATUS_NOTIFY_CLEANUP )
739 Reply->Status = STATUS_PENDING; // ignore backspace because we have no chars to backspace
740 /* There may not be any chars or lines to read yet, so wait */
741 while( Reply->Status == STATUS_PENDING )
742 {
743 /* some chars may have been returned, but not a whole line yet, so recompute buffer and try again */
744 nNumberOfCharsToRead -= Reply->Data.ReadConsoleReply.NrCharactersRead;
745 /* don't overflow caller's buffer, even if you still don't have a complete line */
746 if( !nNumberOfCharsToRead )
747 break;
748 Request.Data.ReadConsoleRequest.NrCharactersToRead = nNumberOfCharsToRead > CSRSS_MAX_READ_CONSOLE_REQUEST ? CSRSS_MAX_READ_CONSOLE_REQUEST : nNumberOfCharsToRead;
749 /* copy any chars already read to buffer */
750 memcpy( lpBuffer + CharsRead, Reply->Data.ReadConsoleReply.Buffer, Reply->Data.ReadConsoleReply.NrCharactersRead );
751 CharsRead += Reply->Data.ReadConsoleReply.NrCharactersRead;
752 /* wait for csrss to signal there is more data to read, but not if we got STATUS_NOTIFY_CLEANUP for backspace */
753 Status = NtWaitForSingleObject( Reply->Data.ReadConsoleReply.EventHandle, FALSE, 0 );
754 if( !NT_SUCCESS( Status ) )
755 {
756 DbgPrint( "Wait for console input failed!\n" );
757 RtlFreeHeap( GetProcessHeap(), 0, Reply );
758 return FALSE;
759 }
760 Request.Data.ReadConsoleRequest.nCharsCanBeDeleted = CharsRead;
761 Status = CsrClientCallServer( &Request, Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) + Request.Data.ReadConsoleRequest.NrCharactersToRead );
762 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply->Status ) )
763 {
764 SetLastErrorByStatus ( Status );
765 RtlFreeHeap( GetProcessHeap(), 0, Reply );
766 return FALSE;
767 }
768 if( Reply->Status == STATUS_NOTIFY_CLEANUP )
769 {
770 // delete last char
771 if( CharsRead )
772 {
773 CharsRead--;
774 nNumberOfCharsToRead++;
775 }
776 Reply->Status = STATUS_PENDING; // retry
777 }
778 }
779 /* copy data to buffer, count total returned, and return */
780 memcpy( lpBuffer + CharsRead, Reply->Data.ReadConsoleReply.Buffer, Reply->Data.ReadConsoleReply.NrCharactersRead );
781 CharsRead += Reply->Data.ReadConsoleReply.NrCharactersRead;
782 if (lpNumberOfCharsRead != NULL)
783 *lpNumberOfCharsRead = CharsRead;
784 RtlFreeHeap(GetProcessHeap(),
785 0,
786 Reply);
787
788 return(TRUE);
789 }
790
791
792 /*--------------------------------------------------------------
793 * AllocConsole
794 */
795 WINBOOL STDCALL AllocConsole(VOID)
796 {
797 CSRSS_API_REQUEST Request;
798 CSRSS_API_REPLY Reply;
799 NTSTATUS Status;
800
801 Request.Type = CSRSS_ALLOC_CONSOLE;
802 Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
803 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
804 {
805 SetLastErrorByStatus ( Status );
806 return FALSE;
807 }
808 SetStdHandle( STD_INPUT_HANDLE, Reply.Data.AllocConsoleReply.InputHandle );
809 SetStdHandle( STD_OUTPUT_HANDLE, Reply.Data.AllocConsoleReply.OutputHandle );
810 SetStdHandle( STD_ERROR_HANDLE, Reply.Data.AllocConsoleReply.OutputHandle );
811 return TRUE;
812 }
813
814
815 /*--------------------------------------------------------------
816 * FreeConsole
817 */
818 WINBOOL STDCALL FreeConsole(VOID)
819 {
820 DbgPrint("FreeConsole() is unimplemented");
821 return FALSE;
822 }
823
824
825 /*--------------------------------------------------------------
826 * GetConsoleScreenBufferInfo
827 */
828 WINBOOL
829 STDCALL
830 GetConsoleScreenBufferInfo(
831 HANDLE hConsoleOutput,
832 PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo
833 )
834 {
835 CSRSS_API_REQUEST Request;
836 CSRSS_API_REPLY Reply;
837 NTSTATUS Status;
838
839 Request.Type = CSRSS_SCREEN_BUFFER_INFO;
840 Request.Data.ScreenBufferInfoRequest.ConsoleHandle = hConsoleOutput;
841 Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
842 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
843 {
844 SetLastErrorByStatus ( Status );
845 return FALSE;
846 }
847 *lpConsoleScreenBufferInfo = Reply.Data.ScreenBufferInfoReply.Info;
848 return TRUE;
849 }
850
851
852 /*--------------------------------------------------------------
853 * SetConsoleCursorPosition
854 */
855 WINBOOL
856 STDCALL
857 SetConsoleCursorPosition(
858 HANDLE hConsoleOutput,
859 COORD dwCursorPosition
860 )
861 {
862 CSRSS_API_REQUEST Request;
863 CSRSS_API_REPLY Reply;
864 NTSTATUS Status;
865
866 Request.Type = CSRSS_SET_CURSOR;
867 Request.Data.SetCursorRequest.ConsoleHandle = hConsoleOutput;
868 Request.Data.SetCursorRequest.Position = dwCursorPosition;
869 Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
870 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
871 {
872 SetLastErrorByStatus ( Status );
873 return FALSE;
874 }
875 return TRUE;
876 }
877
878
879 /*--------------------------------------------------------------
880 * FillConsoleOutputCharacterA
881 */
882 WINBOOL
883 STDCALL
884 FillConsoleOutputCharacterA(
885 HANDLE hConsoleOutput,
886 CHAR cCharacter,
887 DWORD nLength,
888 COORD dwWriteCoord,
889 LPDWORD lpNumberOfCharsWritten
890 )
891 {
892 CSRSS_API_REQUEST Request;
893 CSRSS_API_REPLY Reply;
894 NTSTATUS Status;
895
896 Request.Type = CSRSS_FILL_OUTPUT;
897 Request.Data.FillOutputRequest.ConsoleHandle = hConsoleOutput;
898 Request.Data.FillOutputRequest.Char = cCharacter;
899 Request.Data.FillOutputRequest.Position = dwWriteCoord;
900 Request.Data.FillOutputRequest.Length = nLength;
901 Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
902 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
903 {
904 SetLastErrorByStatus ( Status );
905 return FALSE;
906 }
907 *lpNumberOfCharsWritten = nLength;
908 return TRUE;
909 }
910
911
912 /*--------------------------------------------------------------
913 * FillConsoleOutputCharacterW
914 */
915 WINBOOL
916 STDCALL
917 FillConsoleOutputCharacterW(
918 HANDLE hConsoleOutput,
919 WCHAR cCharacter,
920 DWORD nLength,
921 COORD dwWriteCoord,
922 LPDWORD lpNumberOfCharsWritten
923 )
924 {
925 /* TO DO */
926 return FALSE;
927 }
928
929
930 /*--------------------------------------------------------------
931 * PeekConsoleInputA
932 */
933 WINBASEAPI
934 BOOL
935 WINAPI
936 PeekConsoleInputA(
937 HANDLE hConsoleInput,
938 PINPUT_RECORD lpBuffer,
939 DWORD nLength,
940 LPDWORD lpNumberOfEventsRead
941 )
942 {
943 /* TO DO */
944 return FALSE;
945 }
946
947
948 /*--------------------------------------------------------------
949 * PeekConsoleInputW
950 */
951 WINBASEAPI
952 BOOL
953 WINAPI
954 PeekConsoleInputW(
955 HANDLE hConsoleInput,
956 PINPUT_RECORD lpBuffer,
957 DWORD nLength,
958 LPDWORD lpNumberOfEventsRead
959 )
960 {
961 /* TO DO */
962 return FALSE;
963 }
964
965
966 /*--------------------------------------------------------------
967 * ReadConsoleInputA
968 */
969 WINBASEAPI BOOL WINAPI
970 ReadConsoleInputA(HANDLE hConsoleInput,
971 PINPUT_RECORD lpBuffer,
972 DWORD nLength,
973 LPDWORD lpNumberOfEventsRead)
974 {
975 CSRSS_API_REQUEST Request;
976 CSRSS_API_REPLY Reply;
977 DWORD NumEventsRead;
978 NTSTATUS Status;
979
980 Request.Type = CSRSS_READ_INPUT;
981 Request.Data.ReadInputRequest.ConsoleHandle = hConsoleInput;
982 Status = CsrClientCallServer(&Request, &Reply, sizeof(CSRSS_API_REQUEST),
983 sizeof(CSRSS_API_REPLY));
984 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
985 {
986 SetLastErrorByStatus(Status);
987 return(FALSE);
988 }
989
990 while (Status == STATUS_PENDING)
991 {
992 Status = NtWaitForSingleObject(Reply.Data.ReadInputReply.Event, FALSE,
993 0);
994 if(!NT_SUCCESS(Status))
995 {
996 SetLastErrorByStatus(Status);
997 return FALSE;
998 }
999
1000 Request.Type = CSRSS_READ_INPUT;
1001 Request.Data.ReadInputRequest.ConsoleHandle = hConsoleInput;
1002 Status = CsrClientCallServer(&Request, &Reply, sizeof(CSRSS_API_REQUEST),
1003 sizeof(CSRSS_API_REPLY));
1004 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
1005 {
1006 SetLastErrorByStatus(Status);
1007 return(FALSE);
1008 }
1009 }
1010
1011 NumEventsRead = 0;
1012 *lpBuffer = Reply.Data.ReadInputReply.Input;
1013 lpBuffer++;
1014 NumEventsRead++;
1015
1016 while ((NumEventsRead < nLength) && (Reply.Data.ReadInputReply.MoreEvents))
1017 {
1018 Status = CsrClientCallServer(&Request, &Reply, sizeof(CSRSS_API_REQUEST),
1019 sizeof(CSRSS_API_REPLY));
1020 if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
1021 {
1022 SetLastErrorByStatus(Status);
1023 return(FALSE);
1024 }
1025
1026 if (Status == STATUS_PENDING)
1027 {
1028 break;
1029 }
1030
1031 *lpBuffer = Reply.Data.ReadInputReply.Input;
1032 lpBuffer++;
1033 NumEventsRead++;
1034
1035 }
1036 *lpNumberOfEventsRead = NumEventsRead;
1037
1038 return TRUE;
1039 }
1040
1041
1042 /*--------------------------------------------------------------
1043 * ReadConsoleInputW
1044 */
1045 WINBASEAPI
1046 BOOL
1047 WINAPI
1048 ReadConsoleInputW(
1049 HANDLE hConsoleInput,
1050 PINPUT_RECORD lpBuffer,
1051 DWORD nLength,
1052 LPDWORD lpNumberOfEventsRead
1053 )
1054 {
1055 /* TO DO */
1056 return FALSE;
1057 }
1058
1059
1060 /*--------------------------------------------------------------
1061 * WriteConsoleInputA
1062 */
1063 WINBASEAPI
1064 BOOL
1065 WINAPI
1066 WriteConsoleInputA(
1067 HANDLE hConsoleInput,
1068 CONST INPUT_RECORD *lpBuffer,
1069 DWORD nLength,
1070 LPDWORD lpNumberOfEventsWritten
1071 )
1072 {
1073 /* TO DO */
1074 return FALSE;
1075 }
1076
1077
1078 /*--------------------------------------------------------------
1079 * WriteConsoleInputW
1080 */
1081 WINBASEAPI
1082 BOOL
1083 WINAPI
1084 WriteConsoleInputW(
1085 HANDLE hConsoleInput,
1086 CONST INPUT_RECORD *lpBuffer,
1087 DWORD nLength,
1088 LPDWORD lpNumberOfEventsWritten
1089 )
1090 {
1091 /* TO DO */
1092 return FALSE;
1093 }
1094
1095
1096 /*--------------------------------------------------------------
1097 * ReadConsoleOutputA
1098 */
1099 WINBASEAPI
1100 BOOL
1101 WINAPI
1102 ReadConsoleOutputA(
1103 HANDLE hConsoleOutput,
1104 PCHAR_INFO lpBuffer,
1105 COORD dwBufferSize,
1106 COORD dwBufferCoord,
1107 PSMALL_RECT lpReadRegion
1108 )
1109 {
1110 /* TO DO */
1111 return FALSE;
1112 }
1113
1114
1115 /*--------------------------------------------------------------
1116 * ReadConsoleOutputW
1117 */
1118 WINBASEAPI
1119 BOOL
1120 WINAPI
1121 ReadConsoleOutputW(
1122 HANDLE hConsoleOutput,
1123 PCHAR_INFO lpBuffer,
1124 COORD dwBufferSize,
1125 COORD dwBufferCoord,
1126 PSMALL_RECT lpReadRegion
1127 )
1128 {
1129 /* TO DO */
1130 return FALSE;
1131 }
1132
1133 /*--------------------------------------------------------------
1134 * WriteConsoleOutputA
1135 */
1136 WINBASEAPI
1137 BOOL
1138 WINAPI
1139 WriteConsoleOutputA(
1140 HANDLE hConsoleOutput,
1141 CONST CHAR_INFO *lpBuffer,
1142 COORD dwBufferSize,
1143 COORD dwBufferCoord,
1144 PSMALL_RECT lpWriteRegion
1145 )
1146 {
1147 PCSRSS_API_REQUEST Request;
1148 CSRSS_API_REPLY Reply;
1149 NTSTATUS Status;
1150 DWORD Size;
1151
1152 Size = dwBufferSize.Y * dwBufferSize.X * sizeof(CHAR_INFO);
1153
1154 Request = RtlAllocateHeap(GetProcessHeap(), 0, sizeof(CSRSS_API_REQUEST) + Size);
1155 if( !Request )
1156 {
1157 SetLastError( ERROR_OUTOFMEMORY );
1158 return FALSE;
1159 }
1160 Request->Type = CSRSS_WRITE_CONSOLE_OUTPUT;
1161 Request->Data.WriteConsoleOutputRequest.ConsoleHandle = hConsoleOutput;
1162 Request->Data.WriteConsoleOutputRequest.BufferSize = dwBufferSize;
1163 Request->Data.WriteConsoleOutputRequest.BufferCoord = dwBufferCoord;
1164 Request->Data.WriteConsoleOutputRequest.WriteRegion = *lpWriteRegion;
1165 RtlCopyMemory(&Request->Data.WriteConsoleOutputRequest.CharInfo, lpBuffer, Size);
1166
1167 Status = CsrClientCallServer( Request, &Reply, sizeof( CSRSS_API_REQUEST ) + Size, sizeof( CSRSS_API_REPLY ) );
1168 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
1169 {
1170 RtlFreeHeap( GetProcessHeap(), 0, Request );
1171 SetLastErrorByStatus ( Status );
1172 return FALSE;
1173 }
1174
1175 *lpWriteRegion = Reply.Data.WriteConsoleOutputReply.WriteRegion;
1176
1177 return TRUE;
1178 }
1179
1180
1181 /*--------------------------------------------------------------
1182 * WriteConsoleOutputW
1183 */
1184 WINBASEAPI
1185 BOOL
1186 WINAPI
1187 WriteConsoleOutputW(
1188 HANDLE hConsoleOutput,
1189 CONST CHAR_INFO *lpBuffer,
1190 COORD dwBufferSize,
1191 COORD dwBufferCoord,
1192 PSMALL_RECT lpWriteRegion
1193 )
1194 {
1195 /* TO DO */
1196 return FALSE;
1197 }
1198
1199
1200 /*--------------------------------------------------------------
1201 * ReadConsoleOutputCharacterA
1202 */
1203 WINBASEAPI
1204 BOOL
1205 WINAPI
1206 ReadConsoleOutputCharacterA(
1207 HANDLE hConsoleOutput,
1208 LPSTR lpCharacter,
1209 DWORD nLength,
1210 COORD dwReadCoord,
1211 LPDWORD lpNumberOfCharsRead
1212 )
1213 {
1214 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
1215 return FALSE;
1216 }
1217
1218
1219 /*--------------------------------------------------------------
1220 * ReadConsoleOutputCharacterW
1221 */
1222 WINBASEAPI
1223 BOOL
1224 WINAPI
1225 ReadConsoleOutputCharacterW(
1226 HANDLE hConsoleOutput,
1227 LPWSTR lpCharacter,
1228 DWORD nLength,
1229 COORD dwReadCoord,
1230 LPDWORD lpNumberOfCharsRead
1231 )
1232 {
1233 /* TO DO */
1234 return FALSE;
1235 }
1236
1237
1238 /*--------------------------------------------------------------
1239 * ReadConsoleOutputAttribute
1240 */
1241 WINBASEAPI
1242 BOOL
1243 WINAPI
1244 ReadConsoleOutputAttribute(
1245 HANDLE hConsoleOutput,
1246 LPWORD lpAttribute,
1247 DWORD nLength,
1248 COORD dwReadCoord,
1249 LPDWORD lpNumberOfAttrsRead
1250 )
1251 {
1252 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
1253 return FALSE;
1254 }
1255
1256
1257 /*--------------------------------------------------------------
1258 * WriteConsoleOutputCharacterA
1259 */
1260 WINBASEAPI
1261 BOOL
1262 WINAPI
1263 WriteConsoleOutputCharacterA(
1264 HANDLE hConsoleOutput,
1265 LPCSTR lpCharacter,
1266 DWORD nLength,
1267 COORD dwWriteCoord,
1268 LPDWORD lpNumberOfCharsWritten
1269 )
1270 {
1271 PCSRSS_API_REQUEST Request;
1272 CSRSS_API_REPLY Reply;
1273 NTSTATUS Status;
1274 WORD Size;
1275
1276 Request = RtlAllocateHeap(GetProcessHeap(),
1277 HEAP_ZERO_MEMORY,
1278 sizeof(CSRSS_API_REQUEST) + CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR);
1279 if( !Request )
1280 {
1281 SetLastError( ERROR_OUTOFMEMORY );
1282 return FALSE;
1283 }
1284 Request->Type = CSRSS_WRITE_CONSOLE_OUTPUT_CHAR;
1285 Request->Data.WriteConsoleOutputCharRequest.ConsoleHandle = hConsoleOutput;
1286 Request->Data.WriteConsoleOutputCharRequest.Coord = dwWriteCoord;
1287 if( lpNumberOfCharsWritten )
1288 *lpNumberOfCharsWritten = nLength;
1289 while( nLength )
1290 {
1291 Size = nLength > CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR ? CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR : nLength;
1292 Request->Data.WriteConsoleOutputCharRequest.Length = Size;
1293 memcpy( &Request->Data.WriteConsoleOutputCharRequest.String[0],
1294 lpCharacter,
1295 Size );
1296 Status = CsrClientCallServer( Request, &Reply, sizeof( CSRSS_API_REQUEST ) + Size, sizeof( CSRSS_API_REPLY ) );
1297 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
1298 {
1299 RtlFreeHeap( GetProcessHeap(), 0, Request );
1300 SetLastErrorByStatus ( Status );
1301 return FALSE;
1302 }
1303 nLength -= Size;
1304 lpCharacter += Size;
1305 Request->Data.WriteConsoleOutputCharRequest.Coord = Reply.Data.WriteConsoleOutputCharReply.EndCoord;
1306 }
1307 return TRUE;
1308 }
1309
1310
1311 /*--------------------------------------------------------------
1312 * WriteConsoleOutputCharacterW
1313 */
1314 WINBASEAPI
1315 BOOL
1316 WINAPI
1317 WriteConsoleOutputCharacterW(
1318 HANDLE hConsoleOutput,
1319 LPCWSTR lpCharacter,
1320 DWORD nLength,
1321 COORD dwWriteCoord,
1322 LPDWORD lpNumberOfCharsWritten
1323 )
1324 {
1325 /* TO DO */
1326 return FALSE;
1327 }
1328
1329
1330
1331 /*--------------------------------------------------------------
1332 * WriteConsoleOutputAttribute
1333 */
1334 WINBASEAPI
1335 BOOL
1336 WINAPI
1337 WriteConsoleOutputAttribute(
1338 HANDLE hConsoleOutput,
1339 CONST WORD *lpAttribute,
1340 DWORD nLength,
1341 COORD dwWriteCoord,
1342 LPDWORD lpNumberOfAttrsWritten
1343 )
1344 {
1345 PCSRSS_API_REQUEST Request;
1346 CSRSS_API_REPLY Reply;
1347 NTSTATUS Status;
1348 WORD Size;
1349 int c;
1350
1351 Request = RtlAllocateHeap(GetProcessHeap(),
1352 HEAP_ZERO_MEMORY,
1353 sizeof(CSRSS_API_REQUEST) + CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB);
1354 if( !Request )
1355 {
1356 SetLastError( ERROR_OUTOFMEMORY );
1357 return FALSE;
1358 }
1359 Request->Type = CSRSS_WRITE_CONSOLE_OUTPUT_ATTRIB;
1360 Request->Data.WriteConsoleOutputAttribRequest.ConsoleHandle = hConsoleOutput;
1361 Request->Data.WriteConsoleOutputAttribRequest.Coord = dwWriteCoord;
1362 if( lpNumberOfAttrsWritten )
1363 *lpNumberOfAttrsWritten = nLength;
1364 while( nLength )
1365 {
1366 Size = nLength > CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB ? CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB : nLength;
1367 Request->Data.WriteConsoleOutputAttribRequest.Length = Size;
1368 for( c = 0; c < ( Size * 2 ); c++ )
1369 Request->Data.WriteConsoleOutputAttribRequest.String[c] = (char)lpAttribute[c];
1370 Status = CsrClientCallServer( Request, &Reply, sizeof( CSRSS_API_REQUEST ) + (Size * 2), sizeof( CSRSS_API_REPLY ) );
1371 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
1372 {
1373 RtlFreeHeap( GetProcessHeap(), 0, Request );
1374 SetLastErrorByStatus ( Status );
1375 return FALSE;
1376 }
1377 nLength -= Size;
1378 lpAttribute += Size;
1379 Request->Data.WriteConsoleOutputAttribRequest.Coord = Reply.Data.WriteConsoleOutputAttribReply.EndCoord;
1380 }
1381 return TRUE;
1382 }
1383
1384
1385 /*--------------------------------------------------------------
1386 * FillConsoleOutputAttribute
1387 */
1388 WINBASEAPI
1389 BOOL
1390 WINAPI
1391 FillConsoleOutputAttribute(
1392 HANDLE hConsoleOutput,
1393 WORD wAttribute,
1394 DWORD nLength,
1395 COORD dwWriteCoord,
1396 LPDWORD lpNumberOfAttrsWritten
1397 )
1398 {
1399 CSRSS_API_REQUEST Request;
1400 CSRSS_API_REPLY Reply;
1401 NTSTATUS Status;
1402
1403 Request.Type = CSRSS_FILL_OUTPUT_ATTRIB;
1404 Request.Data.FillOutputAttribRequest.ConsoleHandle = hConsoleOutput;
1405 Request.Data.FillOutputAttribRequest.Attribute = wAttribute;
1406 Request.Data.FillOutputAttribRequest.Coord = dwWriteCoord;
1407 Request.Data.FillOutputAttribRequest.Length = nLength;
1408 Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
1409 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
1410 {
1411 SetLastErrorByStatus ( Status );
1412 return FALSE;
1413 }
1414 if( lpNumberOfAttrsWritten )
1415 *lpNumberOfAttrsWritten = nLength;
1416 return TRUE;
1417 }
1418
1419
1420 /*--------------------------------------------------------------
1421 * GetConsoleMode
1422 */
1423 WINBASEAPI
1424 BOOL
1425 WINAPI
1426 GetConsoleMode(
1427 HANDLE hConsoleHandle,
1428 LPDWORD lpMode
1429 )
1430 {
1431 CSRSS_API_REQUEST Request;
1432 CSRSS_API_REPLY Reply;
1433 NTSTATUS Status;
1434
1435 Request.Type = CSRSS_GET_MODE;
1436 Request.Data.GetConsoleModeRequest.ConsoleHandle = hConsoleHandle;
1437 Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
1438 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
1439 {
1440 SetLastErrorByStatus ( Status );
1441 return FALSE;
1442 }
1443 *lpMode = Reply.Data.GetConsoleModeReply.ConsoleMode;
1444 return TRUE;
1445 }
1446
1447
1448 /*--------------------------------------------------------------
1449 * GetNumberOfConsoleInputEvents
1450 */
1451 WINBASEAPI
1452 BOOL
1453 WINAPI
1454 GetNumberOfConsoleInputEvents(
1455 HANDLE hConsoleInput,
1456 LPDWORD lpNumberOfEvents
1457 )
1458 {
1459 /* TO DO */
1460 return FALSE;
1461 }
1462
1463
1464 /*--------------------------------------------------------------
1465 * GetLargestConsoleWindowSize
1466 */
1467 WINBASEAPI
1468 COORD
1469 WINAPI
1470 GetLargestConsoleWindowSize(
1471 HANDLE hConsoleOutput
1472 )
1473 {
1474 #if 1 /* FIXME: */
1475 COORD Coord = {80,25};
1476
1477 /* TO DO */
1478 return Coord;
1479 #endif
1480 }
1481
1482
1483 /*--------------------------------------------------------------
1484 * GetConsoleCursorInfo
1485 */
1486 WINBASEAPI
1487 BOOL
1488 WINAPI
1489 GetConsoleCursorInfo(
1490 HANDLE hConsoleOutput,
1491 PCONSOLE_CURSOR_INFO lpConsoleCursorInfo
1492 )
1493 {
1494 CSRSS_API_REQUEST Request;
1495 CSRSS_API_REPLY Reply;
1496 NTSTATUS Status;
1497
1498 Request.Type = CSRSS_GET_CURSOR_INFO;
1499 Request.Data.GetCursorInfoRequest.ConsoleHandle = hConsoleOutput;
1500 Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
1501
1502 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
1503 {
1504 SetLastErrorByStatus ( Status );
1505 return FALSE;
1506 }
1507 *lpConsoleCursorInfo = Reply.Data.GetCursorInfoReply.Info;
1508 return TRUE;
1509 }
1510
1511
1512 /*--------------------------------------------------------------
1513 * GetNumberOfConsoleMouseButtons
1514 */
1515 WINBASEAPI
1516 BOOL
1517 WINAPI
1518 GetNumberOfConsoleMouseButtons(
1519 LPDWORD lpNumberOfMouseButtons
1520 )
1521 {
1522 /* TO DO */
1523 return FALSE;
1524 }
1525
1526
1527 /*--------------------------------------------------------------
1528 * SetConsoleMode
1529 */
1530 WINBASEAPI
1531 BOOL
1532 WINAPI
1533 SetConsoleMode(
1534 HANDLE hConsoleHandle,
1535 DWORD dwMode
1536 )
1537 {
1538 CSRSS_API_REQUEST Request;
1539 CSRSS_API_REPLY Reply;
1540 NTSTATUS Status;
1541
1542 Request.Type = CSRSS_SET_MODE;
1543 Request.Data.SetConsoleModeRequest.ConsoleHandle = hConsoleHandle;
1544 Request.Data.SetConsoleModeRequest.Mode = dwMode;
1545 Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
1546 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
1547 {
1548 SetLastErrorByStatus ( Status );
1549 return FALSE;
1550 }
1551 return TRUE;
1552 }
1553
1554
1555 /*--------------------------------------------------------------
1556 * SetConsoleActiveScreenBuffer
1557 */
1558 WINBASEAPI
1559 BOOL
1560 WINAPI
1561 SetConsoleActiveScreenBuffer(
1562 HANDLE hConsoleOutput
1563 )
1564 {
1565 CSRSS_API_REQUEST Request;
1566 CSRSS_API_REPLY Reply;
1567 NTSTATUS Status;
1568
1569 Request.Type = CSRSS_SET_SCREEN_BUFFER;
1570 Request.Data.SetActiveScreenBufferRequest.OutputHandle = hConsoleOutput;
1571 Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
1572 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
1573 {
1574 SetLastErrorByStatus ( Status );
1575 return FALSE;
1576 }
1577 return TRUE;
1578 }
1579
1580
1581 /*--------------------------------------------------------------
1582 * FlushConsoleInputBuffer
1583 */
1584 WINBASEAPI
1585 BOOL
1586 WINAPI
1587 FlushConsoleInputBuffer(
1588 HANDLE hConsoleInput
1589 )
1590 {
1591 CSRSS_API_REQUEST Request;
1592 CSRSS_API_REPLY Reply;
1593 NTSTATUS Status;
1594
1595 Request.Type = CSRSS_FLUSH_INPUT_BUFFER;
1596 Request.Data.FlushInputBufferRequest.ConsoleInput = hConsoleInput;
1597 Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
1598 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
1599 {
1600 SetLastErrorByStatus ( Status );
1601 return FALSE;
1602 }
1603 return TRUE;
1604 }
1605
1606
1607 /*--------------------------------------------------------------
1608 * SetConsoleScreenBufferSize
1609 */
1610 WINBASEAPI
1611 BOOL
1612 WINAPI
1613 SetConsoleScreenBufferSize(
1614 HANDLE hConsoleOutput,
1615 COORD dwSize
1616 )
1617 {
1618 /* TO DO */
1619 return FALSE;
1620 }
1621
1622 /*--------------------------------------------------------------
1623 * SetConsoleCursorInfo
1624 */
1625 WINBASEAPI
1626 BOOL
1627 WINAPI
1628 SetConsoleCursorInfo(
1629 HANDLE hConsoleOutput,
1630 CONST CONSOLE_CURSOR_INFO *lpConsoleCursorInfo
1631 )
1632 {
1633 CSRSS_API_REQUEST Request;
1634 CSRSS_API_REPLY Reply;
1635 NTSTATUS Status;
1636
1637 Request.Type = CSRSS_SET_CURSOR_INFO;
1638 Request.Data.SetCursorInfoRequest.ConsoleHandle = hConsoleOutput;
1639 Request.Data.SetCursorInfoRequest.Info = *lpConsoleCursorInfo;
1640 Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
1641
1642 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
1643 {
1644 SetLastErrorByStatus ( Status );
1645 return FALSE;
1646 }
1647 return TRUE;
1648 }
1649
1650
1651 /*--------------------------------------------------------------
1652 * ScrollConsoleScreenBufferA
1653 */
1654 WINBASEAPI
1655 BOOL
1656 WINAPI
1657 ScrollConsoleScreenBufferA(
1658 HANDLE hConsoleOutput,
1659 CONST SMALL_RECT *lpScrollRectangle,
1660 CONST SMALL_RECT *lpClipRectangle,
1661 COORD dwDestinationOrigin,
1662 CONST CHAR_INFO *lpFill
1663 )
1664 {
1665 CSRSS_API_REQUEST Request;
1666 CSRSS_API_REPLY Reply;
1667 NTSTATUS Status;
1668
1669 Request.Type = CSRSS_SCROLL_CONSOLE_SCREEN_BUFFER;
1670 Request.Data.ScrollConsoleScreenBufferRequest.ConsoleHandle = hConsoleOutput;
1671 Request.Data.ScrollConsoleScreenBufferRequest.ScrollRectangle = *lpScrollRectangle;
1672
1673 if (lpClipRectangle != NULL)
1674 {
1675 Request.Data.ScrollConsoleScreenBufferRequest.UseClipRectangle = TRUE;
1676 Request.Data.ScrollConsoleScreenBufferRequest.ClipRectangle = *lpClipRectangle;
1677 }
1678 else
1679 {
1680 Request.Data.ScrollConsoleScreenBufferRequest.UseClipRectangle = FALSE;
1681 }
1682
1683 Request.Data.ScrollConsoleScreenBufferRequest.DestinationOrigin = dwDestinationOrigin;
1684 Request.Data.ScrollConsoleScreenBufferRequest.Fill = *lpFill;
1685 Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
1686
1687 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
1688 {
1689 SetLastErrorByStatus ( Status );
1690 return FALSE;
1691 }
1692 return TRUE;
1693 }
1694
1695
1696 /*--------------------------------------------------------------
1697 * ScrollConsoleScreenBufferW
1698 */
1699 WINBASEAPI
1700 BOOL
1701 WINAPI
1702 ScrollConsoleScreenBufferW(
1703 HANDLE hConsoleOutput,
1704 CONST SMALL_RECT *lpScrollRectangle,
1705 CONST SMALL_RECT *lpClipRectangle,
1706 COORD dwDestinationOrigin,
1707 CONST CHAR_INFO *lpFill
1708 )
1709 {
1710 /* TO DO */
1711 return FALSE;
1712 }
1713
1714
1715 /*--------------------------------------------------------------
1716 * SetConsoleWindowInfo
1717 */
1718 WINBASEAPI
1719 BOOL
1720 WINAPI
1721 SetConsoleWindowInfo(
1722 HANDLE hConsoleOutput,
1723 BOOL bAbsolute,
1724 CONST SMALL_RECT *lpConsoleWindow
1725 )
1726 {
1727 /* TO DO */
1728 return FALSE;
1729 }
1730
1731
1732 /*--------------------------------------------------------------
1733 * SetConsoleTextAttribute
1734 */
1735 WINBASEAPI
1736 BOOL
1737 WINAPI
1738 SetConsoleTextAttribute(
1739 HANDLE hConsoleOutput,
1740 WORD wAttributes
1741 )
1742 {
1743 CSRSS_API_REQUEST Request;
1744 CSRSS_API_REPLY Reply;
1745 NTSTATUS Status;
1746
1747 Request.Type = CSRSS_SET_ATTRIB;
1748 Request.Data.SetAttribRequest.ConsoleHandle = hConsoleOutput;
1749 Request.Data.SetAttribRequest.Attrib = wAttributes;
1750 Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
1751 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
1752 {
1753 SetLastErrorByStatus ( Status );
1754 return FALSE;
1755 }
1756 return TRUE;
1757 }
1758
1759 BOOL STATIC
1760 AddConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine)
1761 {
1762 if (HandlerRoutine == NULL)
1763 {
1764 IgnoreCtrlEvents = TRUE;
1765 return(TRUE);
1766 }
1767 else
1768 {
1769 NrCtrlHandlers++;
1770 CtrlHandlers =
1771 RtlReAllocateHeap(RtlGetProcessHeap(),
1772 HEAP_ZERO_MEMORY,
1773 (PVOID)CtrlHandlers,
1774 NrCtrlHandlers * sizeof(PHANDLER_ROUTINE));
1775 if (CtrlHandlers == NULL)
1776 {
1777 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1778 return(FALSE);
1779 }
1780 CtrlHandlers[NrCtrlHandlers - 1] = HandlerRoutine;
1781 return(TRUE);
1782 }
1783 }
1784
1785 BOOL STATIC
1786 RemoveConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine)
1787 {
1788 ULONG i;
1789
1790 if (HandlerRoutine == NULL)
1791 {
1792 IgnoreCtrlEvents = FALSE;
1793 return(TRUE);
1794 }
1795 else
1796 {
1797 for (i = 0; i < NrCtrlHandlers; i++)
1798 {
1799 if (CtrlHandlers[i] == HandlerRoutine)
1800 {
1801 CtrlHandlers[i] = CtrlHandlers[NrCtrlHandlers - 1];
1802 NrCtrlHandlers--;
1803 CtrlHandlers =
1804 RtlReAllocateHeap(RtlGetProcessHeap(),
1805 HEAP_ZERO_MEMORY,
1806 (PVOID)CtrlHandlers,
1807 NrCtrlHandlers * sizeof(PHANDLER_ROUTINE));
1808 return(TRUE);
1809 }
1810 }
1811 }
1812 return(FALSE);
1813 }
1814
1815 WINBASEAPI BOOL WINAPI
1816 SetConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine,
1817 BOOL Add)
1818 {
1819 BOOLEAN Ret;
1820
1821 RtlEnterCriticalSection(&DllLock);
1822 if (Add)
1823 {
1824 Ret = AddConsoleCtrlHandler(HandlerRoutine);
1825 }
1826 else
1827 {
1828 Ret = RemoveConsoleCtrlHandler(HandlerRoutine);
1829 }
1830 RtlLeaveCriticalSection(&DllLock);
1831 return(Ret);
1832 }
1833
1834
1835 /*--------------------------------------------------------------
1836 * GenerateConsoleCtrlEvent
1837 */
1838 WINBASEAPI BOOL WINAPI
1839 GenerateConsoleCtrlEvent(
1840 DWORD dwCtrlEvent,
1841 DWORD dwProcessGroupId
1842 )
1843 {
1844 /* TO DO */
1845 return FALSE;
1846 }
1847
1848
1849 /*--------------------------------------------------------------
1850 * GetConsoleTitleW
1851 */
1852 #define MAX_CONSOLE_TITLE_LENGTH 80
1853
1854 WINBASEAPI
1855 DWORD
1856 WINAPI
1857 GetConsoleTitleW(
1858 LPWSTR lpConsoleTitle,
1859 DWORD nSize
1860 )
1861 {
1862 union {
1863 CSRSS_API_REQUEST quest;
1864 CSRSS_API_REPLY ply;
1865 } Re;
1866 NTSTATUS Status;
1867
1868 /* Marshall data */
1869 Re.quest.Type = CSRSS_GET_TITLE;
1870 Re.quest.Data.GetTitleRequest.ConsoleHandle =
1871 GetStdHandle (STD_INPUT_HANDLE);
1872
1873 /* Call CSRSS */
1874 Status = CsrClientCallServer (
1875 & Re.quest,
1876 & Re.ply,
1877 (sizeof (CSRSS_GET_TITLE_REQUEST) +
1878 sizeof (LPC_MESSAGE_HEADER) +
1879 sizeof (ULONG)),
1880 sizeof (CSRSS_API_REPLY)
1881 );
1882 if ( !NT_SUCCESS(Status)
1883 || !NT_SUCCESS (Status = Re.ply.Status)
1884 )
1885 {
1886 SetLastErrorByStatus (Status);
1887 return (0);
1888 }
1889
1890 /* Convert size in characters to size in bytes */
1891 nSize = sizeof (WCHAR) * nSize;
1892
1893 /* Unmarshall data */
1894 if (nSize < Re.ply.Data.GetTitleReply.Length)
1895 {
1896 DbgPrint ("%s: ret=%d\n", __FUNCTION__, Re.ply.Data.GetTitleReply.Length);
1897 nSize /= sizeof (WCHAR);
1898 if (nSize > 1)
1899 {
1900 wcsncpy (
1901 lpConsoleTitle,
1902 Re.ply.Data.GetTitleReply.Title,
1903 (nSize - 1)
1904 );
1905 /* Add null */
1906 lpConsoleTitle [nSize --] = L'\0';
1907 }
1908 }
1909 else
1910 {
1911 nSize = Re.ply.Data.GetTitleReply.Length / sizeof (WCHAR);
1912 wcscpy (lpConsoleTitle, Re.ply.Data.GetTitleReply.Title);
1913 }
1914
1915 return nSize;
1916 }
1917
1918
1919 /*--------------------------------------------------------------
1920 * GetConsoleTitleA
1921 *
1922 * 19990306 EA
1923 */
1924 WINBASEAPI
1925 DWORD
1926 WINAPI
1927 GetConsoleTitleA(
1928 LPSTR lpConsoleTitle,
1929 DWORD nSize
1930 )
1931 {
1932 wchar_t WideTitle [MAX_CONSOLE_TITLE_LENGTH];
1933 DWORD nWideTitle = sizeof WideTitle;
1934 // DWORD nWritten;
1935
1936 if (!lpConsoleTitle || !nSize) return 0;
1937 nWideTitle = GetConsoleTitleW( (LPWSTR) WideTitle, nWideTitle );
1938 if (!nWideTitle) return 0;
1939 #if 0
1940 if ( (nWritten = WideCharToMultiByte(
1941 CP_ACP, // ANSI code page
1942 0, // performance and mapping flags
1943 (LPWSTR) WideTitle, // address of wide-character string
1944 nWideTitle, // number of characters in string
1945 lpConsoleTitle, // address of buffer for new string
1946 nSize, // size of buffer
1947 NULL, // FAST
1948 NULL // FAST
1949 )))
1950 {
1951 lpConsoleTitle[nWritten] = '\0';
1952 return nWritten;
1953 }
1954 #endif
1955 return 0;
1956 }
1957
1958
1959 /*--------------------------------------------------------------
1960 * SetConsoleTitleW
1961 */
1962 WINBASEAPI
1963 BOOL
1964 WINAPI
1965 SetConsoleTitleW(
1966 LPCWSTR lpConsoleTitle
1967 )
1968 {
1969 PCSRSS_API_REQUEST Request;
1970 CSRSS_API_REPLY Reply;
1971 NTSTATUS Status;
1972 unsigned int c;
1973
1974 Request = RtlAllocateHeap(GetProcessHeap(),
1975 HEAP_ZERO_MEMORY,
1976 sizeof(CSRSS_API_REQUEST) + CSRSS_MAX_SET_TITLE_REQUEST);
1977 if (Request == NULL)
1978 {
1979 return(FALSE);
1980 }
1981
1982 Request->Type = CSRSS_SET_TITLE;
1983 Request->Data.SetTitleRequest.Console = GetStdHandle( STD_INPUT_HANDLE );
1984
1985 for( c = 0; lpConsoleTitle[c] && c < CSRSS_MAX_TITLE_LENGTH; c++ )
1986 Request->Data.SetTitleRequest.Title[c] = lpConsoleTitle[c];
1987 // add null
1988 Request->Data.SetTitleRequest.Title[c] = 0;
1989 Request->Data.SetTitleRequest.Length = c;
1990 Status = CsrClientCallServer(Request,
1991 &Reply,
1992 sizeof(CSRSS_SET_TITLE_REQUEST) +
1993 c +
1994 sizeof( LPC_MESSAGE_HEADER ) +
1995 sizeof( ULONG ),
1996 sizeof(CSRSS_API_REPLY));
1997
1998 if (!NT_SUCCESS(Status) || !NT_SUCCESS( Status = Reply.Status ) )
1999 {
2000 RtlFreeHeap( GetProcessHeap(), 0, Request );
2001 SetLastErrorByStatus (Status);
2002 return(FALSE);
2003 }
2004 RtlFreeHeap( GetProcessHeap(), 0, Request );
2005 return TRUE;
2006 }
2007
2008
2009 /*--------------------------------------------------------------
2010 * SetConsoleTitleA
2011 *
2012 * 19990204 EA Added
2013 */
2014 WINBASEAPI
2015 BOOL
2016 WINAPI
2017 SetConsoleTitleA(
2018 LPCSTR lpConsoleTitle
2019 )
2020 {
2021 PCSRSS_API_REQUEST Request;
2022 CSRSS_API_REPLY Reply;
2023 NTSTATUS Status;
2024 unsigned int c;
2025
2026 Request = RtlAllocateHeap(GetProcessHeap(),
2027 HEAP_ZERO_MEMORY,
2028 sizeof(CSRSS_API_REQUEST) + CSRSS_MAX_SET_TITLE_REQUEST);
2029 if (Request == NULL)
2030 {
2031 return(FALSE);
2032 }
2033
2034 Request->Type = CSRSS_SET_TITLE;
2035 Request->Data.SetTitleRequest.Console = GetStdHandle( STD_INPUT_HANDLE );
2036
2037 for( c = 0; lpConsoleTitle[c] && c < CSRSS_MAX_TITLE_LENGTH; c++ )
2038 Request->Data.SetTitleRequest.Title[c] = lpConsoleTitle[c];
2039 // add null
2040 Request->Data.SetTitleRequest.Title[c] = 0;
2041 Request->Data.SetTitleRequest.Length = c;
2042 Status = CsrClientCallServer(Request,
2043 &Reply,
2044 sizeof(CSRSS_SET_TITLE_REQUEST) +
2045 c +
2046 sizeof( LPC_MESSAGE_HEADER ) +
2047 sizeof( ULONG ),
2048 sizeof(CSRSS_API_REPLY));
2049
2050 if (!NT_SUCCESS(Status) || !NT_SUCCESS( Status = Reply.Status ) )
2051 {
2052 RtlFreeHeap( GetProcessHeap(), 0, Request );
2053 SetLastErrorByStatus (Status);
2054 return(FALSE);
2055 }
2056 RtlFreeHeap( GetProcessHeap(), 0, Request );
2057 return TRUE;
2058 }
2059
2060
2061 /*--------------------------------------------------------------
2062 * ReadConsoleW
2063 */
2064 WINBASEAPI
2065 BOOL
2066 WINAPI
2067 ReadConsoleW(
2068 HANDLE hConsoleInput,
2069 LPVOID lpBuffer,
2070 DWORD nNumberOfCharsToRead,
2071 LPDWORD lpNumberOfCharsRead,
2072 LPVOID lpReserved
2073 )
2074 {
2075 /* --- TO DO --- */
2076 return FALSE;
2077 }
2078
2079
2080 /*--------------------------------------------------------------
2081 * WriteConsoleW
2082 */
2083 WINBASEAPI
2084 BOOL
2085 WINAPI
2086 WriteConsoleW(
2087 HANDLE hConsoleOutput,
2088 CONST VOID *lpBuffer,
2089 DWORD nNumberOfCharsToWrite,
2090 LPDWORD lpNumberOfCharsWritten,
2091 LPVOID lpReserved
2092 )
2093 {
2094 #if 0
2095 PCSRSS_API_REQUEST Request;
2096 CSRSS_API_REPLY Reply;
2097 NTSTATUS Status;
2098
2099 Request = RtlAllocateHeap(GetProcessHeap(),
2100 HEAP_ZERO_MEMORY,
2101 sizeof(CSRSS_API_REQUEST) + nNumberOfCharsToWrite * sizeof(WCHAR));
2102 if (Request == NULL)
2103 {
2104 return(FALSE);
2105 }
2106
2107 Request->Type = CSRSS_WRITE_CONSOLE;
2108 Request->Data.WriteConsoleRequest.ConsoleHandle = hConsoleOutput;
2109 Request->Data.WriteConsoleRequest.NrCharactersToWrite =
2110 nNumberOfCharsToWrite;
2111 // DbgPrint("nNumberOfCharsToWrite %d\n", nNumberOfCharsToWrite);
2112 // DbgPrint("Buffer %s\n", Request->Data.WriteConsoleRequest.Buffer);
2113 memcpy(Request->Data.WriteConsoleRequest.Buffer,
2114 lpBuffer,
2115 nNumberOfCharsToWrite * sizeof(WCHAR));
2116
2117 Status = CsrClientCallServer(Request,
2118 &Reply,
2119 sizeof(CSRSS_API_REQUEST) +
2120 nNumberOfCharsToWrite,
2121 sizeof(CSRSS_API_REPLY));
2122
2123 RtlFreeHeap(GetProcessHeap(),
2124 0,
2125 Request);
2126
2127 if (!NT_SUCCESS(Status))
2128 {
2129 return(FALSE);
2130 }
2131
2132 if (lpNumberOfCharsWritten != NULL)
2133 {
2134 *lpNumberOfCharsWritten =
2135 Reply.Data.WriteConsoleReply.NrCharactersWritten;
2136 }
2137
2138 return(TRUE);
2139 #endif
2140 return FALSE;
2141 }
2142
2143
2144 /*--------------------------------------------------------------
2145 * CreateConsoleScreenBuffer
2146 */
2147 WINBASEAPI
2148 HANDLE
2149 WINAPI
2150 CreateConsoleScreenBuffer(
2151 DWORD dwDesiredAccess,
2152 DWORD dwShareMode,
2153 CONST SECURITY_ATTRIBUTES *lpSecurityAttributes,
2154 DWORD dwFlags,
2155 LPVOID lpScreenBufferData
2156 )
2157 {
2158 // FIXME: don't ignore access, share mode, and security
2159 CSRSS_API_REQUEST Request;
2160 CSRSS_API_REPLY Reply;
2161 NTSTATUS Status;
2162
2163 Request.Type = CSRSS_CREATE_SCREEN_BUFFER;
2164 Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
2165 if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
2166 {
2167 SetLastErrorByStatus ( Status );
2168 return FALSE;
2169 }
2170 return Reply.Data.CreateScreenBufferReply.OutputHandle;
2171 }
2172
2173
2174 /*--------------------------------------------------------------
2175 * GetConsoleCP
2176 */
2177 WINBASEAPI
2178 UINT
2179 WINAPI
2180 GetConsoleCP( VOID )
2181 {
2182 /* --- TO DO --- */
2183 return CP_OEMCP; /* FIXME */
2184 }
2185
2186
2187 /*--------------------------------------------------------------
2188 * SetConsoleCP
2189 */
2190 WINBASEAPI
2191 BOOL
2192 WINAPI
2193 SetConsoleCP(
2194 UINT wCodePageID
2195 )
2196 {
2197 /* --- TO DO --- */
2198 return FALSE;
2199 }
2200
2201
2202 /*--------------------------------------------------------------
2203 * GetConsoleOutputCP
2204 */
2205 WINBASEAPI
2206 UINT
2207 WINAPI
2208 GetConsoleOutputCP( VOID )
2209 {
2210 /* --- TO DO --- */
2211 return 0; /* FIXME */
2212 }
2213
2214
2215 /*--------------------------------------------------------------
2216 * SetConsoleOutputCP
2217 */
2218 WINBASEAPI
2219 BOOL
2220 WINAPI
2221 SetConsoleOutputCP(
2222 UINT wCodePageID
2223 )
2224 {
2225 /* --- TO DO --- */
2226 return FALSE;
2227 }
2228
2229
2230 /* EOF */
A free Windows-compatible Operating System