projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
sync to trunk head (37853) (except rbuild changes)
[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 BOOL Ret = FALSE;
3761 int lenName = lstrlenW(lpInputExeName);
3762
3763 if(lenName < 1 ||
3764 lenName > (int)(sizeof(InputExeName) / sizeof(InputExeName[0])) - 1)
3765 {
3766 /* Fail if string is empty or too long */
3767 SetLastError(ERROR_INVALID_PARAMETER);
3768 return FALSE;
3769 }
3770
3771 RtlEnterCriticalSection(&ConsoleLock);
3772 /* wrap copying into SEH as we may copy from invalid buffer and in case of an
3773 exception the console lock would've never been released, which would cause
3774 further calls (if the exception was handled by the caller) to recursively
3775 acquire the lock... */
3776 _SEH2_TRY
3777 {
3778 RtlCopyMemory(InputExeName, lpInputExeName, lenName * sizeof(WCHAR));
3779 InputExeName[lenName] = L'\0';
3780 Ret = TRUE;
3781 }
3782 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
3783 {
3784 lenName = 0;
3785 SetLastErrorByStatus(_SEH2_GetExceptionCode());
3786 }
3787 _SEH2_END;
3788 RtlLeaveCriticalSection(&ConsoleLock);
3789
3790 return Ret;
3791 }
3792
3793
3794 /*--------------------------------------------------------------
3795 * SetConsoleInputExeNameA
3796 *
3797 * @implemented
3798 */
3799 BOOL WINAPI
3800 SetConsoleInputExeNameA(LPCSTR lpInputExeName)
3801 {
3802 ANSI_STRING InputExeNameA;
3803 UNICODE_STRING InputExeNameU;
3804 NTSTATUS Status;
3805 BOOL Ret;
3806
3807 RtlInitAnsiString(&InputExeNameA, lpInputExeName);
3808
3809 if(InputExeNameA.Length < sizeof(InputExeNameA.Buffer[0]) ||
3810 InputExeNameA.Length >= (sizeof(InputExeName) / sizeof(InputExeName[0])) - 1)
3811 {
3812 /* Fail if string is empty or too long */
3813 SetLastError(ERROR_INVALID_PARAMETER);
3814 return FALSE;
3815 }
3816
3817 Status = RtlAnsiStringToUnicodeString(&InputExeNameU, &InputExeNameA, TRUE);
3818 if(NT_SUCCESS(Status))
3819 {
3820 Ret = SetConsoleInputExeNameW(InputExeNameU.Buffer);
3821 RtlFreeUnicodeString(&InputExeNameU);
3822 }
3823 else
3824 {
3825 SetLastErrorByStatus(Status);
3826 Ret = FALSE;
3827 }
3828
3829 return Ret;
3830 }
3831
3832
3833 /*--------------------------------------------------------------
3834 * GetConsoleInputExeNameW
3835 *
3836 * @implemented
3837 */
3838 DWORD WINAPI
3839 GetConsoleInputExeNameW(DWORD nBufferLength, LPWSTR lpBuffer)
3840 {
3841 int lenName;
3842
3843 RtlEnterCriticalSection(&ConsoleLock);
3844
3845 lenName = lstrlenW(InputExeName);
3846 if(lenName >= (int)nBufferLength)
3847 {
3848 /* buffer is not large enough, return the required size */
3849 RtlLeaveCriticalSection(&ConsoleLock);
3850 SetLastError(ERROR_BUFFER_OVERFLOW);
3851 return lenName + 1;
3852 }
3853
3854 /* wrap copying into SEH as we may copy to invalid buffer and in case of an
3855 exception the console lock would've never been released, which would cause
3856 further calls (if the exception was handled by the caller) to recursively
3857 acquire the lock... */
3858 _SEH2_TRY
3859 {
3860 RtlCopyMemory(lpBuffer, InputExeName, (lenName + 1) * sizeof(WCHAR));
3861 }
3862 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
3863 {
3864 lenName = 0;
3865 SetLastErrorByStatus(_SEH2_GetExceptionCode());
3866 }
3867 _SEH2_END;
3868
3869 RtlLeaveCriticalSection(&ConsoleLock);
3870
3871 return lenName;
3872 }
3873
3874
3875 /*--------------------------------------------------------------
3876 * GetConsoleInputExeNameA
3877 *
3878 * @implemented
3879 */
3880 DWORD WINAPI
3881 GetConsoleInputExeNameA(DWORD nBufferLength, LPSTR lpBuffer)
3882 {
3883 WCHAR *Buffer;
3884 DWORD Ret;
3885
3886 if(nBufferLength > 0)
3887 {
3888 Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, nBufferLength * sizeof(WCHAR));
3889 if(Buffer == NULL)
3890 {
3891 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
3892 return 0;
3893 }
3894 }
3895 else
3896 {
3897 Buffer = NULL;
3898 }
3899
3900 Ret = GetConsoleInputExeNameW(nBufferLength, Buffer);
3901 if(nBufferLength > 0)
3902 {
3903 if(Ret > 0)
3904 {
3905 UNICODE_STRING BufferU;
3906 ANSI_STRING BufferA;
3907
3908 RtlInitUnicodeString(&BufferU, Buffer);
3909
3910 BufferA.Length = 0;
3911 BufferA.MaximumLength = (USHORT)nBufferLength;
3912 BufferA.Buffer = lpBuffer;
3913
3914 RtlUnicodeStringToAnsiString(&BufferA, &BufferU, FALSE);
3915 }
3916
3917 RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
3918 }
3919
3920 return Ret;
3921 }
3922
3923
3924 /*--------------------------------------------------------------
3925 * GetConsoleHistoryInfo
3926 *
3927 * @unimplemented
3928 */
3929 BOOL WINAPI
3930 GetConsoleHistoryInfo(PCONSOLE_HISTORY_INFO lpConsoleHistoryInfo)
3931 {
3932 DPRINT1("GetConsoleHistoryInfo(0x%p) UNIMPLEMENTED!\n", lpConsoleHistoryInfo);
3933 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3934 return FALSE;
3935 }
3936
3937
3938 /*--------------------------------------------------------------
3939 * SetConsoleHistoryInfo
3940 *
3941 * @unimplemented
3942 */
3943 BOOL WINAPI
3944 SetConsoleHistoryInfo(IN PCONSOLE_HISTORY_INFO lpConsoleHistoryInfo)
3945 {
3946 DPRINT1("SetConsoleHistoryInfo(0x%p) UNIMPLEMENTED!\n", lpConsoleHistoryInfo);
3947 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3948 return FALSE;
3949 }
3950
3951
3952 /*--------------------------------------------------------------
3953 * GetConsoleOriginalTitleW
3954 *
3955 * @unimplemented
3956 */
3957 DWORD WINAPI
3958 GetConsoleOriginalTitleW(OUT LPWSTR lpConsoleTitle,
3959 IN DWORD nSize)
3960 {
3961 DPRINT1("GetConsoleOriginalTitleW(0x%p, 0x%x) UNIMPLEMENTED!\n", lpConsoleTitle, nSize);
3962 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3963 return 0;
3964 }
3965
3966
3967 /*--------------------------------------------------------------
3968 * GetConsoleOriginalTitleA
3969 *
3970 * @unimplemented
3971 */
3972 DWORD WINAPI
3973 GetConsoleOriginalTitleA(OUT LPSTR lpConsoleTitle,
3974 IN DWORD nSize)
3975 {
3976 DPRINT1("GetConsoleOriginalTitleA(0x%p, 0x%x) UNIMPLEMENTED!\n", lpConsoleTitle, nSize);
3977 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3978 return 0;
3979 }
3980
3981
3982 /*--------------------------------------------------------------
3983 * GetConsoleScreenBufferInfoEx
3984 *
3985 * @unimplemented
3986 */
3987 BOOL WINAPI
3988 GetConsoleScreenBufferInfoEx(IN HANDLE hConsoleOutput,
3989 OUT PCONSOLE_SCREEN_BUFFER_INFOEX lpConsoleScreenBufferInfoEx)
3990 {
3991 DPRINT1("GetConsoleScreenBufferInfoEx(0x%p, 0x%p) UNIMPLEMENTED!\n", hConsoleOutput, lpConsoleScreenBufferInfoEx);
3992 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3993 return FALSE;
3994 }
3995
3996
3997 /*--------------------------------------------------------------
3998 * SetConsoleScreenBufferInfoEx
3999 *
4000 * @unimplemented
4001 */
4002 BOOL WINAPI
4003 SetConsoleScreenBufferInfoEx(IN HANDLE hConsoleOutput,
4004 IN PCONSOLE_SCREEN_BUFFER_INFOEX lpConsoleScreenBufferInfoEx)
4005 {
4006 DPRINT1("SetConsoleScreenBufferInfoEx(0x%p, 0x%p) UNIMPLEMENTED!\n", hConsoleOutput, lpConsoleScreenBufferInfoEx);
4007 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4008 return FALSE;
4009 }
4010
4011
4012 /*--------------------------------------------------------------
4013 * GetCurrentConsoleFontEx
4014 *
4015 * @unimplemented
4016 */
4017 BOOL WINAPI
4018 GetCurrentConsoleFontEx(IN HANDLE hConsoleOutput,
4019 IN BOOL bMaximumWindow,
4020 OUT PCONSOLE_FONT_INFOEX lpConsoleCurrentFontEx)
4021 {
4022 DPRINT1("GetCurrentConsoleFontEx(0x%p, 0x%x, 0x%p) UNIMPLEMENTED!\n", hConsoleOutput, bMaximumWindow, lpConsoleCurrentFontEx);
4023 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4024 return FALSE;
4025 }
4026
4027 /* EOF */
A free Windows-compatible Operating System