7f8bfda7a092b1c676c26176a6c88973d041d6dc
[reactos.git] / win32ss / user / winsrv / consrv / lineinput.c
1 /*
2 * LICENSE: GPL - See COPYING in the top level directory
3 * PROJECT: ReactOS Console Server DLL
4 * FILE: win32ss/user/winsrv/consrv/lineinput.c
5 * PURPOSE: Console line input functions
6 * PROGRAMMERS: Jeffrey Morlan
7 *
8 * NOTE: It's something frontend-related... (--> read my mind... ;) )
9 */
10
11 /* INCLUDES *******************************************************************/
12
13 #include "consrv.h"
14
15 #define NDEBUG
16 #include <debug.h>
17
18 typedef struct _HISTORY_BUFFER
19 {
20 LIST_ENTRY ListEntry;
21 UINT Position;
22 UINT MaxEntries;
23 UINT NumEntries;
24 PUNICODE_STRING Entries;
25 UNICODE_STRING ExeName;
26 } HISTORY_BUFFER, *PHISTORY_BUFFER;
27
28
29 /* PRIVATE FUNCTIONS **********************************************************/
30
31 static PHISTORY_BUFFER
32 HistoryCurrentBuffer(PCONSOLE Console)
33 {
34 /* TODO: use actual EXE name sent from process that called ReadConsole */
35 UNICODE_STRING ExeName = { 14, 14, L"cmd.exe" };
36 PLIST_ENTRY Entry = Console->HistoryBuffers.Flink;
37 PHISTORY_BUFFER Hist;
38
39 for (; Entry != &Console->HistoryBuffers; Entry = Entry->Flink)
40 {
41 Hist = CONTAINING_RECORD(Entry, HISTORY_BUFFER, ListEntry);
42 if (RtlEqualUnicodeString(&ExeName, &Hist->ExeName, FALSE))
43 return Hist;
44 }
45
46 /* Couldn't find the buffer, create a new one */
47 Hist = ConsoleAllocHeap(0, sizeof(HISTORY_BUFFER) + ExeName.Length);
48 if (!Hist) return NULL;
49 Hist->MaxEntries = Console->HistoryBufferSize;
50 Hist->NumEntries = 0;
51 Hist->Entries = ConsoleAllocHeap(0, Hist->MaxEntries * sizeof(UNICODE_STRING));
52 if (!Hist->Entries)
53 {
54 ConsoleFreeHeap(Hist);
55 return NULL;
56 }
57 Hist->ExeName.Length = Hist->ExeName.MaximumLength = ExeName.Length;
58 Hist->ExeName.Buffer = (PWCHAR)(Hist + 1);
59 memcpy(Hist->ExeName.Buffer, ExeName.Buffer, ExeName.Length);
60 InsertHeadList(&Console->HistoryBuffers, &Hist->ListEntry);
61 return Hist;
62 }
63
64 static VOID
65 HistoryAddEntry(PCONSOLE Console)
66 {
67 UNICODE_STRING NewEntry;
68 PHISTORY_BUFFER Hist = HistoryCurrentBuffer(Console);
69 INT i;
70
71 if (!Hist) return;
72
73 NewEntry.Length = NewEntry.MaximumLength = Console->LineSize * sizeof(WCHAR);
74 NewEntry.Buffer = Console->LineBuffer;
75
76 /* Don't add blank or duplicate entries */
77 if (NewEntry.Length == 0 || Hist->MaxEntries == 0 ||
78 (Hist->NumEntries > 0 &&
79 RtlEqualUnicodeString(&Hist->Entries[Hist->NumEntries - 1], &NewEntry, FALSE)))
80 {
81 return;
82 }
83
84 if (Console->HistoryNoDup)
85 {
86 /* Check if this line has been entered before */
87 for (i = Hist->NumEntries - 1; i >= 0; i--)
88 {
89 if (RtlEqualUnicodeString(&Hist->Entries[i], &NewEntry, FALSE))
90 {
91 /* Just rotate the list to bring this entry to the end */
92 NewEntry = Hist->Entries[i];
93 memmove(&Hist->Entries[i], &Hist->Entries[i + 1],
94 (Hist->NumEntries - (i + 1)) * sizeof(UNICODE_STRING));
95 Hist->Entries[Hist->NumEntries - 1] = NewEntry;
96 Hist->Position = Hist->NumEntries - 1;
97 return;
98 }
99 }
100 }
101
102 if (Hist->NumEntries == Hist->MaxEntries)
103 {
104 /* List is full, remove oldest entry */
105 RtlFreeUnicodeString(&Hist->Entries[0]);
106 memmove(&Hist->Entries[0], &Hist->Entries[1],
107 --Hist->NumEntries * sizeof(UNICODE_STRING));
108 }
109
110 if (NT_SUCCESS(RtlDuplicateUnicodeString(0, &NewEntry, &Hist->Entries[Hist->NumEntries])))
111 Hist->NumEntries++;
112 Hist->Position = Hist->NumEntries - 1;
113 }
114
115 static VOID
116 HistoryGetCurrentEntry(PCONSOLE Console, PUNICODE_STRING Entry)
117 {
118 PHISTORY_BUFFER Hist = HistoryCurrentBuffer(Console);
119
120 if (!Hist || Hist->NumEntries == 0)
121 Entry->Length = 0;
122 else
123 *Entry = Hist->Entries[Hist->Position];
124 }
125
126 static PHISTORY_BUFFER
127 HistoryFindBuffer(PCONSOLE Console, PUNICODE_STRING ExeName)
128 {
129 PLIST_ENTRY Entry = Console->HistoryBuffers.Flink;
130 while (Entry != &Console->HistoryBuffers)
131 {
132 /* For the history APIs, the caller is allowed to give only part of the name */
133 PHISTORY_BUFFER Hist = CONTAINING_RECORD(Entry, HISTORY_BUFFER, ListEntry);
134 if (RtlPrefixUnicodeString(ExeName, &Hist->ExeName, TRUE))
135 return Hist;
136 Entry = Entry->Flink;
137 }
138 return NULL;
139 }
140
141 static VOID
142 HistoryDeleteBuffer(PHISTORY_BUFFER Hist)
143 {
144 if (!Hist) return;
145
146 while (Hist->NumEntries != 0)
147 RtlFreeUnicodeString(&Hist->Entries[--Hist->NumEntries]);
148
149 ConsoleFreeHeap(Hist->Entries);
150 RemoveEntryList(&Hist->ListEntry);
151 ConsoleFreeHeap(Hist);
152 }
153
154 VOID
155 HistoryDeleteBuffers(PCONSOLE Console)
156 {
157 PLIST_ENTRY CurrentEntry;
158 PHISTORY_BUFFER HistoryBuffer;
159
160 while (!IsListEmpty(&Console->HistoryBuffers))
161 {
162 CurrentEntry = RemoveHeadList(&Console->HistoryBuffers);
163 HistoryBuffer = CONTAINING_RECORD(CurrentEntry, HISTORY_BUFFER, ListEntry);
164 HistoryDeleteBuffer(HistoryBuffer);
165 }
166 }
167
168 static VOID
169 LineInputSetPos(PCONSOLE Console, UINT Pos)
170 {
171 if (Pos != Console->LinePos && Console->InputBuffer.Mode & ENABLE_ECHO_INPUT)
172 {
173 PCONSOLE_SCREEN_BUFFER Buffer = Console->ActiveBuffer;
174 SHORT OldCursorX = Buffer->CursorPosition.X;
175 SHORT OldCursorY = Buffer->CursorPosition.Y;
176 INT XY = OldCursorY * Buffer->ScreenBufferSize.X + OldCursorX;
177
178 XY += (Pos - Console->LinePos);
179 if (XY < 0)
180 XY = 0;
181 else if (XY >= Buffer->ScreenBufferSize.Y * Buffer->ScreenBufferSize.X)
182 XY = Buffer->ScreenBufferSize.Y * Buffer->ScreenBufferSize.X - 1;
183
184 Buffer->CursorPosition.X = XY % Buffer->ScreenBufferSize.X;
185 Buffer->CursorPosition.Y = XY / Buffer->ScreenBufferSize.X;
186 TermSetScreenInfo(Console, Buffer, OldCursorX, OldCursorY);
187 }
188
189 Console->LinePos = Pos;
190 }
191
192 static VOID
193 LineInputEdit(PCONSOLE Console, UINT NumToDelete, UINT NumToInsert, WCHAR *Insertion)
194 {
195 PTEXTMODE_SCREEN_BUFFER ActiveBuffer;
196 UINT Pos = Console->LinePos;
197 UINT NewSize = Console->LineSize - NumToDelete + NumToInsert;
198 UINT i;
199
200 if (GetType(Console->ActiveBuffer) != TEXTMODE_BUFFER) return;
201 ActiveBuffer = (PTEXTMODE_SCREEN_BUFFER)Console->ActiveBuffer;
202
203 /* Make sure there's always enough room for ending \r\n */
204 if (NewSize + 2 > Console->LineMaxSize)
205 return;
206
207 memmove(&Console->LineBuffer[Pos + NumToInsert],
208 &Console->LineBuffer[Pos + NumToDelete],
209 (Console->LineSize - (Pos + NumToDelete)) * sizeof(WCHAR));
210 memcpy(&Console->LineBuffer[Pos], Insertion, NumToInsert * sizeof(WCHAR));
211
212 if (Console->InputBuffer.Mode & ENABLE_ECHO_INPUT)
213 {
214 for (i = Pos; i < NewSize; i++)
215 {
216 ConioWriteConsole(Console, ActiveBuffer, &Console->LineBuffer[i], 1, TRUE);
217 }
218 for (; i < Console->LineSize; i++)
219 {
220 ConioWriteConsole(Console, ActiveBuffer, L" ", 1, TRUE);
221 }
222 Console->LinePos = i;
223 }
224
225 Console->LineSize = NewSize;
226 LineInputSetPos(Console, Pos + NumToInsert);
227 }
228
229 static VOID
230 LineInputRecallHistory(PCONSOLE Console, INT Offset)
231 {
232 PHISTORY_BUFFER Hist = HistoryCurrentBuffer(Console);
233 UINT Position = 0;
234
235 if (!Hist || Hist->NumEntries == 0) return;
236
237 Position = Hist->Position + Offset;
238 Position = min(max(Position, 0), Hist->NumEntries - 1);
239 Hist->Position = Position;
240
241 LineInputSetPos(Console, 0);
242 LineInputEdit(Console, Console->LineSize,
243 Hist->Entries[Hist->Position].Length / sizeof(WCHAR),
244 Hist->Entries[Hist->Position].Buffer);
245 }
246
247 VOID
248 LineInputKeyDown(PCONSOLE Console, KEY_EVENT_RECORD *KeyEvent)
249 {
250 UINT Pos = Console->LinePos;
251 PHISTORY_BUFFER Hist;
252 UNICODE_STRING Entry;
253 INT HistPos;
254
255 switch (KeyEvent->wVirtualKeyCode)
256 {
257 case VK_ESCAPE:
258 /* Clear entire line */
259 LineInputSetPos(Console, 0);
260 LineInputEdit(Console, Console->LineSize, 0, NULL);
261 return;
262 case VK_HOME:
263 /* Move to start of line. With ctrl, erase everything left of cursor */
264 LineInputSetPos(Console, 0);
265 if (KeyEvent->dwControlKeyState & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))
266 LineInputEdit(Console, Pos, 0, NULL);
267 return;
268 case VK_END:
269 /* Move to end of line. With ctrl, erase everything right of cursor */
270 if (KeyEvent->dwControlKeyState & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))
271 LineInputEdit(Console, Console->LineSize - Pos, 0, NULL);
272 else
273 LineInputSetPos(Console, Console->LineSize);
274 return;
275 case VK_LEFT:
276 /* Move left. With ctrl, move to beginning of previous word */
277 if (KeyEvent->dwControlKeyState & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))
278 {
279 while (Pos > 0 && Console->LineBuffer[Pos - 1] == L' ') Pos--;
280 while (Pos > 0 && Console->LineBuffer[Pos - 1] != L' ') Pos--;
281 }
282 else
283 {
284 Pos -= (Pos > 0);
285 }
286 LineInputSetPos(Console, Pos);
287 return;
288 case VK_RIGHT:
289 case VK_F1:
290 /* Move right. With ctrl, move to beginning of next word */
291 if (KeyEvent->dwControlKeyState & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))
292 {
293 while (Pos < Console->LineSize && Console->LineBuffer[Pos] != L' ') Pos++;
294 while (Pos < Console->LineSize && Console->LineBuffer[Pos] == L' ') Pos++;
295 LineInputSetPos(Console, Pos);
296 return;
297 }
298 else
299 {
300 /* Recall one character (but don't overwrite current line) */
301 HistoryGetCurrentEntry(Console, &Entry);
302 if (Pos < Console->LineSize)
303 LineInputSetPos(Console, Pos + 1);
304 else if (Pos * sizeof(WCHAR) < Entry.Length)
305 LineInputEdit(Console, 0, 1, &Entry.Buffer[Pos]);
306 }
307 return;
308 case VK_INSERT:
309 /* Toggle between insert and overstrike */
310 Console->LineInsertToggle = !Console->LineInsertToggle;
311 TermSetCursorInfo(Console, Console->ActiveBuffer);
312 return;
313 case VK_DELETE:
314 /* Remove character to right of cursor */
315 if (Pos != Console->LineSize)
316 LineInputEdit(Console, 1, 0, NULL);
317 return;
318 case VK_PRIOR:
319 /* Recall first history entry */
320 LineInputRecallHistory(Console, -((WORD)-1));
321 return;
322 case VK_NEXT:
323 /* Recall last history entry */
324 LineInputRecallHistory(Console, +((WORD)-1));
325 return;
326 case VK_UP:
327 case VK_F5:
328 /* Recall previous history entry. On first time, actually recall the
329 * current (usually last) entry; on subsequent times go back. */
330 LineInputRecallHistory(Console, Console->LineUpPressed ? -1 : 0);
331 Console->LineUpPressed = TRUE;
332 return;
333 case VK_DOWN:
334 /* Recall next history entry */
335 LineInputRecallHistory(Console, +1);
336 return;
337 case VK_F3:
338 /* Recall remainder of current history entry */
339 HistoryGetCurrentEntry(Console, &Entry);
340 if (Pos * sizeof(WCHAR) < Entry.Length)
341 {
342 UINT InsertSize = (Entry.Length / sizeof(WCHAR) - Pos);
343 UINT DeleteSize = min(Console->LineSize - Pos, InsertSize);
344 LineInputEdit(Console, DeleteSize, InsertSize, &Entry.Buffer[Pos]);
345 }
346 return;
347 case VK_F6:
348 /* Insert a ^Z character */
349 KeyEvent->uChar.UnicodeChar = 26;
350 break;
351 case VK_F7:
352 if (KeyEvent->dwControlKeyState & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED))
353 HistoryDeleteBuffer(HistoryCurrentBuffer(Console));
354 return;
355 case VK_F8:
356 /* Search for history entries starting with input. */
357 Hist = HistoryCurrentBuffer(Console);
358 if (!Hist || Hist->NumEntries == 0) return;
359
360 /* Like Up/F5, on first time start from current (usually last) entry,
361 * but on subsequent times start at previous entry. */
362 if (Console->LineUpPressed)
363 Hist->Position = (Hist->Position ? Hist->Position : Hist->NumEntries) - 1;
364 Console->LineUpPressed = TRUE;
365
366 Entry.Length = Console->LinePos * sizeof(WCHAR);
367 Entry.Buffer = Console->LineBuffer;
368
369 /* Keep going backwards, even wrapping around to the end,
370 * until we get back to starting point */
371 HistPos = Hist->Position;
372 do
373 {
374 if (RtlPrefixUnicodeString(&Entry, &Hist->Entries[HistPos], FALSE))
375 {
376 Hist->Position = HistPos;
377 LineInputEdit(Console, Console->LineSize - Pos,
378 Hist->Entries[HistPos].Length / sizeof(WCHAR) - Pos,
379 &Hist->Entries[HistPos].Buffer[Pos]);
380 /* Cursor stays where it was */
381 LineInputSetPos(Console, Pos);
382 return;
383 }
384 if (--HistPos < 0) HistPos += Hist->NumEntries;
385 } while (HistPos != Hist->Position);
386 return;
387 }
388
389 if (KeyEvent->uChar.UnicodeChar == L'\b' && Console->InputBuffer.Mode & ENABLE_PROCESSED_INPUT)
390 {
391 /* backspace handling - if processed input enabled then we handle it here
392 * otherwise we treat it like a normal char. */
393 if (Pos > 0)
394 {
395 LineInputSetPos(Console, Pos - 1);
396 LineInputEdit(Console, 1, 0, NULL);
397 }
398 }
399 else if (KeyEvent->uChar.UnicodeChar == L'\r')
400 {
401 HistoryAddEntry(Console);
402
403 /* TODO: Expand aliases */
404
405 LineInputSetPos(Console, Console->LineSize);
406 Console->LineBuffer[Console->LineSize++] = L'\r';
407 if (Console->InputBuffer.Mode & ENABLE_ECHO_INPUT)
408 {
409 if (GetType(Console->ActiveBuffer) == TEXTMODE_BUFFER)
410 {
411 ConioWriteConsole(Console, (PTEXTMODE_SCREEN_BUFFER)(Console->ActiveBuffer), L"\r", 1, TRUE);
412 }
413 }
414
415 /* Add \n if processed input. There should usually be room for it,
416 * but an exception to the rule exists: the buffer could have been
417 * pre-filled with LineMaxSize - 1 characters. */
418 if (Console->InputBuffer.Mode & ENABLE_PROCESSED_INPUT &&
419 Console->LineSize < Console->LineMaxSize)
420 {
421 Console->LineBuffer[Console->LineSize++] = L'\n';
422 if (Console->InputBuffer.Mode & ENABLE_ECHO_INPUT)
423 {
424 if (GetType(Console->ActiveBuffer) == TEXTMODE_BUFFER)
425 {
426 ConioWriteConsole(Console, (PTEXTMODE_SCREEN_BUFFER)(Console->ActiveBuffer), L"\n", 1, TRUE);
427 }
428 }
429 }
430 Console->LineComplete = TRUE;
431 Console->LinePos = 0;
432 }
433 else if (KeyEvent->uChar.UnicodeChar != L'\0')
434 {
435 if (KeyEvent->uChar.UnicodeChar < 0x20 &&
436 Console->LineWakeupMask & (1 << KeyEvent->uChar.UnicodeChar))
437 {
438 /* Control key client wants to handle itself (e.g. for tab completion) */
439 Console->LineBuffer[Console->LineSize++] = L' ';
440 Console->LineBuffer[Console->LinePos] = KeyEvent->uChar.UnicodeChar;
441 Console->LineComplete = TRUE;
442 Console->LinePos = 0;
443 }
444 else
445 {
446 /* Normal character */
447 BOOL Overstrike = !Console->LineInsertToggle && (Console->LinePos != Console->LineSize);
448 LineInputEdit(Console, (Overstrike ? 1 : 0), 1, &KeyEvent->uChar.UnicodeChar);
449 }
450 }
451 }
452
453
454 /* PUBLIC SERVER APIS *********************************************************/
455
456 CSR_API(SrvGetConsoleCommandHistory)
457 {
458 NTSTATUS Status;
459 PCONSOLE_GETCOMMANDHISTORY GetCommandHistoryRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.GetCommandHistoryRequest;
460 PCONSOLE Console;
461 PHISTORY_BUFFER Hist;
462 UNICODE_STRING ExeName;
463 PBYTE Buffer = (PBYTE)GetCommandHistoryRequest->History;
464 ULONG BufferSize = GetCommandHistoryRequest->HistoryLength;
465 UINT i;
466
467 if ( !CsrValidateMessageBuffer(ApiMessage,
468 (PVOID*)&GetCommandHistoryRequest->History,
469 GetCommandHistoryRequest->HistoryLength,
470 sizeof(BYTE)) ||
471 !CsrValidateMessageBuffer(ApiMessage,
472 (PVOID*)&GetCommandHistoryRequest->ExeName,
473 GetCommandHistoryRequest->ExeLength,
474 sizeof(BYTE)) )
475 {
476 return STATUS_INVALID_PARAMETER;
477 }
478
479 Status = ConSrvGetConsole(ConsoleGetPerProcessData(CsrGetClientThread()->Process), &Console, TRUE);
480 if (!NT_SUCCESS(Status)) return Status;
481
482 // FIXME: convert to UNICODE if Unicode(2) == FALSE
483 ExeName.Length = ExeName.MaximumLength = GetCommandHistoryRequest->ExeLength;
484 ExeName.Buffer = GetCommandHistoryRequest->ExeName;
485
486 Hist = HistoryFindBuffer(Console, &ExeName);
487 if (Hist)
488 {
489 for (i = 0; i < Hist->NumEntries; i++)
490 {
491 if (BufferSize < (Hist->Entries[i].Length + sizeof(WCHAR)))
492 {
493 Status = STATUS_BUFFER_OVERFLOW;
494 break;
495 }
496 // FIXME: convert to UNICODE if Unicode == FALSE
497 memcpy(Buffer, Hist->Entries[i].Buffer, Hist->Entries[i].Length);
498 Buffer += Hist->Entries[i].Length;
499 *(PWCHAR)Buffer = L'\0';
500 Buffer += sizeof(WCHAR);
501
502 // {
503 // WideCharToMultiByte(CP_ACP, 0,
504 // GetCommandHistoryRequest->History,
505 // GetCommandHistoryRequest->HistoryLength / sizeof(WCHAR),
506 // lpHistory,
507 // cbHistory,
508 // NULL, NULL);
509 // }
510
511 }
512 }
513 // FIXME: convert to UNICODE if Unicode == FALSE
514 GetCommandHistoryRequest->HistoryLength = Buffer - (PBYTE)GetCommandHistoryRequest->History;
515
516 ConSrvReleaseConsole(Console, TRUE);
517 return Status;
518 }
519
520 CSR_API(SrvGetConsoleCommandHistoryLength)
521 {
522 NTSTATUS Status;
523 PCONSOLE_GETCOMMANDHISTORYLENGTH GetCommandHistoryLengthRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.GetCommandHistoryLengthRequest;
524 PCONSOLE Console;
525 PHISTORY_BUFFER Hist;
526 UNICODE_STRING ExeName;
527 ULONG Length = 0;
528 UINT i;
529
530 if (!CsrValidateMessageBuffer(ApiMessage,
531 (PVOID*)&GetCommandHistoryLengthRequest->ExeName,
532 GetCommandHistoryLengthRequest->ExeLength,
533 sizeof(BYTE)))
534 {
535 return STATUS_INVALID_PARAMETER;
536 }
537
538 Status = ConSrvGetConsole(ConsoleGetPerProcessData(CsrGetClientThread()->Process), &Console, TRUE);
539 if (!NT_SUCCESS(Status)) return Status;
540
541 // FIXME: convert to UNICODE if Unicode(2) == FALSE
542 ExeName.Length = ExeName.MaximumLength = GetCommandHistoryLengthRequest->ExeLength;
543 ExeName.Buffer = GetCommandHistoryLengthRequest->ExeName;
544
545 Hist = HistoryFindBuffer(Console, &ExeName);
546 if (Hist)
547 {
548 for (i = 0; i < Hist->NumEntries; i++)
549 Length += Hist->Entries[i].Length + sizeof(WCHAR);
550 }
551 GetCommandHistoryLengthRequest->HistoryLength = Length;
552
553 /*
554 * Quick and dirty way of getting the number of bytes of the
555 * corresponding ANSI string from the one in UNICODE.
556 */
557 if (!GetCommandHistoryLengthRequest->Unicode)
558 GetCommandHistoryLengthRequest->HistoryLength /= sizeof(WCHAR);
559
560 ConSrvReleaseConsole(Console, TRUE);
561 return Status;
562 }
563
564 CSR_API(SrvExpungeConsoleCommandHistory)
565 {
566 NTSTATUS Status;
567 PCONSOLE_EXPUNGECOMMANDHISTORY ExpungeCommandHistoryRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.ExpungeCommandHistoryRequest;
568 PCONSOLE Console;
569 PHISTORY_BUFFER Hist;
570 UNICODE_STRING ExeName;
571
572 if (!CsrValidateMessageBuffer(ApiMessage,
573 (PVOID*)&ExpungeCommandHistoryRequest->ExeName,
574 ExpungeCommandHistoryRequest->ExeLength,
575 sizeof(BYTE)))
576 {
577 return STATUS_INVALID_PARAMETER;
578 }
579
580 Status = ConSrvGetConsole(ConsoleGetPerProcessData(CsrGetClientThread()->Process), &Console, TRUE);
581 if (!NT_SUCCESS(Status)) return Status;
582
583 // FIXME: convert to UNICODE if Unicode(2) == FALSE
584 ExeName.Length = ExeName.MaximumLength = ExpungeCommandHistoryRequest->ExeLength;
585 ExeName.Buffer = ExpungeCommandHistoryRequest->ExeName;
586
587 Hist = HistoryFindBuffer(Console, &ExeName);
588 HistoryDeleteBuffer(Hist);
589
590 ConSrvReleaseConsole(Console, TRUE);
591 return Status;
592 }
593
594 CSR_API(SrvSetConsoleNumberOfCommands)
595 {
596 NTSTATUS Status;
597 PCONSOLE_SETHISTORYNUMBERCOMMANDS SetHistoryNumberCommandsRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.SetHistoryNumberCommandsRequest;
598 PCONSOLE Console;
599 PHISTORY_BUFFER Hist;
600 UINT MaxEntries = SetHistoryNumberCommandsRequest->NumCommands;
601 UNICODE_STRING ExeName;
602 PUNICODE_STRING OldEntryList, NewEntryList;
603
604 if (!CsrValidateMessageBuffer(ApiMessage,
605 (PVOID*)&SetHistoryNumberCommandsRequest->ExeName,
606 SetHistoryNumberCommandsRequest->ExeLength,
607 sizeof(BYTE)))
608 {
609 return STATUS_INVALID_PARAMETER;
610 }
611
612 Status = ConSrvGetConsole(ConsoleGetPerProcessData(CsrGetClientThread()->Process), &Console, TRUE);
613 if (!NT_SUCCESS(Status)) return Status;
614
615 // FIXME: convert to UNICODE if Unicode(2) == FALSE
616 ExeName.Length = ExeName.MaximumLength = SetHistoryNumberCommandsRequest->ExeLength;
617 ExeName.Buffer = SetHistoryNumberCommandsRequest->ExeName;
618
619 Hist = HistoryFindBuffer(Console, &ExeName);
620 if (Hist)
621 {
622 OldEntryList = Hist->Entries;
623 NewEntryList = ConsoleAllocHeap(0, MaxEntries * sizeof(UNICODE_STRING));
624 if (!NewEntryList)
625 {
626 Status = STATUS_NO_MEMORY;
627 }
628 else
629 {
630 /* If necessary, shrink by removing oldest entries */
631 for (; Hist->NumEntries > MaxEntries; Hist->NumEntries--)
632 {
633 RtlFreeUnicodeString(Hist->Entries++);
634 Hist->Position += (Hist->Position == 0);
635 }
636
637 Hist->MaxEntries = MaxEntries;
638 Hist->Entries = memcpy(NewEntryList, Hist->Entries,
639 Hist->NumEntries * sizeof(UNICODE_STRING));
640 ConsoleFreeHeap(OldEntryList);
641 }
642 }
643
644 ConSrvReleaseConsole(Console, TRUE);
645 return Status;
646 }
647
648 CSR_API(SrvGetConsoleHistory)
649 {
650 PCONSOLE_GETSETHISTORYINFO HistoryInfoRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.HistoryInfoRequest;
651 PCONSOLE Console;
652 NTSTATUS Status = ConSrvGetConsole(ConsoleGetPerProcessData(CsrGetClientThread()->Process), &Console, TRUE);
653 if (NT_SUCCESS(Status))
654 {
655 HistoryInfoRequest->HistoryBufferSize = Console->HistoryBufferSize;
656 HistoryInfoRequest->NumberOfHistoryBuffers = Console->NumberOfHistoryBuffers;
657 HistoryInfoRequest->dwFlags = Console->HistoryNoDup;
658 ConSrvReleaseConsole(Console, TRUE);
659 }
660 return Status;
661 }
662
663 CSR_API(SrvSetConsoleHistory)
664 {
665 PCONSOLE_GETSETHISTORYINFO HistoryInfoRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.HistoryInfoRequest;
666 PCONSOLE Console;
667 NTSTATUS Status = ConSrvGetConsole(ConsoleGetPerProcessData(CsrGetClientThread()->Process), &Console, TRUE);
668 if (NT_SUCCESS(Status))
669 {
670 Console->HistoryBufferSize = HistoryInfoRequest->HistoryBufferSize;
671 Console->NumberOfHistoryBuffers = HistoryInfoRequest->NumberOfHistoryBuffers;
672 Console->HistoryNoDup = HistoryInfoRequest->dwFlags & HISTORY_NO_DUP_FLAG;
673 ConSrvReleaseConsole(Console, TRUE);
674 }
675 return Status;
676 }
677
678 CSR_API(SrvSetConsoleCommandHistoryMode)
679 {
680 NTSTATUS Status;
681 PCONSOLE_SETHISTORYMODE SetHistoryModeRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.SetHistoryModeRequest;
682 PCONSOLE Console;
683
684 DPRINT1("SrvSetConsoleCommandHistoryMode(Mode = %d) is not yet implemented\n",
685 SetHistoryModeRequest->Mode);
686
687 Status = ConSrvGetConsole(ConsoleGetPerProcessData(CsrGetClientThread()->Process), &Console, TRUE);
688 if (!NT_SUCCESS(Status)) return Status;
689
690 /* This API is not yet implemented */
691 Status = STATUS_NOT_IMPLEMENTED;
692
693 ConSrvReleaseConsole(Console, TRUE);
694 return Status;
695 }
696
697 /* EOF */