dll/win32/kernel32/client/console/readwrite.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS system libraries
   4  * FILE:            dll/win32/kernel32/client/console/readwrite.c
   5  * PURPOSE:         Win32 Console Client read-write functions
   6  * PROGRAMMERS:     Emanuele Aliberti
   7  *                  Marty Dill
   8  *                  Filip Navara (xnavara@volny.cz)
   9  *                  Thomas Weidenmueller (w3seek@reactos.org)
  10  *                  Jeffrey Morlan
  11  */
  12
  13 /* INCLUDES *******************************************************************/
  14
  15 #include <k32.h>
  16
  17 #define NDEBUG
  18 #include <debug.h>
  19
  20
  21 /* PRIVATE FUNCTIONS **********************************************************/
  22
  23 /******************
  24  * Read functions *
  25  ******************/
  26
  27 static
  28 BOOL
  29 IntReadConsole(HANDLE hConsoleInput,
  30                PVOID lpBuffer,
  31                DWORD nNumberOfCharsToRead,
  32                LPDWORD lpNumberOfCharsRead,
  33                PCONSOLE_READCONSOLE_CONTROL pInputControl,
  34                BOOL bUnicode)
  35 {
  36     NTSTATUS Status;
  37     CONSOLE_API_MESSAGE ApiMessage;
  38     PCONSOLE_READCONSOLE ReadConsoleRequest = &ApiMessage.Data.ReadConsoleRequest;
  39     PCSR_CAPTURE_BUFFER CaptureBuffer;
  40     ULONG CharSize;
  41
  42     /* Determine the needed size */
  43     CharSize = (bUnicode ? sizeof(WCHAR) : sizeof(CHAR));
  44     ReadConsoleRequest->BufferSize = nNumberOfCharsToRead * CharSize;
  45
  46     /* Allocate a Capture Buffer */
  47     CaptureBuffer = CsrAllocateCaptureBuffer(1, ReadConsoleRequest->BufferSize);
  48     if (CaptureBuffer == NULL)
  49     {
  50         DPRINT1("CsrAllocateCaptureBuffer failed!\n");
  51         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
  52         return FALSE;
  53     }
  54
  55     /* Allocate space in the Buffer */
  56     CsrAllocateMessagePointer(CaptureBuffer,
  57                               ReadConsoleRequest->BufferSize,
  58                               (PVOID*)&ReadConsoleRequest->Buffer);
  59
  60     /* Set up the data to send to the Console Server */
  61     ReadConsoleRequest->InputHandle = hConsoleInput;
  62     ReadConsoleRequest->Unicode = bUnicode;
  63     ReadConsoleRequest->NrCharactersToRead = (WORD)nNumberOfCharsToRead;
  64     ReadConsoleRequest->NrCharactersRead = 0;
  65     ReadConsoleRequest->CtrlWakeupMask = 0;
  66     if (pInputControl && pInputControl->nLength == sizeof(CONSOLE_READCONSOLE_CONTROL))
  67     {
  68         ReadConsoleRequest->NrCharactersRead = pInputControl->nInitialChars;
  69         memcpy(ReadConsoleRequest->Buffer,
  70                lpBuffer,
  71                pInputControl->nInitialChars * sizeof(WCHAR));
  72         ReadConsoleRequest->CtrlWakeupMask = pInputControl->dwCtrlWakeupMask;
  73     }
  74
  75     /* Call the server */
  76     Status = CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
  77                                  CaptureBuffer,
  78                                  CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepReadConsole),
  79                                  sizeof(CONSOLE_READCONSOLE));
  80
  81     /* Check for success */
  82     if (NT_SUCCESS(Status))
  83     {
  84         memcpy(lpBuffer,
  85                ReadConsoleRequest->Buffer,
  86                ReadConsoleRequest->NrCharactersRead * CharSize);
  87
  88         if (lpNumberOfCharsRead != NULL)
  89             *lpNumberOfCharsRead = ReadConsoleRequest->NrCharactersRead;
  90
  91         if (pInputControl && pInputControl->nLength == sizeof(CONSOLE_READCONSOLE_CONTROL))
  92             pInputControl->dwControlKeyState = ReadConsoleRequest->ControlKeyState;
  93     }
  94     else
  95     {
  96         DPRINT1("CSR returned error in ReadConsole\n");
  97
  98         if (lpNumberOfCharsRead != NULL)
  99             *lpNumberOfCharsRead = 0;
 100
 101         /* Error out */
 102         BaseSetLastNTError(Status);
 103     }
 104
 105     CsrFreeCaptureBuffer(CaptureBuffer);
 106
 107     /* Return TRUE or FALSE */
 108     // return TRUE;
 109     return (ReadConsoleRequest->NrCharactersRead > 0);
 110     // return NT_SUCCESS(Status);
 111 }
 112
 113
 114 static
 115 BOOL
 116 IntGetConsoleInput(HANDLE hConsoleInput,
 117                    BOOL bRead,
 118                    PINPUT_RECORD lpBuffer,
 119                    DWORD nLength,
 120                    LPDWORD lpNumberOfEventsRead,
 121                    BOOL bUnicode)
 122 {
 123     NTSTATUS Status;
 124     CONSOLE_API_MESSAGE ApiMessage;
 125     PCONSOLE_GETINPUT GetInputRequest = &ApiMessage.Data.GetInputRequest;
 126     PCSR_CAPTURE_BUFFER CaptureBuffer;
 127     ULONG Size;
 128
 129     if (lpBuffer == NULL)
 130     {
 131         SetLastError(ERROR_INVALID_PARAMETER);
 132         return FALSE;
 133     }
 134
 135     Size = nLength * sizeof(INPUT_RECORD);
 136
 137     DPRINT("IntGetConsoleInput: %lx %p\n", Size, lpNumberOfEventsRead);
 138
 139     /* Allocate a Capture Buffer */
 140     CaptureBuffer = CsrAllocateCaptureBuffer(1, Size);
 141     if (CaptureBuffer == NULL)
 142     {
 143         DPRINT1("CsrAllocateCaptureBuffer failed!\n");
 144         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 145         return FALSE;
 146     }
 147
 148     /* Allocate space in the Buffer */
 149     CsrAllocateMessagePointer(CaptureBuffer,
 150                               Size,
 151                               (PVOID*)&GetInputRequest->InputRecord);
 152
 153     /* Set up the data to send to the Console Server */
 154     GetInputRequest->InputHandle = hConsoleInput;
 155     GetInputRequest->Unicode = bUnicode;
 156     GetInputRequest->bRead = bRead;
 157     GetInputRequest->InputsRead = 0;
 158     GetInputRequest->Length = nLength;
 159
 160     /* Call the server */
 161     Status = CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
 162                                  CaptureBuffer,
 163                                  CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepGetConsoleInput),
 164                                  sizeof(CONSOLE_GETINPUT));
 165     DPRINT("Server returned: %x\n", Status);
 166
 167     /* Check for success */
 168     if (NT_SUCCESS(Status))
 169     {
 170         /* Return the number of events read */
 171         DPRINT("Events read: %lx\n", GetInputRequest->InputsRead);
 172
 173         if (lpNumberOfEventsRead != NULL)
 174             *lpNumberOfEventsRead = GetInputRequest->InputsRead;
 175
 176         /* Copy into the buffer */
 177         DPRINT("Copying to buffer\n");
 178         RtlCopyMemory(lpBuffer,
 179                       GetInputRequest->InputRecord,
 180                       sizeof(INPUT_RECORD) * GetInputRequest->InputsRead);
 181     }
 182     else
 183     {
 184         if (lpNumberOfEventsRead != NULL)
 185             *lpNumberOfEventsRead = 0;
 186
 187         /* Error out */
 188         BaseSetLastNTError(Status);
 189     }
 190
 191     /* Release the capture buffer */
 192     CsrFreeCaptureBuffer(CaptureBuffer);
 193
 194     /* Return TRUE or FALSE */
 195     return (GetInputRequest->InputsRead > 0);
 196     // return NT_SUCCESS(Status);
 197 }
 198
 199
 200 static
 201 BOOL
 202 IntReadConsoleOutput(HANDLE hConsoleOutput,
 203                      PCHAR_INFO lpBuffer,
 204                      COORD dwBufferSize,
 205                      COORD dwBufferCoord,
 206                      PSMALL_RECT lpReadRegion,
 207                      BOOL bUnicode)
 208 {
 209     CONSOLE_API_MESSAGE ApiMessage;
 210     PCONSOLE_READOUTPUT ReadOutputRequest = &ApiMessage.Data.ReadOutputRequest;
 211     PCSR_CAPTURE_BUFFER CaptureBuffer;
 212     DWORD Size, SizeX, SizeY;
 213
 214     if (lpBuffer == NULL)
 215     {
 216         SetLastError(ERROR_INVALID_PARAMETER);
 217         return FALSE;
 218     }
 219
 220     Size = dwBufferSize.X * dwBufferSize.Y * sizeof(CHAR_INFO);
 221
 222     DPRINT("IntReadConsoleOutput: %lx %p\n", Size, lpReadRegion);
 223
 224     /* Allocate a Capture Buffer */
 225     CaptureBuffer = CsrAllocateCaptureBuffer(1, Size);
 226     if (CaptureBuffer == NULL)
 227     {
 228         DPRINT1("CsrAllocateCaptureBuffer failed with size 0x%x!\n", Size);
 229         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 230         return FALSE;
 231     }
 232
 233     /* Allocate space in the Buffer */
 234     CsrAllocateMessagePointer(CaptureBuffer,
 235                               Size,
 236                               (PVOID*)&ReadOutputRequest->CharInfo);
 237
 238     /* Set up the data to send to the Console Server */
 239     ReadOutputRequest->OutputHandle = hConsoleOutput;
 240     ReadOutputRequest->Unicode = bUnicode;
 241     ReadOutputRequest->BufferSize = dwBufferSize;
 242     ReadOutputRequest->BufferCoord = dwBufferCoord;
 243     ReadOutputRequest->ReadRegion = *lpReadRegion;
 244
 245     /* Call the server */
 246     CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
 247                         CaptureBuffer,
 248                         CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepReadConsoleOutput),
 249                         sizeof(CONSOLE_READOUTPUT));
 250     DPRINT("Server returned: %x\n", ApiMessage.Status);
 251
 252     /* Check for success */
 253     if (NT_SUCCESS(ApiMessage.Status))
 254     {
 255         /* Copy into the buffer */
 256         DPRINT("Copying to buffer\n");
 257         SizeX = ReadOutputRequest->ReadRegion.Right -
 258                 ReadOutputRequest->ReadRegion.Left + 1;
 259         SizeY = ReadOutputRequest->ReadRegion.Bottom -
 260                 ReadOutputRequest->ReadRegion.Top + 1;
 261         RtlCopyMemory(lpBuffer,
 262                       ReadOutputRequest->CharInfo,
 263                       sizeof(CHAR_INFO) * SizeX * SizeY);
 264     }
 265     else
 266     {
 267         /* Error out */
 268         BaseSetLastNTError(ApiMessage.Status);
 269     }
 270
 271     /* Return the read region */
 272     DPRINT("read region: %lx\n", ReadOutputRequest->ReadRegion);
 273     *lpReadRegion = ReadOutputRequest->ReadRegion;
 274
 275     /* Release the capture buffer */
 276     CsrFreeCaptureBuffer(CaptureBuffer);
 277
 278     /* Return TRUE or FALSE */
 279     return NT_SUCCESS(ApiMessage.Status);
 280 }
 281
 282
 283 static
 284 BOOL
 285 IntReadConsoleOutputCode(HANDLE hConsoleOutput,
 286                          CODE_TYPE CodeType,
 287                          PVOID pCode,
 288                          DWORD nLength,
 289                          COORD dwReadCoord,
 290                          LPDWORD lpNumberOfCodesRead)
 291 {
 292     NTSTATUS Status;
 293     BOOL bRet = TRUE;
 294     CONSOLE_API_MESSAGE ApiMessage;
 295     PCONSOLE_READOUTPUTCODE ReadOutputCodeRequest = &ApiMessage.Data.ReadOutputCodeRequest;
 296     PCSR_CAPTURE_BUFFER CaptureBuffer;
 297     ULONG SizeBytes, CodeSize;
 298     DWORD CodesRead;
 299
 300     /* Determine the needed size */
 301     switch (CodeType)
 302     {
 303         case CODE_ASCII:
 304             CodeSize = sizeof(CHAR);
 305             break;
 306
 307         case CODE_UNICODE:
 308             CodeSize = sizeof(WCHAR);
 309             break;
 310
 311         case CODE_ATTRIBUTE:
 312             CodeSize = sizeof(WORD);
 313             break;
 314
 315         default:
 316             SetLastError(ERROR_INVALID_PARAMETER);
 317             return FALSE;
 318     }
 319     SizeBytes = nLength * CodeSize;
 320
 321     /* Allocate a Capture Buffer */
 322     CaptureBuffer = CsrAllocateCaptureBuffer(1, SizeBytes);
 323     if (CaptureBuffer == NULL)
 324     {
 325         DPRINT1("CsrAllocateCaptureBuffer failed!\n");
 326         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 327         return FALSE;
 328     }
 329
 330     /* Allocate space in the Buffer */
 331     CsrAllocateMessagePointer(CaptureBuffer,
 332                               SizeBytes,
 333                               (PVOID*)&ReadOutputCodeRequest->pCode.pCode);
 334
 335     /* Start reading */
 336     ReadOutputCodeRequest->OutputHandle = hConsoleOutput;
 337     ReadOutputCodeRequest->CodeType = CodeType;
 338     ReadOutputCodeRequest->ReadCoord = dwReadCoord;
 339
 340     ReadOutputCodeRequest->NumCodesToRead = nLength;
 341
 342     /* Call the server */
 343     Status = CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
 344                                  CaptureBuffer,
 345                                  CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepReadConsoleOutputString),
 346                                  sizeof(CONSOLE_READOUTPUTCODE));
 347
 348     /* Check for success */
 349     if (NT_SUCCESS(Status))
 350     {
 351         CodesRead = ReadOutputCodeRequest->CodesRead;
 352         memcpy(pCode, ReadOutputCodeRequest->pCode.pCode, CodesRead * CodeSize);
 353
 354         // ReadOutputCodeRequest->ReadCoord = ReadOutputCodeRequest->EndCoord;
 355
 356         if (lpNumberOfCodesRead != NULL)
 357             *lpNumberOfCodesRead = CodesRead;
 358
 359         bRet = TRUE;
 360     }
 361     else
 362     {
 363         if (lpNumberOfCodesRead != NULL)
 364             *lpNumberOfCodesRead = 0;
 365
 366         /* Error out */
 367         BaseSetLastNTError(Status);
 368         bRet = FALSE;
 369     }
 370
 371     CsrFreeCaptureBuffer(CaptureBuffer);
 372
 373     return bRet;
 374 }
 375
 376
 377 /*******************
 378  * Write functions *
 379  *******************/
 380
 381 static
 382 BOOL
 383 IntWriteConsole(HANDLE hConsoleOutput,
 384                 PVOID lpBuffer,
 385                 DWORD nNumberOfCharsToWrite,
 386                 LPDWORD lpNumberOfCharsWritten,
 387                 LPVOID lpReserved,
 388                 BOOL bUnicode)
 389 {
 390     NTSTATUS Status;
 391     BOOL bRet = TRUE;
 392     CONSOLE_API_MESSAGE ApiMessage;
 393     PCONSOLE_WRITECONSOLE WriteConsoleRequest = &ApiMessage.Data.WriteConsoleRequest;
 394     PCSR_CAPTURE_BUFFER CaptureBuffer;
 395     ULONG CharSize;
 396
 397     /* Determine the needed size */
 398     CharSize = (bUnicode ? sizeof(WCHAR) : sizeof(CHAR));
 399     WriteConsoleRequest->BufferSize = nNumberOfCharsToWrite * CharSize;
 400
 401     /* Allocate a Capture Buffer */
 402     CaptureBuffer = CsrAllocateCaptureBuffer(1, WriteConsoleRequest->BufferSize);
 403     if (CaptureBuffer == NULL)
 404     {
 405         DPRINT1("CsrAllocateCaptureBuffer failed!\n");
 406         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 407         return FALSE;
 408     }
 409
 410     /* Capture the buffer to write */
 411     CsrCaptureMessageBuffer(CaptureBuffer,
 412                             (PVOID)lpBuffer,
 413                             WriteConsoleRequest->BufferSize,
 414                             (PVOID*)&WriteConsoleRequest->Buffer);
 415
 416     /* Start writing */
 417     WriteConsoleRequest->NrCharactersToWrite = nNumberOfCharsToWrite;
 418     WriteConsoleRequest->OutputHandle = hConsoleOutput;
 419     WriteConsoleRequest->Unicode = bUnicode;
 420
 421     /* Call the server */
 422     Status = CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
 423                                  CaptureBuffer,
 424                                  CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepWriteConsole),
 425                                  sizeof(CONSOLE_WRITECONSOLE));
 426
 427     /* Check for success */
 428     if (NT_SUCCESS(Status))
 429     {
 430         if (lpNumberOfCharsWritten != NULL)
 431             *lpNumberOfCharsWritten = WriteConsoleRequest->NrCharactersWritten;
 432
 433         bRet = TRUE;
 434     }
 435     else
 436     {
 437         if (lpNumberOfCharsWritten != NULL)
 438             *lpNumberOfCharsWritten = 0;
 439
 440         /* Error out */
 441         BaseSetLastNTError(Status);
 442         bRet = FALSE;
 443     }
 444
 445     CsrFreeCaptureBuffer(CaptureBuffer);
 446
 447     return bRet;
 448 }
 449
 450
 451 static
 452 BOOL
 453 IntWriteConsoleInput(HANDLE hConsoleInput,
 454                      PINPUT_RECORD lpBuffer,
 455                      DWORD nLength,
 456                      LPDWORD lpNumberOfEventsWritten,
 457                      BOOL bUnicode)
 458 {
 459     CONSOLE_API_MESSAGE ApiMessage;
 460     PCONSOLE_WRITEINPUT WriteInputRequest = &ApiMessage.Data.WriteInputRequest;
 461     PCSR_CAPTURE_BUFFER CaptureBuffer;
 462     DWORD Size;
 463
 464     Size = nLength * sizeof(INPUT_RECORD);
 465
 466     DPRINT("IntWriteConsoleInput: %lx %p\n", Size, lpNumberOfEventsWritten);
 467
 468     /* Allocate a Capture Buffer */
 469     CaptureBuffer = CsrAllocateCaptureBuffer(1, Size);
 470     if (CaptureBuffer == NULL)
 471     {
 472         DPRINT1("CsrAllocateCaptureBuffer failed!\n");
 473         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 474         return FALSE;
 475     }
 476
 477     /* Capture the user buffer */
 478     CsrCaptureMessageBuffer(CaptureBuffer,
 479                             lpBuffer,
 480                             Size,
 481                             (PVOID*)&WriteInputRequest->InputRecord);
 482
 483     /* Set up the data to send to the Console Server */
 484     WriteInputRequest->InputHandle = hConsoleInput;
 485     WriteInputRequest->Unicode = bUnicode;
 486     WriteInputRequest->Length = nLength;
 487
 488     /* Call the server */
 489     CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
 490                         CaptureBuffer,
 491                         CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepWriteConsoleInput),
 492                         sizeof(CONSOLE_WRITEINPUT));
 493     DPRINT("Server returned: %x\n", ApiMessage.Status);
 494
 495     /* Check for success */
 496     if (NT_SUCCESS(ApiMessage.Status))
 497     {
 498         /* Return the number of events read */
 499         DPRINT("Events read: %lx\n", WriteInputRequest->Length);
 500
 501         if (lpNumberOfEventsWritten != NULL)
 502             *lpNumberOfEventsWritten = WriteInputRequest->Length;
 503     }
 504     else
 505     {
 506         if (lpNumberOfEventsWritten != NULL)
 507             *lpNumberOfEventsWritten = 0;
 508
 509         /* Error out */
 510         BaseSetLastNTError(ApiMessage.Status);
 511     }
 512
 513     /* Release the capture buffer */
 514     CsrFreeCaptureBuffer(CaptureBuffer);
 515
 516     /* Return TRUE or FALSE */
 517     return NT_SUCCESS(ApiMessage.Status);
 518 }
 519
 520
 521 static
 522 BOOL
 523 IntWriteConsoleOutput(HANDLE hConsoleOutput,
 524                       CONST CHAR_INFO *lpBuffer,
 525                       COORD dwBufferSize,
 526                       COORD dwBufferCoord,
 527                       PSMALL_RECT lpWriteRegion,
 528                       BOOL bUnicode)
 529 {
 530     CONSOLE_API_MESSAGE ApiMessage;
 531     PCONSOLE_WRITEOUTPUT WriteOutputRequest = &ApiMessage.Data.WriteOutputRequest;
 532     PCSR_CAPTURE_BUFFER CaptureBuffer;
 533     ULONG Size;
 534
 535     if ((lpBuffer == NULL) || (lpWriteRegion == NULL))
 536     {
 537         SetLastError(ERROR_INVALID_PARAMETER);
 538         return FALSE;
 539     }
 540     /*
 541     if (lpWriteRegion == NULL)
 542     {
 543         SetLastError(ERROR_INVALID_PARAMETER);
 544         return FALSE;
 545     }
 546     */
 547
 548     Size = dwBufferSize.Y * dwBufferSize.X * sizeof(CHAR_INFO);
 549
 550     DPRINT("IntWriteConsoleOutput: %lx %p\n", Size, lpWriteRegion);
 551
 552     /* Allocate a Capture Buffer */
 553     CaptureBuffer = CsrAllocateCaptureBuffer(1, Size);
 554     if (CaptureBuffer == NULL)
 555     {
 556         DPRINT1("CsrAllocateCaptureBuffer failed!\n");
 557         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 558         return FALSE;
 559     }
 560
 561     /* Capture the user buffer */
 562     CsrCaptureMessageBuffer(CaptureBuffer,
 563                             (PVOID)lpBuffer,
 564                             Size,
 565                             (PVOID*)&WriteOutputRequest->CharInfo);
 566
 567     /* Set up the data to send to the Console Server */
 568     WriteOutputRequest->OutputHandle = hConsoleOutput;
 569     WriteOutputRequest->Unicode = bUnicode;
 570     WriteOutputRequest->BufferSize = dwBufferSize;
 571     WriteOutputRequest->BufferCoord = dwBufferCoord;
 572     WriteOutputRequest->WriteRegion = *lpWriteRegion;
 573
 574     /* Call the server */
 575     CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
 576                         CaptureBuffer,
 577                         CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepWriteConsoleOutput),
 578                         sizeof(CONSOLE_WRITEOUTPUT));
 579     DPRINT("Server returned: %x\n", ApiMessage.Status);
 580
 581     /* Check for success */
 582     if (!NT_SUCCESS(ApiMessage.Status))
 583     {
 584         /* Error out */
 585         BaseSetLastNTError(ApiMessage.Status);
 586     }
 587
 588     /* Return the read region */
 589     DPRINT("read region: %lx\n", WriteOutputRequest->WriteRegion);
 590     *lpWriteRegion = WriteOutputRequest->WriteRegion;
 591
 592     /* Release the capture buffer */
 593     CsrFreeCaptureBuffer(CaptureBuffer);
 594
 595     /* Return TRUE or FALSE */
 596     return NT_SUCCESS(ApiMessage.Status);
 597 }
 598
 599
 600 static
 601 BOOL
 602 IntWriteConsoleOutputCode(HANDLE hConsoleOutput,
 603                           CODE_TYPE CodeType,
 604                           CONST VOID *pCode,
 605                           DWORD nLength,
 606                           COORD dwWriteCoord,
 607                           LPDWORD lpNumberOfCodesWritten)
 608 {
 609     NTSTATUS Status;
 610     BOOL bRet = TRUE;
 611     CONSOLE_API_MESSAGE ApiMessage;
 612     PCONSOLE_WRITEOUTPUTCODE WriteOutputCodeRequest = &ApiMessage.Data.WriteOutputCodeRequest;
 613     PCSR_CAPTURE_BUFFER CaptureBuffer;
 614     ULONG CodeSize;
 615
 616     /* Determine the needed size */
 617     switch (CodeType)
 618     {
 619         case CODE_ASCII:
 620             CodeSize = sizeof(CHAR);
 621             break;
 622
 623         case CODE_UNICODE:
 624             CodeSize = sizeof(WCHAR);
 625             break;
 626
 627         case CODE_ATTRIBUTE:
 628             CodeSize = sizeof(WORD);
 629             break;
 630
 631         default:
 632             SetLastError(ERROR_INVALID_PARAMETER);
 633             return FALSE;
 634     }
 635     WriteOutputCodeRequest->BufferSize = nLength * CodeSize;
 636
 637     /* Allocate a Capture Buffer */
 638     CaptureBuffer = CsrAllocateCaptureBuffer(1, WriteOutputCodeRequest->BufferSize);
 639     if (CaptureBuffer == NULL)
 640     {
 641         DPRINT1("CsrAllocateCaptureBuffer failed!\n");
 642         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 643         return FALSE;
 644     }
 645
 646     /* Capture the buffer to write */
 647     CsrCaptureMessageBuffer(CaptureBuffer,
 648                             (PVOID)pCode,
 649                             WriteOutputCodeRequest->BufferSize,
 650                             (PVOID*)&WriteOutputCodeRequest->pCode.pCode);
 651
 652     /* Start writing */
 653     WriteOutputCodeRequest->OutputHandle = hConsoleOutput;
 654     WriteOutputCodeRequest->CodeType = CodeType;
 655     WriteOutputCodeRequest->Coord = dwWriteCoord;
 656
 657     WriteOutputCodeRequest->Length = nLength;
 658
 659     /* Call the server */
 660     Status = CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
 661                                  CaptureBuffer,
 662                                  CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepWriteConsoleOutputString),
 663                                  sizeof(CONSOLE_WRITEOUTPUTCODE));
 664
 665     /* Check for success */
 666     if (NT_SUCCESS(Status))
 667     {
 668         // WriteOutputCodeRequest->Coord = WriteOutputCodeRequest->EndCoord;
 669
 670         if (lpNumberOfCodesWritten != NULL)
 671             // *lpNumberOfCodesWritten = WriteOutputCodeRequest->NrCharactersWritten;
 672             *lpNumberOfCodesWritten = WriteOutputCodeRequest->Length;
 673
 674         bRet = TRUE;
 675     }
 676     else
 677     {
 678         if (lpNumberOfCodesWritten != NULL)
 679             *lpNumberOfCodesWritten = 0;
 680
 681         /* Error out */
 682         BaseSetLastNTError(Status);
 683         bRet = FALSE;
 684     }
 685
 686     CsrFreeCaptureBuffer(CaptureBuffer);
 687
 688     return bRet;
 689 }
 690
 691
 692 static
 693 BOOL
 694 IntFillConsoleOutputCode(HANDLE hConsoleOutput,
 695                          CODE_TYPE CodeType,
 696                          PVOID pCode,
 697                          DWORD nLength,
 698                          COORD dwWriteCoord,
 699                          LPDWORD lpNumberOfCodesWritten)
 700 {
 701     NTSTATUS Status;
 702     CONSOLE_API_MESSAGE ApiMessage;
 703     PCONSOLE_FILLOUTPUTCODE FillOutputRequest = &ApiMessage.Data.FillOutputRequest;
 704
 705     FillOutputRequest->OutputHandle = hConsoleOutput;
 706     FillOutputRequest->CodeType = CodeType;
 707
 708     switch (CodeType)
 709     {
 710         case CODE_ASCII:
 711             FillOutputRequest->Code.AsciiChar = *(PCHAR)pCode;
 712             break;
 713
 714         case CODE_UNICODE:
 715             FillOutputRequest->Code.UnicodeChar = *(PWCHAR)pCode;
 716             break;
 717
 718         case CODE_ATTRIBUTE:
 719             FillOutputRequest->Code.Attribute = *(PWORD)pCode;
 720             break;
 721
 722         default:
 723             SetLastError(ERROR_INVALID_PARAMETER);
 724             return FALSE;
 725     }
 726
 727     /* Set up the data to send to the Console Server */
 728     FillOutputRequest->Coord = dwWriteCoord;
 729     FillOutputRequest->Length = nLength;
 730
 731     /* Call the server */
 732     Status = CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
 733                                  NULL,
 734                                  CSR_CREATE_API_NUMBER(CONSRV_SERVERDLL_INDEX, ConsolepFillConsoleOutput),
 735                                  sizeof(CONSOLE_FILLOUTPUTCODE));
 736
 737     /* Check for success */
 738     if (NT_SUCCESS(Status))
 739     {
 740         if (lpNumberOfCodesWritten != NULL)
 741             *lpNumberOfCodesWritten = FillOutputRequest->Length;
 742             // *lpNumberOfCodesWritten = Request.Data.FillOutputRequest.NrCharactersWritten;
 743
 744         return TRUE;
 745     }
 746     else
 747     {
 748         if (lpNumberOfCodesWritten != NULL)
 749             *lpNumberOfCodesWritten = 0;
 750
 751         BaseSetLastNTError(Status);
 752         return FALSE;
 753     }
 754 }
 755
 756
 757 /* FUNCTIONS ******************************************************************/
 758
 759 /******************
 760  * Read functions *
 761  ******************/
 762
 763 /*--------------------------------------------------------------
 764  *    ReadConsoleW
 765  *
 766  * @implemented
 767  */
 768 BOOL
 769 WINAPI
 770 ReadConsoleW(HANDLE hConsoleInput,
 771              LPVOID lpBuffer,
 772              DWORD nNumberOfCharsToRead,
 773              LPDWORD lpNumberOfCharsRead,
 774              PCONSOLE_READCONSOLE_CONTROL pInputControl)
 775 {
 776     return IntReadConsole(hConsoleInput,
 777                           lpBuffer,
 778                           nNumberOfCharsToRead,
 779                           lpNumberOfCharsRead,
 780                           pInputControl,
 781                           TRUE);
 782 }
 783
 784
 785 /*--------------------------------------------------------------
 786  *    ReadConsoleA
 787  *
 788  * @implemented
 789  */
 790 BOOL
 791 WINAPI
 792 ReadConsoleA(HANDLE hConsoleInput,
 793              LPVOID lpBuffer,
 794              DWORD nNumberOfCharsToRead,
 795              LPDWORD lpNumberOfCharsRead,
 796              PCONSOLE_READCONSOLE_CONTROL pInputControl)
 797 {
 798     return IntReadConsole(hConsoleInput,
 799                           lpBuffer,
 800                           nNumberOfCharsToRead,
 801                           lpNumberOfCharsRead,
 802                           NULL,
 803                           FALSE);
 804 }
 805
 806
 807 /*--------------------------------------------------------------
 808  *     PeekConsoleInputW
 809  *
 810  * @implemented
 811  */
 812 BOOL
 813 WINAPI
 814 PeekConsoleInputW(HANDLE hConsoleInput,
 815                   PINPUT_RECORD lpBuffer,
 816                   DWORD nLength,
 817                   LPDWORD lpNumberOfEventsRead)
 818 {
 819     return IntGetConsoleInput(hConsoleInput,
 820                               FALSE,
 821                               lpBuffer,
 822                               nLength,
 823                               lpNumberOfEventsRead,
 824                               TRUE);
 825 }
 826
 827
 828 /*--------------------------------------------------------------
 829  *     PeekConsoleInputA
 830  *
 831  * @implemented
 832  */
 833 BOOL
 834 WINAPI
 835 PeekConsoleInputA(HANDLE hConsoleInput,
 836                   PINPUT_RECORD lpBuffer,
 837                   DWORD nLength,
 838                   LPDWORD lpNumberOfEventsRead)
 839 {
 840     return IntGetConsoleInput(hConsoleInput,
 841                               FALSE,
 842                               lpBuffer,
 843                               nLength,
 844                               lpNumberOfEventsRead,
 845                               FALSE);
 846 }
 847
 848
 849 /*--------------------------------------------------------------
 850  *     ReadConsoleInputW
 851  *
 852  * @implemented
 853  */
 854 BOOL
 855 WINAPI
 856 ReadConsoleInputW(HANDLE hConsoleInput,
 857                   PINPUT_RECORD lpBuffer,
 858                   DWORD nLength,
 859                   LPDWORD lpNumberOfEventsRead)
 860 {
 861     return IntGetConsoleInput(hConsoleInput,
 862                               TRUE,
 863                               lpBuffer,
 864                               nLength,
 865                               lpNumberOfEventsRead,
 866                               TRUE);
 867 }
 868
 869
 870 /*--------------------------------------------------------------
 871  *     ReadConsoleInputA
 872  *
 873  * @implemented
 874  */
 875 BOOL
 876 WINAPI
 877 ReadConsoleInputA(HANDLE hConsoleInput,
 878                   PINPUT_RECORD lpBuffer,
 879                   DWORD nLength,
 880                   LPDWORD lpNumberOfEventsRead)
 881 {
 882     return IntGetConsoleInput(hConsoleInput,
 883                               TRUE,
 884                               lpBuffer,
 885                               nLength,
 886                               lpNumberOfEventsRead,
 887                               FALSE);
 888 }
 889
 890
 891 BOOL
 892 WINAPI
 893 ReadConsoleInputExW(HANDLE hConsole, LPVOID lpBuffer, DWORD dwLen, LPDWORD Unknown1, DWORD Unknown2)
 894 {
 895     STUB;
 896     return FALSE;
 897 }
 898
 899
 900 BOOL
 901 WINAPI
 902 ReadConsoleInputExA(HANDLE hConsole, LPVOID lpBuffer, DWORD dwLen, LPDWORD Unknown1, DWORD Unknown2)
 903 {
 904     STUB;
 905     return FALSE;
 906 }
 907
 908
 909 /*--------------------------------------------------------------
 910  *     ReadConsoleOutputW
 911  *
 912  * @implemented
 913  */
 914 BOOL
 915 WINAPI
 916 ReadConsoleOutputW(HANDLE hConsoleOutput,
 917                    PCHAR_INFO lpBuffer,
 918                    COORD dwBufferSize,
 919                    COORD dwBufferCoord,
 920                    PSMALL_RECT lpReadRegion)
 921 {
 922     return IntReadConsoleOutput(hConsoleOutput,
 923                                 lpBuffer,
 924                                 dwBufferSize,
 925                                 dwBufferCoord,
 926                                 lpReadRegion,
 927                                 TRUE);
 928 }
 929
 930
 931 /*--------------------------------------------------------------
 932  *     ReadConsoleOutputA
 933  *
 934  * @implemented
 935  */
 936 BOOL
 937 WINAPI
 938 ReadConsoleOutputA(HANDLE hConsoleOutput,
 939                    PCHAR_INFO lpBuffer,
 940                    COORD dwBufferSize,
 941                    COORD dwBufferCoord,
 942                    PSMALL_RECT lpReadRegion)
 943 {
 944     return IntReadConsoleOutput(hConsoleOutput,
 945                                 lpBuffer,
 946                                 dwBufferSize,
 947                                 dwBufferCoord,
 948                                 lpReadRegion,
 949                                 FALSE);
 950 }
 951
 952
 953 /*--------------------------------------------------------------
 954  *      ReadConsoleOutputCharacterW
 955  *
 956  * @implemented
 957  */
 958 BOOL
 959 WINAPI
 960 ReadConsoleOutputCharacterW(HANDLE hConsoleOutput,
 961                             LPWSTR lpCharacter,
 962                             DWORD nLength,
 963                             COORD dwReadCoord,
 964                             LPDWORD lpNumberOfCharsRead)
 965 {
 966     return IntReadConsoleOutputCode(hConsoleOutput,
 967                                     CODE_UNICODE,
 968                                     lpCharacter,
 969                                     nLength,
 970                                     dwReadCoord,
 971                                     lpNumberOfCharsRead);
 972 }
 973
 974
 975 /*--------------------------------------------------------------
 976  *     ReadConsoleOutputCharacterA
 977  *
 978  * @implemented
 979  */
 980 BOOL
 981 WINAPI
 982 ReadConsoleOutputCharacterA(HANDLE hConsoleOutput,
 983                             LPSTR lpCharacter,
 984                             DWORD nLength,
 985                             COORD dwReadCoord,
 986                             LPDWORD lpNumberOfCharsRead)
 987 {
 988     return IntReadConsoleOutputCode(hConsoleOutput,
 989                                     CODE_ASCII,
 990                                     lpCharacter,
 991                                     nLength,
 992                                     dwReadCoord,
 993                                     lpNumberOfCharsRead);
 994 }
 995
 996
 997 /*--------------------------------------------------------------
 998  *     ReadConsoleOutputAttribute
 999  *
1000  * @implemented
1001  */
1002 BOOL
1003 WINAPI
1004 ReadConsoleOutputAttribute(HANDLE hConsoleOutput,
1005                            LPWORD lpAttribute,
1006                            DWORD nLength,
1007                            COORD dwReadCoord,
1008                            LPDWORD lpNumberOfAttrsRead)
1009 {
1010     return IntReadConsoleOutputCode(hConsoleOutput,
1011                                     CODE_ATTRIBUTE,
1012                                     lpAttribute,
1013                                     nLength,
1014                                     dwReadCoord,
1015                                     lpNumberOfAttrsRead);
1016 }
1017
1018
1019 /*******************
1020  * Write functions *
1021  *******************/
1022
1023 /*--------------------------------------------------------------
1024  *    WriteConsoleW
1025  *
1026  * @implemented
1027  */
1028 BOOL
1029 WINAPI
1030 WriteConsoleW(HANDLE hConsoleOutput,
1031               CONST VOID *lpBuffer,
1032               DWORD nNumberOfCharsToWrite,
1033               LPDWORD lpNumberOfCharsWritten,
1034               LPVOID lpReserved)
1035 {
1036     return IntWriteConsole(hConsoleOutput,
1037                            (PVOID)lpBuffer,
1038                            nNumberOfCharsToWrite,
1039                            lpNumberOfCharsWritten,
1040                            lpReserved,
1041                            TRUE);
1042 }
1043
1044
1045 /*--------------------------------------------------------------
1046  *    WriteConsoleA
1047  *
1048  * @implemented
1049  */
1050 BOOL
1051 WINAPI
1052 WriteConsoleA(HANDLE hConsoleOutput,
1053               CONST VOID *lpBuffer,
1054               DWORD nNumberOfCharsToWrite,
1055               LPDWORD lpNumberOfCharsWritten,
1056               LPVOID lpReserved)
1057 {
1058     return IntWriteConsole(hConsoleOutput,
1059                            (PVOID)lpBuffer,
1060                            nNumberOfCharsToWrite,
1061                            lpNumberOfCharsWritten,
1062                            lpReserved,
1063                            FALSE);
1064 }
1065
1066
1067 /*--------------------------------------------------------------
1068  *     WriteConsoleInputW
1069  *
1070  * @implemented
1071  */
1072 BOOL
1073 WINAPI
1074 WriteConsoleInputW(HANDLE hConsoleInput,
1075                    CONST INPUT_RECORD *lpBuffer,
1076                    DWORD nLength,
1077                    LPDWORD lpNumberOfEventsWritten)
1078 {
1079     return IntWriteConsoleInput(hConsoleInput,
1080                                 (PINPUT_RECORD)lpBuffer,
1081                                 nLength,
1082                                 lpNumberOfEventsWritten,
1083                                 TRUE);
1084 }
1085
1086
1087 /*--------------------------------------------------------------
1088  *     WriteConsoleInputA
1089  *
1090  * @implemented
1091  */
1092 BOOL
1093 WINAPI
1094 WriteConsoleInputA(HANDLE hConsoleInput,
1095                    CONST INPUT_RECORD *lpBuffer,
1096                    DWORD nLength,
1097                    LPDWORD lpNumberOfEventsWritten)
1098 {
1099     return IntWriteConsoleInput(hConsoleInput,
1100                                 (PINPUT_RECORD)lpBuffer,
1101                                 nLength,
1102                                 lpNumberOfEventsWritten,
1103                                 FALSE);
1104 }
1105
1106
1107 /*--------------------------------------------------------------
1108  *     WriteConsoleOutputW
1109  *
1110  * @implemented
1111  */
1112 BOOL
1113 WINAPI
1114 WriteConsoleOutputW(HANDLE hConsoleOutput,
1115                     CONST CHAR_INFO *lpBuffer,
1116                     COORD dwBufferSize,
1117                     COORD dwBufferCoord,
1118                     PSMALL_RECT lpWriteRegion)
1119 {
1120     return IntWriteConsoleOutput(hConsoleOutput,
1121                                  lpBuffer,
1122                                  dwBufferSize,
1123                                  dwBufferCoord,
1124                                  lpWriteRegion,
1125                                  TRUE);
1126 }
1127
1128
1129 /*--------------------------------------------------------------
1130  *     WriteConsoleOutputA
1131  *
1132  * @implemented
1133  */
1134 BOOL
1135 WINAPI
1136 WriteConsoleOutputA(HANDLE hConsoleOutput,
1137                     CONST CHAR_INFO *lpBuffer,
1138                     COORD dwBufferSize,
1139                     COORD dwBufferCoord,
1140                     PSMALL_RECT lpWriteRegion)
1141 {
1142     return IntWriteConsoleOutput(hConsoleOutput,
1143                                  lpBuffer,
1144                                  dwBufferSize,
1145                                  dwBufferCoord,
1146                                  lpWriteRegion,
1147                                  FALSE);
1148 }
1149
1150
1151 /*--------------------------------------------------------------
1152  *     WriteConsoleOutputCharacterW
1153  *
1154  * @implemented
1155  */
1156 BOOL
1157 WINAPI
1158 WriteConsoleOutputCharacterW(HANDLE hConsoleOutput,
1159                              LPCWSTR lpCharacter,
1160                              DWORD nLength,
1161                              COORD dwWriteCoord,
1162                              LPDWORD lpNumberOfCharsWritten)
1163 {
1164     return IntWriteConsoleOutputCode(hConsoleOutput,
1165                                      CODE_UNICODE,
1166                                      lpCharacter,
1167                                      nLength,
1168                                      dwWriteCoord,
1169                                      lpNumberOfCharsWritten);
1170 }
1171
1172
1173 /*--------------------------------------------------------------
1174  *     WriteConsoleOutputCharacterA
1175  *
1176  * @implemented
1177  */
1178 BOOL
1179 WINAPI
1180 WriteConsoleOutputCharacterA(HANDLE hConsoleOutput,
1181                              LPCSTR lpCharacter,
1182                              DWORD nLength,
1183                              COORD dwWriteCoord,
1184                              LPDWORD lpNumberOfCharsWritten)
1185 {
1186     return IntWriteConsoleOutputCode(hConsoleOutput,
1187                                      CODE_ASCII,
1188                                      lpCharacter,
1189                                      nLength,
1190                                      dwWriteCoord,
1191                                      lpNumberOfCharsWritten);
1192 }
1193
1194
1195 /*--------------------------------------------------------------
1196  *     WriteConsoleOutputAttribute
1197  *
1198  * @implemented
1199  */
1200 BOOL
1201 WINAPI
1202 WriteConsoleOutputAttribute(HANDLE hConsoleOutput,
1203                             CONST WORD *lpAttribute,
1204                             DWORD nLength,
1205                             COORD dwWriteCoord,
1206                             LPDWORD lpNumberOfAttrsWritten)
1207 {
1208     return IntWriteConsoleOutputCode(hConsoleOutput,
1209                                      CODE_ATTRIBUTE,
1210                                      lpAttribute,
1211                                      nLength,
1212                                      dwWriteCoord,
1213                                      lpNumberOfAttrsWritten);
1214 }
1215
1216
1217 /*--------------------------------------------------------------
1218  *    FillConsoleOutputCharacterW
1219  *
1220  * @implemented
1221  */
1222 BOOL
1223 WINAPI
1224 FillConsoleOutputCharacterW(HANDLE hConsoleOutput,
1225                             WCHAR cCharacter,
1226                             DWORD nLength,
1227                             COORD dwWriteCoord,
1228                             LPDWORD lpNumberOfCharsWritten)
1229 {
1230     return IntFillConsoleOutputCode(hConsoleOutput,
1231                                     CODE_UNICODE,
1232                                     &cCharacter,
1233                                     nLength,
1234                                     dwWriteCoord,
1235                                     lpNumberOfCharsWritten);
1236 }
1237
1238
1239 /*--------------------------------------------------------------
1240  *    FillConsoleOutputCharacterA
1241  *
1242  * @implemented
1243  */
1244 BOOL
1245 WINAPI
1246 FillConsoleOutputCharacterA(HANDLE hConsoleOutput,
1247                             CHAR cCharacter,
1248                             DWORD nLength,
1249                             COORD dwWriteCoord,
1250                             LPDWORD lpNumberOfCharsWritten)
1251 {
1252     return IntFillConsoleOutputCode(hConsoleOutput,
1253                                     CODE_ASCII,
1254                                     &cCharacter,
1255                                     nLength,
1256                                     dwWriteCoord,
1257                                     lpNumberOfCharsWritten);
1258 }
1259
1260
1261 /*--------------------------------------------------------------
1262  *     FillConsoleOutputAttribute
1263  *
1264  * @implemented
1265  */
1266 BOOL
1267 WINAPI
1268 FillConsoleOutputAttribute(HANDLE hConsoleOutput,
1269                            WORD wAttribute,
1270                            DWORD nLength,
1271                            COORD dwWriteCoord,
1272                            LPDWORD lpNumberOfAttrsWritten)
1273 {
1274     return IntFillConsoleOutputCode(hConsoleOutput,
1275                                     CODE_ATTRIBUTE,
1276                                     &wAttribute,
1277                                     nLength,
1278                                     dwWriteCoord,
1279                                     lpNumberOfAttrsWritten);
1280 }
1281
1282 /* EOF */