[KERNEL32][BASESRV]
[reactos.git] / 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 /* NULL is not a valid console handle */
33 if (ConsoleHandle == NULL) return STATUS_INVALID_PARAMETER;
34
35 /* Search for a record that has the same console handle */
36 for (i = VDMConsoleListHead.Flink; i != &VDMConsoleListHead; i = i->Flink)
37 {
38 CurrentRecord = CONTAINING_RECORD(i, VDM_CONSOLE_RECORD, Entry);
39 if (CurrentRecord->ConsoleHandle == ConsoleHandle) break;
40 }
41
42 /* Check if nothing was found */
43 if (i == &VDMConsoleListHead) CurrentRecord = NULL;
44
45 *Record = CurrentRecord;
46 return CurrentRecord ? STATUS_SUCCESS : STATUS_NOT_FOUND;
47 }
48
49 NTSTATUS NTAPI GetConsoleRecordBySessionId(ULONG TaskId, PVDM_CONSOLE_RECORD *Record)
50 {
51 PLIST_ENTRY i;
52 PVDM_CONSOLE_RECORD CurrentRecord = NULL;
53
54 /* Search for a record that has the same console handle */
55 for (i = VDMConsoleListHead.Flink; i != &VDMConsoleListHead; i = i->Flink)
56 {
57 CurrentRecord = CONTAINING_RECORD(i, VDM_CONSOLE_RECORD, Entry);
58 if (CurrentRecord->SessionId == TaskId) break;
59 }
60
61 /* Check if nothing was found */
62 if (i == &VDMConsoleListHead) CurrentRecord = NULL;
63
64 *Record = CurrentRecord;
65 return CurrentRecord ? STATUS_SUCCESS : STATUS_NOT_FOUND;
66 }
67
68 ULONG NTAPI GetNextDosSesId(VOID)
69 {
70 ULONG SessionId;
71 PLIST_ENTRY i;
72 PVDM_CONSOLE_RECORD CurrentRecord = NULL;
73 BOOLEAN Found;
74
75 /* Search for an available session ID */
76 for (SessionId = 1; SessionId != 0; SessionId++)
77 {
78 Found = FALSE;
79
80 /* Check if the ID is already in use */
81 for (i = VDMConsoleListHead.Flink; i != &VDMConsoleListHead; i = i->Flink)
82 {
83 CurrentRecord = CONTAINING_RECORD(i, VDM_CONSOLE_RECORD, Entry);
84 if (CurrentRecord->SessionId == SessionId) Found = TRUE;
85 }
86
87 /* If not, we found one */
88 if (!Found) break;
89 }
90
91 ASSERT(SessionId != 0);
92
93 /* Return the session ID */
94 return SessionId;
95 }
96
97 BOOLEAN NTAPI BaseSrvIsVdmAllowed(VOID)
98 {
99 NTSTATUS Status;
100 BOOLEAN VdmAllowed = TRUE;
101 HANDLE RootKey, KeyHandle;
102 UNICODE_STRING KeyName, ValueName, MachineKeyName;
103 OBJECT_ATTRIBUTES Attributes;
104 UCHAR ValueBuffer[sizeof(KEY_VALUE_PARTIAL_INFORMATION) + sizeof(ULONG)];
105 PKEY_VALUE_PARTIAL_INFORMATION ValueInfo = (PKEY_VALUE_PARTIAL_INFORMATION)ValueBuffer;
106 ULONG ActualSize;
107
108 /* Initialize the unicode strings */
109 RtlInitUnicodeString(&MachineKeyName, L"\\Registry\\Machine");
110 RtlInitUnicodeString(&KeyName, VDM_POLICY_KEY_NAME);
111 RtlInitUnicodeString(&ValueName, VDM_DISALLOWED_VALUE_NAME);
112
113 InitializeObjectAttributes(&Attributes,
114 &MachineKeyName,
115 OBJ_CASE_INSENSITIVE,
116 NULL,
117 NULL);
118
119 /* Open the local machine key */
120 Status = NtOpenKey(&RootKey, KEY_READ, &Attributes);
121 if (!NT_SUCCESS(Status)) return FALSE;
122
123 InitializeObjectAttributes(&Attributes,
124 &KeyName,
125 OBJ_CASE_INSENSITIVE,
126 RootKey,
127 NULL);
128
129 /* Open the policy key in the local machine hive, if it exists */
130 if (NT_SUCCESS(NtOpenKey(&KeyHandle, KEY_READ, &Attributes)))
131 {
132 /* Read the value, if it's set */
133 if (NT_SUCCESS(NtQueryValueKey(KeyHandle,
134 &ValueName,
135 KeyValuePartialInformation,
136 ValueInfo,
137 sizeof(ValueBuffer),
138 &ActualSize)))
139 {
140 if (*((PULONG)ValueInfo->Data))
141 {
142 /* The VDM has been disabled in the registry */
143 VdmAllowed = FALSE;
144 }
145 }
146
147 NtClose(KeyHandle);
148 }
149
150 /* Close the local machine key */
151 NtClose(RootKey);
152
153 /* If it's disabled system-wide, there's no need to check the user key */
154 if (!VdmAllowed) return FALSE;
155
156 /* Open the current user key of the client */
157 if (!CsrImpersonateClient(NULL)) return VdmAllowed;
158 Status = RtlOpenCurrentUser(KEY_READ, &RootKey);
159 CsrRevertToSelf();
160
161 /* If that fails, return the system-wide setting */
162 if (!NT_SUCCESS(Status)) return VdmAllowed;
163
164 InitializeObjectAttributes(&Attributes,
165 &KeyName,
166 OBJ_CASE_INSENSITIVE,
167 RootKey,
168 NULL);
169
170 /* Open the policy key in the current user hive, if it exists */
171 if (NT_SUCCESS(NtOpenKey(&KeyHandle, KEY_READ, &Attributes)))
172 {
173 /* Read the value, if it's set */
174 if (NT_SUCCESS(NtQueryValueKey(KeyHandle,
175 &ValueName,
176 KeyValuePartialInformation,
177 ValueInfo,
178 sizeof(ValueBuffer),
179 &ActualSize)))
180 {
181 if (*((PULONG)ValueInfo->Data))
182 {
183 /* The VDM has been disabled in the registry */
184 VdmAllowed = FALSE;
185 }
186 }
187
188 NtClose(KeyHandle);
189 }
190
191 return VdmAllowed;
192 }
193
194 NTSTATUS NTAPI BaseSrvCreatePairWaitHandles(PHANDLE ServerEvent, PHANDLE ClientEvent)
195 {
196 NTSTATUS Status;
197
198 /* Create the event */
199 Status = NtCreateEvent(ServerEvent, EVENT_ALL_ACCESS, NULL, NotificationEvent, FALSE);
200 if (!NT_SUCCESS(Status)) return Status;
201
202 /* Duplicate the event into the client process */
203 Status = NtDuplicateObject(NtCurrentProcess(),
204 *ServerEvent,
205 CsrGetClientThread()->Process->ProcessHandle,
206 ClientEvent,
207 0,
208 0,
209 DUPLICATE_SAME_ATTRIBUTES | DUPLICATE_SAME_ACCESS);
210
211 if (!NT_SUCCESS(Status)) NtClose(*ServerEvent);
212 return Status;
213 }
214
215 VOID NTAPI BaseSrvFreeVDMInfo(PVDM_COMMAND_INFO CommandInfo)
216 {
217 /* Free the allocated structure members */
218 if (CommandInfo->CmdLine != NULL) RtlFreeHeap(BaseSrvHeap, 0, CommandInfo->CmdLine);
219 if (CommandInfo->AppName != NULL) RtlFreeHeap(BaseSrvHeap, 0, CommandInfo->AppName);
220 if (CommandInfo->PifFile != NULL) RtlFreeHeap(BaseSrvHeap, 0, CommandInfo->PifFile);
221 if (CommandInfo->CurDirectory != NULL) RtlFreeHeap(BaseSrvHeap, 0, CommandInfo->CurDirectory);
222 if (CommandInfo->Env != NULL) RtlFreeHeap(BaseSrvHeap, 0, CommandInfo->Env);
223 if (CommandInfo->Desktop != NULL) RtlFreeHeap(BaseSrvHeap, 0, CommandInfo->Desktop);
224 if (CommandInfo->Title != NULL) RtlFreeHeap(BaseSrvHeap, 0, CommandInfo->Title);
225 if (CommandInfo->Reserved != NULL) RtlFreeHeap(BaseSrvHeap, 0, CommandInfo->Reserved);
226
227 /* Free the structure itself */
228 RtlFreeHeap(BaseSrvHeap, 0, CommandInfo);
229 }
230
231 VOID NTAPI BaseSrvCleanupVdmRecords(ULONG ProcessId)
232 {
233 PLIST_ENTRY i;
234 PVDM_CONSOLE_RECORD ConsoleRecord = NULL;
235 PVDM_DOS_RECORD DosRecord;
236
237 /* Enter the critical section */
238 RtlEnterCriticalSection(&DosCriticalSection);
239
240 /* Search for a record that has the same process handle */
241 for (i = VDMConsoleListHead.Flink; i != &VDMConsoleListHead; i = i->Flink)
242 {
243 ConsoleRecord = CONTAINING_RECORD(i, VDM_CONSOLE_RECORD, Entry);
244
245 if (ConsoleRecord->ProcessId == ProcessId)
246 {
247 /* Cleanup the DOS records */
248 while (ConsoleRecord->DosListHead.Flink != &ConsoleRecord->DosListHead)
249 {
250 DosRecord = CONTAINING_RECORD(ConsoleRecord->DosListHead.Flink,
251 VDM_DOS_RECORD,
252 Entry);
253
254 /* Set the event and close it */
255 NtSetEvent(DosRecord->ServerEvent, NULL);
256 NtClose(DosRecord->ServerEvent);
257
258 /* Remove the DOS entry */
259 if (DosRecord->CommandInfo) BaseSrvFreeVDMInfo(DosRecord->CommandInfo);
260 RemoveEntryList(&DosRecord->Entry);
261 RtlFreeHeap(BaseSrvHeap, 0, DosRecord);
262 }
263
264 if (ConsoleRecord->CurrentDirs != NULL)
265 {
266 /* Free the current directories */
267 RtlFreeHeap(BaseSrvHeap, 0, ConsoleRecord->CurrentDirs);
268 ConsoleRecord->CurrentDirs = NULL;
269 ConsoleRecord->CurDirsLength = 0;
270 }
271
272 /* Close the event handle */
273 if (ConsoleRecord->ServerEvent) NtClose(ConsoleRecord->ServerEvent);
274
275 /* Remove the console record */
276 i = i->Blink;
277 RemoveEntryList(&ConsoleRecord->Entry);
278 RtlFreeHeap(BaseSrvHeap, 0, ConsoleRecord);
279 }
280 }
281
282 /* Leave the critical section */
283 RtlLeaveCriticalSection(&DosCriticalSection);
284 }
285
286 BOOLEAN NTAPI BaseSrvCopyCommand(PBASE_CHECK_VDM CheckVdmRequest, PVDM_DOS_RECORD DosRecord)
287 {
288 BOOLEAN Success = FALSE;
289 PVDM_COMMAND_INFO CommandInfo = NULL;
290
291 /* Allocate the command information structure */
292 CommandInfo = (PVDM_COMMAND_INFO)RtlAllocateHeap(BaseSrvHeap,
293 HEAP_ZERO_MEMORY,
294 sizeof(VDM_COMMAND_INFO));
295 if (CommandInfo == NULL) return FALSE;
296
297 /* Fill the structure */
298 CommandInfo->TaskId = CheckVdmRequest->iTask;
299 CommandInfo->ExitCode = DosRecord->ExitCode;
300 CommandInfo->CodePage = CheckVdmRequest->CodePage;
301 CommandInfo->StdIn = CheckVdmRequest->StdIn;
302 CommandInfo->StdOut = CheckVdmRequest->StdOut;
303 CommandInfo->StdErr = CheckVdmRequest->StdErr;
304
305 /* Allocate memory for the command line */
306 CommandInfo->CmdLine = RtlAllocateHeap(BaseSrvHeap,
307 HEAP_ZERO_MEMORY,
308 CheckVdmRequest->CmdLen);
309 if (CommandInfo->CmdLine == NULL) goto Cleanup;
310
311 /* Copy the command line */
312 RtlMoveMemory(CommandInfo->CmdLine, CheckVdmRequest->CmdLine, CheckVdmRequest->CmdLen);
313
314 /* Allocate memory for the application name */
315 CommandInfo->AppName = RtlAllocateHeap(BaseSrvHeap,
316 HEAP_ZERO_MEMORY,
317 CheckVdmRequest->AppLen);
318 if (CommandInfo->AppName == NULL) goto Cleanup;
319
320 /* Copy the application name */
321 RtlMoveMemory(CommandInfo->AppName, CheckVdmRequest->AppName, CheckVdmRequest->AppLen);
322
323 /* Allocate memory for the PIF file name */
324 if (CheckVdmRequest->PifLen != 0)
325 {
326 CommandInfo->PifFile = RtlAllocateHeap(BaseSrvHeap,
327 HEAP_ZERO_MEMORY,
328 CheckVdmRequest->PifLen);
329 if (CommandInfo->PifFile == NULL) goto Cleanup;
330
331 /* Copy the PIF file name */
332 RtlMoveMemory(CommandInfo->PifFile, CheckVdmRequest->PifFile, CheckVdmRequest->PifLen);
333 }
334 else CommandInfo->PifFile = NULL;
335
336 /* Allocate memory for the current directory */
337 if (CheckVdmRequest->CurDirectoryLen != 0)
338 {
339 CommandInfo->CurDirectory = RtlAllocateHeap(BaseSrvHeap,
340 HEAP_ZERO_MEMORY,
341 CheckVdmRequest->CurDirectoryLen);
342 if (CommandInfo->CurDirectory == NULL) goto Cleanup;
343
344 /* Copy the current directory */
345 RtlMoveMemory(CommandInfo->CurDirectory,
346 CheckVdmRequest->CurDirectory,
347 CheckVdmRequest->CurDirectoryLen);
348 }
349 else CommandInfo->CurDirectory = NULL;
350
351 /* Allocate memory for the environment block */
352 CommandInfo->Env = RtlAllocateHeap(BaseSrvHeap,
353 HEAP_ZERO_MEMORY,
354 CheckVdmRequest->EnvLen);
355 if (CommandInfo->Env == NULL) goto Cleanup;
356
357 /* Copy the environment block */
358 RtlMoveMemory(CommandInfo->Env, CheckVdmRequest->Env, CheckVdmRequest->EnvLen);
359
360 CommandInfo->EnvLen = CheckVdmRequest->EnvLen;
361 RtlMoveMemory(&CommandInfo->StartupInfo,
362 CheckVdmRequest->StartupInfo,
363 sizeof(STARTUPINFOA));
364
365 /* Allocate memory for the desktop */
366 if (CheckVdmRequest->DesktopLen != 0)
367 {
368 CommandInfo->Desktop = RtlAllocateHeap(BaseSrvHeap,
369 HEAP_ZERO_MEMORY,
370 CheckVdmRequest->DesktopLen);
371 if (CommandInfo->Desktop == NULL) goto Cleanup;
372
373 /* Copy the desktop name */
374 RtlMoveMemory(CommandInfo->Desktop, CheckVdmRequest->Desktop, CheckVdmRequest->DesktopLen);
375 }
376 else CommandInfo->Desktop = NULL;
377
378 CommandInfo->DesktopLen = CheckVdmRequest->DesktopLen;
379
380 /* Allocate memory for the title */
381 if (CheckVdmRequest->TitleLen != 0)
382 {
383 CommandInfo->Title = RtlAllocateHeap(BaseSrvHeap,
384 HEAP_ZERO_MEMORY,
385 CheckVdmRequest->TitleLen);
386 if (CommandInfo->Title == NULL) goto Cleanup;
387
388 /* Copy the title */
389 RtlMoveMemory(CommandInfo->Title, CheckVdmRequest->Title, CheckVdmRequest->TitleLen);
390 }
391 else CommandInfo->Title = NULL;
392
393 CommandInfo->TitleLen = CheckVdmRequest->TitleLen;
394
395 /* Allocate memory for the reserved field */
396 if (CheckVdmRequest->ReservedLen != 0)
397 {
398 CommandInfo->Reserved = RtlAllocateHeap(BaseSrvHeap,
399 HEAP_ZERO_MEMORY,
400 CheckVdmRequest->ReservedLen);
401 if (CommandInfo->Reserved == NULL) goto Cleanup;
402
403 /* Copy the reserved field */
404 RtlMoveMemory(CommandInfo->Reserved,
405 CheckVdmRequest->Reserved,
406 CheckVdmRequest->ReservedLen);
407 }
408 else CommandInfo->Reserved = NULL;
409
410 CommandInfo->ReservedLen = CheckVdmRequest->ReservedLen;
411
412 CommandInfo->CmdLen = CheckVdmRequest->CmdLen;
413 CommandInfo->AppLen = CheckVdmRequest->AppLen;
414 CommandInfo->PifLen = CheckVdmRequest->PifLen;
415 CommandInfo->CurDirectoryLen = CheckVdmRequest->CurDirectoryLen;
416 CommandInfo->VDMState = DosRecord->State;
417 // TODO: Set CommandInfo->CurrentDrive
418 // TODO: Set CommandInfo->ComingFromBat
419
420 /* Set the DOS record's command structure */
421 DosRecord->CommandInfo = CommandInfo;
422
423 /* The operation was successful */
424 Success = TRUE;
425
426 Cleanup:
427 /* If it wasn't successful, free the memory */
428 if (!Success) BaseSrvFreeVDMInfo(CommandInfo);
429
430 return Success;
431 }
432
433 NTSTATUS NTAPI BaseSrvFillCommandInfo(PVDM_COMMAND_INFO CommandInfo,
434 PBASE_GET_NEXT_VDM_COMMAND Message)
435 {
436 /* Copy the data */
437 Message->iTask = CommandInfo->TaskId;
438 Message->StdIn = CommandInfo->StdIn;
439 Message->StdOut = CommandInfo->StdOut;
440 Message->StdErr = CommandInfo->StdErr;
441 Message->CodePage = CommandInfo->CodePage;
442 Message->dwCreationFlags = CommandInfo->CreationFlags;
443 Message->ExitCode = CommandInfo->ExitCode;
444 Message->CurrentDrive = CommandInfo->CurrentDrive;
445 Message->VDMState = CommandInfo->VDMState;
446 Message->fComingFromBat = CommandInfo->ComingFromBat;
447
448 if (CommandInfo->CmdLen && Message->CmdLen)
449 {
450 if (Message->CmdLen < CommandInfo->CmdLen) return STATUS_BUFFER_TOO_SMALL;
451
452 /* Copy the command line */
453 RtlMoveMemory(Message->CmdLine, CommandInfo->CmdLine, CommandInfo->CmdLen);
454 Message->CmdLen = CommandInfo->CmdLen;
455 }
456
457 if (CommandInfo->AppLen && Message->AppLen)
458 {
459 if (Message->AppLen < CommandInfo->CmdLen) return STATUS_BUFFER_TOO_SMALL;
460
461 /* Copy the application name */
462 RtlMoveMemory(Message->AppName, CommandInfo->AppName, CommandInfo->AppLen);
463 Message->AppLen = CommandInfo->AppLen;
464 }
465
466 if (CommandInfo->PifLen && Message->PifLen)
467 {
468 if (Message->PifLen < CommandInfo->PifLen) return STATUS_BUFFER_TOO_SMALL;
469
470 /* Copy the PIF file name */
471 RtlMoveMemory(Message->PifFile, CommandInfo->PifFile, CommandInfo->PifLen);
472 Message->PifLen = CommandInfo->PifLen;
473 }
474
475 if (CommandInfo->CurDirectoryLen && Message->CurDirectoryLen)
476 {
477 if (Message->CurDirectoryLen < CommandInfo->CurDirectoryLen) return STATUS_BUFFER_TOO_SMALL;
478
479 /* Copy the current directory */
480 RtlMoveMemory(Message->CurDirectory, CommandInfo->CurDirectory, CommandInfo->CurDirectoryLen);
481 Message->CurDirectoryLen = CommandInfo->CurDirectoryLen;
482 }
483
484 if (CommandInfo->EnvLen && Message->EnvLen)
485 {
486 if (Message->EnvLen < CommandInfo->EnvLen) return STATUS_BUFFER_TOO_SMALL;
487
488 /* Copy the environment */
489 RtlMoveMemory(Message->Env, CommandInfo->Env, CommandInfo->EnvLen);
490 Message->EnvLen = CommandInfo->EnvLen;
491 }
492
493 /* Copy the startup info */
494 RtlMoveMemory(Message->StartupInfo,
495 &CommandInfo->StartupInfo,
496 sizeof(STARTUPINFOA));
497
498 if (CommandInfo->DesktopLen && Message->DesktopLen)
499 {
500 if (Message->DesktopLen < CommandInfo->DesktopLen) return STATUS_BUFFER_TOO_SMALL;
501
502 /* Copy the desktop name */
503 RtlMoveMemory(Message->Desktop, CommandInfo->Desktop, CommandInfo->DesktopLen);
504 Message->DesktopLen = CommandInfo->DesktopLen;
505 }
506
507 if (CommandInfo->TitleLen && Message->TitleLen)
508 {
509 if (Message->TitleLen < CommandInfo->TitleLen) return STATUS_BUFFER_TOO_SMALL;
510
511 /* Copy the title */
512 RtlMoveMemory(Message->Title, CommandInfo->Title, CommandInfo->TitleLen);
513 Message->TitleLen = CommandInfo->TitleLen;
514 }
515
516 if (CommandInfo->ReservedLen && Message->ReservedLen)
517 {
518 if (Message->ReservedLen < CommandInfo->ReservedLen) return STATUS_BUFFER_TOO_SMALL;
519
520 /* Copy the reserved parameter */
521 RtlMoveMemory(Message->Reserved, CommandInfo->Reserved, CommandInfo->ReservedLen);
522 Message->ReservedLen = CommandInfo->ReservedLen;
523 }
524
525 return STATUS_SUCCESS;
526 }
527
528 VOID NTAPI BaseInitializeVDM(VOID)
529 {
530 /* Initialize the list head */
531 InitializeListHead(&VDMConsoleListHead);
532
533 /* Initialize the critical section */
534 RtlInitializeCriticalSection(&DosCriticalSection);
535 RtlInitializeCriticalSection(&WowCriticalSection);
536 }
537
538 /* PUBLIC SERVER APIS *********************************************************/
539
540 CSR_API(BaseSrvCheckVDM)
541 {
542 NTSTATUS Status;
543 PBASE_CHECK_VDM CheckVdmRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.CheckVDMRequest;
544 PRTL_CRITICAL_SECTION CriticalSection = NULL;
545 PVDM_CONSOLE_RECORD ConsoleRecord = NULL;
546 PVDM_DOS_RECORD DosRecord = NULL;
547 BOOLEAN NewConsoleRecord = FALSE;
548
549 /* Don't do anything if the VDM has been disabled in the registry */
550 if (!BaseSrvIsVdmAllowed()) return STATUS_ACCESS_DENIED;
551
552 /* Validate the message buffers */
553 if (!CsrValidateMessageBuffer(ApiMessage,
554 (PVOID*)&CheckVdmRequest->CmdLine,
555 CheckVdmRequest->CmdLen,
556 sizeof(*CheckVdmRequest->CmdLine))
557 || !CsrValidateMessageBuffer(ApiMessage,
558 (PVOID*)&CheckVdmRequest->AppName,
559 CheckVdmRequest->AppLen,
560 sizeof(*CheckVdmRequest->AppName))
561 || !CsrValidateMessageBuffer(ApiMessage,
562 (PVOID*)&CheckVdmRequest->PifFile,
563 CheckVdmRequest->PifLen,
564 sizeof(*CheckVdmRequest->PifFile))
565 || !CsrValidateMessageBuffer(ApiMessage,
566 (PVOID*)&CheckVdmRequest->CurDirectory,
567 CheckVdmRequest->CurDirectoryLen,
568 sizeof(*CheckVdmRequest->CurDirectory))
569 || !CsrValidateMessageBuffer(ApiMessage,
570 (PVOID*)&CheckVdmRequest->Desktop,
571 CheckVdmRequest->DesktopLen,
572 sizeof(*CheckVdmRequest->Desktop))
573 || !CsrValidateMessageBuffer(ApiMessage,
574 (PVOID*)&CheckVdmRequest->Title,
575 CheckVdmRequest->TitleLen,
576 sizeof(*CheckVdmRequest->Title))
577 || !CsrValidateMessageBuffer(ApiMessage,
578 (PVOID*)&CheckVdmRequest->Reserved,
579 CheckVdmRequest->ReservedLen,
580 sizeof(*CheckVdmRequest->Reserved)))
581 {
582 return STATUS_INVALID_PARAMETER;
583 }
584
585 CriticalSection = (CheckVdmRequest->BinaryType != BINARY_TYPE_SEPARATE_WOW)
586 ? &DosCriticalSection
587 : &WowCriticalSection;
588
589 /* Enter the critical section */
590 RtlEnterCriticalSection(CriticalSection);
591
592 /* Check if this is a DOS or WOW VDM */
593 if (CheckVdmRequest->BinaryType != BINARY_TYPE_SEPARATE_WOW)
594 {
595 /* Get the console record */
596 Status = BaseSrvGetConsoleRecord(CheckVdmRequest->ConsoleHandle,
597 &ConsoleRecord);
598
599 if (!NT_SUCCESS(Status))
600 {
601 /* Allocate a new console record */
602 ConsoleRecord = (PVDM_CONSOLE_RECORD)RtlAllocateHeap(BaseSrvHeap,
603 HEAP_ZERO_MEMORY,
604 sizeof(VDM_CONSOLE_RECORD));
605 if (ConsoleRecord == NULL)
606 {
607 Status = STATUS_NO_MEMORY;
608 goto Cleanup;
609 }
610
611 /* Remember that the console record was allocated here */
612 NewConsoleRecord = TRUE;
613
614 /* Initialize the console record */
615 ConsoleRecord->ConsoleHandle = CheckVdmRequest->ConsoleHandle;
616 ConsoleRecord->ProcessHandle = CsrGetClientThread()->Process->ProcessHandle;
617 ConsoleRecord->ServerEvent = ConsoleRecord->ClientEvent = NULL;
618 ConsoleRecord->ReenterCount = 0;
619 ConsoleRecord->CurrentDirs = NULL;
620 ConsoleRecord->CurDirsLength = 0;
621 ConsoleRecord->SessionId = GetNextDosSesId();
622 InitializeListHead(&ConsoleRecord->DosListHead);
623 }
624
625 /* Allocate a new DOS record */
626 DosRecord = (PVDM_DOS_RECORD)RtlAllocateHeap(BaseSrvHeap,
627 HEAP_ZERO_MEMORY,
628 sizeof(VDM_DOS_RECORD));
629 if (DosRecord == NULL)
630 {
631 Status = STATUS_NO_MEMORY;
632 goto Cleanup;
633 }
634
635 /* Initialize the DOS record */
636 DosRecord->State = VDM_NOT_LOADED;
637 DosRecord->ExitCode = 0;
638
639 Status = BaseSrvCreatePairWaitHandles(&DosRecord->ServerEvent, &DosRecord->ClientEvent);
640 if (!NT_SUCCESS(Status)) goto Cleanup;
641
642 /* Return the client event handle */
643 CheckVdmRequest->WaitObjectForParent = DosRecord->ClientEvent;
644
645 /* Translate the input structure into a VDM command structure and set it in the DOS record */
646 if (!BaseSrvCopyCommand(CheckVdmRequest, DosRecord))
647 {
648 /* The only possibility is that an allocation failure occurred */
649 Status = STATUS_NO_MEMORY;
650 goto Cleanup;
651 }
652
653 /* Add the DOS record */
654 InsertHeadList(&ConsoleRecord->DosListHead, &DosRecord->Entry);
655
656 if (ConsoleRecord->ServerEvent)
657 {
658 /* Signal the session event */
659 NtSetEvent(ConsoleRecord->ServerEvent, NULL);
660 }
661
662 if (NewConsoleRecord)
663 {
664 /* Add the console record */
665 InsertTailList(&VDMConsoleListHead, &ConsoleRecord->Entry);
666 }
667
668 if (ConsoleRecord->ConsoleHandle == NULL)
669 {
670 /* The parent doesn't have a console, so return the session ID */
671 CheckVdmRequest->iTask = ConsoleRecord->SessionId;
672 }
673 else CheckVdmRequest->iTask = 0;
674
675 CheckVdmRequest->VDMState = NewConsoleRecord ? VDM_NOT_LOADED : VDM_READY;
676 Status = STATUS_SUCCESS;
677 }
678 else
679 {
680 // TODO: NOT IMPLEMENTED
681 UNIMPLEMENTED;
682 Status = STATUS_NOT_IMPLEMENTED;
683 }
684
685 Cleanup:
686 /* Check if it failed */
687 if (!NT_SUCCESS(Status))
688 {
689 /* Free the DOS record */
690 if (DosRecord != NULL)
691 {
692 if (DosRecord->ServerEvent) NtClose(DosRecord->ServerEvent);
693 if (DosRecord->ClientEvent)
694 {
695 /* Close the remote handle */
696 NtDuplicateObject(CsrGetClientThread()->Process->ProcessHandle,
697 DosRecord->ClientEvent,
698 NULL,
699 NULL,
700 0,
701 0,
702 DUPLICATE_CLOSE_SOURCE);
703 }
704
705 RtlFreeHeap(BaseSrvHeap, 0, DosRecord);
706 DosRecord = NULL;
707 }
708
709 /* Free the console record if it was allocated here */
710 if (NewConsoleRecord)
711 {
712 RtlFreeHeap(BaseSrvHeap, 0, ConsoleRecord);
713 ConsoleRecord = NULL;
714 }
715 }
716
717 /* Leave the critical section */
718 RtlLeaveCriticalSection(CriticalSection);
719
720 return Status;
721 }
722
723 CSR_API(BaseSrvUpdateVDMEntry)
724 {
725 NTSTATUS Status;
726 PBASE_UPDATE_VDM_ENTRY UpdateVdmEntryRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.UpdateVDMEntryRequest;
727 PRTL_CRITICAL_SECTION CriticalSection = NULL;
728 PVDM_CONSOLE_RECORD ConsoleRecord = NULL;
729 PVDM_DOS_RECORD DosRecord = NULL;
730
731 CriticalSection = (UpdateVdmEntryRequest->BinaryType != BINARY_TYPE_SEPARATE_WOW)
732 ? &DosCriticalSection
733 : &WowCriticalSection;
734
735 /* Enter the critical section */
736 RtlEnterCriticalSection(CriticalSection);
737
738 /* Check if this is a DOS or WOW VDM */
739 if (UpdateVdmEntryRequest->BinaryType != BINARY_TYPE_SEPARATE_WOW)
740 {
741 if (UpdateVdmEntryRequest->iTask != 0)
742 {
743 /* Get the console record using the task ID */
744 Status = GetConsoleRecordBySessionId(UpdateVdmEntryRequest->iTask,
745 &ConsoleRecord);
746 }
747 else
748 {
749 /* Get the console record using the console handle */
750 Status = BaseSrvGetConsoleRecord(UpdateVdmEntryRequest->ConsoleHandle,
751 &ConsoleRecord);
752 }
753
754 if (!NT_SUCCESS(Status)) goto Cleanup;
755
756 /* Get the primary DOS record */
757 DosRecord = (PVDM_DOS_RECORD)CONTAINING_RECORD(ConsoleRecord->DosListHead.Flink,
758 VDM_DOS_RECORD,
759 Entry);
760
761 switch (UpdateVdmEntryRequest->EntryIndex)
762 {
763 case VdmEntryUndo:
764 {
765 /* Close the server event handle, the client will close the client handle */
766 NtClose(DosRecord->ServerEvent);
767 DosRecord->ServerEvent = DosRecord->ClientEvent = NULL;
768
769 if (UpdateVdmEntryRequest->VDMCreationState & (VDM_UNDO_PARTIAL | VDM_UNDO_FULL))
770 {
771 /* Remove the DOS record */
772 if (DosRecord->CommandInfo) BaseSrvFreeVDMInfo(DosRecord->CommandInfo);
773 RemoveEntryList(&DosRecord->Entry);
774 RtlFreeHeap(BaseSrvHeap, 0, DosRecord);
775
776 /*
777 * Since this is an undo, if that was the only DOS record the VDM
778 * won't even start, so the console record should be removed too.
779 */
780 if (ConsoleRecord->DosListHead.Flink == &ConsoleRecord->DosListHead)
781 {
782 if (ConsoleRecord->ServerEvent) NtClose(ConsoleRecord->ServerEvent);
783 RemoveEntryList(&ConsoleRecord->Entry);
784 RtlFreeHeap(BaseSrvHeap, 0, ConsoleRecord);
785 }
786 }
787
788 /* It was successful */
789 Status = STATUS_SUCCESS;
790
791 break;
792 }
793
794 case VdmEntryUpdateProcess:
795 {
796 /* Duplicate the VDM process handle */
797 Status = NtDuplicateObject(CsrGetClientThread()->Process->ProcessHandle,
798 UpdateVdmEntryRequest->VDMProcessHandle,
799 NtCurrentProcess(),
800 &ConsoleRecord->ProcessHandle,
801 0,
802 0,
803 DUPLICATE_SAME_ATTRIBUTES | DUPLICATE_SAME_ACCESS);
804 if (!NT_SUCCESS(Status)) goto Cleanup;
805
806 /* Create a pair of handles to one event object */
807 Status = BaseSrvCreatePairWaitHandles(&DosRecord->ServerEvent,
808 &DosRecord->ClientEvent);
809 if (!NT_SUCCESS(Status)) goto Cleanup;
810
811 /* Return the client event handle */
812 UpdateVdmEntryRequest->WaitObjectForParent = DosRecord->ClientEvent;
813
814 break;
815 }
816
817 case VdmEntryUpdateControlCHandler:
818 {
819 // TODO: NOT IMPLEMENTED
820 DPRINT1("BaseSrvUpdateVDMEntry: VdmEntryUpdateControlCHandler not implemented!");
821 Status = STATUS_NOT_IMPLEMENTED;
822
823 break;
824 }
825
826 default:
827 {
828 /* Invalid */
829 Status = STATUS_INVALID_PARAMETER;
830 }
831 }
832 }
833 else
834 {
835 // TODO: NOT IMPLEMENTED
836 UNIMPLEMENTED;
837 Status = STATUS_NOT_IMPLEMENTED;
838 }
839
840 Cleanup:
841 /* Leave the critical section */
842 RtlLeaveCriticalSection(CriticalSection);
843
844 return Status;
845 }
846
847 CSR_API(BaseSrvGetNextVDMCommand)
848 {
849 NTSTATUS Status;
850 PBASE_GET_NEXT_VDM_COMMAND GetNextVdmCommandRequest =
851 &((PBASE_API_MESSAGE)ApiMessage)->Data.GetNextVDMCommandRequest;
852 PRTL_CRITICAL_SECTION CriticalSection;
853 PLIST_ENTRY i = NULL;
854 PVDM_CONSOLE_RECORD ConsoleRecord = NULL;
855 PVDM_DOS_RECORD DosRecord = NULL;
856
857 /* Validate the message buffers */
858 if (!CsrValidateMessageBuffer(ApiMessage,
859 (PVOID*)&GetNextVdmCommandRequest->CmdLine,
860 GetNextVdmCommandRequest->CmdLen,
861 sizeof(*GetNextVdmCommandRequest->CmdLine))
862 || !CsrValidateMessageBuffer(ApiMessage,
863 (PVOID*)&GetNextVdmCommandRequest->AppName,
864 GetNextVdmCommandRequest->AppLen,
865 sizeof(*GetNextVdmCommandRequest->AppName))
866 || !CsrValidateMessageBuffer(ApiMessage,
867 (PVOID*)&GetNextVdmCommandRequest->PifFile,
868 GetNextVdmCommandRequest->PifLen,
869 sizeof(*GetNextVdmCommandRequest->PifFile))
870 || !CsrValidateMessageBuffer(ApiMessage,
871 (PVOID*)&GetNextVdmCommandRequest->CurDirectory,
872 GetNextVdmCommandRequest->CurDirectoryLen,
873 sizeof(*GetNextVdmCommandRequest->CurDirectory))
874 || !CsrValidateMessageBuffer(ApiMessage,
875 (PVOID*)&GetNextVdmCommandRequest->Env,
876 GetNextVdmCommandRequest->EnvLen,
877 sizeof(*GetNextVdmCommandRequest->Env))
878 || !CsrValidateMessageBuffer(ApiMessage,
879 (PVOID*)&GetNextVdmCommandRequest->Desktop,
880 GetNextVdmCommandRequest->DesktopLen,
881 sizeof(*GetNextVdmCommandRequest->Desktop))
882 || !CsrValidateMessageBuffer(ApiMessage,
883 (PVOID*)&GetNextVdmCommandRequest->Title,
884 GetNextVdmCommandRequest->TitleLen,
885 sizeof(*GetNextVdmCommandRequest->Title))
886 || !CsrValidateMessageBuffer(ApiMessage,
887 (PVOID*)&GetNextVdmCommandRequest->Reserved,
888 GetNextVdmCommandRequest->ReservedLen,
889 sizeof(*GetNextVdmCommandRequest->Reserved))
890 || !CsrValidateMessageBuffer(ApiMessage,
891 (PVOID*)&GetNextVdmCommandRequest->StartupInfo,
892 1,
893 sizeof(STARTUPINFOA)))
894 {
895 return STATUS_INVALID_PARAMETER;
896 }
897
898 CriticalSection = (GetNextVdmCommandRequest->VDMState & VDM_FLAG_WOW)
899 ? &WowCriticalSection
900 : &DosCriticalSection;
901
902 /* Enter the critical section */
903 RtlEnterCriticalSection(CriticalSection);
904
905 if (!(GetNextVdmCommandRequest->VDMState & VDM_FLAG_WOW))
906 {
907 if (GetNextVdmCommandRequest->iTask != 0)
908 {
909 /* Get the console record using the task ID */
910 Status = GetConsoleRecordBySessionId(GetNextVdmCommandRequest->iTask,
911 &ConsoleRecord);
912 }
913 else
914 {
915 /* Get the console record using the console handle */
916 Status = BaseSrvGetConsoleRecord(GetNextVdmCommandRequest->ConsoleHandle,
917 &ConsoleRecord);
918 }
919
920 /* Make sure we found the console record */
921 if (!NT_SUCCESS(Status)) goto Cleanup;
922
923 /* Return the session ID */
924 GetNextVdmCommandRequest->iTask = ConsoleRecord->SessionId;
925 GetNextVdmCommandRequest->WaitObjectForVDM = NULL;
926
927 if (GetNextVdmCommandRequest->VDMState & VDM_GET_FIRST_COMMAND)
928 {
929 /* Check if the DOS record list is empty */
930 if (ConsoleRecord->DosListHead.Flink == &ConsoleRecord->DosListHead)
931 {
932 Status = STATUS_INVALID_PARAMETER;
933 goto Cleanup;
934 }
935
936 /* Get the first DOS record */
937 DosRecord = CONTAINING_RECORD(ConsoleRecord->DosListHead.Flink, VDM_DOS_RECORD, Entry);
938
939 /* Make sure its command information is still there */
940 if (DosRecord->CommandInfo == NULL)
941 {
942 Status = STATUS_INVALID_PARAMETER;
943 goto Cleanup;
944 }
945
946 /* Fill the command information */
947 Status = BaseSrvFillCommandInfo(DosRecord->CommandInfo, GetNextVdmCommandRequest);
948 goto Cleanup;
949 }
950
951 /* Check if we should set the state of a running DOS record to ready */
952 if (!(GetNextVdmCommandRequest->VDMState
953 & (VDM_FLAG_FIRST_TASK | VDM_FLAG_RETRY | VDM_FLAG_NESTED_TASK)))
954 {
955 /* Search for a DOS record that is currently running */
956 for (i = ConsoleRecord->DosListHead.Flink; i != &ConsoleRecord->DosListHead; i = i->Flink)
957 {
958 DosRecord = CONTAINING_RECORD(i, VDM_DOS_RECORD, Entry);
959 if (DosRecord->State == VDM_NOT_READY) break;
960 }
961
962 /* Check if we found any */
963 if (i == &ConsoleRecord->DosListHead)
964 {
965 Status = STATUS_INVALID_PARAMETER;
966 goto Cleanup;
967 }
968
969 /* Set the exit code */
970 DosRecord->ExitCode = GetNextVdmCommandRequest->ExitCode;
971
972 /* Update the VDM state */
973 DosRecord->State = VDM_READY;
974
975 /* Notify all waiting threads that the task is finished */
976 NtSetEvent(DosRecord->ServerEvent, NULL);
977 NtClose(DosRecord->ServerEvent);
978 DosRecord->ServerEvent = NULL;
979 }
980
981 /* Search for a DOS record that isn't loaded yet */
982 for (i = ConsoleRecord->DosListHead.Flink; i != &ConsoleRecord->DosListHead; i = i->Flink)
983 {
984 DosRecord = CONTAINING_RECORD(i, VDM_DOS_RECORD, Entry);
985 if (DosRecord->State == VDM_NOT_LOADED) break;
986 }
987
988 if (i != &ConsoleRecord->DosListHead)
989 {
990 /* DOS tasks which haven't been loaded yet should have a command info structure */
991 ASSERT(DosRecord->CommandInfo != NULL);
992
993 /* Check if the caller only wants environment data */
994 if (GetNextVdmCommandRequest->VDMState & VDM_GET_ENVIRONMENT)
995 {
996 if (GetNextVdmCommandRequest->EnvLen < DosRecord->CommandInfo->EnvLen)
997 {
998 /* Not enough space was reserved */
999 GetNextVdmCommandRequest->EnvLen = DosRecord->CommandInfo->EnvLen;
1000 Status = STATUS_BUFFER_OVERFLOW;
1001 goto Cleanup;
1002 }
1003
1004 /* Copy the environment data */
1005 RtlMoveMemory(GetNextVdmCommandRequest->Env,
1006 DosRecord->CommandInfo->Env,
1007 DosRecord->CommandInfo->EnvLen);
1008
1009 /* Return the actual size to the caller */
1010 GetNextVdmCommandRequest->EnvLen = DosRecord->CommandInfo->EnvLen;
1011 }
1012 else
1013 {
1014 /* Fill the command information */
1015 Status = BaseSrvFillCommandInfo(DosRecord->CommandInfo, GetNextVdmCommandRequest);
1016
1017 /* Free the command information, it's no longer needed */
1018 BaseSrvFreeVDMInfo(DosRecord->CommandInfo);
1019 DosRecord->CommandInfo = NULL;
1020
1021 /* Update the VDM state */
1022 GetNextVdmCommandRequest->VDMState = DosRecord->State = VDM_NOT_READY;
1023 }
1024
1025 Status = STATUS_SUCCESS;
1026 goto Cleanup;
1027 }
1028 }
1029 else
1030 {
1031 // TODO: WOW SUPPORT NOT IMPLEMENTED
1032 Status = STATUS_NOT_IMPLEMENTED;
1033 goto Cleanup;
1034 }
1035
1036 /* There is no command yet */
1037 if ((GetNextVdmCommandRequest->VDMState & (VDM_FLAG_DONT_WAIT | VDM_FLAG_RETRY))
1038 != (VDM_FLAG_DONT_WAIT | VDM_FLAG_RETRY))
1039 {
1040 if (ConsoleRecord->ServerEvent)
1041 {
1042 /* Reset the event */
1043 NtResetEvent(ConsoleRecord->ServerEvent, NULL);
1044 }
1045 else
1046 {
1047 /* Create a pair of wait handles */
1048 Status = BaseSrvCreatePairWaitHandles(&ConsoleRecord->ServerEvent,
1049 &ConsoleRecord->ClientEvent);
1050 if (!NT_SUCCESS(Status)) goto Cleanup;
1051 }
1052
1053 /* Return the client event handle */
1054 GetNextVdmCommandRequest->WaitObjectForVDM = ConsoleRecord->ClientEvent;
1055 }
1056
1057 Cleanup:
1058 /* Leave the critical section */
1059 RtlLeaveCriticalSection(CriticalSection);
1060
1061 return Status;
1062 }
1063
1064 CSR_API(BaseSrvExitVDM)
1065 {
1066 NTSTATUS Status;
1067 PBASE_EXIT_VDM ExitVdmRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.ExitVDMRequest;
1068 PRTL_CRITICAL_SECTION CriticalSection = NULL;
1069 PVDM_CONSOLE_RECORD ConsoleRecord = NULL;
1070 PVDM_DOS_RECORD DosRecord;
1071
1072 CriticalSection = (ExitVdmRequest->iWowTask == 0)
1073 ? &DosCriticalSection
1074 : &WowCriticalSection;
1075
1076 /* Enter the critical section */
1077 RtlEnterCriticalSection(CriticalSection);
1078
1079 if (ExitVdmRequest->iWowTask == 0)
1080 {
1081 /* Get the console record */
1082 Status = BaseSrvGetConsoleRecord(ExitVdmRequest->ConsoleHandle, &ConsoleRecord);
1083 if (!NT_SUCCESS(Status)) goto Cleanup;
1084
1085 /* Cleanup the DOS records */
1086 while (ConsoleRecord->DosListHead.Flink != &ConsoleRecord->DosListHead)
1087 {
1088 DosRecord = CONTAINING_RECORD(ConsoleRecord->DosListHead.Flink,
1089 VDM_DOS_RECORD,
1090 Entry);
1091
1092 /* Set the event and close it */
1093 NtSetEvent(DosRecord->ServerEvent, NULL);
1094 NtClose(DosRecord->ServerEvent);
1095
1096 /* Remove the DOS entry */
1097 if (DosRecord->CommandInfo) BaseSrvFreeVDMInfo(DosRecord->CommandInfo);
1098 RemoveEntryList(&DosRecord->Entry);
1099 RtlFreeHeap(BaseSrvHeap, 0, DosRecord);
1100 }
1101
1102 if (ConsoleRecord->CurrentDirs != NULL)
1103 {
1104 /* Free the current directories */
1105 RtlFreeHeap(BaseSrvHeap, 0, ConsoleRecord->CurrentDirs);
1106 ConsoleRecord->CurrentDirs = NULL;
1107 ConsoleRecord->CurDirsLength = 0;
1108 }
1109
1110 /* Close the event handle */
1111 if (ConsoleRecord->ServerEvent) NtClose(ConsoleRecord->ServerEvent);
1112
1113 /* Remove the console record */
1114 RemoveEntryList(&ConsoleRecord->Entry);
1115 RtlFreeHeap(BaseSrvHeap, 0, ConsoleRecord);
1116 }
1117 else
1118 {
1119 // TODO: NOT IMPLEMENTED
1120 UNIMPLEMENTED;
1121 Status = STATUS_NOT_IMPLEMENTED;
1122 }
1123
1124 Cleanup:
1125 /* Leave the critical section */
1126 RtlLeaveCriticalSection(CriticalSection);
1127
1128 return Status;
1129 }
1130
1131 CSR_API(BaseSrvIsFirstVDM)
1132 {
1133 PBASE_IS_FIRST_VDM IsFirstVDMRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.IsFirstVDMRequest;
1134
1135 /* Return the result */
1136 IsFirstVDMRequest->FirstVDM = FirstVDM;
1137
1138 /* Clear the first VDM flag */
1139 FirstVDM = FALSE;
1140
1141 return STATUS_SUCCESS;
1142 }
1143
1144 CSR_API(BaseSrvGetVDMExitCode)
1145 {
1146 NTSTATUS Status;
1147 PBASE_GET_VDM_EXIT_CODE GetVDMExitCodeRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.GetVDMExitCodeRequest;
1148 PLIST_ENTRY i = NULL;
1149 PVDM_CONSOLE_RECORD ConsoleRecord = NULL;
1150 PVDM_DOS_RECORD DosRecord = NULL;
1151
1152 /* Enter the critical section */
1153 RtlEnterCriticalSection(&DosCriticalSection);
1154
1155 /* Get the console record */
1156 Status = BaseSrvGetConsoleRecord(GetVDMExitCodeRequest->ConsoleHandle, &ConsoleRecord);
1157 if (!NT_SUCCESS(Status)) goto Cleanup;
1158
1159 /* Search for a DOS record that has the same parent process handle */
1160 for (i = ConsoleRecord->DosListHead.Flink; i != &ConsoleRecord->DosListHead; i = i->Flink)
1161 {
1162 DosRecord = CONTAINING_RECORD(i, VDM_DOS_RECORD, Entry);
1163 if (DosRecord->ClientEvent == GetVDMExitCodeRequest->hParent) break;
1164 }
1165
1166 /* Check if no DOS record was found */
1167 if (i == &ConsoleRecord->DosListHead)
1168 {
1169 Status = STATUS_NOT_FOUND;
1170 goto Cleanup;
1171 }
1172
1173 /* Check if this task is still running */
1174 if (DosRecord->State == VDM_READY)
1175 {
1176 GetVDMExitCodeRequest->ExitCode = STATUS_PENDING;
1177 goto Cleanup;
1178 }
1179
1180 /* Return the exit code */
1181 GetVDMExitCodeRequest->ExitCode = DosRecord->ExitCode;
1182
1183 /* Since this is a zombie task record, remove it */
1184 if (DosRecord->CommandInfo) BaseSrvFreeVDMInfo(DosRecord->CommandInfo);
1185 RemoveEntryList(&DosRecord->Entry);
1186 RtlFreeHeap(BaseSrvHeap, 0, DosRecord);
1187
1188 Cleanup:
1189 /* Leave the critical section */
1190 RtlLeaveCriticalSection(&DosCriticalSection);
1191
1192 return Status;
1193 }
1194
1195 CSR_API(BaseSrvSetReenterCount)
1196 {
1197 NTSTATUS Status = STATUS_SUCCESS;
1198 PBASE_SET_REENTER_COUNT SetReenterCountRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.SetReenterCountRequest;
1199 PVDM_CONSOLE_RECORD ConsoleRecord;
1200
1201 /* Enter the critical section */
1202 RtlEnterCriticalSection(&DosCriticalSection);
1203
1204 /* Get the console record */
1205 Status = BaseSrvGetConsoleRecord(SetReenterCountRequest->ConsoleHandle, &ConsoleRecord);
1206 if (!NT_SUCCESS(Status)) goto Cleanup;
1207
1208 if (SetReenterCountRequest->fIncDec == VDM_INC_REENTER_COUNT) ConsoleRecord->ReenterCount++;
1209 else if (SetReenterCountRequest->fIncDec == VDM_DEC_REENTER_COUNT)
1210 {
1211 ConsoleRecord->ReenterCount--;
1212 if (ConsoleRecord->ServerEvent != NULL) NtSetEvent(ConsoleRecord->ServerEvent, NULL);
1213 }
1214 else Status = STATUS_INVALID_PARAMETER;
1215
1216 Cleanup:
1217 /* Leave the critical section */
1218 RtlLeaveCriticalSection(&DosCriticalSection);
1219
1220 return Status;
1221 }
1222
1223 CSR_API(BaseSrvSetVDMCurDirs)
1224 {
1225 NTSTATUS Status;
1226 PBASE_GETSET_VDM_CURDIRS VDMCurrentDirsRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.VDMCurrentDirsRequest;
1227 PVDM_CONSOLE_RECORD ConsoleRecord;
1228 PCHAR Buffer = NULL;
1229
1230 /* Validate the input buffer */
1231 if (!CsrValidateMessageBuffer(ApiMessage,
1232 (PVOID*)&VDMCurrentDirsRequest->lpszzCurDirs,
1233 VDMCurrentDirsRequest->cchCurDirs,
1234 sizeof(*VDMCurrentDirsRequest->lpszzCurDirs)))
1235 {
1236 return STATUS_INVALID_PARAMETER;
1237 }
1238
1239 /* Enter the critical section */
1240 RtlEnterCriticalSection(&DosCriticalSection);
1241
1242 /* Find the console record */
1243 Status = BaseSrvGetConsoleRecord(VDMCurrentDirsRequest->ConsoleHandle, &ConsoleRecord);
1244 if (!NT_SUCCESS(Status)) goto Cleanup;
1245
1246 if (ConsoleRecord->CurrentDirs == NULL)
1247 {
1248 /* Allocate memory for the current directory information */
1249 Buffer = RtlAllocateHeap(BaseSrvHeap,
1250 HEAP_ZERO_MEMORY,
1251 VDMCurrentDirsRequest->cchCurDirs);
1252 }
1253 else
1254 {
1255 /* Resize the amount of allocated memory */
1256 Buffer = RtlReAllocateHeap(BaseSrvHeap,
1257 HEAP_ZERO_MEMORY,
1258 ConsoleRecord->CurrentDirs,
1259 VDMCurrentDirsRequest->cchCurDirs);
1260 }
1261
1262 if (Buffer == NULL)
1263 {
1264 /* Allocation failed */
1265 Status = STATUS_NO_MEMORY;
1266 goto Cleanup;
1267 }
1268
1269 /* Update the console record */
1270 ConsoleRecord->CurrentDirs = Buffer;
1271 ConsoleRecord->CurDirsLength = VDMCurrentDirsRequest->cchCurDirs;
1272
1273 /* Copy the data */
1274 RtlMoveMemory(ConsoleRecord->CurrentDirs,
1275 VDMCurrentDirsRequest->lpszzCurDirs,
1276 VDMCurrentDirsRequest->cchCurDirs);
1277
1278 Cleanup:
1279 /* Leave the critical section */
1280 RtlLeaveCriticalSection(&DosCriticalSection);
1281
1282 return Status;
1283 }
1284
1285 CSR_API(BaseSrvGetVDMCurDirs)
1286 {
1287 NTSTATUS Status;
1288 PBASE_GETSET_VDM_CURDIRS VDMCurrentDirsRequest = &((PBASE_API_MESSAGE)ApiMessage)->Data.VDMCurrentDirsRequest;
1289 PVDM_CONSOLE_RECORD ConsoleRecord;
1290
1291 /* Validate the output buffer */
1292 if (!CsrValidateMessageBuffer(ApiMessage,
1293 (PVOID*)&VDMCurrentDirsRequest->lpszzCurDirs,
1294 VDMCurrentDirsRequest->cchCurDirs,
1295 sizeof(*VDMCurrentDirsRequest->lpszzCurDirs)))
1296 {
1297 return STATUS_INVALID_PARAMETER;
1298 }
1299
1300 /* Enter the critical section */
1301 RtlEnterCriticalSection(&DosCriticalSection);
1302
1303 /* Find the console record */
1304 Status = BaseSrvGetConsoleRecord(VDMCurrentDirsRequest->ConsoleHandle, &ConsoleRecord);
1305 if (!NT_SUCCESS(Status)) goto Cleanup;
1306
1307 /* Return the actual size of the current directory information */
1308 VDMCurrentDirsRequest->cchCurDirs = ConsoleRecord->CurDirsLength;
1309
1310 /* Check if the buffer is large enough */
1311 if (VDMCurrentDirsRequest->cchCurDirs < ConsoleRecord->CurDirsLength)
1312 {
1313 Status = STATUS_BUFFER_TOO_SMALL;
1314 goto Cleanup;
1315 }
1316
1317 /* Copy the data */
1318 RtlMoveMemory(VDMCurrentDirsRequest->lpszzCurDirs,
1319 ConsoleRecord->CurrentDirs,
1320 ConsoleRecord->CurDirsLength);
1321
1322 Cleanup:
1323 /* Leave the critical section */
1324 RtlLeaveCriticalSection(&DosCriticalSection);
1325
1326 return Status;
1327 }
1328
1329 CSR_API(BaseSrvBatNotification)
1330 {
1331 DPRINT1("%s not yet implemented\n", __FUNCTION__);
1332 return STATUS_NOT_IMPLEMENTED;
1333 }
1334
1335 CSR_API(BaseSrvRegisterWowExec)
1336 {
1337 DPRINT1("%s not yet implemented\n", __FUNCTION__);
1338 return STATUS_NOT_IMPLEMENTED;
1339 }
1340
1341 CSR_API(BaseSrvRefreshIniFileMapping)
1342 {
1343 DPRINT1("%s not yet implemented\n", __FUNCTION__);
1344 return STATUS_NOT_IMPLEMENTED;
1345 }
1346
1347 /* EOF */