reactos/win32ss/user/winsrv/consrv/console.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Console Server DLL
   4  * FILE:            consrv/console.c
   5  * PURPOSE:         Console Management Functions
   6  * PROGRAMMERS:     Gé van Geldorp
   7  *                  Jeffrey Morlan
   8  *                  Hermes Belusca-Maito (hermes.belusca@sfr.fr)
   9  */
  10
  11 /* INCLUDES *******************************************************************/
  12
  13 #include "consrv.h"
  14
  15 /* This is for COM usage */
  16 #define COBJMACROS
  17 #include <shlobj.h>
  18
  19
  20 #include <alias.h>
  21 #include <history.h>
  22 #include "procinit.h"
  23
  24 #define NDEBUG
  25 #include <debug.h>
  26
  27 // FIXME: Add this prototype to winternl.h / rtlfuncs.h / ...
  28 NTSTATUS NTAPI RtlGetLastNtStatus(VOID);
  29
  30 /* GLOBALS ********************************************************************/
  31
  32 /* The list of the ConSrv consoles */
  33 static ULONG ConsoleListSize;
  34 static PCONSRV_CONSOLE* ConsoleList;
  35 static RTL_RESOURCE ListLock;
  36
  37 #define ConSrvLockConsoleListExclusive()    \
  38     RtlAcquireResourceExclusive(&ListLock, TRUE)
  39
  40 #define ConSrvLockConsoleListShared()       \
  41     RtlAcquireResourceShared(&ListLock, TRUE)
  42
  43 #define ConSrvUnlockConsoleList()           \
  44     RtlReleaseResource(&ListLock)
  45
  46
  47 static NTSTATUS
  48 InsertConsole(OUT PHANDLE Handle,
  49               IN PCONSRV_CONSOLE Console)
  50 {
  51 #define CONSOLE_HANDLES_INCREMENT   2 * 3
  52
  53     NTSTATUS Status = STATUS_SUCCESS;
  54     ULONG i = 0;
  55     PCONSRV_CONSOLE* Block;
  56
  57     ASSERT( (ConsoleList == NULL && ConsoleListSize == 0) ||
  58             (ConsoleList != NULL && ConsoleListSize != 0) );
  59
  60     /* All went right, so add the console to the list */
  61     ConSrvLockConsoleListExclusive();
  62     DPRINT("Insert in the list\n");
  63
  64     if (ConsoleList)
  65     {
  66         for (i = 0; i < ConsoleListSize; i++)
  67         {
  68             if (ConsoleList[i] == NULL) break;
  69         }
  70     }
  71
  72     if (i >= ConsoleListSize)
  73     {
  74         DPRINT("Creation of a new handles table\n");
  75         /* Allocate a new handles table */
  76         Block = ConsoleAllocHeap(HEAP_ZERO_MEMORY,
  77                                  (ConsoleListSize +
  78                                     CONSOLE_HANDLES_INCREMENT) * sizeof(PCONSRV_CONSOLE));
  79         if (Block == NULL)
  80         {
  81             Status = STATUS_UNSUCCESSFUL;
  82             goto Quit;
  83         }
  84
  85         /* If we previously had a handles table, free it and use the new one */
  86         if (ConsoleList)
  87         {
  88             /* Copy the handles from the old table to the new one */
  89             RtlCopyMemory(Block,
  90                           ConsoleList,
  91                           ConsoleListSize * sizeof(PCONSRV_CONSOLE));
  92             ConsoleFreeHeap(ConsoleList);
  93         }
  94         ConsoleList = Block;
  95         ConsoleListSize += CONSOLE_HANDLES_INCREMENT;
  96     }
  97
  98     ConsoleList[i] = Console;
  99     *Handle = ULongToHandle((i << 2) | 0x3);
 100
 101 Quit:
 102     /* Unlock the console list and return status */
 103     ConSrvUnlockConsoleList();
 104     return Status;
 105 }
 106
 107 /* Unused */
 108 #if 0
 109 static NTSTATUS
 110 RemoveConsoleByHandle(IN HANDLE Handle)
 111 {
 112     NTSTATUS Status = STATUS_SUCCESS;
 113     PCONSRV_CONSOLE Console;
 114
 115     BOOLEAN ValidHandle = ((HandleToULong(Handle) & 0x3) == 0x3);
 116     ULONG Index = HandleToULong(Handle) >> 2;
 117
 118     if (!ValidHandle) return STATUS_INVALID_HANDLE;
 119
 120     ASSERT( (ConsoleList == NULL && ConsoleListSize == 0) ||
 121             (ConsoleList != NULL && ConsoleListSize != 0) );
 122
 123     /* Remove the console from the list */
 124     ConSrvLockConsoleListExclusive();
 125
 126     if (Index >= ConsoleListSize ||
 127         (Console = ConsoleList[Index]) == NULL)
 128     {
 129         Status = STATUS_INVALID_HANDLE;
 130         goto Quit;
 131     }
 132
 133     ConsoleList[Index] = NULL;
 134
 135 Quit:
 136     /* Unlock the console list and return status */
 137     ConSrvUnlockConsoleList();
 138     return Status;
 139 }
 140 #endif
 141
 142 static NTSTATUS
 143 RemoveConsoleByPointer(IN PCONSRV_CONSOLE Console)
 144 {
 145     ULONG i = 0;
 146
 147     if (!Console) return STATUS_INVALID_PARAMETER;
 148
 149     ASSERT( (ConsoleList == NULL && ConsoleListSize == 0) ||
 150             (ConsoleList != NULL && ConsoleListSize != 0) );
 151
 152     /* Remove the console from the list */
 153     ConSrvLockConsoleListExclusive();
 154
 155     if (ConsoleList)
 156     {
 157         for (i = 0; i < ConsoleListSize; i++)
 158         {
 159             if (ConsoleList[i] == Console) ConsoleList[i] = NULL;
 160         }
 161     }
 162
 163     /* Unlock the console list and return */
 164     ConSrvUnlockConsoleList();
 165     return STATUS_SUCCESS;
 166 }
 167
 168 BOOLEAN NTAPI
 169 ConSrvValidateConsole(OUT PCONSRV_CONSOLE* Console,
 170                       IN HANDLE ConsoleHandle,
 171                       IN CONSOLE_STATE ExpectedState,
 172                       IN BOOLEAN LockConsole)
 173 {
 174     BOOLEAN RetVal = FALSE;
 175     PCONSRV_CONSOLE ValidatedConsole;
 176
 177     BOOLEAN ValidHandle = ((HandleToULong(ConsoleHandle) & 0x3) == 0x3);
 178     ULONG Index = HandleToULong(ConsoleHandle) >> 2;
 179
 180     if (!ValidHandle) return FALSE;
 181
 182     if (!Console) return FALSE;
 183     *Console = NULL;
 184
 185     /*
 186      * Forbid creation or deletion of consoles when
 187      * checking for the existence of a console.
 188      */
 189     ConSrvLockConsoleListShared();
 190
 191     if (Index >= ConsoleListSize ||
 192         (ValidatedConsole = ConsoleList[Index]) == NULL)
 193     {
 194         /* Unlock the console list and return */
 195         ConSrvUnlockConsoleList();
 196         return FALSE;
 197     }
 198
 199     ValidatedConsole = ConsoleList[Index];
 200
 201     /* Unlock the console list and return */
 202     ConSrvUnlockConsoleList();
 203
 204     RetVal = ConDrvValidateConsoleUnsafe((PCONSOLE)ValidatedConsole,
 205                                          ExpectedState,
 206                                          LockConsole);
 207     if (RetVal) *Console = ValidatedConsole;
 208
 209     return RetVal;
 210 }
 211
 212
 213 /* PRIVATE FUNCTIONS **********************************************************/
 214
 215 // Adapted from reactos/lib/rtl/unicode.c, RtlCreateUnicodeString line 2180
 216 static BOOLEAN
 217 ConsoleCreateUnicodeString(IN OUT PUNICODE_STRING UniDest,
 218                            IN PCWSTR Source)
 219 {
 220     SIZE_T Size = (wcslen(Source) + 1) * sizeof(WCHAR);
 221     if (Size > MAXUSHORT) return FALSE;
 222
 223     UniDest->Buffer = ConsoleAllocHeap(HEAP_ZERO_MEMORY, Size);
 224     if (UniDest->Buffer == NULL) return FALSE;
 225
 226     RtlCopyMemory(UniDest->Buffer, Source, Size);
 227     UniDest->MaximumLength = (USHORT)Size;
 228     UniDest->Length = (USHORT)Size - sizeof(WCHAR);
 229
 230     return TRUE;
 231 }
 232
 233 // Adapted from reactos/lib/rtl/unicode.c, RtlFreeUnicodeString line 431
 234 static VOID
 235 ConsoleFreeUnicodeString(IN PUNICODE_STRING UnicodeString)
 236 {
 237     if (UnicodeString->Buffer)
 238     {
 239         ConsoleFreeHeap(UnicodeString->Buffer);
 240         RtlZeroMemory(UnicodeString, sizeof(UNICODE_STRING));
 241     }
 242 }
 243
 244 VOID
 245 ConioPause(PCONSRV_CONSOLE Console, UINT Flags)
 246 {
 247     Console->PauseFlags |= Flags;
 248     ConDrvPause((PCONSOLE)Console);
 249 }
 250
 251 VOID
 252 ConioUnpause(PCONSRV_CONSOLE Console, UINT Flags)
 253 {
 254     Console->PauseFlags &= ~Flags;
 255
 256     // if ((Console->PauseFlags & (PAUSED_FROM_KEYBOARD | PAUSED_FROM_SCROLLBAR | PAUSED_FROM_SELECTION)) == 0)
 257     if (Console->PauseFlags == 0)
 258     {
 259         ConDrvUnpause((PCONSOLE)Console);
 260
 261         CsrNotifyWait(&Console->WriteWaitQueue,
 262                       TRUE,
 263                       NULL,
 264                       NULL);
 265         if (!IsListEmpty(&Console->WriteWaitQueue))
 266         {
 267             CsrDereferenceWait(&Console->WriteWaitQueue);
 268         }
 269     }
 270 }
 271
 272 NTSTATUS
 273 ConSrvGetConsole(IN PCONSOLE_PROCESS_DATA ProcessData,
 274                  OUT PCONSRV_CONSOLE* Console,
 275                  IN BOOLEAN LockConsole)
 276 {
 277     NTSTATUS Status = STATUS_INVALID_HANDLE;
 278     PCONSRV_CONSOLE GrabConsole;
 279
 280     // if (Console == NULL) return STATUS_INVALID_PARAMETER;
 281     ASSERT(Console);
 282     *Console = NULL;
 283
 284     if (ConSrvValidateConsole(&GrabConsole,
 285                               ProcessData->ConsoleHandle,
 286                               CONSOLE_RUNNING,
 287                               LockConsole))
 288     {
 289         InterlockedIncrement(&GrabConsole->ReferenceCount);
 290         *Console = GrabConsole;
 291         Status = STATUS_SUCCESS;
 292     }
 293
 294     return Status;
 295 }
 296
 297 VOID
 298 ConSrvReleaseConsole(IN PCONSRV_CONSOLE Console,
 299                      IN BOOLEAN WasConsoleLocked)
 300 {
 301     LONG RefCount = 0;
 302
 303     if (!Console) return;
 304     // if (Console->ReferenceCount == 0) return; // This shouldn't happen
 305     ASSERT(Console->ReferenceCount > 0);
 306
 307     /* The console must be locked */
 308     // ASSERT(Console_locked);
 309
 310     /*
 311      * Decrement the reference count. Save the new value too,
 312      * because Console->ReferenceCount might be modified after
 313      * the console gets unlocked but before we check whether we
 314      * can destroy it.
 315      */
 316     RefCount = _InterlockedDecrement(&Console->ReferenceCount);
 317
 318     /* Unlock the console if needed */
 319     if (WasConsoleLocked) LeaveCriticalSection(&Console->Lock);
 320
 321     /* Delete the console if needed */
 322     if (RefCount <= 0) ConSrvDeleteConsole(Console);
 323 }
 324
 325
 326 /* CONSOLE INITIALIZATION FUNCTIONS *******************************************/
 327
 328 VOID NTAPI
 329 ConSrvInitConsoleSupport(VOID)
 330 {
 331     DPRINT("CONSRV: ConSrvInitConsoleSupport()\n");
 332
 333     /* Initialize the console list and its lock */
 334     ConsoleListSize = 0;
 335     ConsoleList = NULL;
 336     RtlInitializeResource(&ListLock);
 337
 338     /* Should call LoadKeyboardLayout */
 339 }
 340
 341 NTSTATUS NTAPI
 342 ConSrvInitTerminal(IN OUT PTERMINAL Terminal,
 343                    IN OUT PCONSOLE_INFO ConsoleInfo,
 344                    IN OUT PVOID ExtraConsoleInfo,
 345                    IN ULONG ProcessId);
 346 NTSTATUS NTAPI
 347 ConSrvDeinitTerminal(IN OUT PTERMINAL Terminal);
 348
 349
 350 static BOOL
 351 LoadShellLinkConsoleInfo(IN OUT PCONSOLE_INFO ConsoleInfo,
 352                          IN OUT PCONSOLE_INIT_INFO ConsoleInitInfo)
 353 {
 354 #define PATH_SEPARATOR L'\\'
 355
 356     BOOL    RetVal   = FALSE;
 357     HRESULT hRes     = S_OK;
 358     SIZE_T  Length   = 0;
 359     LPWSTR  LinkName = NULL;
 360     LPWSTR  IconPath = NULL;
 361     WCHAR   Buffer[MAX_PATH + 1];
 362
 363     ConsoleInitInfo->ConsoleStartInfo->IconIndex = 0;
 364
 365     if ((ConsoleInitInfo->ConsoleStartInfo->dwStartupFlags & STARTF_TITLEISLINKNAME) == 0)
 366     {
 367         // return FALSE; // FIXME!! (for icon loading)
 368         RetVal = TRUE;
 369         goto Finish;
 370     }
 371
 372     /* 1- Find the last path separator if any */
 373     LinkName = wcsrchr(ConsoleInfo->ConsoleTitle, PATH_SEPARATOR);
 374     if (LinkName == NULL)
 375         LinkName = ConsoleInfo->ConsoleTitle;
 376     else
 377         ++LinkName; // Skip the path separator
 378
 379     /* 2- Check for the link extension. The name ".lnk" is considered invalid. */
 380     Length = wcslen(LinkName);
 381     if ( (Length <= 4) || (wcsicmp(LinkName + (Length - 4), L".lnk") != 0) )
 382         return FALSE;
 383
 384     /* 3- It may be a link. Try to retrieve some properties */
 385     hRes = CoInitialize(NULL);
 386     if (SUCCEEDED(hRes))
 387     {
 388         /* Get a pointer to the IShellLink interface */
 389         IShellLinkW* pshl = NULL;
 390         hRes = CoCreateInstance(&CLSID_ShellLink,
 391                                 NULL,
 392                                 CLSCTX_INPROC_SERVER,
 393                                 &IID_IShellLinkW,
 394                                 (LPVOID*)&pshl);
 395         if (SUCCEEDED(hRes))
 396         {
 397             /* Get a pointer to the IPersistFile interface */
 398             IPersistFile* ppf = NULL;
 399             hRes = IPersistFile_QueryInterface(pshl, &IID_IPersistFile, (LPVOID*)&ppf);
 400             if (SUCCEEDED(hRes))
 401             {
 402                 /* Load the shortcut */
 403                 hRes = IPersistFile_Load(ppf, ConsoleInfo->ConsoleTitle, STGM_READ);
 404                 if (SUCCEEDED(hRes))
 405                 {
 406                     /*
 407                      * Finally we can get the properties !
 408                      * Update the old ones if needed.
 409                      */
 410                     INT ShowCmd = 0;
 411                     // WORD HotKey = 0;
 412
 413                     /* Reset the name of the console with the name of the shortcut */
 414                     Length = min(/*Length*/ Length - 4, // 4 == len(".lnk")
 415                                  sizeof(ConsoleInfo->ConsoleTitle) / sizeof(ConsoleInfo->ConsoleTitle[0]) - 1);
 416                     wcsncpy(ConsoleInfo->ConsoleTitle, LinkName, Length);
 417                     ConsoleInfo->ConsoleTitle[Length] = L'\0';
 418
 419                     /* Get the window showing command */
 420                     hRes = IShellLinkW_GetShowCmd(pshl, &ShowCmd);
 421                     if (SUCCEEDED(hRes)) ConsoleInitInfo->ConsoleStartInfo->wShowWindow = (WORD)ShowCmd;
 422
 423                     /* Get the hotkey */
 424                     // hRes = pshl->GetHotkey(&ShowCmd);
 425                     // if (SUCCEEDED(hRes)) ConsoleInitInfo->ConsoleStartInfo->HotKey = HotKey;
 426
 427                     /* Get the icon location, if any */
 428                     hRes = IShellLinkW_GetIconLocation(pshl,
 429                                                        Buffer,
 430                                                        sizeof(Buffer)/sizeof(Buffer[0]) - 1, // == MAX_PATH
 431                                                        &ConsoleInitInfo->ConsoleStartInfo->IconIndex);
 432                     if (!SUCCEEDED(hRes))
 433                     {
 434                         ConsoleInitInfo->ConsoleStartInfo->IconIndex = 0;
 435                     }
 436                     else
 437                     {
 438                         IconPath = Buffer;
 439                     }
 440
 441                     // FIXME: Since we still don't load console properties from the shortcut,
 442                     // return false. When this will be done, we will return true instead.
 443                     RetVal = TRUE; // FALSE;
 444                 }
 445                 IPersistFile_Release(ppf);
 446             }
 447             IShellLinkW_Release(pshl);
 448         }
 449     }
 450     CoUninitialize();
 451
 452 Finish:
 453
 454     if (RetVal)
 455     {
 456         /* Get the associated icon, if any */
 457         if (IconPath == NULL)
 458         {
 459             // Question: How to retrieve the full path name
 460             // of the app we are going to run??
 461             Length = RtlDosSearchPath_U(ConsoleInitInfo->CurDir,
 462                                         ConsoleInitInfo->AppName,
 463                                         NULL,
 464                                         sizeof(Buffer),
 465                                         Buffer,
 466                                         NULL);
 467             if (Length > 0 && Length < sizeof(Buffer))
 468                 IconPath = Buffer;
 469             else
 470                 IconPath = ConsoleInitInfo->AppName;
 471
 472             // ConsoleInitInfo->ConsoleStartInfo->IconIndex = 0;
 473         }
 474         DPRINT("IconPath = '%S' ; IconIndex = %lu\n",
 475                IconPath, ConsoleInitInfo->ConsoleStartInfo->IconIndex);
 476         if (IconPath && *IconPath)
 477         {
 478             HICON hIcon = NULL, hIconSm = NULL;
 479             PrivateExtractIconExW(IconPath,
 480                                   ConsoleInitInfo->ConsoleStartInfo->IconIndex,
 481                                   &hIcon,
 482                                   &hIconSm,
 483                                   1);
 484             DPRINT("hIcon = 0x%p ; hIconSm = 0x%p\n", hIcon, hIconSm);
 485             if (hIcon   != NULL) ConsoleInitInfo->ConsoleStartInfo->hIcon   = hIcon;
 486             if (hIconSm != NULL) ConsoleInitInfo->ConsoleStartInfo->hIconSm = hIconSm;
 487         }
 488     }
 489
 490     // FIXME: See the previous FIXME above.
 491     RetVal = FALSE;
 492
 493     return RetVal;
 494 }
 495
 496 NTSTATUS NTAPI
 497 ConSrvInitConsole(OUT PHANDLE NewConsoleHandle,
 498                   OUT PCONSRV_CONSOLE* NewConsole,
 499                   IN OUT PCONSOLE_INIT_INFO ConsoleInitInfo,
 500                   IN ULONG ConsoleLeaderProcessId)
 501 {
 502     NTSTATUS Status;
 503     HANDLE ConsoleHandle;
 504     PCONSRV_CONSOLE Console;
 505     CONSOLE_INFO ConsoleInfo;
 506     SIZE_T Length = 0;
 507
 508     TERMINAL Terminal; /* The ConSrv terminal for this console */
 509
 510     if (NewConsole == NULL || ConsoleInitInfo == NULL)
 511         return STATUS_INVALID_PARAMETER;
 512
 513     *NewConsole = NULL;
 514
 515     /*
 516      * Load the console settings
 517      */
 518
 519     /* 1. Load the default settings */
 520     ConSrvGetDefaultSettings(&ConsoleInfo, ConsoleLeaderProcessId);
 521
 522     /* 2. Get the title of the console (initialize ConsoleInfo.ConsoleTitle) */
 523     Length = min(ConsoleInitInfo->TitleLength,
 524                  sizeof(ConsoleInfo.ConsoleTitle) / sizeof(ConsoleInfo.ConsoleTitle[0]) - 1);
 525     wcsncpy(ConsoleInfo.ConsoleTitle, ConsoleInitInfo->ConsoleTitle, Length);
 526     ConsoleInfo.ConsoleTitle[Length] = L'\0'; // NULL-terminate it.
 527
 528     /* 3. Initialize the ConSrv terminal */
 529     Status = ConSrvInitTerminal(&Terminal,
 530                                 &ConsoleInfo,
 531                                 ConsoleInitInfo,
 532                                 ConsoleLeaderProcessId);
 533     if (!NT_SUCCESS(Status))
 534     {
 535         DPRINT1("CONSRV: Failed to initialize a terminal, Status = 0x%08lx\n", Status);
 536         return Status;
 537     }
 538     DPRINT("CONSRV: Terminal initialized\n");
 539
 540     /*
 541      * Load per-application terminal settings.
 542      *
 543      * Check whether the process creating the console was launched via
 544      * a shell-link. ConsoleInfo->ConsoleTitle may be updated with the
 545      * name of the shortcut, and ConsoleStartInfo->Icon[Path|Index] too.
 546      */
 547     // if (ConsoleInitInfo->ConsoleStartInfo->dwStartupFlags & STARTF_TITLEISLINKNAME) // FIXME!! (for icon loading)
 548     {
 549         if (!LoadShellLinkConsoleInfo(&ConsoleInfo, ConsoleInitInfo))
 550         {
 551             ConsoleInitInfo->ConsoleStartInfo->dwStartupFlags &= ~STARTF_TITLEISLINKNAME;
 552         }
 553     }
 554
 555     /*
 556      * 4. Load the remaining console settings via the registry.
 557      */
 558     if ((ConsoleInitInfo->ConsoleStartInfo->dwStartupFlags & STARTF_TITLEISLINKNAME) == 0)
 559     {
 560         /*
 561          * Either we weren't created by an app launched via a shell-link,
 562          * or we failed to load shell-link console properties.
 563          * Therefore, load the console infos for the application from the registry.
 564          */
 565         ConSrvReadUserSettings(&ConsoleInfo, ConsoleLeaderProcessId);
 566
 567         /*
 568          * Now, update them with the properties the user might gave to us
 569          * via the STARTUPINFO structure before calling CreateProcess
 570          * (and which was transmitted via the ConsoleStartInfo structure).
 571          * We therefore overwrite the values read in the registry.
 572          */
 573         if (ConsoleInitInfo->ConsoleStartInfo->dwStartupFlags & STARTF_USEFILLATTRIBUTE)
 574         {
 575             ConsoleInfo.ScreenAttrib = (USHORT)ConsoleInitInfo->ConsoleStartInfo->wFillAttribute;
 576         }
 577         if (ConsoleInitInfo->ConsoleStartInfo->dwStartupFlags & STARTF_USECOUNTCHARS)
 578         {
 579             ConsoleInfo.ScreenBufferSize = ConsoleInitInfo->ConsoleStartInfo->dwScreenBufferSize;
 580         }
 581         if (ConsoleInitInfo->ConsoleStartInfo->dwStartupFlags & STARTF_USESIZE)
 582         {
 583             ConsoleInfo.ConsoleSize = ConsoleInitInfo->ConsoleStartInfo->dwWindowSize;
 584         }
 585     }
 586
 587     /* Set-up the code page */
 588     ConsoleInfo.CodePage = GetOEMCP();
 589
 590     /* Initialize a new console via the driver */
 591     Status = ConDrvInitConsole(&Console, &ConsoleInfo);
 592     if (!NT_SUCCESS(Status))
 593     {
 594         DPRINT1("Creating a new console failed, Status = 0x%08lx\n", Status);
 595         ConSrvDeinitTerminal(&Terminal);
 596         return Status;
 597     }
 598
 599     ASSERT(Console);
 600     DPRINT("Console initialized\n");
 601
 602     /*** Register ConSrv features ***/
 603
 604     /* Initialize the console title */
 605 #if 0
 606     WCHAR DefaultTitle[128];
 607 #endif
 608     ConsoleCreateUnicodeString(&Console->OriginalTitle, ConsoleInfo.ConsoleTitle);
 609 #if 0
 610     if (ConsoleInfo.ConsoleTitle[0] == L'\0')
 611     {
 612         if (LoadStringW(ConSrvDllInstance, IDS_CONSOLE_TITLE, DefaultTitle, sizeof(DefaultTitle) / sizeof(DefaultTitle[0])))
 613         {
 614             ConsoleCreateUnicodeString(&Console->Title, DefaultTitle);
 615         }
 616         else
 617         {
 618             ConsoleCreateUnicodeString(&Console->Title, L"ReactOS Console");
 619         }
 620     }
 621     else
 622     {
 623 #endif
 624         ConsoleCreateUnicodeString(&Console->Title, ConsoleInfo.ConsoleTitle);
 625 #if 0
 626     }
 627 #endif
 628
 629     /* Initialize process support */
 630     InitializeListHead(&Console->ProcessList);
 631     Console->NotifiedLastCloseProcess = NULL;
 632     Console->NotifyLastClose = FALSE;
 633
 634     /* Initialize pausing support */
 635     Console->PauseFlags = 0;
 636     InitializeListHead(&Console->ReadWaitQueue);
 637     InitializeListHead(&Console->WriteWaitQueue);
 638
 639     /* Initialize the alias and history buffers */
 640     Console->Aliases = NULL;
 641     InitializeListHead(&Console->HistoryBuffers);
 642     Console->HistoryBufferSize      = ConsoleInfo.HistoryBufferSize;
 643     Console->NumberOfHistoryBuffers = ConsoleInfo.NumberOfHistoryBuffers;
 644     Console->HistoryNoDup           = ConsoleInfo.HistoryNoDup;
 645
 646     /* Initialize the Input Line Discipline */
 647     Console->LineBuffer = NULL;
 648     Console->LinePos = Console->LineMaxSize = Console->LineSize = 0;
 649     Console->LineComplete = Console->LineUpPressed = FALSE;
 650     // LineWakeupMask
 651     Console->LineInsertToggle =
 652     Console->InsertMode = ConsoleInfo.InsertMode;
 653     Console->QuickEdit  = ConsoleInfo.QuickEdit;
 654
 655     /* Popup windows */
 656     InitializeListHead(&Console->PopupWindows);
 657
 658     /* Colour table */
 659     memcpy(Console->Colors, ConsoleInfo.Colors, sizeof(ConsoleInfo.Colors));
 660
 661     /* Create the Initialization Events */
 662     Status = NtCreateEvent(&Console->InitEvents[INIT_SUCCESS], EVENT_ALL_ACCESS,
 663                            NULL, NotificationEvent, FALSE);
 664     if (!NT_SUCCESS(Status))
 665     {
 666         DPRINT1("NtCreateEvent(InitEvents[INIT_SUCCESS]) failed: %lu\n", Status);
 667         ConDrvDeleteConsole(Console);
 668         ConSrvDeinitTerminal(&Terminal);
 669         return Status;
 670     }
 671     Status = NtCreateEvent(&Console->InitEvents[INIT_FAILURE], EVENT_ALL_ACCESS,
 672                            NULL, NotificationEvent, FALSE);
 673     if (!NT_SUCCESS(Status))
 674     {
 675         DPRINT1("NtCreateEvent(InitEvents[INIT_FAILURE]) failed: %lu\n", Status);
 676         NtClose(Console->InitEvents[INIT_SUCCESS]);
 677         ConDrvDeleteConsole(Console);
 678         ConSrvDeinitTerminal(&Terminal);
 679         return Status;
 680     }
 681
 682     /*
 683      * Attach the ConSrv terminal to the console.
 684      * This call makes a copy of our local Terminal variable.
 685      */
 686     Status = ConDrvRegisterTerminal(Console, &Terminal);
 687     if (!NT_SUCCESS(Status))
 688     {
 689         DPRINT1("Failed to register terminal to the given console, Status = 0x%08lx\n", Status);
 690         NtClose(Console->InitEvents[INIT_FAILURE]);
 691         NtClose(Console->InitEvents[INIT_SUCCESS]);
 692         ConDrvDeleteConsole(Console);
 693         ConSrvDeinitTerminal(&Terminal);
 694         return Status;
 695     }
 696     DPRINT("Terminal registered\n");
 697
 698     /* All went right, so add the console to the list */
 699     Status = InsertConsole(&ConsoleHandle, Console);
 700
 701     // FIXME! We do not support at all asynchronous console creation!
 702     NtSetEvent(Console->InitEvents[INIT_SUCCESS], NULL);
 703     // NtSetEvent(Console->InitEvents[INIT_FAILURE], NULL);
 704
 705     /* Return the newly created console to the caller and a success code too */
 706     *NewConsoleHandle = ConsoleHandle;
 707     *NewConsole       = Console;
 708     return STATUS_SUCCESS;
 709 }
 710
 711 VOID NTAPI
 712 ConSrvDeleteConsole(PCONSRV_CONSOLE Console)
 713 {
 714     DPRINT("ConSrvDeleteConsole\n");
 715
 716     // FIXME: Send a terminate message to all the processes owning this console
 717
 718     /* Remove the console from the list */
 719     RemoveConsoleByPointer(Console);
 720
 721     /* Destroy the Initialization Events */
 722     NtClose(Console->InitEvents[INIT_FAILURE]);
 723     NtClose(Console->InitEvents[INIT_SUCCESS]);
 724
 725     /* Clean the Input Line Discipline */
 726     if (Console->LineBuffer) ConsoleFreeHeap(Console->LineBuffer);
 727
 728     /* Clean aliases and history */
 729     IntDeleteAllAliases(Console);
 730     HistoryDeleteBuffers(Console);
 731
 732     /* Free the console title */
 733     ConsoleFreeUnicodeString(&Console->OriginalTitle);
 734     ConsoleFreeUnicodeString(&Console->Title);
 735
 736     /* Now, call the driver. ConDrvDeregisterTerminal is called on-demand. */
 737     ConDrvDeleteConsole((PCONSOLE)Console);
 738
 739     /* Deinit the ConSrv terminal */
 740     // FIXME!!
 741     // ConSrvDeinitTerminal(&Terminal);
 742 }
 743
 744
 745
 746
 747
 748
 749 static NTSTATUS
 750 ConSrvConsoleCtrlEventTimeout(IN ULONG CtrlEvent,
 751                               IN PCONSOLE_PROCESS_DATA ProcessData,
 752                               IN ULONG Timeout)
 753 {
 754     NTSTATUS Status = STATUS_SUCCESS;
 755
 756     DPRINT("ConSrvConsoleCtrlEventTimeout Parent ProcessId = %x\n", ProcessData->Process->ClientId.UniqueProcess);
 757
 758     if (ProcessData->CtrlRoutine)
 759     {
 760         _SEH2_TRY
 761         {
 762             HANDLE Thread = NULL;
 763
 764             _SEH2_TRY
 765             {
 766                 Thread = CreateRemoteThread(ProcessData->Process->ProcessHandle, NULL, 0,
 767                                             ProcessData->CtrlRoutine,
 768                                             UlongToPtr(CtrlEvent), 0, NULL);
 769                 if (NULL == Thread)
 770                 {
 771                     Status = RtlGetLastNtStatus();
 772                     DPRINT1("Failed thread creation, Status = 0x%08lx\n", Status);
 773                 }
 774                 else
 775                 {
 776                     DPRINT("ProcessData->CtrlRoutine remote thread creation succeeded, ProcessId = %x, Process = 0x%p\n",
 777                            ProcessData->Process->ClientId.UniqueProcess, ProcessData->Process);
 778                     WaitForSingleObject(Thread, Timeout);
 779                 }
 780             }
 781             _SEH2_FINALLY
 782             {
 783                 CloseHandle(Thread);
 784             }
 785             _SEH2_END;
 786         }
 787         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 788         {
 789             Status = _SEH2_GetExceptionCode();
 790             DPRINT1("ConSrvConsoleCtrlEventTimeout - Caught an exception, Status = 0x%08lx\n", Status);
 791         }
 792         _SEH2_END;
 793     }
 794
 795     return Status;
 796 }
 797
 798 NTSTATUS
 799 ConSrvConsoleCtrlEvent(IN ULONG CtrlEvent,
 800                        IN PCONSOLE_PROCESS_DATA ProcessData)
 801 {
 802     return ConSrvConsoleCtrlEventTimeout(CtrlEvent, ProcessData, 0);
 803 }
 804
 805 PCONSOLE_PROCESS_DATA NTAPI
 806 ConSrvGetConsoleLeaderProcess(IN PCONSRV_CONSOLE Console)
 807 {
 808     if (Console == NULL) return NULL;
 809
 810     return CONTAINING_RECORD(Console->ProcessList.Blink,
 811                              CONSOLE_PROCESS_DATA,
 812                              ConsoleLink);
 813 }
 814
 815 NTSTATUS NTAPI
 816 ConSrvGetConsoleProcessList(IN PCONSRV_CONSOLE Console,
 817                             IN OUT PULONG ProcessIdsList,
 818                             IN ULONG MaxIdListItems,
 819                             OUT PULONG ProcessIdsTotal)
 820 {
 821     PCONSOLE_PROCESS_DATA current;
 822     PLIST_ENTRY current_entry;
 823
 824     if (Console == NULL || ProcessIdsList == NULL || ProcessIdsTotal == NULL)
 825         return STATUS_INVALID_PARAMETER;
 826
 827     *ProcessIdsTotal = 0;
 828
 829     for (current_entry = Console->ProcessList.Flink;
 830          current_entry != &Console->ProcessList;
 831          current_entry = current_entry->Flink)
 832     {
 833         current = CONTAINING_RECORD(current_entry, CONSOLE_PROCESS_DATA, ConsoleLink);
 834         if (++(*ProcessIdsTotal) <= MaxIdListItems)
 835         {
 836             *ProcessIdsList++ = HandleToUlong(current->Process->ClientId.UniqueProcess);
 837         }
 838     }
 839
 840     return STATUS_SUCCESS;
 841 }
 842
 843 // ConSrvGenerateConsoleCtrlEvent
 844 NTSTATUS NTAPI
 845 ConSrvConsoleProcessCtrlEvent(IN PCONSRV_CONSOLE Console,
 846                               IN ULONG ProcessGroupId,
 847                               IN ULONG CtrlEvent)
 848 {
 849     NTSTATUS Status = STATUS_SUCCESS;
 850     PLIST_ENTRY current_entry;
 851     PCONSOLE_PROCESS_DATA current;
 852
 853     /* If the console is already being destroyed, just return */
 854     if (!ConDrvValidateConsoleState((PCONSOLE)Console, CONSOLE_RUNNING))
 855         return STATUS_UNSUCCESSFUL;
 856
 857     /*
 858      * Loop through the process list, from the most recent process
 859      * (the active one) to the oldest one (the first created, i.e.
 860      * the console leader process), and for each, send an event
 861      * (new processes are inserted at the head of the console process list).
 862      */
 863     current_entry = Console->ProcessList.Flink;
 864     while (current_entry != &Console->ProcessList)
 865     {
 866         current = CONTAINING_RECORD(current_entry, CONSOLE_PROCESS_DATA, ConsoleLink);
 867         current_entry = current_entry->Flink;
 868
 869         /*
 870          * Only processes belonging to the same process group are signaled.
 871          * If the process group ID is zero, then all the processes are signaled.
 872          */
 873         if (ProcessGroupId == 0 || current->Process->ProcessGroupId == ProcessGroupId)
 874         {
 875             Status = ConSrvConsoleCtrlEvent(CtrlEvent, current);
 876         }
 877     }
 878
 879     return Status;
 880 }
 881
 882
 883 /* PUBLIC SERVER APIS *********************************************************/
 884
 885 CSR_API(SrvAllocConsole)
 886 {
 887     NTSTATUS Status = STATUS_SUCCESS;
 888     PCONSOLE_ALLOCCONSOLE AllocConsoleRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.AllocConsoleRequest;
 889     PCSR_PROCESS CsrProcess = CsrGetClientThread()->Process;
 890     PCONSOLE_PROCESS_DATA ProcessData = ConsoleGetPerProcessData(CsrProcess);
 891     CONSOLE_INIT_INFO ConsoleInitInfo;
 892
 893     if (ProcessData->ConsoleHandle != NULL)
 894     {
 895         DPRINT1("Process already has a console\n");
 896         return STATUS_ACCESS_DENIED;
 897     }
 898
 899     if ( !CsrValidateMessageBuffer(ApiMessage,
 900                                    (PVOID*)&AllocConsoleRequest->ConsoleStartInfo,
 901                                    1,
 902                                    sizeof(CONSOLE_START_INFO))      ||
 903          !CsrValidateMessageBuffer(ApiMessage,
 904                                    (PVOID*)&AllocConsoleRequest->ConsoleTitle,
 905                                    AllocConsoleRequest->TitleLength,
 906                                    sizeof(BYTE))                    ||
 907          !CsrValidateMessageBuffer(ApiMessage,
 908                                    (PVOID*)&AllocConsoleRequest->Desktop,
 909                                    AllocConsoleRequest->DesktopLength,
 910                                    sizeof(BYTE))                    ||
 911          !CsrValidateMessageBuffer(ApiMessage,
 912                                    (PVOID*)&AllocConsoleRequest->CurDir,
 913                                    AllocConsoleRequest->CurDirLength,
 914                                    sizeof(BYTE))                    ||
 915          !CsrValidateMessageBuffer(ApiMessage,
 916                                    (PVOID*)&AllocConsoleRequest->AppName,
 917                                    AllocConsoleRequest->AppNameLength,
 918                                    sizeof(BYTE)) )
 919     {
 920         return STATUS_INVALID_PARAMETER;
 921     }
 922
 923     /* Initialize the console initialization info structure */
 924     ConsoleInitInfo.ConsoleStartInfo = AllocConsoleRequest->ConsoleStartInfo;
 925     ConsoleInitInfo.IsWindowVisible  = TRUE; // The console window is always visible.
 926     ConsoleInitInfo.TitleLength      = AllocConsoleRequest->TitleLength;
 927     ConsoleInitInfo.ConsoleTitle     = AllocConsoleRequest->ConsoleTitle;
 928     ConsoleInitInfo.DesktopLength    = AllocConsoleRequest->DesktopLength;
 929     ConsoleInitInfo.Desktop          = AllocConsoleRequest->Desktop;
 930     ConsoleInitInfo.AppNameLength    = AllocConsoleRequest->AppNameLength;
 931     ConsoleInitInfo.AppName          = AllocConsoleRequest->AppName;
 932     ConsoleInitInfo.CurDirLength     = AllocConsoleRequest->CurDirLength;
 933     ConsoleInitInfo.CurDir           = AllocConsoleRequest->CurDir;
 934
 935     /* Initialize a new Console owned by the Console Leader Process */
 936     Status = ConSrvAllocateConsole(ProcessData,
 937                                    &AllocConsoleRequest->ConsoleStartInfo->InputHandle,
 938                                    &AllocConsoleRequest->ConsoleStartInfo->OutputHandle,
 939                                    &AllocConsoleRequest->ConsoleStartInfo->ErrorHandle,
 940                                    &ConsoleInitInfo);
 941     if (!NT_SUCCESS(Status))
 942     {
 943         DPRINT1("Console allocation failed\n");
 944         return Status;
 945     }
 946
 947     /* Set the Property-Dialog and Control-Dispatcher handlers */
 948     ProcessData->PropRoutine = AllocConsoleRequest->PropRoutine;
 949     ProcessData->CtrlRoutine = AllocConsoleRequest->CtrlRoutine;
 950
 951     return STATUS_SUCCESS;
 952 }
 953
 954 CSR_API(SrvAttachConsole)
 955 {
 956     NTSTATUS Status = STATUS_SUCCESS;
 957     PCONSOLE_ATTACHCONSOLE AttachConsoleRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.AttachConsoleRequest;
 958     PCSR_PROCESS SourceProcess = NULL;  // The parent process.
 959     PCSR_PROCESS TargetProcess = CsrGetClientThread()->Process; // Ourselves.
 960     HANDLE ProcessId = ULongToHandle(AttachConsoleRequest->ProcessId);
 961     PCONSOLE_PROCESS_DATA SourceProcessData, TargetProcessData;
 962
 963     TargetProcessData = ConsoleGetPerProcessData(TargetProcess);
 964
 965     if (TargetProcessData->ConsoleHandle != NULL)
 966     {
 967         DPRINT1("Process already has a console\n");
 968         return STATUS_ACCESS_DENIED;
 969     }
 970
 971     if (!CsrValidateMessageBuffer(ApiMessage,
 972                                   (PVOID*)&AttachConsoleRequest->ConsoleStartInfo,
 973                                   1,
 974                                   sizeof(CONSOLE_START_INFO)))
 975     {
 976         return STATUS_INVALID_PARAMETER;
 977     }
 978
 979     /* Check whether we try to attach to the parent's console */
 980     if (ProcessId == ULongToHandle(ATTACH_PARENT_PROCESS))
 981     {
 982         PROCESS_BASIC_INFORMATION ProcessInfo;
 983         ULONG Length = sizeof(ProcessInfo);
 984
 985         /* Get the real parent's ID */
 986
 987         Status = NtQueryInformationProcess(TargetProcess->ProcessHandle,
 988                                            ProcessBasicInformation,
 989                                            &ProcessInfo,
 990                                            Length, &Length);
 991         if (!NT_SUCCESS(Status))
 992         {
 993             DPRINT1("SrvAttachConsole - Cannot retrieve basic process info, Status = 0x%08lx\n", Status);
 994             return Status;
 995         }
 996
 997         ProcessId = ULongToHandle(ProcessInfo.InheritedFromUniqueProcessId);
 998     }
 999
1000     /* Lock the source process via its PID */
1001     Status = CsrLockProcessByClientId(ProcessId, &SourceProcess);
1002     if (!NT_SUCCESS(Status)) return Status;
1003
1004     SourceProcessData = ConsoleGetPerProcessData(SourceProcess);
1005
1006     if (SourceProcessData->ConsoleHandle == NULL)
1007     {
1008         Status = STATUS_INVALID_HANDLE;
1009         goto Quit;
1010     }
1011
1012     /*
1013      * Inherit the console from the parent,
1014      * if any, otherwise return an error.
1015      */
1016     Status = ConSrvInheritConsole(TargetProcessData,
1017                                   SourceProcessData->ConsoleHandle,
1018                                   TRUE,
1019                                   &AttachConsoleRequest->ConsoleStartInfo->InputHandle,
1020                                   &AttachConsoleRequest->ConsoleStartInfo->OutputHandle,
1021                                   &AttachConsoleRequest->ConsoleStartInfo->ErrorHandle,
1022                                   AttachConsoleRequest->ConsoleStartInfo);
1023     if (!NT_SUCCESS(Status))
1024     {
1025         DPRINT1("Console inheritance failed\n");
1026         goto Quit;
1027     }
1028
1029     /* Set the Property-Dialog and Control-Dispatcher handlers */
1030     TargetProcessData->PropRoutine = AttachConsoleRequest->PropRoutine;
1031     TargetProcessData->CtrlRoutine = AttachConsoleRequest->CtrlRoutine;
1032
1033     Status = STATUS_SUCCESS;
1034
1035 Quit:
1036     /* Unlock the "source" process and exit */
1037     CsrUnlockProcess(SourceProcess);
1038     return Status;
1039 }
1040
1041 CSR_API(SrvFreeConsole)
1042 {
1043     return ConSrvRemoveConsole(ConsoleGetPerProcessData(CsrGetClientThread()->Process));
1044 }
1045
1046 NTSTATUS NTAPI
1047 ConDrvGetConsoleMode(IN PCONSOLE Console,
1048                      IN PCONSOLE_IO_OBJECT Object,
1049                      OUT PULONG ConsoleMode);
1050 CSR_API(SrvGetConsoleMode)
1051 {
1052     NTSTATUS Status;
1053     PCONSOLE_GETSETCONSOLEMODE ConsoleModeRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.ConsoleModeRequest;
1054     PCONSOLE_IO_OBJECT Object;
1055
1056     PULONG ConsoleMode = &ConsoleModeRequest->Mode;
1057
1058     Status = ConSrvGetObject(ConsoleGetPerProcessData(CsrGetClientThread()->Process),
1059                              ConsoleModeRequest->Handle,
1060                              &Object, NULL, GENERIC_READ, TRUE, 0);
1061     if (!NT_SUCCESS(Status)) return Status;
1062
1063     /* Get the standard console modes */
1064     Status = ConDrvGetConsoleMode(Object->Console, Object,
1065                                   ConsoleMode);
1066     if (NT_SUCCESS(Status))
1067     {
1068         /*
1069          * If getting the console modes succeeds, then retrieve
1070          * the extended CONSRV-specific input modes.
1071          */
1072         if (INPUT_BUFFER == Object->Type)
1073         {
1074             if (Object->Console->InsertMode || Object->Console->QuickEdit)
1075             {
1076                 /* Windows also adds ENABLE_EXTENDED_FLAGS, even if it's not documented on MSDN */
1077                 *ConsoleMode |= ENABLE_EXTENDED_FLAGS;
1078
1079                 if (Object->Console->InsertMode) *ConsoleMode |= ENABLE_INSERT_MODE;
1080                 if (Object->Console->QuickEdit ) *ConsoleMode |= ENABLE_QUICK_EDIT_MODE;
1081             }
1082         }
1083     }
1084
1085     ConSrvReleaseObject(Object, TRUE);
1086     return Status;
1087 }
1088
1089 NTSTATUS NTAPI
1090 ConDrvSetConsoleMode(IN PCONSOLE Console,
1091                      IN PCONSOLE_IO_OBJECT Object,
1092                      IN ULONG ConsoleMode);
1093 CSR_API(SrvSetConsoleMode)
1094 {
1095 #define CONSOLE_VALID_CONTROL_MODES ( ENABLE_EXTENDED_FLAGS | \
1096                                       ENABLE_INSERT_MODE    | ENABLE_QUICK_EDIT_MODE )
1097
1098     NTSTATUS Status;
1099     PCONSOLE_GETSETCONSOLEMODE ConsoleModeRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.ConsoleModeRequest;
1100     PCONSOLE_IO_OBJECT Object;
1101
1102     ULONG ConsoleMode = ConsoleModeRequest->Mode;
1103
1104     Status = ConSrvGetObject(ConsoleGetPerProcessData(CsrGetClientThread()->Process),
1105                              ConsoleModeRequest->Handle,
1106                              &Object, NULL, GENERIC_WRITE, TRUE, 0);
1107     if (!NT_SUCCESS(Status)) return Status;
1108
1109     /* Set the standard console modes (without the CONSRV-specific input modes) */
1110     ConsoleMode &= ~CONSOLE_VALID_CONTROL_MODES; // Remove CONSRV-specific input modes.
1111     Status = ConDrvSetConsoleMode(Object->Console, Object,
1112                                   ConsoleMode);
1113     if (NT_SUCCESS(Status))
1114     {
1115         /*
1116          * If setting the console modes succeeds, then set
1117          * the extended CONSRV-specific input modes.
1118          */
1119         if (INPUT_BUFFER == Object->Type)
1120         {
1121             ConsoleMode = ConsoleModeRequest->Mode;
1122
1123             if (ConsoleMode & CONSOLE_VALID_CONTROL_MODES)
1124             {
1125                 /*
1126                  * If we use control mode flags without ENABLE_EXTENDED_FLAGS,
1127                  * then consider the flags invalid.
1128                  */
1129                 if ((ConsoleMode & ENABLE_EXTENDED_FLAGS) == 0)
1130                 {
1131                     Status = STATUS_INVALID_PARAMETER;
1132                 }
1133                 else
1134                 {
1135                     Object->Console->InsertMode = !!(ConsoleMode & ENABLE_INSERT_MODE);
1136                     Object->Console->QuickEdit  = !!(ConsoleMode & ENABLE_QUICK_EDIT_MODE);
1137                 }
1138             }
1139         }
1140     }
1141
1142     ConSrvReleaseObject(Object, TRUE);
1143     return Status;
1144 }
1145
1146 CSR_API(SrvGetConsoleTitle)
1147 {
1148     NTSTATUS Status;
1149     PCONSOLE_GETSETCONSOLETITLE TitleRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.TitleRequest;
1150     PCONSRV_CONSOLE Console;
1151     ULONG Length;
1152
1153     if (!CsrValidateMessageBuffer(ApiMessage,
1154                                   (PVOID)&TitleRequest->Title,
1155                                   TitleRequest->Length,
1156                                   sizeof(BYTE)))
1157     {
1158         return STATUS_INVALID_PARAMETER;
1159     }
1160
1161     Status = ConSrvGetConsole(ConsoleGetPerProcessData(CsrGetClientThread()->Process), &Console, TRUE);
1162     if (!NT_SUCCESS(Status))
1163     {
1164         DPRINT1("Can't get console\n");
1165         return Status;
1166     }
1167
1168     /* Copy title of the console to the user title buffer */
1169     if (TitleRequest->Unicode)
1170     {
1171         if (TitleRequest->Length >= sizeof(WCHAR))
1172         {
1173             Length = min(TitleRequest->Length - sizeof(WCHAR), Console->Title.Length);
1174             RtlCopyMemory(TitleRequest->Title, Console->Title.Buffer, Length);
1175             ((PWCHAR)TitleRequest->Title)[Length / sizeof(WCHAR)] = L'\0';
1176             TitleRequest->Length = Length;
1177         }
1178         else
1179         {
1180             TitleRequest->Length = Console->Title.Length;
1181         }
1182     }
1183     else
1184     {
1185         if (TitleRequest->Length >= sizeof(CHAR))
1186         {
1187             Length = min(TitleRequest->Length - sizeof(CHAR), Console->Title.Length / sizeof(WCHAR));
1188             Length = WideCharToMultiByte(Console->InputCodePage, 0,
1189                                          Console->Title.Buffer, Length,
1190                                          TitleRequest->Title, Length,
1191                                          NULL, NULL);
1192             ((PCHAR)TitleRequest->Title)[Length] = '\0';
1193             TitleRequest->Length = Length;
1194         }
1195         else
1196         {
1197             TitleRequest->Length = Console->Title.Length / sizeof(WCHAR);
1198         }
1199     }
1200
1201     ConSrvReleaseConsole(Console, TRUE);
1202     return Status;
1203 }
1204
1205 CSR_API(SrvSetConsoleTitle)
1206 {
1207     NTSTATUS Status;
1208     PCONSOLE_GETSETCONSOLETITLE TitleRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.TitleRequest;
1209     PCONSRV_CONSOLE Console;
1210
1211     PWCHAR Buffer;
1212     ULONG  Length;
1213
1214     if (!CsrValidateMessageBuffer(ApiMessage,
1215                                   (PVOID)&TitleRequest->Title,
1216                                   TitleRequest->Length,
1217                                   sizeof(BYTE)))
1218     {
1219         return STATUS_INVALID_PARAMETER;
1220     }
1221
1222     Status = ConSrvGetConsole(ConsoleGetPerProcessData(CsrGetClientThread()->Process), &Console, TRUE);
1223     if (!NT_SUCCESS(Status))
1224     {
1225         DPRINT1("Can't get console\n");
1226         return Status;
1227     }
1228
1229     if (TitleRequest->Unicode)
1230     {
1231         /* Length is in bytes */
1232         Length = TitleRequest->Length;
1233     }
1234     else
1235     {
1236         /* Use the console input CP for the conversion */
1237         Length = MultiByteToWideChar(Console->InputCodePage, 0,
1238                                      TitleRequest->Title, TitleRequest->Length,
1239                                      NULL, 0);
1240         /* The returned Length was in number of wchars, convert it in bytes */
1241         Length *= sizeof(WCHAR);
1242     }
1243
1244     /* Allocate a new buffer to hold the new title (NULL-terminated) */
1245     Buffer = ConsoleAllocHeap(HEAP_ZERO_MEMORY, Length + sizeof(WCHAR));
1246     if (!Buffer)
1247     {
1248         Status = STATUS_NO_MEMORY;
1249         goto Quit;
1250     }
1251
1252     /* Free the old title */
1253     ConsoleFreeUnicodeString(&Console->Title);
1254
1255     /* Copy title to console */
1256     Console->Title.Buffer = Buffer;
1257     Console->Title.Length = Length;
1258     Console->Title.MaximumLength = Console->Title.Length + sizeof(WCHAR);
1259
1260     if (TitleRequest->Unicode)
1261     {
1262         RtlCopyMemory(Console->Title.Buffer, TitleRequest->Title, Console->Title.Length);
1263     }
1264     else
1265     {
1266         MultiByteToWideChar(Console->InputCodePage, 0,
1267                             TitleRequest->Title, TitleRequest->Length,
1268                             Console->Title.Buffer,
1269                             Console->Title.Length / sizeof(WCHAR));
1270     }
1271
1272     /* NULL-terminate */
1273     Console->Title.Buffer[Console->Title.Length / sizeof(WCHAR)] = L'\0';
1274
1275     TermChangeTitle(Console);
1276     Status = STATUS_SUCCESS;
1277
1278 Quit:
1279     ConSrvReleaseConsole(Console, TRUE);
1280     return Status;
1281 }
1282
1283 NTSTATUS NTAPI
1284 ConDrvGetConsoleCP(IN PCONSOLE Console,
1285                    OUT PUINT CodePage,
1286                    IN BOOLEAN OutputCP);
1287 CSR_API(SrvGetConsoleCP)
1288 {
1289     NTSTATUS Status;
1290     PCONSOLE_GETINPUTOUTPUTCP GetConsoleCPRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.GetConsoleCPRequest;
1291     PCONSRV_CONSOLE Console;
1292
1293     DPRINT("SrvGetConsoleCP, getting %s Code Page\n",
1294             GetConsoleCPRequest->OutputCP ? "Output" : "Input");
1295
1296     Status = ConSrvGetConsole(ConsoleGetPerProcessData(CsrGetClientThread()->Process), &Console, TRUE);
1297     if (!NT_SUCCESS(Status)) return Status;
1298
1299     Status = ConDrvGetConsoleCP(Console,
1300                                 &GetConsoleCPRequest->CodePage,
1301                                 GetConsoleCPRequest->OutputCP);
1302
1303     ConSrvReleaseConsole(Console, TRUE);
1304     return Status;
1305 }
1306
1307 NTSTATUS NTAPI
1308 ConDrvSetConsoleCP(IN PCONSOLE Console,
1309                    IN UINT CodePage,
1310                    IN BOOLEAN OutputCP);
1311 CSR_API(SrvSetConsoleCP)
1312 {
1313     NTSTATUS Status = STATUS_INVALID_PARAMETER;
1314     PCONSOLE_SETINPUTOUTPUTCP SetConsoleCPRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.SetConsoleCPRequest;
1315     PCONSRV_CONSOLE Console;
1316
1317     DPRINT("SrvSetConsoleCP, setting %s Code Page\n",
1318             SetConsoleCPRequest->OutputCP ? "Output" : "Input");
1319
1320     Status = ConSrvGetConsole(ConsoleGetPerProcessData(CsrGetClientThread()->Process), &Console, TRUE);
1321     if (!NT_SUCCESS(Status)) return Status;
1322
1323     Status = ConDrvSetConsoleCP(Console,
1324                                 SetConsoleCPRequest->CodePage,
1325                                 SetConsoleCPRequest->OutputCP);
1326
1327     ConSrvReleaseConsole(Console, TRUE);
1328     return Status;
1329 }
1330
1331 CSR_API(SrvGetConsoleProcessList)
1332 {
1333     NTSTATUS Status;
1334     PCONSOLE_GETPROCESSLIST GetProcessListRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.GetProcessListRequest;
1335     PCONSRV_CONSOLE Console;
1336
1337     if (!CsrValidateMessageBuffer(ApiMessage,
1338                                   (PVOID)&GetProcessListRequest->ProcessIdsList,
1339                                   GetProcessListRequest->ProcessCount,
1340                                   sizeof(DWORD)))
1341     {
1342         return STATUS_INVALID_PARAMETER;
1343     }
1344
1345     Status = ConSrvGetConsole(ConsoleGetPerProcessData(CsrGetClientThread()->Process), &Console, TRUE);
1346     if (!NT_SUCCESS(Status)) return Status;
1347
1348     Status = ConSrvGetConsoleProcessList(Console,
1349                                          GetProcessListRequest->ProcessIdsList,
1350                                          GetProcessListRequest->ProcessCount,
1351                                          &GetProcessListRequest->ProcessCount);
1352
1353     ConSrvReleaseConsole(Console, TRUE);
1354     return Status;
1355 }
1356
1357 CSR_API(SrvGenerateConsoleCtrlEvent)
1358 {
1359     NTSTATUS Status;
1360     PCONSOLE_GENERATECTRLEVENT GenerateCtrlEventRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.GenerateCtrlEventRequest;
1361     PCONSRV_CONSOLE Console;
1362
1363     Status = ConSrvGetConsole(ConsoleGetPerProcessData(CsrGetClientThread()->Process), &Console, TRUE);
1364     if (!NT_SUCCESS(Status)) return Status;
1365
1366     Status = ConSrvConsoleProcessCtrlEvent(Console,
1367                                            GenerateCtrlEventRequest->ProcessGroupId,
1368                                            GenerateCtrlEventRequest->CtrlEvent);
1369
1370     ConSrvReleaseConsole(Console, TRUE);
1371     return Status;
1372 }
1373
1374 CSR_API(SrvConsoleNotifyLastClose)
1375 {
1376     NTSTATUS Status;
1377     PCONSOLE_PROCESS_DATA ProcessData = ConsoleGetPerProcessData(CsrGetClientThread()->Process);
1378     PCONSRV_CONSOLE Console;
1379
1380     Status = ConSrvGetConsole(ProcessData, &Console, TRUE);
1381     if (!NT_SUCCESS(Status)) return Status;
1382
1383     /* Only one process is allowed to be registered for last close notification */
1384     if (!Console->NotifyLastClose)
1385     {
1386         Console->NotifyLastClose = TRUE;
1387         Console->NotifiedLastCloseProcess = ProcessData;
1388         Status = STATUS_SUCCESS;
1389     }
1390     else
1391     {
1392         Status = STATUS_ACCESS_DENIED;
1393     }
1394
1395     ConSrvReleaseConsole(Console, TRUE);
1396     return Status;
1397 }
1398
1399
1400
1401 CSR_API(SrvGetConsoleMouseInfo)
1402 {
1403     NTSTATUS Status;
1404     PCONSOLE_GETMOUSEINFO GetMouseInfoRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.GetMouseInfoRequest;
1405     PCONSRV_CONSOLE Console;
1406
1407     Status = ConSrvGetConsole(ConsoleGetPerProcessData(CsrGetClientThread()->Process), &Console, TRUE);
1408     if (!NT_SUCCESS(Status)) return Status;
1409
1410     /* Just retrieve the number of buttons of the mouse attached to this console */
1411     GetMouseInfoRequest->NumButtons = GetSystemMetrics(SM_CMOUSEBUTTONS);
1412
1413     ConSrvReleaseConsole(Console, TRUE);
1414     return STATUS_SUCCESS;
1415 }
1416
1417 CSR_API(SrvSetConsoleKeyShortcuts)
1418 {
1419     DPRINT1("%s not yet implemented\n", __FUNCTION__);
1420     return STATUS_NOT_IMPLEMENTED;
1421 }
1422
1423 CSR_API(SrvGetConsoleKeyboardLayoutName)
1424 {
1425     NTSTATUS Status;
1426     PCONSOLE_GETKBDLAYOUTNAME GetKbdLayoutNameRequest = &((PCONSOLE_API_MESSAGE)ApiMessage)->Data.GetKbdLayoutNameRequest;
1427     PCONSRV_CONSOLE Console;
1428
1429     Status = ConSrvGetConsole(ConsoleGetPerProcessData(CsrGetClientThread()->Process), &Console, TRUE);
1430     if (!NT_SUCCESS(Status)) return Status;
1431
1432     /* Retrieve the keyboard layout name of the system */
1433     if (GetKbdLayoutNameRequest->Ansi)
1434         GetKeyboardLayoutNameA((PCHAR)GetKbdLayoutNameRequest->LayoutBuffer);
1435     else
1436         GetKeyboardLayoutNameW((PWCHAR)GetKbdLayoutNameRequest->LayoutBuffer);
1437
1438     ConSrvReleaseConsole(Console, TRUE);
1439     return STATUS_SUCCESS;
1440 }
1441
1442 CSR_API(SrvGetConsoleCharType)
1443 {
1444     DPRINT1("%s not yet implemented\n", __FUNCTION__);
1445     return STATUS_NOT_IMPLEMENTED;
1446 }
1447
1448 CSR_API(SrvSetConsoleLocalEUDC)
1449 {
1450     DPRINT1("%s not yet implemented\n", __FUNCTION__);
1451     return STATUS_NOT_IMPLEMENTED;
1452 }
1453
1454 CSR_API(SrvSetConsoleCursorMode)
1455 {
1456     DPRINT1("%s not yet implemented\n", __FUNCTION__);
1457     return STATUS_NOT_IMPLEMENTED;
1458 }
1459
1460 CSR_API(SrvGetConsoleCursorMode)
1461 {
1462     DPRINT1("%s not yet implemented\n", __FUNCTION__);
1463     return STATUS_NOT_IMPLEMENTED;
1464 }
1465
1466 CSR_API(SrvGetConsoleNlsMode)
1467 {
1468     DPRINT1("%s not yet implemented\n", __FUNCTION__);
1469     return STATUS_NOT_IMPLEMENTED;
1470 }
1471
1472 CSR_API(SrvSetConsoleNlsMode)
1473 {
1474     DPRINT1("%s not yet implemented\n", __FUNCTION__);
1475     return STATUS_NOT_IMPLEMENTED;
1476 }
1477
1478 CSR_API(SrvGetConsoleLangId)
1479 {
1480     DPRINT1("%s not yet implemented\n", __FUNCTION__);
1481     return STATUS_NOT_IMPLEMENTED;
1482 }
1483
1484 /* EOF */