subsystems/win/basesrv/vdm.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Base API Server DLL
   4  * FILE:            subsystems/win/basesrv/vdm.c
   5  * PURPOSE:         Virtual DOS Machines (VDM) Support
   6  * PROGRAMMERS:     Hermes Belusca-Maito (hermes.belusca@sfr.fr)
   7  *                  Aleksandar Andrejevic <theflash AT sdf DOT lonestar DOT org>
   8  */
   9
  10 /* INCLUDES *******************************************************************/
  11
  12 #include "basesrv.h"
  13 #include "vdm.h"
  14
  15 #define NDEBUG
  16 #include <debug.h>
  17
  18 /* GLOBALS ********************************************************************/
  19
  20 BOOLEAN FirstVDM = TRUE;
  21 LIST_ENTRY VDMConsoleListHead;
  22 RTL_CRITICAL_SECTION DosCriticalSection;
  23 RTL_CRITICAL_SECTION WowCriticalSection;
  24
  25 /* FUNCTIONS ******************************************************************/
  26
  27 NTSTATUS NTAPI BaseSrvGetConsoleRecord(HANDLE ConsoleHandle, PVDM_CONSOLE_RECORD *Record)
  28 {
  29     PLIST_ENTRY i;
  30     PVDM_CONSOLE_RECORD CurrentRecord = NULL;
  31
  32     /* Search for a record that has the same console handle */
  33     for (i = VDMConsoleListHead.Flink; i != &VDMConsoleListHead; i = i->Flink)
  34     {
  35         CurrentRecord = CONTAINING_RECORD(i, VDM_CONSOLE_RECORD, Entry);
  36         if (CurrentRecord->ConsoleHandle == ConsoleHandle) break;
  37     }
  38
  39     *Record = CurrentRecord;
  40     return CurrentRecord ? STATUS_SUCCESS : STATUS_NOT_FOUND;
  41 }
  42
  43 NTSTATUS NTAPI GetConsoleRecordBySessionId(ULONG TaskId, PVDM_CONSOLE_RECORD *Record)
  44 {
  45     PLIST_ENTRY i;
  46     PVDM_CONSOLE_RECORD CurrentRecord = NULL;
  47
  48     /* Search for a record that has the same console handle */
  49     for (i = VDMConsoleListHead.Flink; i != &VDMConsoleListHead; i = i->Flink)
  50     {
  51         CurrentRecord = CONTAINING_RECORD(i, VDM_CONSOLE_RECORD, Entry);
  52         if (CurrentRecord->SessionId == TaskId) break;
  53     }
  54
  55     *Record = CurrentRecord;
  56     return CurrentRecord ? STATUS_SUCCESS : STATUS_NOT_FOUND;
  57 }
  58
  59 ULONG NTAPI GetNextDosSesId(VOID)
  60 {
  61     ULONG SessionId;
  62     PLIST_ENTRY i;
  63     PVDM_CONSOLE_RECORD CurrentRecord = NULL;
  64     BOOLEAN Found;
  65
  66     /* Search for an available session ID */
  67     for (SessionId = 1; SessionId != 0; SessionId++)
  68     {
  69         Found = FALSE;
  70
  71         /* Check if the ID is already in use */
  72         for (i = VDMConsoleListHead.Flink; i != &VDMConsoleListHead; i = i->Flink)
  73         {
  74             CurrentRecord = CONTAINING_RECORD(i, VDM_CONSOLE_RECORD, Entry);
  75             if (CurrentRecord->SessionId == SessionId) Found = TRUE;
  76         }
  77
  78         /* If not, we found one */
  79         if (!Found) break;
  80     }
  81
  82     ASSERT(SessionId != 0);
  83
  84     /* Return the session ID */
  85     return SessionId;
  86 }
  87
  88 BOOLEAN NTAPI BaseSrvIsVdmAllowed(VOID)
  89 {
  90     NTSTATUS Status;
  91     BOOLEAN VdmAllowed = TRUE;
  92     HANDLE RootKey, KeyHandle;
  93     UNICODE_STRING KeyName, ValueName, MachineKeyName;
  94     OBJECT_ATTRIBUTES Attributes;
  95     UCHAR ValueBuffer[sizeof(KEY_VALUE_PARTIAL_INFORMATION) + sizeof(ULONG)];
  96     PKEY_VALUE_PARTIAL_INFORMATION ValueInfo = (PKEY_VALUE_PARTIAL_INFORMATION)ValueBuffer;
  97     ULONG ActualSize;
  98
  99     /* Initialize the unicode strings */
 100     RtlInitUnicodeString(&MachineKeyName, L"\\Registry\\Machine");
 101     RtlInitUnicodeString(&KeyName, VDM_POLICY_KEY_NAME);
 102     RtlInitUnicodeString(&ValueName, VDM_DISALLOWED_VALUE_NAME);
 103
 104     InitializeObjectAttributes(&Attributes,
 105                                &MachineKeyName,
 106                                OBJ_CASE_INSENSITIVE,
 107                                NULL,
 108                                NULL);
 109
 110     /* Open the local machine key */
 111     Status = NtOpenKey(&RootKey, KEY_READ, &Attributes);
 112     if (!NT_SUCCESS(Status)) return FALSE;
 113
 114     InitializeObjectAttributes(&Attributes,
 115                                &KeyName,
 116                                OBJ_CASE_INSENSITIVE,
 117                                RootKey,
 118                                NULL);
 119
 120     /* Open the policy key in the local machine hive, if it exists */
 121     if (NT_SUCCESS(NtOpenKey(&KeyHandle, KEY_READ, &Attributes)))
 122     {
 123         /* Read the value, if it's set */
 124         if (NT_SUCCESS(NtQueryValueKey(KeyHandle,
 125                                        &ValueName,
 126                                        KeyValuePartialInformation,
 127                                        ValueInfo,
 128                                        sizeof(ValueBuffer),
 129                                        &ActualSize)))
 130         {
 131             if (*((PULONG)ValueInfo->Data))
 132             {
 133                 /* The VDM has been disabled in the registry */
 134                 VdmAllowed = FALSE;
 135             }
 136         }
 137
 138         NtClose(KeyHandle);
 139     }
 140
 141     /* Close the local machine key */
 142     NtClose(RootKey);
 143
 144     /* If it's disabled system-wide, there's no need to check the user key */
 145     if (!VdmAllowed) return FALSE;
 146
 147     /* Open the current user key of the client */
 148     if (!CsrImpersonateClient(NULL)) return VdmAllowed;
 149     Status = RtlOpenCurrentUser(KEY_READ, &RootKey);
 150     CsrRevertToSelf();
 151
 152     /* If that fails, return the system-wide setting */
 153     if (!NT_SUCCESS(Status)) return VdmAllowed;
 154
 155     InitializeObjectAttributes(&Attributes,
 156                                &KeyName,
 157                                OBJ_CASE_INSENSITIVE,
 158                                RootKey,
 159                                NULL);
 160
 161     /* Open the policy key in the current user hive, if it exists */
 162     if (NT_SUCCESS(NtOpenKey(&KeyHandle, KEY_READ, &Attributes)))
 163     {
 164         /* Read the value, if it's set */
 165         if (NT_SUCCESS(NtQueryValueKey(KeyHandle,
 166                                        &ValueName,
 167                                        KeyValuePartialInformation,
 168                                        ValueInfo,
 169                                        sizeof(ValueBuffer),
 170                                        &ActualSize)))
 171         {
 172             if (*((PULONG)ValueInfo->Data))
 173             {
 174                 /* The VDM has been disabled in the registry */
 175                 VdmAllowed = FALSE;
 176             }
 177         }
 178
 179         NtClose(KeyHandle);
 180     }
 181
 182     return VdmAllowed;
 183 }
 184
 185 NTSTATUS NTAPI BaseSrvCreatePairWaitHandles(PHANDLE ServerEvent, PHANDLE ClientEvent)
 186 {
 187     NTSTATUS Status;
 188
 189     /* Create the event */
 190     Status = NtCreateEvent(ServerEvent, EVENT_ALL_ACCESS, NULL, NotificationEvent, FALSE);
 191     if (!NT_SUCCESS(Status)) return Status;
 192
 193     /* Duplicate the event into the client process */
 194     Status = NtDuplicateObject(NtCurrentProcess(),
 195                                *ServerEvent,
 196                                CsrGetClientThread()->Process->ProcessHandle,
 197                                ClientEvent,
 198                                0,
 199                                0,
 200                                DUPLICATE_SAME_ATTRIBUTES | DUPLICATE_SAME_ACCESS);
 201
 202     if (!NT_SUCCESS(Status)) NtClose(*ServerEvent);
 203     return Status;
 204 }
 205
 206 VOID BaseSrvFreeVDMInfo(PVDM_COMMAND_INFO CommandInfo)
 207 {
 208     /* Free the allocated structure members */
 209     if (CommandInfo->CmdLine != NULL) RtlFreeHeap(BaseSrvHeap, 0, CommandInfo->CmdLine);
 210     if (CommandInfo->AppName != NULL) RtlFreeHeap(BaseSrvHeap, 0, CommandInfo->AppName);
 211     if (CommandInfo->PifFile != NULL) RtlFreeHeap(BaseSrvHeap, 0, CommandInfo->PifFile);
 212     if (CommandInfo->CurDirectory != NULL) RtlFreeHeap(BaseSrvHeap, 0, CommandInfo->CurDirectory);
 213     if (CommandInfo->Env != NULL) RtlFreeHeap(BaseSrvHeap, 0, CommandInfo->Env);
 214     if (CommandInfo->Desktop != NULL) RtlFreeHeap(BaseSrvHeap, 0, CommandInfo->Desktop);
 215     if (CommandInfo->Title != NULL) RtlFreeHeap(BaseSrvHeap, 0, CommandInfo->Title);
 216     if (CommandInfo->Reserved != NULL) RtlFreeHeap(BaseSrvHeap, 0, CommandInfo->Reserved);
 217
 218     /* Free the structure itself */
 219     RtlFreeHeap(BaseSrvHeap, 0, CommandInfo);
 220 }
 221
 222 BOOLEAN NTAPI BaseSrvCopyCommand(PBASE_CHECK_VDM CheckVdmRequest, PVDM_DOS_RECORD DosRecord)
 223 {
 224     BOOLEAN Success = FALSE;
 225     PVDM_COMMAND_INFO CommandInfo = NULL;
 226
 227     /* Allocate the command information structure */
 228     CommandInfo = (PVDM_COMMAND_INFO)RtlAllocateHeap(BaseSrvHeap,
 229                                                      HEAP_ZERO_MEMORY,
 230                                                      sizeof(VDM_COMMAND_INFO));
 231     if (CommandInfo == NULL) return FALSE;
 232
 233     /* Fill the structure */
 234     CommandInfo->TaskId = CheckVdmRequest->iTask;
 235     CommandInfo->ExitCode = DosRecord->ExitCode;
 236     CommandInfo->CodePage = CheckVdmRequest->CodePage;
 237     CommandInfo->StdIn = CheckVdmRequest->StdIn;
 238     CommandInfo->StdOut = CheckVdmRequest->StdOut;
 239     CommandInfo->StdErr = CheckVdmRequest->StdErr;
 240
 241     /* Allocate memory for the command line */
 242     CommandInfo->CmdLine = RtlAllocateHeap(BaseSrvHeap,
 243                                            HEAP_ZERO_MEMORY,
 244                                            CheckVdmRequest->CmdLen);
 245     if (CommandInfo->CmdLine == NULL) goto Cleanup;
 246
 247     /* Copy the command line */
 248     RtlMoveMemory(CommandInfo->CmdLine, CheckVdmRequest->CmdLine, CheckVdmRequest->CmdLen);
 249
 250     /* Allocate memory for the application name */
 251     CommandInfo->AppName = RtlAllocateHeap(BaseSrvHeap,
 252                                            HEAP_ZERO_MEMORY,
 253                                            CheckVdmRequest->AppLen);
 254     if (CommandInfo->AppName == NULL) goto Cleanup;
 255
 256     /* Copy the application name */
 257     RtlMoveMemory(CommandInfo->AppName, CheckVdmRequest->AppName, CheckVdmRequest->AppLen);
 258
 259     /* Allocate memory for the PIF file name */
 260     if (CheckVdmRequest->PifLen != 0)
 261     {
 262         CommandInfo->PifFile = RtlAllocateHeap(BaseSrvHeap,
 263                                                HEAP_ZERO_MEMORY,
 264                                                CheckVdmRequest->PifLen);
 265         if (CommandInfo->PifFile == NULL) goto Cleanup;
 266
 267         /* Copy the PIF file name */
 268         RtlMoveMemory(CommandInfo->PifFile, CheckVdmRequest->PifFile, CheckVdmRequest->PifLen);
 269     }
 270     else CommandInfo->PifFile = NULL;
 271
 272     /* Allocate memory for the current directory */
 273     if (CheckVdmRequest->CurDirectoryLen != 0)
 274     {
 275         CommandInfo->CurDirectory = RtlAllocateHeap(BaseSrvHeap,
 276                                                     HEAP_ZERO_MEMORY,
 277                                                     CheckVdmRequest->CurDirectoryLen);
 278         if (CommandInfo->CurDirectory == NULL) goto Cleanup;
 279
 280         /* Copy the current directory */
 281         RtlMoveMemory(CommandInfo->CurDirectory,
 282                       CheckVdmRequest->CurDirectory,
 283                       CheckVdmRequest->CurDirectoryLen);
 284     }
 285     else CommandInfo->CurDirectory = NULL;
 286
 287     /* Allocate memory for the environment block */
 288     CommandInfo->Env = RtlAllocateHeap(BaseSrvHeap,
 289                                        HEAP_ZERO_MEMORY,
 290                                        CheckVdmRequest->EnvLen);
 291     if (CommandInfo->Env == NULL) goto Cleanup;
 292
 293     /* Copy the environment block */
 294     RtlMoveMemory(CommandInfo->Env, CheckVdmRequest->Env, CheckVdmRequest->EnvLen);
 295
 296     CommandInfo->EnvLen = CheckVdmRequest->EnvLen;
 297     RtlMoveMemory(&CommandInfo->StartupInfo,
 298                   CheckVdmRequest->StartupInfo,
 299                   sizeof(STARTUPINFOA));
 300
 301     /* Allocate memory for the desktop */
 302     if (CheckVdmRequest->DesktopLen != 0)
 303     {
 304         CommandInfo->Desktop = RtlAllocateHeap(BaseSrvHeap,
 305                                                HEAP_ZERO_MEMORY,
 306                                                CheckVdmRequest->DesktopLen);
 307         if (CommandInfo->Desktop == NULL) goto Cleanup;
 308
 309         /* Copy the desktop name */
 310         RtlMoveMemory(CommandInfo->Desktop, CheckVdmRequest->Desktop, CheckVdmRequest->DesktopLen);
 311     }
 312     else CommandInfo->Desktop = NULL;
 313
 314     CommandInfo->DesktopLen = CheckVdmRequest->DesktopLen;
 315
 316     /* Allocate memory for the title */
 317     if (CheckVdmRequest->TitleLen != 0)
 318     {
 319         CommandInfo->Title = RtlAllocateHeap(BaseSrvHeap,
 320                                              HEAP_ZERO_MEMORY,
 321                                              CheckVdmRequest->TitleLen);
 322         if (CommandInfo->Title == NULL) goto Cleanup;
 323
 324         /* Copy the title */
 325         RtlMoveMemory(CommandInfo->Title, CheckVdmRequest->Title, CheckVdmRequest->TitleLen);
 326     }
 327     else CommandInfo->Title = NULL;
 328
 329     CommandInfo->TitleLen = CheckVdmRequest->TitleLen;
 330
 331     /* Allocate memory for the reserved field */
 332     if (CheckVdmRequest->ReservedLen != 0)
 333     {
 334         CommandInfo->Reserved = RtlAllocateHeap(BaseSrvHeap,
 335                                                 HEAP_ZERO_MEMORY,
 336                                                 CheckVdmRequest->ReservedLen);
 337         if (CommandInfo->Reserved == NULL) goto Cleanup;
 338
 339         /* Copy the reserved field */
 340         RtlMoveMemory(CommandInfo->Reserved,
 341                       CheckVdmRequest->Reserved,
 342                       CheckVdmRequest->ReservedLen);
 343     }
 344     else CommandInfo->Reserved = NULL;
 345
 346     CommandInfo->ReservedLen = CheckVdmRequest->ReservedLen;
 347
 348     CommandInfo->CmdLen = CheckVdmRequest->CmdLen;
 349     CommandInfo->AppLen = CheckVdmRequest->AppLen;
 350     CommandInfo->PifLen = CheckVdmRequest->PifLen;
 351     CommandInfo->CurDirectoryLen = CheckVdmRequest->CurDirectoryLen;
 352     CommandInfo->VDMState = DosRecord->State;
 353     // TODO: Set CommandInfo->CurrentDrive
 354     // TODO: Set CommandInfo->ComingFromBat
 355
 356     /* Set the DOS record's command structure */
 357     DosRecord->CommandInfo = CommandInfo;
 358
 359     /* The operation was successful */
 360     Success = TRUE;
 361
 362 Cleanup:
 363     /* If it wasn't successful, free the memory */
 364     if (!Success) BaseSrvFreeVDMInfo(CommandInfo);
 365
 366     return Success;
 367 }
 368
 369 VOID NTAPI BaseInitializeVDM(VOID)
 370 {
 371     /* Initialize the list head */
 372     InitializeListHead(&VDMConsoleListHead);
 373
 374     /* Initialize the critical section */
 375     RtlInitializeCriticalSection(&DosCriticalSection);
 376     RtlInitializeCriticalSection(&WowCriticalSection);
 377 }
 378
 379 /* PUBLIC SERVER APIS *********************************************************/
 380
 381 CSR_API(BaseSrvCheckVDM)
 382 {
 383     NTSTATUS Status;
 384     PBASE_CHECK_VDM CheckVdmRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.CheckVDMRequest;
 385     PCSR_PROCESS ClientProcess;
 386     PRTL_CRITICAL_SECTION CriticalSection = NULL;
 387     PVDM_CONSOLE_RECORD ConsoleRecord = NULL;
 388     PVDM_DOS_RECORD DosRecord = NULL;
 389     BOOLEAN NewConsoleRecord = FALSE;
 390
 391     /* Don't do anything if the VDM has been disabled in the registry */
 392     if (!BaseSrvIsVdmAllowed()) return STATUS_ACCESS_DENIED;
 393
 394     /* Validate the message buffers */
 395     if (!CsrValidateMessageBuffer(ApiMessage,
 396                                   (PVOID*)&CheckVdmRequest->CmdLine,
 397                                   CheckVdmRequest->CmdLen,
 398                                   sizeof(*CheckVdmRequest->CmdLine))
 399         || !CsrValidateMessageBuffer(ApiMessage,
 400                                      (PVOID*)&CheckVdmRequest->AppName,
 401                                      CheckVdmRequest->AppLen,
 402                                      sizeof(*CheckVdmRequest->AppName))
 403         || !CsrValidateMessageBuffer(ApiMessage,
 404                                      (PVOID*)&CheckVdmRequest->PifFile,
 405                                      CheckVdmRequest->PifLen,
 406                                      sizeof(*CheckVdmRequest->PifFile))
 407         || !CsrValidateMessageBuffer(ApiMessage,
 408                                      (PVOID*)&CheckVdmRequest->CurDirectory,
 409                                      CheckVdmRequest->CurDirectoryLen,
 410                                      sizeof(*CheckVdmRequest->CurDirectory))
 411         || !CsrValidateMessageBuffer(ApiMessage,
 412                                      (PVOID*)&CheckVdmRequest->Desktop,
 413                                      CheckVdmRequest->DesktopLen,
 414                                      sizeof(*CheckVdmRequest->Desktop))
 415         || !CsrValidateMessageBuffer(ApiMessage,
 416                                      (PVOID*)&CheckVdmRequest->Title,
 417                                      CheckVdmRequest->TitleLen,
 418                                      sizeof(*CheckVdmRequest->Title))
 419         || !CsrValidateMessageBuffer(ApiMessage,
 420                                      (PVOID*)&CheckVdmRequest->Reserved,
 421                                      CheckVdmRequest->ReservedLen,
 422                                      sizeof(*CheckVdmRequest->Reserved)))
 423     {
 424         return STATUS_INVALID_PARAMETER;
 425     }
 426
 427     /* Lock the process */
 428     Status = CsrLockProcessByClientId(ApiMessage->Header.ClientId.UniqueProcess,
 429                                       &ClientProcess);
 430     if (!NT_SUCCESS(Status)) return Status;
 431
 432     CriticalSection = (CheckVdmRequest->BinaryType != BINARY_TYPE_SEPARATE_WOW)
 433                       ? &DosCriticalSection
 434                       : &WowCriticalSection;
 435
 436     /* Enter the critical section */
 437     RtlEnterCriticalSection(CriticalSection);
 438
 439     /* Check if this is a DOS or WOW VDM */
 440     if (CheckVdmRequest->BinaryType != BINARY_TYPE_SEPARATE_WOW)
 441     {
 442         /* Get the console record */
 443         Status = BaseSrvGetConsoleRecord(CheckVdmRequest->ConsoleHandle,
 444                                          &ConsoleRecord);
 445
 446         if (!NT_SUCCESS(Status))
 447         {
 448             /* Allocate a new console record */
 449             ConsoleRecord = (PVDM_CONSOLE_RECORD)RtlAllocateHeap(BaseSrvHeap,
 450                                                                  HEAP_ZERO_MEMORY,
 451                                                                  sizeof(VDM_CONSOLE_RECORD));
 452             if (ConsoleRecord == NULL)
 453             {
 454                 Status = STATUS_NO_MEMORY;
 455                 goto Cleanup;
 456             }
 457
 458             /* Initialize the console record */
 459             ConsoleRecord->ConsoleHandle = CheckVdmRequest->ConsoleHandle;
 460             ConsoleRecord->ProcessHandle = ClientProcess->ProcessHandle;
 461             ConsoleRecord->ServerEvent = ConsoleRecord->ClientEvent = NULL;
 462             ConsoleRecord->ReenterCount = 0;
 463             ConsoleRecord->CurrentDirs = NULL;
 464             ConsoleRecord->CurDirsLength = 0;
 465             ConsoleRecord->SessionId = GetNextDosSesId();
 466             InitializeListHead(&ConsoleRecord->DosListHead);
 467             // TODO: The console record structure is incomplete
 468
 469             /* Remember that the console record was allocated here */
 470             NewConsoleRecord = TRUE;
 471         }
 472
 473         /* Allocate a new DOS record */
 474         DosRecord = (PVDM_DOS_RECORD)RtlAllocateHeap(BaseSrvHeap,
 475                                                      HEAP_ZERO_MEMORY,
 476                                                      sizeof(VDM_DOS_RECORD));
 477         if (DosRecord == NULL)
 478         {
 479             Status = STATUS_NO_MEMORY;
 480             goto Cleanup;
 481         }
 482
 483         /* Initialize the DOS record */
 484         DosRecord->State = NewConsoleRecord ? VDM_NOT_LOADED : VDM_READY;
 485         DosRecord->ExitCode = 0;
 486         // TODO: The DOS record structure is incomplete
 487
 488         Status = BaseSrvCreatePairWaitHandles(&DosRecord->ServerEvent, &DosRecord->ClientEvent);
 489         if (!NT_SUCCESS(Status)) goto Cleanup;
 490
 491         /* Return the client event handle */
 492         CheckVdmRequest->WaitObjectForParent = DosRecord->ClientEvent;
 493
 494         /* Translate the input structure into a VDM command structure and set it in the DOS record */
 495         if (!BaseSrvCopyCommand(CheckVdmRequest, DosRecord))
 496         {
 497             /* The only possibility is that an allocation failure occurred */
 498             Status = STATUS_NO_MEMORY;
 499             goto Cleanup;
 500         }
 501
 502         /* Add the DOS record */
 503         InsertHeadList(&ConsoleRecord->DosListHead, &DosRecord->Entry);
 504
 505         if (NewConsoleRecord)
 506         {
 507             /* Add the console record */
 508             InsertTailList(&VDMConsoleListHead, &ConsoleRecord->Entry);
 509         }
 510
 511         CheckVdmRequest->VDMState = DosRecord->State;
 512         Status = STATUS_SUCCESS;
 513     }
 514     else
 515     {
 516         // TODO: NOT IMPLEMENTED
 517         UNIMPLEMENTED;
 518         Status = STATUS_NOT_IMPLEMENTED;
 519     }
 520
 521 Cleanup:
 522     /* Check if it failed */
 523     if (!NT_SUCCESS(Status))
 524     {
 525         /* Free the DOS record */
 526         if (DosRecord != NULL)
 527         {
 528             if (DosRecord->ServerEvent) NtClose(DosRecord->ServerEvent);
 529             if (DosRecord->ClientEvent)
 530             {
 531                 /* Close the remote handle */
 532                 NtDuplicateObject(CsrGetClientThread()->Process->ProcessHandle,
 533                                   DosRecord->ClientEvent,
 534                                   NULL,
 535                                   NULL,
 536                                   0,
 537                                   0,
 538                                   DUPLICATE_CLOSE_SOURCE);
 539             }
 540
 541             RtlFreeHeap(BaseSrvHeap, 0, DosRecord);
 542             DosRecord = NULL;
 543         }
 544
 545         /* Free the console record if it was allocated here */
 546         if (NewConsoleRecord)
 547         {
 548             RtlFreeHeap(BaseSrvHeap, 0, ConsoleRecord);
 549             ConsoleRecord = NULL;
 550         }
 551     }
 552
 553     /* Leave the critical section */
 554     RtlLeaveCriticalSection(CriticalSection);
 555
 556     /* Unlock the process */
 557     CsrUnlockProcess(ClientProcess);
 558
 559     return Status;
 560 }
 561
 562 CSR_API(BaseSrvUpdateVDMEntry)
 563 {
 564     NTSTATUS Status;
 565     PBASE_UPDATE_VDM_ENTRY UpdateVdmEntryRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.UpdateVDMEntryRequest;
 566     PRTL_CRITICAL_SECTION CriticalSection = NULL;
 567     PVDM_CONSOLE_RECORD ConsoleRecord = NULL;
 568     PVDM_DOS_RECORD DosRecord = NULL;
 569
 570     CriticalSection = (UpdateVdmEntryRequest->BinaryType != BINARY_TYPE_SEPARATE_WOW)
 571                       ? &DosCriticalSection
 572                       : &WowCriticalSection;
 573
 574     /* Enter the critical section */
 575     RtlEnterCriticalSection(CriticalSection);
 576
 577     /* Check if this is a DOS or WOW VDM */
 578     if (UpdateVdmEntryRequest->BinaryType != BINARY_TYPE_SEPARATE_WOW)
 579     {
 580         if (UpdateVdmEntryRequest->iTask != 0)
 581         {
 582             /* Get the console record using the task ID */
 583             Status = GetConsoleRecordBySessionId(UpdateVdmEntryRequest->iTask,
 584                                                  &ConsoleRecord);
 585         }
 586         else
 587         {
 588             /* Get the console record using the console handle */
 589             Status = BaseSrvGetConsoleRecord(UpdateVdmEntryRequest->ConsoleHandle,
 590                                              &ConsoleRecord);
 591         }
 592
 593         if (!NT_SUCCESS(Status)) goto Cleanup;
 594
 595         /* Get the primary DOS record */
 596         DosRecord = (PVDM_DOS_RECORD)CONTAINING_RECORD(ConsoleRecord->DosListHead.Flink,
 597                                                        VDM_DOS_RECORD,
 598                                                        Entry);
 599
 600         switch (UpdateVdmEntryRequest->EntryIndex)
 601         {
 602             case VdmEntryUndo:
 603             {
 604                 /* Close the server event handle, the client will close the client handle */
 605                 NtClose(DosRecord->ServerEvent);
 606                 DosRecord->ServerEvent = DosRecord->ClientEvent = NULL;
 607
 608                 if (UpdateVdmEntryRequest->VDMCreationState & (VDM_UNDO_PARTIAL | VDM_UNDO_FULL))
 609                 {
 610                     /* Remove the DOS record */
 611                     if (DosRecord->CommandInfo) BaseSrvFreeVDMInfo(DosRecord->CommandInfo);
 612                     RemoveEntryList(&DosRecord->Entry);
 613                     RtlFreeHeap(BaseSrvHeap, 0, DosRecord);
 614
 615                     /*
 616                      * Since this is an undo, if that was the only DOS record the VDM
 617                      * won't even start, so the console record should be removed too.
 618                      */
 619                     if (ConsoleRecord->DosListHead.Flink == &ConsoleRecord->DosListHead)
 620                     {
 621                         RemoveEntryList(&ConsoleRecord->Entry);
 622                         RtlFreeHeap(BaseSrvHeap, 0, ConsoleRecord);
 623                     }
 624                 }
 625
 626                 /* It was successful */
 627                 Status = STATUS_SUCCESS;
 628
 629                 break;
 630             }
 631
 632             case VdmEntryUpdateProcess:
 633             {
 634                 /* Duplicate the VDM process handle */
 635                 Status = NtDuplicateObject(CsrGetClientThread()->Process->ProcessHandle,
 636                                            UpdateVdmEntryRequest->VDMProcessHandle,
 637                                            NtCurrentProcess(),
 638                                            &ConsoleRecord->ProcessHandle,
 639                                            0,
 640                                            0,
 641                                            DUPLICATE_SAME_ATTRIBUTES | DUPLICATE_SAME_ACCESS);
 642                 if (!NT_SUCCESS(Status)) goto Cleanup;
 643
 644                 /* Create a pair of handles to one event object */
 645                 Status = BaseSrvCreatePairWaitHandles(&DosRecord->ServerEvent,
 646                                                       &DosRecord->ClientEvent);
 647                 if (!NT_SUCCESS(Status)) goto Cleanup;
 648
 649                 /* Return the client event handle */
 650                 UpdateVdmEntryRequest->WaitObjectForParent = DosRecord->ClientEvent;
 651
 652                 break;
 653             }
 654
 655             case VdmEntryUpdateControlCHandler:
 656             {
 657                 // TODO: NOT IMPLEMENTED
 658                 DPRINT1("BaseSrvUpdateVDMEntry: VdmEntryUpdateControlCHandler not implemented!");
 659                 Status = STATUS_NOT_IMPLEMENTED;
 660
 661                 break;
 662             }
 663
 664             default:
 665             {
 666                 /* Invalid */
 667                 Status = STATUS_INVALID_PARAMETER;
 668             }
 669         }
 670     }
 671     else
 672     {
 673         // TODO: NOT IMPLEMENTED
 674         UNIMPLEMENTED;
 675         Status = STATUS_NOT_IMPLEMENTED;
 676     }
 677
 678 Cleanup:
 679     /* Leave the critical section */
 680     RtlLeaveCriticalSection(CriticalSection);
 681
 682     return Status;
 683 }
 684
 685 CSR_API(BaseSrvGetNextVDMCommand)
 686 {
 687     DPRINT1("%s not yet implemented\n", __FUNCTION__);
 688     return STATUS_NOT_IMPLEMENTED;
 689 }
 690
 691 CSR_API(BaseSrvExitVDM)
 692 {
 693     NTSTATUS Status;
 694     PBASE_EXIT_VDM ExitVdmRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.ExitVDMRequest;
 695     PRTL_CRITICAL_SECTION CriticalSection = NULL;
 696     PVDM_CONSOLE_RECORD ConsoleRecord = NULL;
 697     PVDM_DOS_RECORD DosRecord;
 698
 699     CriticalSection = (ExitVdmRequest->iWowTask == 0)
 700                       ? &DosCriticalSection
 701                       : &WowCriticalSection;
 702
 703     /* Enter the critical section */
 704     RtlEnterCriticalSection(CriticalSection);
 705
 706     if (ExitVdmRequest->iWowTask == 0)
 707     {
 708         /* Get the console record */
 709         Status = BaseSrvGetConsoleRecord(ExitVdmRequest->ConsoleHandle, &ConsoleRecord);
 710         if (!NT_SUCCESS(Status)) goto Cleanup;
 711
 712         /* Cleanup the DOS records */
 713         while (ConsoleRecord->DosListHead.Flink != &ConsoleRecord->DosListHead)
 714         {
 715             DosRecord = CONTAINING_RECORD(ConsoleRecord->DosListHead.Flink,
 716                                           VDM_DOS_RECORD,
 717                                           Entry);
 718
 719             /* Set the event and close it */
 720             NtSetEvent(DosRecord->ServerEvent, NULL);
 721             NtClose(DosRecord->ServerEvent);
 722
 723             /* Remove the DOS entry */
 724             if (DosRecord->CommandInfo) BaseSrvFreeVDMInfo(DosRecord->CommandInfo);
 725             RemoveEntryList(&DosRecord->Entry);
 726             RtlFreeHeap(BaseSrvHeap, 0, DosRecord);
 727         }
 728
 729         if (ConsoleRecord->CurrentDirs != NULL)
 730         {
 731             /* Free the current directories */
 732             RtlFreeHeap(BaseSrvHeap, 0, ConsoleRecord->CurrentDirs);
 733             ConsoleRecord->CurrentDirs = NULL;
 734             ConsoleRecord->CurDirsLength = 0;
 735         }
 736
 737         /* Remove the console record */
 738         RemoveEntryList(&ConsoleRecord->Entry);
 739         RtlFreeHeap(BaseSrvHeap, 0, ConsoleRecord);
 740     }
 741     else
 742     {
 743         // TODO: NOT IMPLEMENTED
 744         UNIMPLEMENTED;
 745         Status = STATUS_NOT_IMPLEMENTED;
 746     }
 747
 748 Cleanup:
 749     /* Leave the critical section */
 750     RtlLeaveCriticalSection(CriticalSection);
 751
 752     return Status;
 753 }
 754
 755 CSR_API(BaseSrvIsFirstVDM)
 756 {
 757     PBASE_IS_FIRST_VDM IsFirstVDMRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.IsFirstVDMRequest;
 758
 759     /* Return the result */
 760     IsFirstVDMRequest->FirstVDM = FirstVDM;
 761
 762     /* Clear the first VDM flag */
 763     FirstVDM = FALSE;
 764
 765     return STATUS_SUCCESS;
 766 }
 767
 768 CSR_API(BaseSrvGetVDMExitCode)
 769 {
 770     NTSTATUS Status;
 771     PBASE_GET_VDM_EXIT_CODE GetVDMExitCodeRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.GetVDMExitCodeRequest;
 772     PLIST_ENTRY i = NULL;
 773     PVDM_CONSOLE_RECORD ConsoleRecord = NULL;
 774     PVDM_DOS_RECORD DosRecord = NULL;
 775
 776     /* Enter the critical section */
 777     RtlEnterCriticalSection(&DosCriticalSection);
 778
 779     /* Get the console record */
 780     Status = BaseSrvGetConsoleRecord(GetVDMExitCodeRequest->ConsoleHandle, &ConsoleRecord);
 781     if (!NT_SUCCESS(Status)) goto Cleanup;
 782
 783     /* Search for a DOS record that has the same parent process handle */
 784     for (i = ConsoleRecord->DosListHead.Flink; i != &ConsoleRecord->DosListHead; i = i->Flink)
 785     {
 786         DosRecord = CONTAINING_RECORD(i, VDM_DOS_RECORD, Entry);
 787         if (DosRecord->ClientEvent == GetVDMExitCodeRequest->hParent) break;
 788     }
 789
 790     /* Check if no DOS record was found */
 791     if (i == &ConsoleRecord->DosListHead)
 792     {
 793         Status = STATUS_NOT_FOUND;
 794         goto Cleanup;
 795     }
 796
 797     /* Check if this task is still running */
 798     if (DosRecord->State == VDM_READY)
 799     {
 800         GetVDMExitCodeRequest->ExitCode = STATUS_PENDING;
 801         goto Cleanup;
 802     }
 803
 804     /* Return the exit code */
 805     GetVDMExitCodeRequest->ExitCode = DosRecord->ExitCode;
 806
 807     /* Since this is a zombie task record, remove it */
 808     if (DosRecord->CommandInfo) BaseSrvFreeVDMInfo(DosRecord->CommandInfo);
 809     RemoveEntryList(&DosRecord->Entry);
 810     RtlFreeHeap(BaseSrvHeap, 0, DosRecord);
 811
 812 Cleanup:
 813     /* Leave the critical section */
 814     RtlLeaveCriticalSection(&DosCriticalSection);
 815
 816     return Status;
 817 }
 818
 819 CSR_API(BaseSrvSetReenterCount)
 820 {
 821     NTSTATUS Status = STATUS_SUCCESS;
 822     PBASE_SET_REENTER_COUNT SetReenterCountRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.SetReenterCountRequest;
 823     PVDM_CONSOLE_RECORD ConsoleRecord;
 824
 825     /* Enter the critical section */
 826     RtlEnterCriticalSection(&DosCriticalSection);
 827
 828     /* Get the console record */
 829     Status = BaseSrvGetConsoleRecord(SetReenterCountRequest->ConsoleHandle, &ConsoleRecord);
 830     if (!NT_SUCCESS(Status)) goto Cleanup;
 831
 832     if (SetReenterCountRequest->fIncDec == VDM_INC_REENTER_COUNT) ConsoleRecord->ReenterCount++;
 833     else if (SetReenterCountRequest->fIncDec == VDM_DEC_REENTER_COUNT)
 834     {
 835         ConsoleRecord->ReenterCount--;
 836         if (ConsoleRecord->ServerEvent != NULL) NtSetEvent(ConsoleRecord->ServerEvent, NULL);
 837     }
 838     else Status = STATUS_INVALID_PARAMETER;
 839
 840 Cleanup:
 841     /* Leave the critical section */
 842     RtlLeaveCriticalSection(&DosCriticalSection);
 843
 844     return Status;
 845 }
 846
 847 CSR_API(BaseSrvSetVDMCurDirs)
 848 {
 849     NTSTATUS Status;
 850     PBASE_GETSET_VDM_CURDIRS VDMCurrentDirsRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.VDMCurrentDirsRequest;
 851     PVDM_CONSOLE_RECORD ConsoleRecord;
 852     PCHAR Buffer = NULL;
 853
 854     /* Validate the input buffer */
 855     if (!CsrValidateMessageBuffer(ApiMessage,
 856                                   (PVOID*)&VDMCurrentDirsRequest->lpszzCurDirs,
 857                                   VDMCurrentDirsRequest->cchCurDirs,
 858                                   sizeof(*VDMCurrentDirsRequest->lpszzCurDirs)))
 859     {
 860         return STATUS_INVALID_PARAMETER;
 861     }
 862
 863     /* Enter the critical section */
 864     RtlEnterCriticalSection(&DosCriticalSection);
 865
 866     /* Find the console record */
 867     Status = BaseSrvGetConsoleRecord(VDMCurrentDirsRequest->ConsoleHandle, &ConsoleRecord);
 868     if (!NT_SUCCESS(Status)) goto Cleanup;
 869
 870     if (ConsoleRecord->CurrentDirs == NULL)
 871     {
 872         /* Allocate memory for the current directory information */
 873         Buffer = RtlAllocateHeap(BaseSrvHeap,
 874                                  HEAP_ZERO_MEMORY,
 875                                  VDMCurrentDirsRequest->cchCurDirs);
 876     }
 877     else
 878     {
 879         /* Resize the amount of allocated memory */
 880         Buffer = RtlReAllocateHeap(BaseSrvHeap,
 881                                    HEAP_ZERO_MEMORY,
 882                                    ConsoleRecord->CurrentDirs,
 883                                    VDMCurrentDirsRequest->cchCurDirs);
 884     }
 885
 886     if (Buffer == NULL)
 887     {
 888         /* Allocation failed */
 889         Status = STATUS_NO_MEMORY;
 890         goto Cleanup;
 891     }
 892
 893     /* Update the console record */
 894     ConsoleRecord->CurrentDirs = Buffer;
 895     ConsoleRecord->CurDirsLength = VDMCurrentDirsRequest->cchCurDirs;
 896
 897     /* Copy the data */
 898     RtlMoveMemory(ConsoleRecord->CurrentDirs,
 899                   VDMCurrentDirsRequest->lpszzCurDirs,
 900                   VDMCurrentDirsRequest->cchCurDirs);
 901
 902 Cleanup:
 903     /* Leave the critical section */
 904     RtlLeaveCriticalSection(&DosCriticalSection);
 905
 906     return Status;
 907 }
 908
 909 CSR_API(BaseSrvGetVDMCurDirs)
 910 {
 911     NTSTATUS Status;
 912     PBASE_GETSET_VDM_CURDIRS VDMCurrentDirsRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.VDMCurrentDirsRequest;
 913     PVDM_CONSOLE_RECORD ConsoleRecord;
 914
 915     /* Validate the output buffer */
 916     if (!CsrValidateMessageBuffer(ApiMessage,
 917                                   (PVOID*)&VDMCurrentDirsRequest->lpszzCurDirs,
 918                                   VDMCurrentDirsRequest->cchCurDirs,
 919                                   sizeof(*VDMCurrentDirsRequest->lpszzCurDirs)))
 920     {
 921         return STATUS_INVALID_PARAMETER;
 922     }
 923
 924     /* Enter the critical section */
 925     RtlEnterCriticalSection(&DosCriticalSection);
 926
 927     /* Find the console record */
 928     Status = BaseSrvGetConsoleRecord(VDMCurrentDirsRequest->ConsoleHandle, &ConsoleRecord);
 929     if (!NT_SUCCESS(Status)) goto Cleanup;
 930
 931     /* Return the actual size of the current directory information */
 932     VDMCurrentDirsRequest->cchCurDirs = ConsoleRecord->CurDirsLength;
 933
 934     /* Check if the buffer is large enough */
 935     if (VDMCurrentDirsRequest->cchCurDirs < ConsoleRecord->CurDirsLength)
 936     {
 937         Status = STATUS_BUFFER_TOO_SMALL;
 938         goto Cleanup;
 939     }
 940
 941     /* Copy the data */
 942     RtlMoveMemory(VDMCurrentDirsRequest->lpszzCurDirs,
 943                   ConsoleRecord->CurrentDirs,
 944                   ConsoleRecord->CurDirsLength);
 945
 946 Cleanup:
 947     /* Leave the critical section */
 948     RtlLeaveCriticalSection(&DosCriticalSection);
 949
 950     return Status;
 951 }
 952
 953 CSR_API(BaseSrvBatNotification)
 954 {
 955     DPRINT1("%s not yet implemented\n", __FUNCTION__);
 956     return STATUS_NOT_IMPLEMENTED;
 957 }
 958
 959 CSR_API(BaseSrvRegisterWowExec)
 960 {
 961     DPRINT1("%s not yet implemented\n", __FUNCTION__);
 962     return STATUS_NOT_IMPLEMENTED;
 963 }
 964
 965 CSR_API(BaseSrvRefreshIniFileMapping)
 966 {
 967     DPRINT1("%s not yet implemented\n", __FUNCTION__);
 968     return STATUS_NOT_IMPLEMENTED;
 969 }
 970
 971 /* EOF */