win32ss/user/winsrv/consrv/coninput.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Console Server DLL
   4  * FILE:            win32ss/user/winsrv/consrv/coninput.c
   5  * PURPOSE:         Console Input functions
   6  * PROGRAMMERS:     Jeffrey Morlan
   7  *                  Hermes Belusca-Maito (hermes.belusca@sfr.fr)
   8  */
   9
  10 /* INCLUDES *******************************************************************/
  11
  12 #include "consrv.h"
  13
  14 #define NDEBUG
  15 #include <debug.h>
  16
  17 /* GLOBALS ********************************************************************/
  18
  19 #define ConSrvGetInputBuffer(ProcessData, Handle, Ptr, Access, LockConsole)     \
  20     ConSrvGetObject((ProcessData), (Handle), (PCONSOLE_IO_OBJECT*)(Ptr), NULL,  \
  21                     (Access), (LockConsole), INPUT_BUFFER)
  22 #define ConSrvGetInputBufferAndHandleEntry(ProcessData, Handle, Ptr, Entry, Access, LockConsole)    \
  23     ConSrvGetObject((ProcessData), (Handle), (PCONSOLE_IO_OBJECT*)(Ptr), (Entry),                   \
  24                     (Access), (LockConsole), INPUT_BUFFER)
  25 #define ConSrvReleaseInputBuffer(Buff, IsConsoleLocked) \
  26     ConSrvReleaseObject(&(Buff)->Header, (IsConsoleLocked))
  27
  28
  29 /*
  30  * From MSDN:
  31  * "The lpMultiByteStr and lpWideCharStr pointers must not be the same.
  32  *  If they are the same, the function fails, and GetLastError returns
  33  *  ERROR_INVALID_PARAMETER."
  34  */
  35 #define ConsoleInputUnicodeToAnsiChar(Console, dChar, sWChar) \
  36     ASSERT((ULONG_PTR)dChar != (ULONG_PTR)sWChar); \
  37     WideCharToMultiByte((Console)->InputCodePage, 0, (sWChar), 1, (dChar), 1, NULL, NULL)
  38
  39 #define ConsoleInputAnsiToUnicodeChar(Console, dWChar, sChar) \
  40     ASSERT((ULONG_PTR)dWChar != (ULONG_PTR)sChar); \
  41     MultiByteToWideChar((Console)->InputCodePage, 0, (sChar), 1, (dWChar), 1)
  42
  43
  44 typedef struct _GET_INPUT_INFO
  45 {
  46     PCSR_THREAD           CallingThread;    // The thread which called the input API.
  47     PVOID                 HandleEntry;      // The handle data associated with the wait thread.
  48     PCONSOLE_INPUT_BUFFER InputBuffer;      // The input buffer corresponding to the handle.
  49 } GET_INPUT_INFO, *PGET_INPUT_INFO;
  50
  51
  52 /* PRIVATE FUNCTIONS **********************************************************/
  53
  54 static VOID
  55 ConioInputEventToAnsi(PCONSOLE Console, PINPUT_RECORD InputEvent)
  56 {
  57     if (InputEvent->EventType == KEY_EVENT)
  58     {
  59         WCHAR UnicodeChar = InputEvent->Event.KeyEvent.uChar.UnicodeChar;
  60         InputEvent->Event.KeyEvent.uChar.UnicodeChar = 0;
  61         ConsoleInputUnicodeToAnsiChar(Console,
  62                                       &InputEvent->Event.KeyEvent.uChar.AsciiChar,
  63                                       &UnicodeChar);
  64     }
  65 }
  66
  67 static VOID
  68 ConioInputEventToUnicode(PCONSOLE Console, PINPUT_RECORD InputEvent)
  69 {
  70     if (InputEvent->EventType == KEY_EVENT)
  71     {
  72         CHAR AsciiChar = InputEvent->Event.KeyEvent.uChar.AsciiChar;
  73         InputEvent->Event.KeyEvent.uChar.AsciiChar = 0;
  74         ConsoleInputAnsiToUnicodeChar(Console,
  75                                       &InputEvent->Event.KeyEvent.uChar.UnicodeChar,
  76                                       &AsciiChar);
  77     }
  78 }
  79
  80 static ULONG
  81 PreprocessInput(PCONSRV_CONSOLE Console,
  82                 PINPUT_RECORD InputEvent,
  83                 ULONG NumEventsToWrite)
  84 {
  85     ULONG NumEvents;
  86
  87     /*
  88      * Loop each event, and for each, check for pause or unpause
  89      * and perform adequate behaviour.
  90      */
  91     for (NumEvents = NumEventsToWrite; NumEvents > 0; --NumEvents)
  92     {
  93         /* Check for pause or unpause */
  94         if (InputEvent->EventType == KEY_EVENT && InputEvent->Event.KeyEvent.bKeyDown)
  95         {
  96             WORD vk = InputEvent->Event.KeyEvent.wVirtualKeyCode;
  97             if (!(Console->PauseFlags & PAUSED_FROM_KEYBOARD))
  98             {
  99                 DWORD cks = InputEvent->Event.KeyEvent.dwControlKeyState;
 100                 if (Console->InputBuffer.Mode & ENABLE_LINE_INPUT &&
 101                     (vk == VK_PAUSE ||
 102                     (vk == 'S' && (cks & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED)) &&
 103                                  !(cks & (LEFT_ALT_PRESSED  | RIGHT_ALT_PRESSED)))))
 104                 {
 105                     ConioPause(Console, PAUSED_FROM_KEYBOARD);
 106
 107                     /* Skip the event */
 108                     RtlMoveMemory(InputEvent,
 109                                   InputEvent + 1,
 110                                   (NumEvents - 1) * sizeof(INPUT_RECORD));
 111                     --NumEventsToWrite;
 112                     continue;
 113                 }
 114             }
 115             else
 116             {
 117                 if ((vk < VK_SHIFT || vk > VK_CAPITAL) && vk != VK_LWIN &&
 118                     vk != VK_RWIN && vk != VK_NUMLOCK && vk != VK_SCROLL)
 119                 {
 120                     ConioUnpause(Console, PAUSED_FROM_KEYBOARD);
 121
 122                     /* Skip the event */
 123                     RtlMoveMemory(InputEvent,
 124                                   InputEvent + 1,
 125                                   (NumEvents - 1) * sizeof(INPUT_RECORD));
 126                     --NumEventsToWrite;
 127                     continue;
 128                 }
 129             }
 130         }
 131
 132         /* Go to the next event */
 133         ++InputEvent;
 134     }
 135
 136     return NumEventsToWrite;
 137 }
 138
 139 static VOID
 140 PostprocessInput(PCONSRV_CONSOLE Console)
 141 {
 142     CsrNotifyWait(&Console->ReadWaitQueue,
 143                   FALSE,
 144                   NULL,
 145                   NULL);
 146     if (!IsListEmpty(&Console->ReadWaitQueue))
 147     {
 148         CsrDereferenceWait(&Console->ReadWaitQueue);
 149     }
 150 }
 151
 152
 153 NTSTATUS NTAPI
 154 ConDrvWriteConsoleInput(IN PCONSOLE Console,
 155                         IN PCONSOLE_INPUT_BUFFER InputBuffer,
 156                         IN BOOLEAN AppendToEnd,
 157                         IN PINPUT_RECORD InputRecord,
 158                         IN ULONG NumEventsToWrite,
 159                         OUT PULONG NumEventsWritten OPTIONAL);
 160 static NTSTATUS
 161 ConioAddInputEvents(PCONSRV_CONSOLE Console,
 162                     PINPUT_RECORD InputRecords, // InputEvent
 163                     ULONG NumEventsToWrite,
 164                     PULONG NumEventsWritten,
 165                     BOOLEAN AppendToEnd)
 166 {
 167     NTSTATUS Status = STATUS_SUCCESS;
 168
 169     if (NumEventsWritten) *NumEventsWritten = 0;
 170
 171     NumEventsToWrite = PreprocessInput(Console, InputRecords, NumEventsToWrite);
 172     if (NumEventsToWrite == 0) return STATUS_SUCCESS;
 173
 174     // Status = ConDrvAddInputEvents(Console,
 175                                   // InputRecords,
 176                                   // NumEventsToWrite,
 177                                   // NumEventsWritten,
 178                                   // AppendToEnd);
 179
 180     Status = ConDrvWriteConsoleInput((PCONSOLE)Console,
 181                                      &Console->InputBuffer,
 182                                      AppendToEnd,
 183                                      InputRecords,
 184                                      NumEventsToWrite,
 185                                      NumEventsWritten);
 186
 187     // if (NT_SUCCESS(Status))
 188     if (Status == STATUS_SUCCESS) PostprocessInput(Console);
 189
 190     return Status;
 191 }
 192
 193 /* FIXME: This function can be called by CONDRV, in ConioResizeBuffer() in text.c */
 194 NTSTATUS
 195 ConioProcessInputEvent(PCONSRV_CONSOLE Console,
 196                        PINPUT_RECORD InputEvent)
 197 {
 198     ULONG NumEventsWritten;
 199     return ConioAddInputEvents(Console,
 200                                InputEvent,
 201                                1,
 202                                &NumEventsWritten,
 203                                TRUE);
 204 }
 205
 206
 207 static NTSTATUS
 208 WaitBeforeReading(IN PGET_INPUT_INFO InputInfo,
 209                   IN PCSR_API_MESSAGE ApiMessage,
 210                   IN CSR_WAIT_FUNCTION WaitFunction OPTIONAL,
 211                   IN BOOLEAN CreateWaitBlock OPTIONAL)
 212 {
 213     if (CreateWaitBlock)
 214     {
 215         PGET_INPUT_INFO CapturedInputInfo;
 216         PCONSRV_CONSOLE Console = (PCONSRV_CONSOLE)InputInfo->InputBuffer->Header.Console;
 217
 218         CapturedInputInfo = ConsoleAllocHeap(0, sizeof(GET_INPUT_INFO));
 219         if (!CapturedInputInfo) return STATUS_NO_MEMORY;
 220
 221         RtlMoveMemory(CapturedInputInfo, InputInfo, sizeof(GET_INPUT_INFO));
 222
 223         if (!CsrCreateWait(&Console->ReadWaitQueue,
 224                            WaitFunction,
 225                            InputInfo->CallingThread,
 226                            ApiMessage,
 227                            CapturedInputInfo))
 228         {
 229             ConsoleFreeHeap(CapturedInputInfo);
 230             return STATUS_NO_MEMORY;
 231         }
 232     }
 233
 234     /* Wait for input */
 235     return STATUS_PENDING;
 236 }
 237
 238 static NTSTATUS
 239 ReadChars(IN PGET_INPUT_INFO InputInfo,
 240           IN PCSR_API_MESSAGE ApiMessage,
 241           IN BOOLEAN CreateWaitBlock OPTIONAL);
 242
 243 // Wait function CSR_WAIT_FUNCTION
 244 static BOOLEAN
 245 NTAPI
 246 ReadCharsThread(IN PLIST_ENTRY WaitList,
 247                 IN PCSR_THREAD WaitThread,
 248                 IN PCSR_API_MESSAGE WaitApiMessage,
 249                 IN PVOID WaitContext,
 250                 IN PVOID WaitArgument1,
 251                 IN PVOID WaitArgument2,
 252                 IN ULONG WaitFlags)
 253 {
 254     NTSTATUS Status;
 255     PGET_INPUT_INFO InputInfo = (PGET_INPUT_INFO)WaitContext;
 256
 257     PVOID InputHandle = WaitArgument2;
 258
 259     DPRINT("ReadCharsThread - WaitContext = 0x%p, WaitArgument1 = 0x%p, WaitArgument2 = 0x%p, WaitFlags = %lu\n", WaitContext, WaitArgument1, WaitArgument2, WaitFlags);
 260
 261     /*
 262      * If we are notified of the process termination via a call
 263      * to CsrNotifyWaitBlock triggered by CsrDestroyProcess or
 264      * CsrDestroyThread, just return.
 265      */
 266     if (WaitFlags & CsrProcessTerminating)
 267     {
 268         Status = STATUS_THREAD_IS_TERMINATING;
 269         goto Quit;
 270     }
 271
 272     /*
 273      * Somebody is closing a handle to this input buffer,
 274      * by calling ConSrvCloseHandleEntry.
 275      * See whether we are linked to that handle (ie. we
 276      * are a waiter for this handle), and if so, return.
 277      * Otherwise, ignore the call and continue waiting.
 278      */
 279     if (InputHandle != NULL)
 280     {
 281         Status = (InputHandle == InputInfo->HandleEntry ? STATUS_ALERTED
 282                                                         : STATUS_PENDING);
 283         goto Quit;
 284     }
 285
 286     /*
 287      * If we go there, that means we are notified for some new input.
 288      * The console is therefore already locked.
 289      */
 290     Status = ReadChars(InputInfo, WaitApiMessage, FALSE);
 291
 292 Quit:
 293     if (Status != STATUS_PENDING)
 294     {
 295         WaitApiMessage->Status = Status;
 296         ConsoleFreeHeap(InputInfo);
 297     }
 298
 299     return (Status == STATUS_PENDING ? FALSE : TRUE);
 300 }
 301
 302 NTSTATUS NTAPI
 303 ConDrvReadConsole(IN PCONSOLE Console,
 304                   IN PCONSOLE_INPUT_BUFFER InputBuffer,
 305                   /**/IN PUNICODE_STRING ExeName /**/OPTIONAL/**/,/**/
 306                   IN BOOLEAN Unicode,
 307                   OUT PVOID Buffer,
 308                   IN OUT PCONSOLE_READCONSOLE_CONTROL ReadControl,
 309                   IN ULONG NumCharsToRead,
 310                   OUT PULONG NumCharsRead OPTIONAL);
 311 static NTSTATUS
 312 ReadChars(IN PGET_INPUT_INFO InputInfo,
 313           IN PCSR_API_MESSAGE ApiMessage,
 314           IN BOOLEAN CreateWaitBlock OPTIONAL)
 315 {
 316     NTSTATUS Status;
 317     PCONSOLE_READCONSOLE ReadConsoleRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.ReadConsoleRequest;
 318     PCONSOLE_INPUT_BUFFER InputBuffer = InputInfo->InputBuffer;
 319     CONSOLE_READCONSOLE_CONTROL ReadControl;
 320
 321     UNICODE_STRING ExeName;
 322
 323     PVOID Buffer;
 324     ULONG NrCharactersRead = 0;
 325     ULONG CharSize = (ReadConsoleRequest->Unicode ? sizeof(WCHAR) : sizeof(CHAR));
 326
 327     /* Compute the executable name, if needed */
 328     if (ReadConsoleRequest->InitialNumBytes == 0 &&
 329         ReadConsoleRequest->ExeLength <= sizeof(ReadConsoleRequest->StaticBuffer))
 330     {
 331         ExeName.Length = ExeName.MaximumLength = ReadConsoleRequest->ExeLength;
 332         ExeName.Buffer = (PWCHAR)ReadConsoleRequest->StaticBuffer;
 333     }
 334     else
 335     {
 336         ExeName.Length = ExeName.MaximumLength = 0;
 337         ExeName.Buffer = NULL;
 338     }
 339
 340     /* Build the ReadControl structure */
 341     ReadControl.nLength           = sizeof(CONSOLE_READCONSOLE_CONTROL);
 342     ReadControl.nInitialChars     = ReadConsoleRequest->InitialNumBytes / CharSize;
 343     ReadControl.dwCtrlWakeupMask  = ReadConsoleRequest->CtrlWakeupMask;
 344     ReadControl.dwControlKeyState = ReadConsoleRequest->ControlKeyState;
 345
 346     /*
 347      * For optimization purposes, Windows (and hence ReactOS, too, for
 348      * compatibility reasons) uses a static buffer if no more than eighty
 349      * bytes are read. Otherwise a new buffer is used.
 350      * The client-side expects that we know this behaviour.
 351      */
 352     if (ReadConsoleRequest->CaptureBufferSize <= sizeof(ReadConsoleRequest->StaticBuffer))
 353     {
 354         /*
 355          * Adjust the internal pointer, because its old value points to
 356          * the static buffer in the original ApiMessage structure.
 357          */
 358         // ReadConsoleRequest->Buffer = ReadConsoleRequest->StaticBuffer;
 359         Buffer = ReadConsoleRequest->StaticBuffer;
 360     }
 361     else
 362     {
 363         Buffer = ReadConsoleRequest->Buffer;
 364     }
 365
 366     DPRINT("Calling ConDrvReadConsole(%wZ)\n", &ExeName);
 367     Status = ConDrvReadConsole(InputBuffer->Header.Console,
 368                                InputBuffer,
 369                                &ExeName,
 370                                ReadConsoleRequest->Unicode,
 371                                Buffer,
 372                                &ReadControl,
 373                                ReadConsoleRequest->NumBytes / CharSize, // NrCharactersToRead
 374                                &NrCharactersRead);
 375     DPRINT("ConDrvReadConsole returned (%d ; Status = 0x%08x)\n",
 376            NrCharactersRead, Status);
 377
 378     // ReadConsoleRequest->ControlKeyState = ReadControl.dwControlKeyState;
 379
 380     if (Status == STATUS_PENDING)
 381     {
 382         /* We haven't completed a read, so start a wait */
 383         return WaitBeforeReading(InputInfo,
 384                                  ApiMessage,
 385                                  ReadCharsThread,
 386                                  CreateWaitBlock);
 387     }
 388     else
 389     {
 390         /*
 391          * We read all what we wanted. Set the number of bytes read and
 392          * return the error code we were given.
 393          */
 394         ReadConsoleRequest->NumBytes = NrCharactersRead * CharSize;
 395         ReadConsoleRequest->ControlKeyState = ReadControl.dwControlKeyState;
 396
 397         return Status;
 398         // return STATUS_SUCCESS;
 399     }
 400 }
 401
 402 static NTSTATUS
 403 ReadInputBuffer(IN PGET_INPUT_INFO InputInfo,
 404                 IN PCSR_API_MESSAGE ApiMessage,
 405                 IN BOOLEAN CreateWaitBlock OPTIONAL);
 406
 407 // Wait function CSR_WAIT_FUNCTION
 408 static BOOLEAN
 409 NTAPI
 410 ReadInputBufferThread(IN PLIST_ENTRY WaitList,
 411                       IN PCSR_THREAD WaitThread,
 412                       IN PCSR_API_MESSAGE WaitApiMessage,
 413                       IN PVOID WaitContext,
 414                       IN PVOID WaitArgument1,
 415                       IN PVOID WaitArgument2,
 416                       IN ULONG WaitFlags)
 417 {
 418     NTSTATUS Status;
 419     PGET_INPUT_INFO InputInfo = (PGET_INPUT_INFO)WaitContext;
 420
 421     PVOID InputHandle = WaitArgument2;
 422
 423     DPRINT("ReadInputBufferThread - WaitContext = 0x%p, WaitArgument1 = 0x%p, WaitArgument2 = 0x%p, WaitFlags = %lu\n", WaitContext, WaitArgument1, WaitArgument2, WaitFlags);
 424
 425     /*
 426      * If we are notified of the process termination via a call
 427      * to CsrNotifyWaitBlock triggered by CsrDestroyProcess or
 428      * CsrDestroyThread, just return.
 429      */
 430     if (WaitFlags & CsrProcessTerminating)
 431     {
 432         Status = STATUS_THREAD_IS_TERMINATING;
 433         goto Quit;
 434     }
 435
 436     /*
 437      * Somebody is closing a handle to this input buffer,
 438      * by calling ConSrvCloseHandleEntry.
 439      * See whether we are linked to that handle (ie. we
 440      * are a waiter for this handle), and if so, return.
 441      * Otherwise, ignore the call and continue waiting.
 442      */
 443     if (InputHandle != NULL)
 444     {
 445         Status = (InputHandle == InputInfo->HandleEntry ? STATUS_ALERTED
 446                                                         : STATUS_PENDING);
 447         goto Quit;
 448     }
 449
 450     /*
 451      * If we go there, that means we are notified for some new input.
 452      * The console is therefore already locked.
 453      */
 454     Status = ReadInputBuffer(InputInfo, WaitApiMessage, FALSE);
 455
 456 Quit:
 457     if (Status != STATUS_PENDING)
 458     {
 459         WaitApiMessage->Status = Status;
 460         ConsoleFreeHeap(InputInfo);
 461     }
 462
 463     return (Status == STATUS_PENDING ? FALSE : TRUE);
 464 }
 465
 466 NTSTATUS NTAPI
 467 ConDrvGetConsoleInput(IN PCONSOLE Console,
 468                       IN PCONSOLE_INPUT_BUFFER InputBuffer,
 469                       IN BOOLEAN KeepEvents,
 470                       IN BOOLEAN WaitForMoreEvents,
 471                       OUT PINPUT_RECORD InputRecord,
 472                       IN ULONG NumEventsToRead,
 473                       OUT PULONG NumEventsRead OPTIONAL);
 474 static NTSTATUS
 475 ReadInputBuffer(IN PGET_INPUT_INFO InputInfo,
 476                 IN PCSR_API_MESSAGE ApiMessage,
 477                 IN BOOLEAN CreateWaitBlock OPTIONAL)
 478 {
 479     NTSTATUS Status;
 480     PCONSOLE_GETINPUT GetInputRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.GetInputRequest;
 481     PCONSOLE_INPUT_BUFFER InputBuffer = InputInfo->InputBuffer;
 482     ULONG NumEventsRead;
 483
 484     PINPUT_RECORD InputRecord;
 485
 486     /*
 487      * For optimization purposes, Windows (and hence ReactOS, too, for
 488      * compatibility reasons) uses a static buffer if no more than five
 489      * input records are read. Otherwise a new buffer is used.
 490      * The client-side expects that we know this behaviour.
 491      */
 492     if (GetInputRequest->NumRecords <= sizeof(GetInputRequest->RecordStaticBuffer)/sizeof(INPUT_RECORD))
 493     {
 494         /*
 495          * Adjust the internal pointer, because its old value points to
 496          * the static buffer in the original ApiMessage structure.
 497          */
 498         // GetInputRequest->RecordBufPtr = GetInputRequest->RecordStaticBuffer;
 499         InputRecord = GetInputRequest->RecordStaticBuffer;
 500     }
 501     else
 502     {
 503         InputRecord = GetInputRequest->RecordBufPtr;
 504     }
 505
 506     NumEventsRead = 0;
 507     Status = ConDrvGetConsoleInput(InputBuffer->Header.Console,
 508                                    InputBuffer,
 509                                    (GetInputRequest->Flags & CONSOLE_READ_KEEPEVENT) != 0,
 510                                    (GetInputRequest->Flags & CONSOLE_READ_CONTINUE ) == 0,
 511                                    InputRecord,
 512                                    GetInputRequest->NumRecords,
 513                                    &NumEventsRead);
 514
 515     if (Status == STATUS_PENDING)
 516     {
 517         /* We haven't completed a read, so start a wait */
 518         return WaitBeforeReading(InputInfo,
 519                                  ApiMessage,
 520                                  ReadInputBufferThread,
 521                                  CreateWaitBlock);
 522     }
 523     else
 524     {
 525         /*
 526          * We read all what we wanted. Set the number of events read and
 527          * return the error code we were given.
 528          */
 529         GetInputRequest->NumRecords = NumEventsRead;
 530
 531         if (NT_SUCCESS(Status))
 532         {
 533             /* Now translate everything to ANSI */
 534             if (!GetInputRequest->Unicode)
 535             {
 536                 for (; NumEventsRead > 0; --NumEventsRead)
 537                 {
 538                     ConioInputEventToAnsi(InputBuffer->Header.Console, --InputRecord);
 539                 }
 540             }
 541         }
 542
 543         return Status;
 544         // return STATUS_SUCCESS;
 545     }
 546 }
 547
 548
 549 /* PUBLIC SERVER APIS *********************************************************/
 550
 551 CSR_API(SrvReadConsole)
 552 {
 553     NTSTATUS Status;
 554     PCONSOLE_READCONSOLE ReadConsoleRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.ReadConsoleRequest;
 555     PCONSOLE_PROCESS_DATA ProcessData = ConsoleGetPerProcessData(CsrGetClientThread()->Process);
 556     PVOID HandleEntry;
 557     PCONSOLE_INPUT_BUFFER InputBuffer;
 558     GET_INPUT_INFO InputInfo;
 559
 560     DPRINT("SrvReadConsole\n");
 561
 562     /*
 563      * For optimization purposes, Windows (and hence ReactOS, too, for
 564      * compatibility reasons) uses a static buffer if no more than eighty
 565      * bytes are read. Otherwise a new buffer is used.
 566      * The client-side expects that we know this behaviour.
 567      */
 568     if (ReadConsoleRequest->CaptureBufferSize <= sizeof(ReadConsoleRequest->StaticBuffer))
 569     {
 570         /*
 571          * Adjust the internal pointer, because its old value points to
 572          * the static buffer in the original ApiMessage structure.
 573          */
 574         // ReadConsoleRequest->Buffer = ReadConsoleRequest->StaticBuffer;
 575     }
 576     else
 577     {
 578         if (!CsrValidateMessageBuffer(ApiMessage,
 579                                       (PVOID*)&ReadConsoleRequest->Buffer,
 580                                       ReadConsoleRequest->CaptureBufferSize,
 581                                       sizeof(BYTE)))
 582         {
 583             return STATUS_INVALID_PARAMETER;
 584         }
 585     }
 586
 587     if (ReadConsoleRequest->InitialNumBytes > ReadConsoleRequest->NumBytes)
 588     {
 589         return STATUS_INVALID_PARAMETER;
 590     }
 591
 592     Status = ConSrvGetInputBufferAndHandleEntry(ProcessData, ReadConsoleRequest->InputHandle, &InputBuffer, &HandleEntry, GENERIC_READ, TRUE);
 593     if (!NT_SUCCESS(Status)) return Status;
 594
 595     InputInfo.CallingThread = CsrGetClientThread();
 596     InputInfo.HandleEntry   = HandleEntry;
 597     InputInfo.InputBuffer   = InputBuffer;
 598
 599     Status = ReadChars(&InputInfo, ApiMessage, TRUE);
 600
 601     ConSrvReleaseInputBuffer(InputBuffer, TRUE);
 602
 603     if (Status == STATUS_PENDING) *ReplyCode = CsrReplyPending;
 604
 605     return Status;
 606 }
 607
 608 CSR_API(SrvGetConsoleInput)
 609 {
 610     NTSTATUS Status;
 611     PCONSOLE_GETINPUT GetInputRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.GetInputRequest;
 612     PCONSOLE_PROCESS_DATA ProcessData = ConsoleGetPerProcessData(CsrGetClientThread()->Process);
 613     PVOID HandleEntry;
 614     PCONSOLE_INPUT_BUFFER InputBuffer;
 615     GET_INPUT_INFO InputInfo;
 616
 617     DPRINT("SrvGetConsoleInput\n");
 618
 619     if (GetInputRequest->Flags & ~(CONSOLE_READ_KEEPEVENT | CONSOLE_READ_CONTINUE))
 620         return STATUS_INVALID_PARAMETER;
 621
 622     /*
 623      * For optimization purposes, Windows (and hence ReactOS, too, for
 624      * compatibility reasons) uses a static buffer if no more than five
 625      * input records are read. Otherwise a new buffer is used.
 626      * The client-side expects that we know this behaviour.
 627      */
 628     if (GetInputRequest->NumRecords <= sizeof(GetInputRequest->RecordStaticBuffer)/sizeof(INPUT_RECORD))
 629     {
 630         /*
 631          * Adjust the internal pointer, because its old value points to
 632          * the static buffer in the original ApiMessage structure.
 633          */
 634         // GetInputRequest->RecordBufPtr = GetInputRequest->RecordStaticBuffer;
 635     }
 636     else
 637     {
 638         if (!CsrValidateMessageBuffer(ApiMessage,
 639                                       (PVOID*)&GetInputRequest->RecordBufPtr,
 640                                       GetInputRequest->NumRecords,
 641                                       sizeof(INPUT_RECORD)))
 642         {
 643             return STATUS_INVALID_PARAMETER;
 644         }
 645     }
 646
 647     Status = ConSrvGetInputBufferAndHandleEntry(ProcessData, GetInputRequest->InputHandle, &InputBuffer, &HandleEntry, GENERIC_READ, TRUE);
 648     if (!NT_SUCCESS(Status)) return Status;
 649
 650     InputInfo.CallingThread = CsrGetClientThread();
 651     InputInfo.HandleEntry   = HandleEntry;
 652     InputInfo.InputBuffer   = InputBuffer;
 653
 654     Status = ReadInputBuffer(&InputInfo, ApiMessage, TRUE);
 655
 656     ConSrvReleaseInputBuffer(InputBuffer, TRUE);
 657
 658     if (Status == STATUS_PENDING) *ReplyCode = CsrReplyPending;
 659
 660     return Status;
 661 }
 662
 663 #if 0
 664 NTSTATUS NTAPI
 665 ConDrvWriteConsoleInput(IN PCONSOLE Console,
 666                         IN PCONSOLE_INPUT_BUFFER InputBuffer,
 667                         IN BOOLEAN AppendToEnd,
 668                         IN PINPUT_RECORD InputRecord,
 669                         IN ULONG NumEventsToWrite,
 670                         OUT PULONG NumEventsWritten OPTIONAL);
 671 #endif
 672 CSR_API(SrvWriteConsoleInput)
 673 {
 674     NTSTATUS Status;
 675     PCONSOLE_WRITEINPUT WriteInputRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.WriteInputRequest;
 676     PCONSOLE_INPUT_BUFFER InputBuffer;
 677     ULONG NumEventsWritten;
 678
 679     PINPUT_RECORD InputRecord;
 680
 681     DPRINT("SrvWriteConsoleInput\n");
 682
 683     /*
 684      * For optimization purposes, Windows (and hence ReactOS, too, for
 685      * compatibility reasons) uses a static buffer if no more than five
 686      * input records are written. Otherwise a new buffer is used.
 687      * The client-side expects that we know this behaviour.
 688      */
 689     if (WriteInputRequest->NumRecords <= sizeof(WriteInputRequest->RecordStaticBuffer)/sizeof(INPUT_RECORD))
 690     {
 691         /*
 692          * Adjust the internal pointer, because its old value points to
 693          * the static buffer in the original ApiMessage structure.
 694          */
 695         // WriteInputRequest->RecordBufPtr = WriteInputRequest->RecordStaticBuffer;
 696         InputRecord = WriteInputRequest->RecordStaticBuffer;
 697     }
 698     else
 699     {
 700         if (!CsrValidateMessageBuffer(ApiMessage,
 701                                       (PVOID*)&WriteInputRequest->RecordBufPtr,
 702                                       WriteInputRequest->NumRecords,
 703                                       sizeof(INPUT_RECORD)))
 704         {
 705             return STATUS_INVALID_PARAMETER;
 706         }
 707
 708         InputRecord = WriteInputRequest->RecordBufPtr;
 709     }
 710
 711     Status = ConSrvGetInputBuffer(ConsoleGetPerProcessData(CsrGetClientThread()->Process),
 712                                   WriteInputRequest->InputHandle,
 713                                   &InputBuffer, GENERIC_WRITE, TRUE);
 714     if (!NT_SUCCESS(Status))
 715     {
 716         WriteInputRequest->NumRecords = 0;
 717         return Status;
 718     }
 719
 720     /* First translate everything to UNICODE */
 721     if (!WriteInputRequest->Unicode)
 722     {
 723         ULONG i;
 724         for (i = 0; i < WriteInputRequest->NumRecords; ++i)
 725         {
 726             ConioInputEventToUnicode(InputBuffer->Header.Console, &InputRecord[i]);
 727         }
 728     }
 729
 730     /* Now, add the events */
 731     NumEventsWritten = 0;
 732     Status = ConioAddInputEvents((PCONSRV_CONSOLE)InputBuffer->Header.Console,
 733                                  // InputBuffer,
 734                                  InputRecord,
 735                                  WriteInputRequest->NumRecords,
 736                                  &NumEventsWritten,
 737                                  WriteInputRequest->AppendToEnd);
 738
 739     // Status = ConDrvWriteConsoleInput(InputBuffer->Header.Console,
 740                                      // InputBuffer,
 741                                      // WriteInputRequest->AppendToEnd,
 742                                      // InputRecord,
 743                                      // WriteInputRequest->NumRecords,
 744                                      // &NumEventsWritten);
 745
 746     WriteInputRequest->NumRecords = NumEventsWritten;
 747
 748     ConSrvReleaseInputBuffer(InputBuffer, TRUE);
 749     return Status;
 750 }
 751
 752 NTSTATUS NTAPI
 753 ConDrvFlushConsoleInputBuffer(IN PCONSOLE Console,
 754                               IN PCONSOLE_INPUT_BUFFER InputBuffer);
 755 CSR_API(SrvFlushConsoleInputBuffer)
 756 {
 757     NTSTATUS Status;
 758     PCONSOLE_FLUSHINPUTBUFFER FlushInputBufferRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.FlushInputBufferRequest;
 759     PCONSOLE_INPUT_BUFFER InputBuffer;
 760
 761     DPRINT("SrvFlushConsoleInputBuffer\n");
 762
 763     Status = ConSrvGetInputBuffer(ConsoleGetPerProcessData(CsrGetClientThread()->Process),
 764                                   FlushInputBufferRequest->InputHandle,
 765                                   &InputBuffer, GENERIC_WRITE, TRUE);
 766     if (!NT_SUCCESS(Status)) return Status;
 767
 768     Status = ConDrvFlushConsoleInputBuffer(InputBuffer->Header.Console,
 769                                            InputBuffer);
 770
 771     ConSrvReleaseInputBuffer(InputBuffer, TRUE);
 772     return Status;
 773 }
 774
 775 NTSTATUS NTAPI
 776 ConDrvGetConsoleNumberOfInputEvents(IN PCONSOLE Console,
 777                                     IN PCONSOLE_INPUT_BUFFER InputBuffer,
 778                                     OUT PULONG NumberOfEvents);
 779 CSR_API(SrvGetConsoleNumberOfInputEvents)
 780 {
 781     NTSTATUS Status;
 782     PCONSOLE_GETNUMINPUTEVENTS GetNumInputEventsRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.GetNumInputEventsRequest;
 783     PCONSOLE_INPUT_BUFFER InputBuffer;
 784
 785     DPRINT("SrvGetConsoleNumberOfInputEvents\n");
 786
 787     Status = ConSrvGetInputBuffer(ConsoleGetPerProcessData(CsrGetClientThread()->Process),
 788                                   GetNumInputEventsRequest->InputHandle,
 789                                   &InputBuffer, GENERIC_READ, TRUE);
 790     if (!NT_SUCCESS(Status)) return Status;
 791
 792     Status = ConDrvGetConsoleNumberOfInputEvents(InputBuffer->Header.Console,
 793                                                  InputBuffer,
 794                                                  &GetNumInputEventsRequest->NumberOfEvents);
 795
 796     ConSrvReleaseInputBuffer(InputBuffer, TRUE);
 797     return Status;
 798 }
 799
 800 /* EOF */