reactos/lib/kernel32/misc/console.c

   1 /* $Id: console.c,v 1.42 2002/09/07 15:12:27 chorns Exp $
   2  *
   3  * COPYRIGHT:       See COPYING in the top level directory
   4  * PROJECT:         ReactOS system libraries
   5  * FILE:            lib/kernel32/misc/console.c
   6  * PURPOSE:         Win32 server console functions
   7  * PROGRAMMER:      ???
   8  * UPDATE HISTORY:
   9  *      199901?? ??     Created
  10  *      19990204 EA     SetConsoleTitleA
  11  *      19990306 EA     Stubs
  12  */
  13
  14 /* INCLUDES ******************************************************************/
  15
  16 #include <kernel32.h>
  17 #define NTOS_USER_MODE
  18 #include <ntos.h>
  19 #include <assert.h>
  20 #include <wchar.h>
  21 #include <csrss/csrss.h>
  22
  23 #define NDEBUG
  24 #include <kernel32/kernel32.h>
  25 #include <kernel32/error.h>
  26
  27 /* GLOBALS *******************************************************************/
  28
  29 static BOOL IgnoreCtrlEvents = FALSE;
  30 static ULONG NrCtrlHandlers = 0;
  31 static PHANDLER_ROUTINE* CtrlHandlers = NULL;
  32
  33 /* FUNCTIONS *****************************************************************/
  34
  35 BOOL STDCALL
  36 AddConsoleAliasA (DWORD a0,
  37                   DWORD a1,
  38                   DWORD a2)
  39      /*
  40       * Undocumented
  41       */
  42 {
  43   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  44   return FALSE;
  45 }
  46
  47 BOOL STDCALL
  48 AddConsoleAliasW (DWORD a0,
  49                   DWORD a1,
  50                   DWORD a2)
  51      /*
  52       * Undocumented
  53       */
  54 {
  55   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  56   return FALSE;
  57 }
  58
  59 BOOL STDCALL
  60 ConsoleMenuControl (HANDLE      hConsole,
  61                     DWORD       Unknown1,
  62                     DWORD       Unknown2)
  63      /*
  64       * Undocumented
  65       */
  66 {
  67   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  68   return FALSE;
  69 }
  70
  71 BOOL STDCALL
  72 DuplicateConsoleHandle (HANDLE  hConsole,
  73                         DWORD   Unknown1,
  74                         DWORD   Unknown2,
  75                         DWORD   Unknown3)
  76      /*
  77       * Undocumented
  78       */
  79 {
  80   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  81   return FALSE;
  82 }
  83
  84 DWORD STDCALL
  85 ExpungeConsoleCommandHistoryW (DWORD    Unknown0)
  86      /*
  87       * Undocumented
  88       */
  89 {
  90   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  91   return 0;
  92 }
  93
  94
  95 DWORD STDCALL
  96 ExpungeConsoleCommandHistoryA (DWORD    Unknown0)
  97      /*
  98       * Undocumented
  99       */
 100 {
 101   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 102   return 0;
 103 }
 104
 105 DWORD STDCALL
 106 GetConsoleAliasW (DWORD Unknown0,
 107                   DWORD Unknown1,
 108                   DWORD Unknown2,
 109                   DWORD Unknown3)
 110      /*
 111       * Undocumented
 112       */
 113 {
 114   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 115   return 0;
 116 }
 117
 118
 119 DWORD STDCALL
 120 GetConsoleAliasA (DWORD Unknown0,
 121                   DWORD Unknown1,
 122                   DWORD Unknown2,
 123                   DWORD Unknown3)
 124      /*
 125       * Undocumented
 126       */
 127 {
 128         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 129         return 0;
 130 }
 131
 132 DWORD STDCALL
 133 GetConsoleAliasExesW (DWORD     Unknown0,
 134                       DWORD     Unknown1)
 135      /*
 136       * Undocumented
 137       */
 138 {
 139   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 140   return 0;
 141 }
 142
 143
 144
 145 DWORD STDCALL
 146 GetConsoleAliasExesA (DWORD     Unknown0,
 147                       DWORD     Unknown1)
 148      /*
 149       * Undocumented
 150       */
 151 {
 152         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 153         return 0;
 154 }
 155
 156
 157
 158 DWORD STDCALL
 159 GetConsoleAliasExesLengthA (VOID)
 160      /*
 161       * Undocumented
 162       */
 163 {
 164   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 165   return 0;
 166 }
 167
 168 DWORD STDCALL
 169 GetConsoleAliasExesLengthW (VOID)
 170      /*
 171       * Undocumented
 172       */
 173 {
 174   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 175   return 0;
 176 }
 177
 178 DWORD STDCALL
 179 GetConsoleAliasesW (DWORD       Unknown0,
 180                     DWORD       Unknown1,
 181                     DWORD       Unknown2)
 182      /*
 183       * Undocumented
 184       */
 185 {
 186   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 187   return 0;
 188 }
 189
 190 DWORD STDCALL
 191 GetConsoleAliasesA (DWORD       Unknown0,
 192                     DWORD       Unknown1,
 193                     DWORD       Unknown2)
 194      /*
 195       * Undocumented
 196       */
 197 {
 198   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 199   return 0;
 200 }
 201
 202 DWORD STDCALL
 203 GetConsoleAliasesLengthW (DWORD Unknown0)
 204      /*
 205       * Undocumented
 206       */
 207 {
 208   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 209   return 0;
 210 }
 211
 212 DWORD STDCALL
 213 GetConsoleAliasesLengthA (DWORD Unknown0)
 214      /*
 215       * Undocumented
 216       */
 217 {
 218   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 219   return 0;
 220 }
 221
 222 DWORD STDCALL
 223 GetConsoleCommandHistoryW (DWORD        Unknown0,
 224                            DWORD        Unknown1,
 225                            DWORD        Unknown2)
 226      /*
 227       * Undocumented
 228       */
 229 {
 230   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 231   return 0;
 232 }
 233
 234 DWORD STDCALL
 235 GetConsoleCommandHistoryA (DWORD        Unknown0,
 236                            DWORD        Unknown1,
 237                            DWORD        Unknown2)
 238      /*
 239       * Undocumented
 240       */
 241 {
 242   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 243   return 0;
 244 }
 245
 246 DWORD STDCALL
 247 GetConsoleCommandHistoryLengthW (DWORD  Unknown0)
 248      /*
 249       * Undocumented
 250       */
 251 {
 252   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 253   return 0;
 254 }
 255
 256 DWORD STDCALL
 257 GetConsoleCommandHistoryLengthA (DWORD  Unknown0)
 258      /*
 259       * Undocumented
 260       */
 261 {
 262   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 263   return 0;
 264 }
 265
 266 DWORD STDCALL
 267 GetConsoleDisplayMode (LPDWORD lpdwMode)
 268      /*
 269       * FUNCTION: Get the console display mode
 270       * ARGUMENTS:
 271       *      lpdwMode - Address of variable that receives the current value
 272       *                 of display mode
 273       * STATUS: Undocumented
 274       */
 275 {
 276   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 277   return 0;
 278 }
 279
 280 DWORD STDCALL
 281 GetConsoleFontInfo (DWORD       Unknown0,
 282                     DWORD       Unknown1,
 283                     DWORD       Unknown2,
 284                     DWORD       Unknown3)
 285      /*
 286       * Undocumented
 287       */
 288 {
 289   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 290   return 0;
 291 }
 292
 293 DWORD STDCALL
 294 GetConsoleFontSize(HANDLE hConsoleOutput,
 295                    DWORD nFont)
 296 {
 297   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 298   return 0;
 299 }
 300
 301 DWORD STDCALL
 302 GetConsoleHardwareState (DWORD  Unknown0,
 303                          DWORD  Unknown1,
 304                          DWORD  Unknown2)
 305      /*
 306       * Undocumented
 307       */
 308 {
 309   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 310   return 0;
 311 }
 312
 313 DWORD STDCALL
 314 GetConsoleInputWaitHandle (VOID)
 315      /*
 316       * Undocumented
 317       */
 318 {
 319   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 320   return FALSE;
 321 }
 322
 323 DWORD STDCALL
 324 GetCurrentConsoleFont(HANDLE hConsoleOutput,
 325                       BOOL bMaximumWindow,
 326                       PCONSOLE_FONT_INFO lpConsoleCurrentFont)
 327 {
 328   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 329   return 0;
 330 }
 331
 332 ULONG STDCALL
 333 GetNumberOfConsoleFonts (VOID)
 334      /*
 335       * Undocumented
 336       */
 337 {
 338   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 339   return 1; /* FIXME: call csrss.exe */
 340 }
 341
 342 DWORD STDCALL
 343 InvalidateConsoleDIBits (DWORD  Unknown0,
 344                          DWORD  Unknown1)
 345      /*
 346       * Undocumented
 347       */
 348 {
 349   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 350   return 0;
 351 }
 352
 353 DWORD STDCALL
 354 OpenConsoleW (DWORD     Unknown0,
 355               DWORD     Unknown1,
 356               DWORD     Unknown2,
 357               DWORD     Unknown3)
 358      /*
 359       * Undocumented
 360       */
 361 {
 362   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 363   return 0;
 364 }
 365
 366 WINBOOL STDCALL
 367 SetConsoleCommandHistoryMode (DWORD     dwMode)
 368      /*
 369       * Undocumented
 370       */
 371 {
 372   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 373   return FALSE;
 374 }
 375
 376 WINBOOL STDCALL
 377 SetConsoleCursor (DWORD Unknown0,
 378                   DWORD Unknown1)
 379      /*
 380       * Undocumented
 381       */
 382 {
 383   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 384   return FALSE;
 385 }
 386
 387 WINBOOL STDCALL
 388 SetConsoleDisplayMode (HANDLE hOut,
 389                        DWORD dwNewMode,
 390                        LPDWORD lpdwOldMode)
 391      /*
 392       * FUNCTION: Set the console display mode.
 393       * ARGUMENTS:
 394       *       hOut - Standard output handle.
 395       *       dwNewMode - New mode.
 396       *       lpdwOldMode - Address of a variable that receives the old mode.
 397       */
 398 {
 399   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 400   return FALSE;
 401 }
 402
 403 WINBOOL STDCALL
 404 SetConsoleFont (DWORD   Unknown0,
 405                 DWORD   Unknown1)
 406      /*
 407       * Undocumented
 408       */
 409 {
 410   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 411   return FALSE;
 412 }
 413
 414 WINBOOL STDCALL
 415 SetConsoleHardwareState (DWORD  Unknown0,
 416                          DWORD  Unknown1,
 417                          DWORD  Unknown2)
 418      /*
 419       * Undocumented
 420       */
 421 {
 422   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 423   return FALSE;
 424 }
 425
 426 WINBOOL STDCALL
 427 SetConsoleKeyShortcuts (DWORD   Unknown0,
 428                         DWORD   Unknown1,
 429                         DWORD   Unknown2,
 430                         DWORD   Unknown3)
 431      /*
 432       * Undocumented
 433       */
 434 {
 435   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 436   return FALSE;
 437 }
 438
 439 WINBOOL STDCALL
 440 SetConsoleMaximumWindowSize (DWORD      Unknown0,
 441                              DWORD      Unknown1)
 442      /*
 443       * Undocumented
 444       */
 445 {
 446   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 447   return FALSE;
 448 }
 449
 450 WINBOOL STDCALL
 451 SetConsoleMenuClose (DWORD      Unknown0)
 452      /*
 453       * Undocumented
 454       */
 455 {
 456   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 457   return FALSE;
 458 }
 459
 460 WINBOOL STDCALL
 461 SetConsoleNumberOfCommandsA (DWORD      Unknown0,
 462                              DWORD      Unknown1)
 463      /*
 464       * Undocumented
 465       */
 466 {
 467   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 468   return FALSE;
 469 }
 470
 471 WINBOOL STDCALL
 472 SetConsoleNumberOfCommandsW (DWORD      Unknown0,
 473                              DWORD      Unknown1)
 474      /*
 475       * Undocumented
 476       */
 477 {
 478   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 479   return FALSE;
 480 }
 481
 482 WINBOOL STDCALL
 483 SetConsolePalette (DWORD        Unknown0,
 484                    DWORD        Unknown1,
 485                    DWORD        Unknown2)
 486      /*
 487       * Undocumented
 488       */
 489 {
 490   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 491   return FALSE;
 492 }
 493
 494 WINBOOL STDCALL
 495 SetLastConsoleEventActive (VOID)
 496      /*
 497       * Undocumented
 498       */
 499 {
 500   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 501   return FALSE;
 502 }
 503
 504 DWORD STDCALL
 505 ShowConsoleCursor (DWORD        Unknown0,
 506                    DWORD        Unknown1)
 507      /*
 508       * Undocumented
 509       */
 510 {
 511   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 512   return 0;
 513 }
 514
 515 DWORD STDCALL
 516 VerifyConsoleIoHandle (DWORD    Unknown0)
 517      /*
 518       * Undocumented
 519       */
 520 {
 521   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 522   return 0;
 523 }
 524
 525 DWORD STDCALL
 526 WriteConsoleInputVDMA (DWORD    Unknown0,
 527                        DWORD    Unknown1,
 528                        DWORD    Unknown2,
 529                        DWORD    Unknown3)
 530 {
 531   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 532   return 0;
 533 }
 534
 535 DWORD STDCALL
 536 WriteConsoleInputVDMW (DWORD    Unknown0,
 537                        DWORD    Unknown1,
 538                        DWORD    Unknown2,
 539                        DWORD    Unknown3)
 540 {
 541   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 542   return 0;
 543 }
 544
 545 WINBOOL STDCALL
 546 CloseConsoleHandle(HANDLE Handle)
 547      /*
 548       * Undocumented
 549       */
 550 {
 551   if (IsConsoleHandle (Handle) == FALSE)
 552     {
 553       SetLastError (ERROR_INVALID_PARAMETER);
 554       return FALSE;
 555     }
 556   /* FIXME: call CSRSS */
 557   return TRUE/*FALSE*/;
 558 }
 559
 560 BOOLEAN STDCALL
 561 IsConsoleHandle(HANDLE Handle)
 562 {
 563   if ((((ULONG)Handle) & 0x10000003) == 0x3)
 564     {
 565       return(TRUE);
 566     }
 567   return(FALSE);
 568 }
 569
 570 HANDLE STDCALL
 571 GetStdHandle(DWORD nStdHandle)
 572      /*
 573       * FUNCTION: Get a handle for the standard input, standard output
 574       * and a standard error device.
 575       * ARGUMENTS:
 576       *       nStdHandle - Specifies the device for which to return the handle.
 577       * RETURNS: If the function succeeds, the return value is the handle
 578       * of the specified device. Otherwise the value is INVALID_HANDLE_VALUE.
 579       */
 580 {
 581   PRTL_ROS_USER_PROCESS_PARAMETERS Ppb;
 582
 583   Ppb = NtCurrentPeb()->ProcessParameters;
 584   switch (nStdHandle)
 585     {
 586     case STD_INPUT_HANDLE:      return Ppb->InputHandle;
 587     case STD_OUTPUT_HANDLE:     return Ppb->OutputHandle;
 588     case STD_ERROR_HANDLE:      return Ppb->ErrorHandle;
 589     }
 590   SetLastError (ERROR_INVALID_PARAMETER);
 591   return INVALID_HANDLE_VALUE;
 592 }
 593
 594 WINBASEAPI BOOL WINAPI
 595 SetStdHandle(DWORD nStdHandle,
 596              HANDLE hHandle)
 597      /*
 598       * FUNCTION: Set the handle for the standard input, standard output or
 599       * the standard error device.
 600       * ARGUMENTS:
 601       *        nStdHandle - Specifies the handle to be set.
 602       *        hHandle - The handle to set.
 603       * RETURNS: TRUE if the function succeeds, FALSE otherwise.
 604       */
 605 {
 606   PRTL_ROS_USER_PROCESS_PARAMETERS Ppb;
 607
 608   Ppb = NtCurrentPeb()->ProcessParameters;
 609
 610   /* More checking needed? */
 611   if (hHandle == INVALID_HANDLE_VALUE)
 612     {
 613       SetLastError (ERROR_INVALID_HANDLE);
 614       return FALSE;
 615     }
 616
 617   SetLastError(ERROR_SUCCESS); /* OK */
 618   switch (nStdHandle)
 619     {
 620     case STD_INPUT_HANDLE:
 621       Ppb->InputHandle = hHandle;
 622       return TRUE;
 623     case STD_OUTPUT_HANDLE:
 624       Ppb->OutputHandle = hHandle;
 625       return TRUE;
 626     case STD_ERROR_HANDLE:
 627       Ppb->ErrorHandle = hHandle;
 628       return TRUE;
 629     }
 630   SetLastError (ERROR_INVALID_PARAMETER);
 631   return FALSE;
 632 }
 633
 634
 635 /*--------------------------------------------------------------
 636  *      WriteConsoleA
 637  */
 638 WINBOOL STDCALL
 639 WriteConsoleA(HANDLE hConsoleOutput,
 640               CONST VOID *lpBuffer,
 641               DWORD nNumberOfCharsToWrite,
 642               LPDWORD lpNumberOfCharsWritten,
 643               LPVOID lpReserved)
 644 {
 645   PCSRSS_API_REQUEST Request;
 646   CSRSS_API_REPLY Reply;
 647   NTSTATUS Status;
 648   USHORT Size;
 649   ULONG MessageSize;
 650
 651   Request = RtlAllocateHeap(GetProcessHeap(),
 652                             HEAP_ZERO_MEMORY,
 653                             sizeof(CSRSS_API_REQUEST) +
 654                             CSRSS_MAX_WRITE_CONSOLE_REQUEST);
 655   if (Request == NULL)
 656     {
 657       SetLastError(ERROR_OUTOFMEMORY);
 658       return(FALSE);
 659     }
 660
 661   Request->Type = CSRSS_WRITE_CONSOLE;
 662   Request->Data.WriteConsoleRequest.ConsoleHandle = hConsoleOutput;
 663   if (lpNumberOfCharsWritten != NULL)
 664     *lpNumberOfCharsWritten = nNumberOfCharsToWrite;
 665   while (nNumberOfCharsToWrite)
 666     {
 667       if (nNumberOfCharsToWrite > CSRSS_MAX_WRITE_CONSOLE_REQUEST)
 668         {
 669           Size = CSRSS_MAX_WRITE_CONSOLE_REQUEST;
 670         }
 671       else
 672         {
 673           Size = nNumberOfCharsToWrite;
 674         }
 675       Request->Data.WriteConsoleRequest.NrCharactersToWrite = Size;
 676
 677       memcpy(Request->Data.WriteConsoleRequest.Buffer, lpBuffer, Size);
 678
 679       MessageSize = CSRSS_REQUEST_HEADER_SIZE +
 680         sizeof(CSRSS_WRITE_CONSOLE_REQUEST) + Size;
 681       Status = CsrClientCallServer(Request,
 682                                    &Reply,
 683                                    MessageSize,
 684                                    sizeof(CSRSS_API_REPLY));
 685
 686       if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
 687         {
 688           RtlFreeHeap(GetProcessHeap(), 0, Request);
 689           SetLastErrorByStatus(Status);
 690           return(FALSE);
 691         }
 692       nNumberOfCharsToWrite -= Size;
 693       lpBuffer += Size;
 694     }
 695   RtlFreeHeap(GetProcessHeap(), 0, Request);
 696   return TRUE;
 697 }
 698
 699
 700 /*--------------------------------------------------------------
 701  *      ReadConsoleA
 702  */
 703 WINBOOL STDCALL ReadConsoleA(HANDLE hConsoleInput,
 704                              LPVOID lpBuffer,
 705                              DWORD nNumberOfCharsToRead,
 706                              LPDWORD lpNumberOfCharsRead,
 707                              LPVOID lpReserved)
 708 {
 709    CSRSS_API_REQUEST Request;
 710    PCSRSS_API_REPLY Reply;
 711    NTSTATUS Status;
 712    ULONG CharsRead = 0;
 713
 714    Reply = RtlAllocateHeap(GetProcessHeap(),
 715                      HEAP_ZERO_MEMORY,
 716                      sizeof(CSRSS_API_REPLY) + nNumberOfCharsToRead);
 717    if (Reply == NULL)
 718      {
 719         SetLastError(ERROR_OUTOFMEMORY);
 720         return(FALSE);
 721      }
 722
 723    Request.Type = CSRSS_READ_CONSOLE;
 724    Request.Data.ReadConsoleRequest.ConsoleHandle = hConsoleInput;
 725    Request.Data.ReadConsoleRequest.NrCharactersToRead = nNumberOfCharsToRead > CSRSS_MAX_READ_CONSOLE_REQUEST ? CSRSS_MAX_READ_CONSOLE_REQUEST : nNumberOfCharsToRead;
 726    Request.Data.ReadConsoleRequest.nCharsCanBeDeleted = 0;
 727    Status = CsrClientCallServer(&Request,
 728                                 Reply,
 729                                 sizeof(CSRSS_API_REQUEST),
 730                                 sizeof(CSRSS_API_REPLY) +
 731                                 Request.Data.ReadConsoleRequest.NrCharactersToRead);
 732    if (!NT_SUCCESS(Status) || !NT_SUCCESS( Status = Reply->Status ))
 733      {
 734         DbgPrint( "CSR returned error in ReadConsole\n" );
 735         SetLastErrorByStatus ( Status );
 736         RtlFreeHeap( GetProcessHeap(), 0, Reply );
 737         return(FALSE);
 738      }
 739    if( Reply->Status == STATUS_NOTIFY_CLEANUP )
 740       Reply->Status = STATUS_PENDING;     // ignore backspace because we have no chars to backspace
 741    /* There may not be any chars or lines to read yet, so wait */
 742    while( Reply->Status == STATUS_PENDING )
 743      {
 744        /* some chars may have been returned, but not a whole line yet, so recompute buffer and try again */
 745        nNumberOfCharsToRead -= Reply->Data.ReadConsoleReply.NrCharactersRead;
 746        /* don't overflow caller's buffer, even if you still don't have a complete line */
 747        if( !nNumberOfCharsToRead )
 748          break;
 749        Request.Data.ReadConsoleRequest.NrCharactersToRead = nNumberOfCharsToRead > CSRSS_MAX_READ_CONSOLE_REQUEST ? CSRSS_MAX_READ_CONSOLE_REQUEST : nNumberOfCharsToRead;
 750        /* copy any chars already read to buffer */
 751        memcpy( lpBuffer + CharsRead, Reply->Data.ReadConsoleReply.Buffer, Reply->Data.ReadConsoleReply.NrCharactersRead );
 752        CharsRead += Reply->Data.ReadConsoleReply.NrCharactersRead;
 753        /* wait for csrss to signal there is more data to read, but not if we got STATUS_NOTIFY_CLEANUP for backspace */
 754        Status = NtWaitForSingleObject( Reply->Data.ReadConsoleReply.EventHandle, FALSE, 0 );
 755        if( !NT_SUCCESS( Status ) )
 756           {
 757              DbgPrint( "Wait for console input failed!\n" );
 758              RtlFreeHeap( GetProcessHeap(), 0, Reply );
 759              return FALSE;
 760           }
 761        Request.Data.ReadConsoleRequest.nCharsCanBeDeleted = CharsRead;
 762        Status = CsrClientCallServer( &Request, Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) + Request.Data.ReadConsoleRequest.NrCharactersToRead );
 763        if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply->Status ) )
 764          {
 765            SetLastErrorByStatus ( Status );
 766            RtlFreeHeap( GetProcessHeap(), 0, Reply );
 767            return FALSE;
 768          }
 769        if( Reply->Status == STATUS_NOTIFY_CLEANUP )
 770           {
 771              // delete last char
 772              if( CharsRead )
 773                 {
 774                    CharsRead--;
 775                    nNumberOfCharsToRead++;
 776                 }
 777              Reply->Status = STATUS_PENDING;  // retry
 778           }
 779      }
 780    /* copy data to buffer, count total returned, and return */
 781    memcpy( lpBuffer + CharsRead, Reply->Data.ReadConsoleReply.Buffer, Reply->Data.ReadConsoleReply.NrCharactersRead );
 782    CharsRead += Reply->Data.ReadConsoleReply.NrCharactersRead;
 783    if (lpNumberOfCharsRead != NULL)
 784      *lpNumberOfCharsRead = CharsRead;
 785    RtlFreeHeap(GetProcessHeap(),
 786             0,
 787             Reply);
 788
 789    return(TRUE);
 790 }
 791
 792
 793 /*--------------------------------------------------------------
 794  *      AllocConsole
 795  */
 796 WINBOOL STDCALL AllocConsole(VOID)
 797 {
 798    CSRSS_API_REQUEST Request;
 799    CSRSS_API_REPLY Reply;
 800    NTSTATUS Status;
 801
 802    Request.Type = CSRSS_ALLOC_CONSOLE;
 803    Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
 804    if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
 805       {
 806          SetLastErrorByStatus ( Status );
 807          return FALSE;
 808       }
 809    SetStdHandle( STD_INPUT_HANDLE, Reply.Data.AllocConsoleReply.InputHandle );
 810    SetStdHandle( STD_OUTPUT_HANDLE, Reply.Data.AllocConsoleReply.OutputHandle );
 811    SetStdHandle( STD_ERROR_HANDLE, Reply.Data.AllocConsoleReply.OutputHandle );
 812    return TRUE;
 813 }
 814
 815
 816 /*--------------------------------------------------------------
 817  *      FreeConsole
 818  */
 819 WINBOOL STDCALL FreeConsole(VOID)
 820 {
 821    DbgPrint("FreeConsole() is unimplemented\n");
 822    return FALSE;
 823 }
 824
 825
 826 /*--------------------------------------------------------------
 827  *      GetConsoleScreenBufferInfo
 828  */
 829 WINBOOL
 830 STDCALL
 831 GetConsoleScreenBufferInfo(
 832     HANDLE hConsoleOutput,
 833     PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo
 834     )
 835 {
 836    CSRSS_API_REQUEST Request;
 837    CSRSS_API_REPLY Reply;
 838    NTSTATUS Status;
 839
 840    Request.Type = CSRSS_SCREEN_BUFFER_INFO;
 841    Request.Data.ScreenBufferInfoRequest.ConsoleHandle = hConsoleOutput;
 842    Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
 843    if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
 844       {
 845          SetLastErrorByStatus ( Status );
 846          return FALSE;
 847       }
 848    *lpConsoleScreenBufferInfo = Reply.Data.ScreenBufferInfoReply.Info;
 849    return TRUE;
 850 }
 851
 852
 853 /*--------------------------------------------------------------
 854  *      SetConsoleCursorPosition
 855  */
 856 WINBOOL
 857 STDCALL
 858 SetConsoleCursorPosition(
 859     HANDLE hConsoleOutput,
 860     COORD dwCursorPosition
 861     )
 862 {
 863    CSRSS_API_REQUEST Request;
 864    CSRSS_API_REPLY Reply;
 865    NTSTATUS Status;
 866
 867    Request.Type = CSRSS_SET_CURSOR;
 868    Request.Data.SetCursorRequest.ConsoleHandle = hConsoleOutput;
 869    Request.Data.SetCursorRequest.Position = dwCursorPosition;
 870    Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
 871    if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
 872       {
 873          SetLastErrorByStatus ( Status );
 874          return FALSE;
 875       }
 876    return TRUE;
 877 }
 878
 879
 880 /*--------------------------------------------------------------
 881  *      FillConsoleOutputCharacterA
 882  */
 883 WINBOOL STDCALL
 884 FillConsoleOutputCharacterA(
 885         HANDLE          hConsoleOutput,
 886         CHAR            cCharacter,
 887         DWORD           nLength,
 888         COORD           dwWriteCoord,
 889         LPDWORD         lpNumberOfCharsWritten
 890         )
 891 {
 892   CSRSS_API_REQUEST Request;
 893   CSRSS_API_REPLY Reply;
 894   NTSTATUS Status;
 895
 896   Request.Type = CSRSS_FILL_OUTPUT;
 897   Request.Data.FillOutputRequest.ConsoleHandle = hConsoleOutput;
 898   Request.Data.FillOutputRequest.Char = cCharacter;
 899   Request.Data.FillOutputRequest.Position = dwWriteCoord;
 900   Request.Data.FillOutputRequest.Length = nLength;
 901   Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
 902   if ( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
 903     {
 904       SetLastErrorByStatus(Status);
 905       return(FALSE);
 906     }
 907   if (lpNumberOfCharsWritten != NULL)
 908      *lpNumberOfCharsWritten = nLength;
 909   return(TRUE);
 910 }
 911
 912
 913 /*--------------------------------------------------------------
 914  *      FillConsoleOutputCharacterW
 915  */
 916 WINBOOL
 917 STDCALL
 918 FillConsoleOutputCharacterW(
 919         HANDLE          hConsoleOutput,
 920         WCHAR           cCharacter,
 921         DWORD           nLength,
 922         COORD           dwWriteCoord,
 923         LPDWORD         lpNumberOfCharsWritten
 924         )
 925 {
 926 /* TO DO */
 927         return FALSE;
 928 }
 929
 930
 931 /*--------------------------------------------------------------
 932  *      PeekConsoleInputA
 933  */
 934 WINBASEAPI
 935 BOOL
 936 WINAPI
 937 PeekConsoleInputA(
 938         HANDLE                  hConsoleInput,
 939         PINPUT_RECORD           lpBuffer,
 940         DWORD                   nLength,
 941         LPDWORD                 lpNumberOfEventsRead
 942         )
 943 {
 944 /* TO DO */
 945         return FALSE;
 946 }
 947
 948
 949 /*--------------------------------------------------------------
 950  *      PeekConsoleInputW
 951  */
 952 WINBASEAPI
 953 BOOL
 954 WINAPI
 955 PeekConsoleInputW(
 956         HANDLE                  hConsoleInput,
 957         PINPUT_RECORD           lpBuffer,
 958         DWORD                   nLength,
 959         LPDWORD                 lpNumberOfEventsRead
 960         )
 961 {
 962 /* TO DO */
 963         return FALSE;
 964 }
 965
 966
 967 /*--------------------------------------------------------------
 968  *      ReadConsoleInputA
 969  */
 970 WINBASEAPI BOOL WINAPI
 971 ReadConsoleInputA(HANDLE hConsoleInput,
 972                   PINPUT_RECORD lpBuffer,
 973                   DWORD nLength,
 974                   LPDWORD lpNumberOfEventsRead)
 975 {
 976   CSRSS_API_REQUEST Request;
 977   CSRSS_API_REPLY Reply;
 978   DWORD NumEventsRead;
 979   NTSTATUS Status;
 980
 981   Request.Type = CSRSS_READ_INPUT;
 982   Request.Data.ReadInputRequest.ConsoleHandle = hConsoleInput;
 983   Status = CsrClientCallServer(&Request, &Reply, sizeof(CSRSS_API_REQUEST),
 984                                 sizeof(CSRSS_API_REPLY));
 985   if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
 986     {
 987       SetLastErrorByStatus(Status);
 988       return(FALSE);
 989     }
 990
 991   while (Status == STATUS_PENDING)
 992     {
 993       Status = NtWaitForSingleObject(Reply.Data.ReadInputReply.Event, FALSE,
 994                                      0);
 995       if(!NT_SUCCESS(Status))
 996         {
 997           SetLastErrorByStatus(Status);
 998           return FALSE;
 999         }
1000
1001       Request.Type = CSRSS_READ_INPUT;
1002       Request.Data.ReadInputRequest.ConsoleHandle = hConsoleInput;
1003       Status = CsrClientCallServer(&Request, &Reply, sizeof(CSRSS_API_REQUEST),
1004                                    sizeof(CSRSS_API_REPLY));
1005       if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
1006         {
1007           SetLastErrorByStatus(Status);
1008           return(FALSE);
1009         }
1010     }
1011
1012   NumEventsRead = 0;
1013   *lpBuffer = Reply.Data.ReadInputReply.Input;
1014   lpBuffer++;
1015   NumEventsRead++;
1016
1017   while ((NumEventsRead < nLength) && (Reply.Data.ReadInputReply.MoreEvents))
1018     {
1019       Status = CsrClientCallServer(&Request, &Reply, sizeof(CSRSS_API_REQUEST),
1020                                    sizeof(CSRSS_API_REPLY));
1021       if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
1022         {
1023           SetLastErrorByStatus(Status);
1024           return(FALSE);
1025         }
1026
1027       if (Status == STATUS_PENDING)
1028         {
1029           break;
1030         }
1031
1032       *lpBuffer = Reply.Data.ReadInputReply.Input;
1033       lpBuffer++;
1034       NumEventsRead++;
1035
1036     }
1037   *lpNumberOfEventsRead = NumEventsRead;
1038
1039   return TRUE;
1040 }
1041
1042
1043 /*--------------------------------------------------------------
1044  *      ReadConsoleInputW
1045  */
1046 WINBASEAPI
1047 BOOL
1048 WINAPI
1049 ReadConsoleInputW(
1050         HANDLE                  hConsoleInput,
1051         PINPUT_RECORD           lpBuffer,
1052         DWORD                   nLength,
1053         LPDWORD                 lpNumberOfEventsRead
1054         )
1055 {
1056 /* TO DO */
1057         return FALSE;
1058 }
1059
1060
1061 /*--------------------------------------------------------------
1062  *      WriteConsoleInputA
1063  */
1064 WINBASEAPI
1065 BOOL
1066 WINAPI
1067 WriteConsoleInputA(
1068         HANDLE                   hConsoleInput,
1069         CONST INPUT_RECORD      *lpBuffer,
1070         DWORD                    nLength,
1071         LPDWORD                  lpNumberOfEventsWritten
1072         )
1073 {
1074 /* TO DO */
1075         return FALSE;
1076 }
1077
1078
1079 /*--------------------------------------------------------------
1080  *      WriteConsoleInputW
1081  */
1082 WINBASEAPI
1083 BOOL
1084 WINAPI
1085 WriteConsoleInputW(
1086         HANDLE                   hConsoleInput,
1087         CONST INPUT_RECORD      *lpBuffer,
1088         DWORD                    nLength,
1089         LPDWORD                  lpNumberOfEventsWritten
1090         )
1091 {
1092 /* TO DO */
1093         return FALSE;
1094 }
1095
1096
1097 /*--------------------------------------------------------------
1098  *      ReadConsoleOutputA
1099  */
1100 WINBASEAPI
1101 BOOL
1102 WINAPI
1103 ReadConsoleOutputA(
1104         HANDLE          hConsoleOutput,
1105         PCHAR_INFO      lpBuffer,
1106         COORD           dwBufferSize,
1107         COORD           dwBufferCoord,
1108         PSMALL_RECT     lpReadRegion
1109         )
1110 {
1111 /* TO DO */
1112         return FALSE;
1113 }
1114
1115
1116 /*--------------------------------------------------------------
1117  *      ReadConsoleOutputW
1118  */
1119 WINBASEAPI
1120 BOOL
1121 WINAPI
1122 ReadConsoleOutputW(
1123         HANDLE          hConsoleOutput,
1124         PCHAR_INFO      lpBuffer,
1125         COORD           dwBufferSize,
1126         COORD           dwBufferCoord,
1127         PSMALL_RECT     lpReadRegion
1128         )
1129 {
1130 /* TO DO */
1131         return FALSE;
1132 }
1133
1134 /*--------------------------------------------------------------
1135  *      WriteConsoleOutputA
1136  */
1137 WINBASEAPI BOOL WINAPI
1138 WriteConsoleOutputA(HANDLE               hConsoleOutput,
1139                     CONST CHAR_INFO     *lpBuffer,
1140                     COORD                dwBufferSize,
1141                     COORD                dwBufferCoord,
1142                     PSMALL_RECT  lpWriteRegion)
1143 {
1144   PCSRSS_API_REQUEST Request;
1145   CSRSS_API_REPLY Reply;
1146   NTSTATUS Status;
1147   ULONG Size;
1148   BOOLEAN Result;
1149   ULONG i, j;
1150   PVOID BufferBase;
1151   PVOID BufferTargetBase;
1152
1153   Size = dwBufferSize.Y * dwBufferSize.X * sizeof(CHAR_INFO);
1154
1155   Status = CsrCaptureParameterBuffer((PVOID)lpBuffer,
1156                                      Size,
1157                                      &BufferBase,
1158                                      &BufferTargetBase);
1159   if (!NT_SUCCESS(Status))
1160     {
1161       SetLastErrorByStatus(Status);
1162       return(FALSE);
1163     }
1164
1165   Request = RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY,
1166                             sizeof(CSRSS_API_REQUEST));
1167   if (Request == NULL)
1168     {
1169       SetLastError(ERROR_OUTOFMEMORY);
1170       return FALSE;
1171     }
1172   Request->Type = CSRSS_WRITE_CONSOLE_OUTPUT;
1173   Request->Data.WriteConsoleOutputRequest.ConsoleHandle = hConsoleOutput;
1174   Request->Data.WriteConsoleOutputRequest.BufferSize = dwBufferSize;
1175   Request->Data.WriteConsoleOutputRequest.BufferCoord = dwBufferCoord;
1176   Request->Data.WriteConsoleOutputRequest.WriteRegion = *lpWriteRegion;
1177   Request->Data.WriteConsoleOutputRequest.CharInfo =
1178     (CHAR_INFO*)BufferTargetBase;
1179
1180   Status = CsrClientCallServer(Request, &Reply,
1181                                sizeof(CSRSS_API_REQUEST),
1182                                sizeof(CSRSS_API_REPLY));
1183   if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
1184     {
1185       RtlFreeHeap(GetProcessHeap(), 0, Request);
1186       SetLastErrorByStatus(Status);
1187       return FALSE;
1188     }
1189
1190   *lpWriteRegion = Reply.Data.WriteConsoleOutputReply.WriteRegion;
1191   RtlFreeHeap(GetProcessHeap(), 0, Request);
1192   CsrReleaseParameterBuffer(BufferBase);
1193   return(TRUE);
1194 }
1195
1196
1197 /*--------------------------------------------------------------
1198  *      WriteConsoleOutputW
1199  */
1200 WINBASEAPI
1201 BOOL
1202 WINAPI
1203 WriteConsoleOutputW(
1204         HANDLE           hConsoleOutput,
1205         CONST CHAR_INFO *lpBuffer,
1206         COORD            dwBufferSize,
1207         COORD            dwBufferCoord,
1208         PSMALL_RECT      lpWriteRegion
1209         )
1210 {
1211 /* TO DO */
1212         return FALSE;
1213 }
1214
1215
1216 /*--------------------------------------------------------------
1217  *      ReadConsoleOutputCharacterA
1218  */
1219 WINBASEAPI
1220 BOOL
1221 WINAPI
1222 ReadConsoleOutputCharacterA(
1223         HANDLE          hConsoleOutput,
1224         LPSTR           lpCharacter,
1225         DWORD           nLength,
1226         COORD           dwReadCoord,
1227         LPDWORD         lpNumberOfCharsRead
1228         )
1229 {
1230   CSRSS_API_REQUEST Request;
1231   PCSRSS_API_REPLY Reply;
1232   NTSTATUS Status;
1233   DWORD Size;
1234
1235   Reply = RtlAllocateHeap(GetProcessHeap(),
1236                           HEAP_ZERO_MEMORY,
1237                           sizeof(CSRSS_API_REPLY) + CSRSS_MAX_READ_CONSOLE_OUTPUT_CHAR);
1238   if (Reply == NULL)
1239     {
1240       SetLastError(ERROR_OUTOFMEMORY);
1241       return(FALSE);
1242     }
1243
1244   if (lpNumberOfCharsRead != NULL)
1245     *lpNumberOfCharsRead = Size;
1246
1247   Request.Type = CSRSS_READ_CONSOLE_OUTPUT_CHAR;
1248   Request.Data.ReadConsoleOutputCharRequest.ConsoleHandle = hConsoleOutput;
1249   Request.Data.ReadConsoleOutputCharRequest.ReadCoord = dwReadCoord;
1250
1251   while (nLength != 0)
1252     {
1253       if (nLength > CSRSS_MAX_READ_CONSOLE_OUTPUT_CHAR)
1254         Size = CSRSS_MAX_READ_CONSOLE_OUTPUT_CHAR;
1255       else
1256         Size = nLength;
1257
1258       Request.Data.ReadConsoleOutputCharRequest.NumCharsToRead = Size;
1259
1260       Status = CsrClientCallServer(&Request,
1261                                    Reply,
1262                                    sizeof(CSRSS_API_REQUEST),
1263                                    sizeof(CSRSS_API_REPLY) + Size);
1264       if (!NT_SUCCESS(Status) || !NT_SUCCESS(Reply->Status))
1265         {
1266           RtlFreeHeap(GetProcessHeap(), 0, Reply);
1267           SetLastErrorByStatus(Status);
1268           return(FALSE);
1269         }
1270
1271       memcpy(lpCharacter, &Reply->Data.ReadConsoleOutputCharReply.String[0], Size);
1272       lpCharacter += Size;
1273       nLength -= Size;
1274       Request.Data.ReadConsoleOutputCharRequest.ReadCoord = Reply->Data.ReadConsoleOutputCharReply.EndCoord;
1275     }
1276
1277   RtlFreeHeap(GetProcessHeap(), 0, Reply);
1278
1279   return(TRUE);
1280 }
1281
1282
1283 /*--------------------------------------------------------------
1284  *      ReadConsoleOutputCharacterW
1285  */
1286 WINBASEAPI
1287 BOOL
1288 WINAPI
1289 ReadConsoleOutputCharacterW(
1290         HANDLE          hConsoleOutput,
1291         LPWSTR          lpCharacter,
1292         DWORD           nLength,
1293         COORD           dwReadCoord,
1294         LPDWORD         lpNumberOfCharsRead
1295         )
1296 {
1297 /* TO DO */
1298         return FALSE;
1299 }
1300
1301
1302 /*--------------------------------------------------------------
1303  *      ReadConsoleOutputAttribute
1304  */
1305 WINBASEAPI
1306 BOOL
1307 WINAPI
1308 ReadConsoleOutputAttribute(
1309         HANDLE          hConsoleOutput,
1310         LPWORD          lpAttribute,
1311         DWORD           nLength,
1312         COORD           dwReadCoord,
1313         LPDWORD         lpNumberOfAttrsRead
1314         )
1315 {
1316    SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
1317    return FALSE;
1318 }
1319
1320
1321 /*--------------------------------------------------------------
1322  *      WriteConsoleOutputCharacterA
1323  */
1324 WINBASEAPI BOOL WINAPI
1325 WriteConsoleOutputCharacterA(HANDLE             hConsoleOutput,
1326                              LPCSTR             lpCharacter,
1327                              DWORD              nLength,
1328                              COORD              dwWriteCoord,
1329                              LPDWORD            lpNumberOfCharsWritten)
1330 {
1331   PCSRSS_API_REQUEST Request;
1332   CSRSS_API_REPLY Reply;
1333   NTSTATUS Status;
1334   WORD Size;
1335
1336   Request = RtlAllocateHeap(GetProcessHeap(),
1337                             HEAP_ZERO_MEMORY,
1338                             sizeof(CSRSS_API_REQUEST) + CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR);
1339   if( !Request )
1340     {
1341       SetLastError( ERROR_OUTOFMEMORY );
1342       return FALSE;
1343     }
1344   Request->Type = CSRSS_WRITE_CONSOLE_OUTPUT_CHAR;
1345   Request->Data.WriteConsoleOutputCharRequest.ConsoleHandle = hConsoleOutput;
1346   Request->Data.WriteConsoleOutputCharRequest.Coord = dwWriteCoord;
1347   if( lpNumberOfCharsWritten )
1348     *lpNumberOfCharsWritten = nLength;
1349   while( nLength )
1350     {
1351       Size = nLength > CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR ? CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR : nLength;
1352       Request->Data.WriteConsoleOutputCharRequest.Length = Size;
1353       memcpy( &Request->Data.WriteConsoleOutputCharRequest.String[0],
1354               lpCharacter,
1355               Size );
1356       Status = CsrClientCallServer( Request, &Reply, sizeof( CSRSS_API_REQUEST ) + Size, sizeof( CSRSS_API_REPLY ) );
1357       if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
1358         {
1359           RtlFreeHeap( GetProcessHeap(), 0, Request );
1360           SetLastErrorByStatus ( Status );
1361           return FALSE;
1362         }
1363       nLength -= Size;
1364       lpCharacter += Size;
1365       Request->Data.WriteConsoleOutputCharRequest.Coord = Reply.Data.WriteConsoleOutputCharReply.EndCoord;
1366     }
1367   return TRUE;
1368 }
1369
1370
1371 /*--------------------------------------------------------------
1372  *      WriteConsoleOutputCharacterW
1373  */
1374 WINBASEAPI
1375 BOOL
1376 WINAPI
1377 WriteConsoleOutputCharacterW(
1378         HANDLE          hConsoleOutput,
1379         LPCWSTR         lpCharacter,
1380         DWORD           nLength,
1381         COORD           dwWriteCoord,
1382         LPDWORD         lpNumberOfCharsWritten
1383         )
1384 {
1385 /* TO DO */
1386         return FALSE;
1387 }
1388
1389
1390
1391 /*--------------------------------------------------------------
1392  *      WriteConsoleOutputAttribute
1393  */
1394 WINBASEAPI
1395 BOOL
1396 WINAPI
1397 WriteConsoleOutputAttribute(
1398         HANDLE           hConsoleOutput,
1399         CONST WORD      *lpAttribute,
1400         DWORD            nLength,
1401         COORD            dwWriteCoord,
1402         LPDWORD          lpNumberOfAttrsWritten
1403         )
1404 {
1405    PCSRSS_API_REQUEST Request;
1406    CSRSS_API_REPLY Reply;
1407    NTSTATUS Status;
1408    WORD Size;
1409    int c;
1410
1411    Request = RtlAllocateHeap(GetProcessHeap(),
1412                        HEAP_ZERO_MEMORY,
1413                        sizeof(CSRSS_API_REQUEST) + CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB);
1414    if( !Request )
1415      {
1416        SetLastError( ERROR_OUTOFMEMORY );
1417        return FALSE;
1418      }
1419    Request->Type = CSRSS_WRITE_CONSOLE_OUTPUT_ATTRIB;
1420    Request->Data.WriteConsoleOutputAttribRequest.ConsoleHandle = hConsoleOutput;
1421    Request->Data.WriteConsoleOutputAttribRequest.Coord = dwWriteCoord;
1422    if( lpNumberOfAttrsWritten )
1423       *lpNumberOfAttrsWritten = nLength;
1424    while( nLength )
1425       {
1426          Size = nLength > CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB ? CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB : nLength;
1427          Request->Data.WriteConsoleOutputAttribRequest.Length = Size;
1428          for( c = 0; c < ( Size * 2 ); c++ )
1429            Request->Data.WriteConsoleOutputAttribRequest.String[c] = (char)lpAttribute[c];
1430          Status = CsrClientCallServer( Request, &Reply, sizeof( CSRSS_API_REQUEST ) + (Size * 2), sizeof( CSRSS_API_REPLY ) );
1431          if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
1432             {
1433          RtlFreeHeap( GetProcessHeap(), 0, Request );
1434                SetLastErrorByStatus ( Status );
1435                return FALSE;
1436             }
1437          nLength -= Size;
1438          lpAttribute += Size;
1439          Request->Data.WriteConsoleOutputAttribRequest.Coord = Reply.Data.WriteConsoleOutputAttribReply.EndCoord;
1440       }
1441    return TRUE;
1442 }
1443
1444
1445 /*--------------------------------------------------------------
1446  *      FillConsoleOutputAttribute
1447  */
1448 WINBASEAPI
1449 BOOL
1450 WINAPI
1451 FillConsoleOutputAttribute(
1452         HANDLE          hConsoleOutput,
1453         WORD            wAttribute,
1454         DWORD           nLength,
1455         COORD           dwWriteCoord,
1456         LPDWORD         lpNumberOfAttrsWritten
1457         )
1458 {
1459    CSRSS_API_REQUEST Request;
1460    CSRSS_API_REPLY Reply;
1461    NTSTATUS Status;
1462
1463    Request.Type = CSRSS_FILL_OUTPUT_ATTRIB;
1464    Request.Data.FillOutputAttribRequest.ConsoleHandle = hConsoleOutput;
1465    Request.Data.FillOutputAttribRequest.Attribute = wAttribute;
1466    Request.Data.FillOutputAttribRequest.Coord = dwWriteCoord;
1467    Request.Data.FillOutputAttribRequest.Length = nLength;
1468    Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
1469    if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
1470       {
1471          SetLastErrorByStatus ( Status );
1472          return FALSE;
1473       }
1474    if( lpNumberOfAttrsWritten )
1475       *lpNumberOfAttrsWritten = nLength;
1476    return TRUE;
1477 }
1478
1479
1480 /*--------------------------------------------------------------
1481  *      GetConsoleMode
1482  */
1483 WINBASEAPI
1484 BOOL
1485 WINAPI
1486 GetConsoleMode(
1487         HANDLE          hConsoleHandle,
1488         LPDWORD         lpMode
1489         )
1490 {
1491   CSRSS_API_REQUEST Request;
1492   CSRSS_API_REPLY Reply;
1493   NTSTATUS Status;
1494
1495   Request.Type = CSRSS_GET_MODE;
1496   Request.Data.GetConsoleModeRequest.ConsoleHandle = hConsoleHandle;
1497   Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
1498   if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
1499       {
1500         SetLastErrorByStatus ( Status );
1501         return FALSE;
1502       }
1503   *lpMode = Reply.Data.GetConsoleModeReply.ConsoleMode;
1504   return TRUE;
1505 }
1506
1507
1508 /*--------------------------------------------------------------
1509  *      GetNumberOfConsoleInputEvents
1510  */
1511 WINBASEAPI
1512 BOOL
1513 WINAPI
1514 GetNumberOfConsoleInputEvents(
1515         HANDLE          hConsoleInput,
1516         LPDWORD         lpNumberOfEvents
1517         )
1518 {
1519 /* TO DO */
1520         return FALSE;
1521 }
1522
1523
1524 /*--------------------------------------------------------------
1525  *      GetLargestConsoleWindowSize
1526  */
1527 WINBASEAPI
1528 COORD
1529 WINAPI
1530 GetLargestConsoleWindowSize(
1531         HANDLE          hConsoleOutput
1532         )
1533 {
1534 #if 1   /* FIXME: */
1535         COORD Coord = {80,25};
1536
1537 /* TO DO */
1538         return Coord;
1539 #endif
1540 }
1541
1542
1543 /*--------------------------------------------------------------
1544  *      GetConsoleCursorInfo
1545  */
1546 WINBASEAPI
1547 BOOL
1548 WINAPI
1549 GetConsoleCursorInfo(
1550         HANDLE                  hConsoleOutput,
1551         PCONSOLE_CURSOR_INFO    lpConsoleCursorInfo
1552         )
1553 {
1554    CSRSS_API_REQUEST Request;
1555    CSRSS_API_REPLY Reply;
1556    NTSTATUS Status;
1557
1558    Request.Type = CSRSS_GET_CURSOR_INFO;
1559    Request.Data.GetCursorInfoRequest.ConsoleHandle = hConsoleOutput;
1560    Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
1561
1562    if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
1563       {
1564          SetLastErrorByStatus ( Status );
1565          return FALSE;
1566       }
1567    *lpConsoleCursorInfo = Reply.Data.GetCursorInfoReply.Info;
1568    return TRUE;
1569 }
1570
1571
1572 /*--------------------------------------------------------------
1573  *      GetNumberOfConsoleMouseButtons
1574  */
1575 WINBASEAPI
1576 BOOL
1577 WINAPI
1578 GetNumberOfConsoleMouseButtons(
1579         LPDWORD         lpNumberOfMouseButtons
1580         )
1581 {
1582 /* TO DO */
1583         return FALSE;
1584 }
1585
1586
1587 /*--------------------------------------------------------------
1588  *      SetConsoleMode
1589  */
1590 WINBASEAPI
1591 BOOL
1592 WINAPI
1593 SetConsoleMode(
1594         HANDLE          hConsoleHandle,
1595         DWORD           dwMode
1596         )
1597 {
1598   CSRSS_API_REQUEST Request;
1599   CSRSS_API_REPLY Reply;
1600   NTSTATUS Status;
1601
1602   Request.Type = CSRSS_SET_MODE;
1603   Request.Data.SetConsoleModeRequest.ConsoleHandle = hConsoleHandle;
1604   Request.Data.SetConsoleModeRequest.Mode = dwMode;
1605   Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
1606   if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
1607       {
1608         SetLastErrorByStatus ( Status );
1609         return FALSE;
1610       }
1611   return TRUE;
1612 }
1613
1614
1615 /*--------------------------------------------------------------
1616  *      SetConsoleActiveScreenBuffer
1617  */
1618 WINBASEAPI
1619 BOOL
1620 WINAPI
1621 SetConsoleActiveScreenBuffer(
1622         HANDLE          hConsoleOutput
1623         )
1624 {
1625    CSRSS_API_REQUEST Request;
1626    CSRSS_API_REPLY Reply;
1627    NTSTATUS Status;
1628
1629    Request.Type = CSRSS_SET_SCREEN_BUFFER;
1630    Request.Data.SetActiveScreenBufferRequest.OutputHandle = hConsoleOutput;
1631    Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
1632    if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
1633       {
1634          SetLastErrorByStatus ( Status );
1635          return FALSE;
1636       }
1637    return TRUE;
1638 }
1639
1640
1641 /*--------------------------------------------------------------
1642  *      FlushConsoleInputBuffer
1643  */
1644 WINBASEAPI
1645 BOOL
1646 WINAPI
1647 FlushConsoleInputBuffer(
1648         HANDLE          hConsoleInput
1649         )
1650 {
1651    CSRSS_API_REQUEST Request;
1652    CSRSS_API_REPLY Reply;
1653    NTSTATUS Status;
1654
1655    Request.Type = CSRSS_FLUSH_INPUT_BUFFER;
1656    Request.Data.FlushInputBufferRequest.ConsoleInput = hConsoleInput;
1657    Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
1658    if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
1659       {
1660          SetLastErrorByStatus ( Status );
1661          return FALSE;
1662       }
1663    return TRUE;
1664 }
1665
1666
1667 /*--------------------------------------------------------------
1668  *      SetConsoleScreenBufferSize
1669  */
1670 WINBASEAPI
1671 BOOL
1672 WINAPI
1673 SetConsoleScreenBufferSize(
1674         HANDLE          hConsoleOutput,
1675         COORD           dwSize
1676         )
1677 {
1678 /* TO DO */
1679         return FALSE;
1680 }
1681
1682 /*--------------------------------------------------------------
1683  *      SetConsoleCursorInfo
1684  */
1685 WINBASEAPI
1686 BOOL
1687 WINAPI
1688 SetConsoleCursorInfo(
1689         HANDLE                           hConsoleOutput,
1690         CONST CONSOLE_CURSOR_INFO       *lpConsoleCursorInfo
1691         )
1692 {
1693    CSRSS_API_REQUEST Request;
1694    CSRSS_API_REPLY Reply;
1695    NTSTATUS Status;
1696
1697    Request.Type = CSRSS_SET_CURSOR_INFO;
1698    Request.Data.SetCursorInfoRequest.ConsoleHandle = hConsoleOutput;
1699    Request.Data.SetCursorInfoRequest.Info = *lpConsoleCursorInfo;
1700    Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
1701
1702    if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
1703       {
1704          SetLastErrorByStatus ( Status );
1705          return FALSE;
1706       }
1707    return TRUE;
1708 }
1709
1710
1711 /*--------------------------------------------------------------
1712  *      ScrollConsoleScreenBufferA
1713  */
1714 WINBASEAPI
1715 BOOL
1716 WINAPI
1717 ScrollConsoleScreenBufferA(
1718         HANDLE                   hConsoleOutput,
1719         CONST SMALL_RECT        *lpScrollRectangle,
1720         CONST SMALL_RECT        *lpClipRectangle,
1721         COORD                    dwDestinationOrigin,
1722         CONST CHAR_INFO         *lpFill
1723         )
1724 {
1725   CSRSS_API_REQUEST Request;
1726   CSRSS_API_REPLY Reply;
1727   NTSTATUS Status;
1728
1729   Request.Type = CSRSS_SCROLL_CONSOLE_SCREEN_BUFFER;
1730   Request.Data.ScrollConsoleScreenBufferRequest.ConsoleHandle = hConsoleOutput;
1731   Request.Data.ScrollConsoleScreenBufferRequest.ScrollRectangle = *lpScrollRectangle;
1732
1733   if (lpClipRectangle != NULL)
1734     {
1735   Request.Data.ScrollConsoleScreenBufferRequest.UseClipRectangle = TRUE;
1736   Request.Data.ScrollConsoleScreenBufferRequest.ClipRectangle = *lpClipRectangle;
1737     }
1738   else
1739     {
1740   Request.Data.ScrollConsoleScreenBufferRequest.UseClipRectangle = FALSE;
1741     }
1742
1743   Request.Data.ScrollConsoleScreenBufferRequest.DestinationOrigin = dwDestinationOrigin;
1744   Request.Data.ScrollConsoleScreenBufferRequest.Fill = *lpFill;
1745   Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
1746
1747   if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
1748     {
1749       SetLastErrorByStatus ( Status );
1750       return FALSE;
1751     }
1752   return TRUE;
1753 }
1754
1755
1756 /*--------------------------------------------------------------
1757  *      ScrollConsoleScreenBufferW
1758  */
1759 WINBASEAPI
1760 BOOL
1761 WINAPI
1762 ScrollConsoleScreenBufferW(
1763         HANDLE                   hConsoleOutput,
1764         CONST SMALL_RECT        *lpScrollRectangle,
1765         CONST SMALL_RECT        *lpClipRectangle,
1766         COORD                    dwDestinationOrigin,
1767         CONST CHAR_INFO         *lpFill
1768         )
1769 {
1770 /* TO DO */
1771         return FALSE;
1772 }
1773
1774
1775 /*--------------------------------------------------------------
1776  *      SetConsoleWindowInfo
1777  */
1778 WINBASEAPI
1779 BOOL
1780 WINAPI
1781 SetConsoleWindowInfo(
1782         HANDLE                   hConsoleOutput,
1783         BOOL                     bAbsolute,
1784         CONST SMALL_RECT        *lpConsoleWindow
1785         )
1786 {
1787 /* TO DO */
1788         return FALSE;
1789 }
1790
1791
1792 /*--------------------------------------------------------------
1793  *      SetConsoleTextAttribute
1794  */
1795 WINBASEAPI
1796 BOOL
1797 WINAPI
1798 SetConsoleTextAttribute(
1799         HANDLE          hConsoleOutput,
1800         WORD            wAttributes
1801         )
1802 {
1803    CSRSS_API_REQUEST Request;
1804    CSRSS_API_REPLY Reply;
1805    NTSTATUS Status;
1806
1807    Request.Type = CSRSS_SET_ATTRIB;
1808    Request.Data.SetAttribRequest.ConsoleHandle = hConsoleOutput;
1809    Request.Data.SetAttribRequest.Attrib = wAttributes;
1810    Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
1811    if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
1812       {
1813          SetLastErrorByStatus ( Status );
1814          return FALSE;
1815       }
1816    return TRUE;
1817 }
1818
1819 BOOL STATIC
1820 AddConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine)
1821 {
1822   if (HandlerRoutine == NULL)
1823     {
1824       IgnoreCtrlEvents = TRUE;
1825       return(TRUE);
1826     }
1827   else
1828     {
1829       NrCtrlHandlers++;
1830       CtrlHandlers =
1831         RtlReAllocateHeap(RtlGetProcessHeap(),
1832                            HEAP_ZERO_MEMORY,
1833                            (PVOID)CtrlHandlers,
1834                            NrCtrlHandlers * sizeof(PHANDLER_ROUTINE));
1835       if (CtrlHandlers == NULL)
1836         {
1837           SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1838           return(FALSE);
1839         }
1840       CtrlHandlers[NrCtrlHandlers - 1] = HandlerRoutine;
1841       return(TRUE);
1842     }
1843 }
1844
1845 BOOL STATIC
1846 RemoveConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine)
1847 {
1848   ULONG i;
1849
1850   if (HandlerRoutine == NULL)
1851     {
1852       IgnoreCtrlEvents = FALSE;
1853       return(TRUE);
1854     }
1855   else
1856     {
1857       for (i = 0; i < NrCtrlHandlers; i++)
1858         {
1859           if (CtrlHandlers[i] == HandlerRoutine)
1860             {
1861               CtrlHandlers[i] = CtrlHandlers[NrCtrlHandlers - 1];
1862               NrCtrlHandlers--;
1863               CtrlHandlers =
1864                 RtlReAllocateHeap(RtlGetProcessHeap(),
1865                                   HEAP_ZERO_MEMORY,
1866                                   (PVOID)CtrlHandlers,
1867                                   NrCtrlHandlers * sizeof(PHANDLER_ROUTINE));
1868               return(TRUE);
1869             }
1870         }
1871     }
1872   return(FALSE);
1873 }
1874
1875 WINBASEAPI BOOL WINAPI
1876 SetConsoleCtrlHandler(PHANDLER_ROUTINE  HandlerRoutine,
1877                       BOOL Add)
1878 {
1879   BOOLEAN Ret;
1880
1881   RtlEnterCriticalSection(&DllLock);
1882   if (Add)
1883     {
1884       Ret = AddConsoleCtrlHandler(HandlerRoutine);
1885     }
1886   else
1887     {
1888       Ret = RemoveConsoleCtrlHandler(HandlerRoutine);
1889     }
1890   RtlLeaveCriticalSection(&DllLock);
1891   return(Ret);
1892 }
1893
1894
1895 /*--------------------------------------------------------------
1896  *      GenerateConsoleCtrlEvent
1897  */
1898 WINBASEAPI BOOL WINAPI
1899 GenerateConsoleCtrlEvent(
1900         DWORD           dwCtrlEvent,
1901         DWORD           dwProcessGroupId
1902         )
1903 {
1904   /* TO DO */
1905   return FALSE;
1906 }
1907
1908
1909 /*--------------------------------------------------------------
1910  *      GetConsoleTitleW
1911  */
1912 #define MAX_CONSOLE_TITLE_LENGTH 80
1913
1914 WINBASEAPI
1915 DWORD
1916 WINAPI
1917 GetConsoleTitleW(
1918         LPWSTR          lpConsoleTitle,
1919         DWORD           nSize
1920         )
1921 {
1922         union {
1923         CSRSS_API_REQUEST       quest;
1924         CSRSS_API_REPLY         ply;
1925         } Re;
1926         NTSTATUS                Status;
1927
1928         /* Marshall data */
1929         Re.quest.Type = CSRSS_GET_TITLE;
1930         Re.quest.Data.GetTitleRequest.ConsoleHandle =
1931                 GetStdHandle (STD_INPUT_HANDLE);
1932
1933         /* Call CSRSS */
1934         Status = CsrClientCallServer (
1935                         & Re.quest,
1936                         & Re.ply,
1937                         (sizeof (CSRSS_GET_TITLE_REQUEST) +
1938                         sizeof (LPC_MESSAGE) +
1939                         sizeof (ULONG)),
1940                         sizeof (CSRSS_API_REPLY)
1941                         );
1942         if (    !NT_SUCCESS(Status)
1943                 || !NT_SUCCESS (Status = Re.ply.Status)
1944                 )
1945         {
1946                 SetLastErrorByStatus (Status);
1947                 return (0);
1948         }
1949
1950         /* Convert size in characters to size in bytes */
1951         nSize = sizeof (WCHAR) * nSize;
1952
1953         /* Unmarshall data */
1954         if (nSize < Re.ply.Data.GetTitleReply.Length)
1955         {
1956                 DbgPrint ("%s: ret=%d\n", __FUNCTION__, Re.ply.Data.GetTitleReply.Length);
1957                 nSize /= sizeof (WCHAR);
1958                 if (nSize > 1)
1959                 {
1960                         wcsncpy (
1961                                 lpConsoleTitle,
1962                                 Re.ply.Data.GetTitleReply.Title,
1963                                 (nSize - 1)
1964                                 );
1965                         /* Add null */
1966                         lpConsoleTitle [nSize --] = L'\0';
1967                 }
1968         }
1969         else
1970         {
1971                 nSize = Re.ply.Data.GetTitleReply.Length / sizeof (WCHAR);
1972                 wcscpy (lpConsoleTitle, Re.ply.Data.GetTitleReply.Title);
1973         }
1974
1975         return nSize;
1976 }
1977
1978
1979 /*--------------------------------------------------------------
1980  *      GetConsoleTitleA
1981  *
1982  *      19990306 EA
1983  */
1984 WINBASEAPI
1985 DWORD
1986 WINAPI
1987 GetConsoleTitleA(
1988         LPSTR           lpConsoleTitle,
1989         DWORD           nSize
1990         )
1991 {
1992         wchar_t WideTitle [MAX_CONSOLE_TITLE_LENGTH];
1993         DWORD   nWideTitle = sizeof WideTitle;
1994 //      DWORD   nWritten;
1995
1996         if (!lpConsoleTitle || !nSize) return 0;
1997         nWideTitle = GetConsoleTitleW( (LPWSTR) WideTitle, nWideTitle );
1998         if (!nWideTitle) return 0;
1999 #if 0
2000         if ( (nWritten = WideCharToMultiByte(
2001                 CP_ACP,                 // ANSI code page
2002                 0,                      // performance and mapping flags
2003                 (LPWSTR) WideTitle,     // address of wide-character string
2004                 nWideTitle,             // number of characters in string
2005                 lpConsoleTitle,         // address of buffer for new string
2006                 nSize,                  // size of buffer
2007                 NULL,                   // FAST
2008                 NULL                    // FAST
2009                 )))
2010         {
2011                 lpConsoleTitle[nWritten] = '\0';
2012                 return nWritten;
2013         }
2014 #endif
2015         return 0;
2016 }
2017
2018
2019 /*--------------------------------------------------------------
2020  *      SetConsoleTitleW
2021  */
2022 WINBASEAPI
2023 BOOL
2024 WINAPI
2025 SetConsoleTitleW(
2026         LPCWSTR         lpConsoleTitle
2027         )
2028 {
2029   PCSRSS_API_REQUEST Request;
2030   CSRSS_API_REPLY Reply;
2031   NTSTATUS Status;
2032   unsigned int c;
2033
2034   Request = RtlAllocateHeap(GetProcessHeap(),
2035                             HEAP_ZERO_MEMORY,
2036                             sizeof(CSRSS_API_REQUEST) + CSRSS_MAX_SET_TITLE_REQUEST);
2037   if (Request == NULL)
2038     {
2039       SetLastError(ERROR_OUTOFMEMORY);
2040       return(FALSE);
2041     }
2042
2043   Request->Type = CSRSS_SET_TITLE;
2044   Request->Data.SetTitleRequest.Console = GetStdHandle( STD_INPUT_HANDLE );
2045
2046   for( c = 0; lpConsoleTitle[c] && c < CSRSS_MAX_TITLE_LENGTH; c++ )
2047     Request->Data.SetTitleRequest.Title[c] = lpConsoleTitle[c];
2048   // add null
2049   Request->Data.SetTitleRequest.Title[c] = 0;
2050   Request->Data.SetTitleRequest.Length = c;
2051   Status = CsrClientCallServer(Request,
2052                                &Reply,
2053                                sizeof(CSRSS_SET_TITLE_REQUEST) +
2054                                c +
2055                                sizeof( LPC_MESSAGE ) +
2056                                sizeof( ULONG ),
2057                                sizeof(CSRSS_API_REPLY));
2058
2059   if (!NT_SUCCESS(Status) || !NT_SUCCESS( Status = Reply.Status ) )
2060     {
2061       RtlFreeHeap( GetProcessHeap(), 0, Request );
2062       SetLastErrorByStatus (Status);
2063       return(FALSE);
2064     }
2065   RtlFreeHeap( GetProcessHeap(), 0, Request );
2066   return TRUE;
2067 }
2068
2069
2070 /*--------------------------------------------------------------
2071  *      SetConsoleTitleA
2072  *
2073  *      19990204 EA     Added
2074  */
2075 WINBASEAPI
2076 BOOL
2077 WINAPI
2078 SetConsoleTitleA(
2079         LPCSTR          lpConsoleTitle
2080         )
2081 {
2082   PCSRSS_API_REQUEST Request;
2083   CSRSS_API_REPLY Reply;
2084   NTSTATUS Status;
2085   unsigned int c;
2086
2087   Request = RtlAllocateHeap(GetProcessHeap(),
2088                             HEAP_ZERO_MEMORY,
2089                             sizeof(CSRSS_API_REQUEST) + CSRSS_MAX_SET_TITLE_REQUEST);
2090   if (Request == NULL)
2091     {
2092       SetLastError(ERROR_OUTOFMEMORY);
2093       return(FALSE);
2094     }
2095
2096   Request->Type = CSRSS_SET_TITLE;
2097   Request->Data.SetTitleRequest.Console = GetStdHandle( STD_INPUT_HANDLE );
2098
2099   for( c = 0; lpConsoleTitle[c] && c < CSRSS_MAX_TITLE_LENGTH; c++ )
2100     Request->Data.SetTitleRequest.Title[c] = lpConsoleTitle[c];
2101   // add null
2102   Request->Data.SetTitleRequest.Title[c] = 0;
2103   Request->Data.SetTitleRequest.Length = c;
2104   Status = CsrClientCallServer(Request,
2105                                &Reply,
2106                                sizeof(CSRSS_SET_TITLE_REQUEST) +
2107                                c +
2108                                sizeof( LPC_MESSAGE ) +
2109                                sizeof( ULONG ),
2110                                sizeof(CSRSS_API_REPLY));
2111
2112   if (!NT_SUCCESS(Status) || !NT_SUCCESS( Status = Reply.Status ) )
2113     {
2114       RtlFreeHeap( GetProcessHeap(), 0, Request );
2115       SetLastErrorByStatus (Status);
2116       return(FALSE);
2117     }
2118   RtlFreeHeap( GetProcessHeap(), 0, Request );
2119   return TRUE;
2120 }
2121
2122
2123 /*--------------------------------------------------------------
2124  *      ReadConsoleW
2125  */
2126 WINBASEAPI
2127 BOOL
2128 WINAPI
2129 ReadConsoleW(
2130         HANDLE          hConsoleInput,
2131         LPVOID          lpBuffer,
2132         DWORD           nNumberOfCharsToRead,
2133         LPDWORD         lpNumberOfCharsRead,
2134         LPVOID          lpReserved
2135         )
2136 {
2137 /* --- TO DO --- */
2138         return FALSE;
2139 }
2140
2141
2142 /*--------------------------------------------------------------
2143  *      WriteConsoleW
2144  */
2145 WINBASEAPI
2146 BOOL
2147 WINAPI
2148 WriteConsoleW(
2149         HANDLE           hConsoleOutput,
2150         CONST VOID      *lpBuffer,
2151         DWORD            nNumberOfCharsToWrite,
2152         LPDWORD          lpNumberOfCharsWritten,
2153         LPVOID           lpReserved
2154         )
2155 {
2156 #if 0
2157   PCSRSS_API_REQUEST Request;
2158   CSRSS_API_REPLY Reply;
2159   NTSTATUS Status;
2160
2161   Request = RtlAllocateHeap(GetProcessHeap(),
2162                             HEAP_ZERO_MEMORY,
2163                             sizeof(CSRSS_API_REQUEST) + nNumberOfCharsToWrite * sizeof(WCHAR));
2164   if (Request == NULL)
2165     {
2166       SetLastError(ERROR_OUTOFMEMORY);
2167       return(FALSE);
2168     }
2169
2170   Request->Type = CSRSS_WRITE_CONSOLE;
2171   Request->Data.WriteConsoleRequest.ConsoleHandle = hConsoleOutput;
2172   Request->Data.WriteConsoleRequest.NrCharactersToWrite =
2173     nNumberOfCharsToWrite;
2174 //  DbgPrint("nNumberOfCharsToWrite %d\n", nNumberOfCharsToWrite);
2175 //  DbgPrint("Buffer %s\n", Request->Data.WriteConsoleRequest.Buffer);
2176   memcpy(Request->Data.WriteConsoleRequest.Buffer,
2177          lpBuffer,
2178          nNumberOfCharsToWrite * sizeof(WCHAR));
2179
2180   Status = CsrClientCallServer(Request,
2181                                &Reply,
2182                                sizeof(CSRSS_API_REQUEST) + nNumberOfCharsToWrite,
2183                                sizeof(CSRSS_API_REPLY));
2184
2185   RtlFreeHeap(GetProcessHeap(),
2186               0,
2187               Request);
2188
2189   if (!NT_SUCCESS(Status))
2190     {
2191       return(FALSE);
2192     }
2193
2194   if (lpNumberOfCharsWritten != NULL)
2195     {
2196       *lpNumberOfCharsWritten =
2197           Reply.Data.WriteConsoleReply.NrCharactersWritten;
2198     }
2199
2200   return(TRUE);
2201 #endif
2202   return(FALSE);
2203 }
2204
2205 /*--------------------------------------------------------------
2206  *      CreateConsoleScreenBuffer
2207  */
2208 WINBASEAPI
2209 HANDLE
2210 WINAPI
2211 CreateConsoleScreenBuffer(
2212         DWORD                            dwDesiredAccess,
2213         DWORD                            dwShareMode,
2214         CONST SECURITY_ATTRIBUTES       *lpSecurityAttributes,
2215         DWORD                            dwFlags,
2216         LPVOID                           lpScreenBufferData
2217         )
2218 {
2219    // FIXME: don't ignore access, share mode, and security
2220    CSRSS_API_REQUEST Request;
2221    CSRSS_API_REPLY Reply;
2222    NTSTATUS Status;
2223
2224    Request.Type = CSRSS_CREATE_SCREEN_BUFFER;
2225    Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
2226    if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
2227       {
2228          SetLastErrorByStatus ( Status );
2229          return FALSE;
2230       }
2231    return Reply.Data.CreateScreenBufferReply.OutputHandle;
2232 }
2233
2234
2235 /*--------------------------------------------------------------
2236  *      GetConsoleCP
2237  */
2238 WINBASEAPI
2239 UINT
2240 WINAPI
2241 GetConsoleCP( VOID )
2242 {
2243 /* --- TO DO --- */
2244         return CP_OEMCP; /* FIXME */
2245 }
2246
2247
2248 /*--------------------------------------------------------------
2249  *      SetConsoleCP
2250  */
2251 WINBASEAPI
2252 BOOL
2253 WINAPI
2254 SetConsoleCP(
2255         UINT            wCodePageID
2256         )
2257 {
2258 /* --- TO DO --- */
2259         return FALSE;
2260 }
2261
2262
2263 /*--------------------------------------------------------------
2264  *      GetConsoleOutputCP
2265  */
2266 WINBASEAPI
2267 UINT
2268 WINAPI
2269 GetConsoleOutputCP( VOID )
2270 {
2271 /* --- TO DO --- */
2272         return 0; /* FIXME */
2273 }
2274
2275
2276 /*--------------------------------------------------------------
2277  *      SetConsoleOutputCP
2278  */
2279 WINBASEAPI
2280 BOOL
2281 WINAPI
2282 SetConsoleOutputCP(
2283         UINT            wCodePageID
2284         )
2285 {
2286 /* --- TO DO --- */
2287         return FALSE;
2288 }
2289
2290
2291 /* EOF */