xref: /reactos/subsystems/mvdm/ntvdm/ntvdm.c (revision d5399189) 
1 /*
2  * COPYRIGHT:       GPL - See COPYING in the top level directory
3  * PROJECT:         ReactOS Virtual DOS Machine
4  * FILE:            subsystems/mvdm/ntvdm/ntvdm.c
5  * PURPOSE:         Virtual DOS Machine
6  * PROGRAMMERS:     Aleksandar Andrejevic <theflash AT sdf DOT lonestar DOT org>
7  */
8 
9 /* INCLUDES *******************************************************************/
10 
11 #include "ntvdm.h"
12 
13 #define NDEBUG
14 #include <debug.h>
15 
16 #include "emulator.h"
17 
18 #include "bios/bios.h"
19 #include "cpu/cpu.h"
20 
21 #include "dos/dem.h"
22 
23 /* VARIABLES ******************************************************************/
24 
25 NTVDM_SETTINGS GlobalSettings;
26 
27 // Command line of NTVDM
28 INT     NtVdmArgc;
29 WCHAR** NtVdmArgv;
30 
31 /* PRIVATE FUNCTIONS **********************************************************/
32 
33 static NTSTATUS
34 NTAPI
35 NtVdmConfigureBios(IN PWSTR ValueName,
36                    IN ULONG ValueType,
37                    IN PVOID ValueData,
38                    IN ULONG ValueLength,
39                    IN PVOID Context,
40                    IN PVOID EntryContext)
41 {
42     PNTVDM_SETTINGS Settings = (PNTVDM_SETTINGS)Context;
43     UNICODE_STRING ValueString;
44 
45     /* Check for the type of the value */
46     if (ValueType != REG_SZ)
47     {
48         RtlInitEmptyAnsiString(&Settings->BiosFileName, NULL, 0);
49         return STATUS_SUCCESS;
50     }
51 
52     /* Convert the UNICODE string to ANSI and store it */
53     RtlInitEmptyUnicodeString(&ValueString, (PWCHAR)ValueData, ValueLength);
54     ValueString.Length = ValueString.MaximumLength;
55     RtlUnicodeStringToAnsiString(&Settings->BiosFileName, &ValueString, TRUE);
56 
57     return STATUS_SUCCESS;
58 }
59 
60 static NTSTATUS
61 NTAPI
62 NtVdmConfigureRom(IN PWSTR ValueName,
63                   IN ULONG ValueType,
64                   IN PVOID ValueData,
65                   IN ULONG ValueLength,
66                   IN PVOID Context,
67                   IN PVOID EntryContext)
68 {
69     PNTVDM_SETTINGS Settings = (PNTVDM_SETTINGS)Context;
70     UNICODE_STRING ValueString;
71 
72     /* Check for the type of the value */
73     if (ValueType != REG_MULTI_SZ)
74     {
75         RtlInitEmptyAnsiString(&Settings->RomFiles, NULL, 0);
76         return STATUS_SUCCESS;
77     }
78 
79     /* Convert the UNICODE string to ANSI and store it */
80     RtlInitEmptyUnicodeString(&ValueString, (PWCHAR)ValueData, ValueLength);
81     ValueString.Length = ValueString.MaximumLength;
82     RtlUnicodeStringToAnsiString(&Settings->RomFiles, &ValueString, TRUE);
83 
84     return STATUS_SUCCESS;
85 }
86 
87 static NTSTATUS
88 NTAPI
89 NtVdmConfigureFloppy(IN PWSTR ValueName,
90                      IN ULONG ValueType,
91                      IN PVOID ValueData,
92                      IN ULONG ValueLength,
93                      IN PVOID Context,
94                      IN PVOID EntryContext)
95 {
96     BOOLEAN Success;
97     PNTVDM_SETTINGS Settings = (PNTVDM_SETTINGS)Context;
98     ULONG DiskNumber = PtrToUlong(EntryContext);
99 
100     ASSERT(DiskNumber < ARRAYSIZE(Settings->FloppyDisks));
101 
102     /* Check whether the Hard Disk entry was not already configured */
103     if (Settings->FloppyDisks[DiskNumber].Buffer != NULL)
104     {
105         DPRINT1("Floppy Disk %d -- '%wZ' already configured\n", DiskNumber, &Settings->FloppyDisks[DiskNumber]);
106         return STATUS_SUCCESS;
107     }
108 
109     /* Check for the type of the value */
110     if (ValueType != REG_SZ)
111     {
112         RtlInitEmptyUnicodeString(&Settings->FloppyDisks[DiskNumber], NULL, 0);
113         return STATUS_SUCCESS;
114     }
115 
116     /* Initialize the string */
117     Success = RtlCreateUnicodeString(&Settings->FloppyDisks[DiskNumber], (PCWSTR)ValueData);
118     ASSERT(Success);
119 
120     return STATUS_SUCCESS;
121 }
122 
123 static NTSTATUS
124 NTAPI
125 NtVdmConfigureHDD(IN PWSTR ValueName,
126                   IN ULONG ValueType,
127                   IN PVOID ValueData,
128                   IN ULONG ValueLength,
129                   IN PVOID Context,
130                   IN PVOID EntryContext)
131 {
132     BOOLEAN Success;
133     PNTVDM_SETTINGS Settings = (PNTVDM_SETTINGS)Context;
134     ULONG DiskNumber = PtrToUlong(EntryContext);
135 
136     ASSERT(DiskNumber < ARRAYSIZE(Settings->HardDisks));
137 
138     /* Check whether the Hard Disk entry was not already configured */
139     if (Settings->HardDisks[DiskNumber].Buffer != NULL)
140     {
141         DPRINT1("Hard Disk %d -- '%wZ' already configured\n", DiskNumber, &Settings->HardDisks[DiskNumber]);
142         return STATUS_SUCCESS;
143     }
144 
145     /* Check for the type of the value */
146     if (ValueType != REG_SZ)
147     {
148         RtlInitEmptyUnicodeString(&Settings->HardDisks[DiskNumber], NULL, 0);
149         return STATUS_SUCCESS;
150     }
151 
152     /* Initialize the string */
153     Success = RtlCreateUnicodeString(&Settings->HardDisks[DiskNumber], (PCWSTR)ValueData);
154     ASSERT(Success);
155 
156     return STATUS_SUCCESS;
157 }
158 
159 static RTL_QUERY_REGISTRY_TABLE
160 NtVdmConfigurationTable[] =
161 {
162     {
163         NtVdmConfigureBios,
164         0,
165         L"BiosFile",
166         NULL,
167         REG_NONE,
168         NULL,
169         0
170     },
171 
172     {
173         NtVdmConfigureRom,
174         RTL_QUERY_REGISTRY_NOEXPAND,
175         L"RomFiles",
176         NULL,
177         REG_NONE,
178         NULL,
179         0
180     },
181 
182     {
183         NtVdmConfigureFloppy,
184         0,
185         L"FloppyDisk0",
186         (PVOID)0,
187         REG_NONE,
188         NULL,
189         0
190     },
191 
192     {
193         NtVdmConfigureFloppy,
194         0,
195         L"FloppyDisk1",
196         (PVOID)1,
197         REG_NONE,
198         NULL,
199         0
200     },
201 
202     {
203         NtVdmConfigureHDD,
204         0,
205         L"HardDisk0",
206         (PVOID)0,
207         REG_NONE,
208         NULL,
209         0
210     },
211 
212     {
213         NtVdmConfigureHDD,
214         0,
215         L"HardDisk1",
216         (PVOID)1,
217         REG_NONE,
218         NULL,
219         0
220     },
221 
222     {
223         NtVdmConfigureHDD,
224         0,
225         L"HardDisk2",
226         (PVOID)2,
227         REG_NONE,
228         NULL,
229         0
230     },
231 
232     {
233         NtVdmConfigureHDD,
234         0,
235         L"HardDisk3",
236         (PVOID)3,
237         REG_NONE,
238         NULL,
239         0
240     },
241 
242     /* End of table */
243     {0}
244 };
245 
246 static BOOL
247 LoadGlobalSettings(IN PNTVDM_SETTINGS Settings)
248 {
249     NTSTATUS Status;
250 
251     ASSERT(Settings);
252 
253     /*
254      * Now we can do:
255      * - CPU core choice
256      * - Video choice
257      * - Sound choice
258      * - Mem?
259      * - ...
260      * - Standalone mode?
261      * - Debug settings
262      */
263     Status = RtlQueryRegistryValues(RTL_REGISTRY_CONTROL,
264                                     L"NTVDM",
265                                     NtVdmConfigurationTable,
266                                     Settings,
267                                     NULL);
268     if (!NT_SUCCESS(Status))
269     {
270         DPRINT1("NTVDM registry settings cannot be fully initialized, using default ones. Status = 0x%08lx\n", Status);
271     }
272 
273     return NT_SUCCESS(Status);
274 }
275 
276 static VOID
277 FreeGlobalSettings(IN PNTVDM_SETTINGS Settings)
278 {
279     USHORT i;
280 
281     ASSERT(Settings);
282 
283     if (Settings->BiosFileName.Buffer)
284         RtlFreeAnsiString(&Settings->BiosFileName);
285 
286     if (Settings->RomFiles.Buffer)
287         RtlFreeAnsiString(&Settings->RomFiles);
288 
289     for (i = 0; i < ARRAYSIZE(Settings->FloppyDisks); ++i)
290     {
291         if (Settings->FloppyDisks[i].Buffer)
292             RtlFreeUnicodeString(&Settings->FloppyDisks[i]);
293     }
294 
295     for (i = 0; i < ARRAYSIZE(Settings->HardDisks); ++i)
296     {
297         if (Settings->HardDisks[i].Buffer)
298             RtlFreeUnicodeString(&Settings->HardDisks[i]);
299     }
300 }
301 
302 static VOID
303 ConsoleCleanup(VOID);
304 
305 /** HACK!! **/
306 #include "./console/console.c"
307 /** HACK!! **/
308 
309 /*static*/ VOID
310 VdmShutdown(BOOLEAN Immediate)
311 {
312     /*
313      * Immediate = TRUE:  Immediate shutdown;
314      *             FALSE: Delayed shutdown.
315      */
316     static BOOLEAN MustShutdown = FALSE;
317 
318     /* If a shutdown is ongoing, just return */
319     if (MustShutdown)
320     {
321         DPRINT1("Shutdown is ongoing...\n");
322         Sleep(INFINITE);
323         return;
324     }
325 
326     /* First notify DOS to see whether we can shut down now */
327     MustShutdown = DosShutdown(Immediate);
328     /*
329      * In case we perform an immediate shutdown, or the DOS says
330      * we can shut down, do it now.
331      */
332     MustShutdown = MustShutdown || Immediate;
333 
334     if (MustShutdown)
335     {
336         EmulatorTerminate();
337 
338         BiosCleanup();
339         EmulatorCleanup();
340         ConsoleCleanup();
341 
342         FreeGlobalSettings(&GlobalSettings);
343 
344         DPRINT1("\n\n\nNTVDM - Exiting...\n\n\n");
345         /* Some VDDs rely on the fact that NTVDM calls ExitProcess on Windows */
346         ExitProcess(0);
347     }
348 }
349 
350 /* PUBLIC FUNCTIONS ***********************************************************/
351 
352 VOID
353 DisplayMessage(IN LPCWSTR Format, ...)
354 {
355 #ifndef WIN2K_COMPLIANT
356     WCHAR  StaticBuffer[256];
357     LPWSTR Buffer = StaticBuffer; // Use the static buffer by default.
358 #else
359     WCHAR  Buffer[2048]; // Large enough. If not, increase it by hand.
360 #endif
361     size_t MsgLen;
362     va_list args;
363 
364     va_start(args, Format);
365 
366 #ifndef WIN2K_COMPLIANT
367     /*
368      * Retrieve the message length and if it is too long, allocate
369      * an auxiliary buffer; otherwise use the static buffer.
370      * The string is built to be NULL-terminated.
371      */
372     MsgLen = _vscwprintf(Format, args);
373     if (MsgLen >= ARRAYSIZE(StaticBuffer))
374     {
375         Buffer = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, (MsgLen + 1) * sizeof(WCHAR));
376         if (Buffer == NULL)
377         {
378             /* Allocation failed, use the static buffer and display a suitable error message */
379             Buffer = StaticBuffer;
380             Format = L"DisplayMessage()\nOriginal message is too long and allocating an auxiliary buffer failed.";
381             MsgLen = wcslen(Format);
382         }
383     }
384 #else
385     MsgLen = ARRAYSIZE(Buffer) - 1;
386 #endif
387 
388     RtlZeroMemory(Buffer, (MsgLen + 1) * sizeof(WCHAR));
389     _vsnwprintf(Buffer, MsgLen, Format, args);
390 
391     va_end(args);
392 
393     /* Display the message */
394     DPRINT1("\n\nNTVDM Subsystem\n%S\n\n", Buffer);
395     MessageBoxW(hConsoleWnd, Buffer, L"NTVDM Subsystem", MB_OK);
396 
397 #ifndef WIN2K_COMPLIANT
398     /* Free the buffer if needed */
399     if (Buffer != StaticBuffer) RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
400 #endif
401 }
402 
403 /*
404  * This function, derived from DisplayMessage, is used by the BIOS and
405  * the DOS to display messages to an output device. A printer function
406  * is given for printing the characters.
407  */
408 VOID
409 PrintMessageAnsi(IN CHAR_PRINT CharPrint,
410                  IN LPCSTR Format, ...)
411 {
412     static CHAR CurChar = 0;
413     LPSTR str;
414 
415 #ifndef WIN2K_COMPLIANT
416     CHAR  StaticBuffer[256];
417     LPSTR Buffer = StaticBuffer; // Use the static buffer by default.
418 #else
419     CHAR  Buffer[2048]; // Large enough. If not, increase it by hand.
420 #endif
421     size_t MsgLen;
422     va_list args;
423 
424     va_start(args, Format);
425 
426 #ifndef WIN2K_COMPLIANT
427     /*
428      * Retrieve the message length and if it is too long, allocate
429      * an auxiliary buffer; otherwise use the static buffer.
430      * The string is built to be NULL-terminated.
431      */
432     MsgLen = _vscprintf(Format, args);
433     if (MsgLen >= ARRAYSIZE(StaticBuffer))
434     {
435         Buffer = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, (MsgLen + 1) * sizeof(CHAR));
436         if (Buffer == NULL)
437         {
438             /* Allocation failed, use the static buffer and display a suitable error message */
439             Buffer = StaticBuffer;
440             Format = "DisplayMessageAnsi()\nOriginal message is too long and allocating an auxiliary buffer failed.";
441             MsgLen = strlen(Format);
442         }
443     }
444 #else
445     MsgLen = ARRAYSIZE(Buffer) - 1;
446 #endif
447 
448     RtlZeroMemory(Buffer, (MsgLen + 1) * sizeof(CHAR));
449     _vsnprintf(Buffer, MsgLen, Format, args);
450 
451     va_end(args);
452 
453     /* Display the message */
454     // DPRINT1("\n\nNTVDM DOS32\n%s\n\n", Buffer);
455 
456     MsgLen = strlen(Buffer);
457     str = Buffer;
458     while (MsgLen--)
459     {
460         if (*str == '\n' && CurChar != '\r')
461             CharPrint('\r');
462 
463         CurChar = *str++;
464         CharPrint(CurChar);
465     }
466 
467 #ifndef WIN2K_COMPLIANT
468     /* Free the buffer if needed */
469     if (Buffer != StaticBuffer) RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
470 #endif
471 }
472 
473 INT
474 wmain(INT argc, WCHAR *argv[])
475 {
476     NtVdmArgc = argc;
477     NtVdmArgv = argv;
478 
479 #ifdef STANDALONE
480 
481     if (argc < 2)
482     {
483         wprintf(L"\nReactOS Virtual DOS Machine\n\n"
484                 L"Usage: NTVDM <executable> [<parameters>]\n");
485         return 0;
486     }
487 
488 #endif
489 
490 #ifdef ADVANCED_DEBUGGING
491     {
492     INT i = 20;
493 
494     printf("Waiting for debugger (10 secs)..");
495     while (i--)
496     {
497         printf(".");
498         if (IsDebuggerPresent())
499         {
500             DbgBreakPoint();
501             break;
502         }
503         Sleep(500);
504     }
505     printf("Continue\n");
506     }
507 #endif
508 
509     /* Load the global VDM settings */
510     LoadGlobalSettings(&GlobalSettings);
511 
512     DPRINT1("\n\n\nNTVDM - Starting...\n\n\n");
513 
514     /* Initialize the console */
515     if (!ConsoleInit())
516     {
517         wprintf(L"FATAL: A problem occurred when trying to initialize the console\n");
518         goto Cleanup;
519     }
520 
521     /* Initialize the emulator */
522     if (!EmulatorInitialize(ConsoleInput, ConsoleOutput))
523     {
524         wprintf(L"FATAL: Failed to initialize the emulator\n");
525         goto Cleanup;
526     }
527 
528     /* Initialize the system BIOS and option ROMs */
529     if (!BiosInitialize(GlobalSettings.BiosFileName.Buffer,
530                         GlobalSettings.RomFiles.Buffer))
531     {
532         wprintf(L"FATAL: Failed to initialize the VDM BIOS.\n");
533         goto Cleanup;
534     }
535 
536     /* Let's go! Start simulation */
537     CpuSimulate();
538 
539     /* Quit the VDM */
540 Cleanup:
541     VdmShutdown(TRUE);
542     return 0;
543 }
544 
545 /* EOF */
546