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