[NTVDM]: Fix DOS file find. Introduced in r61507, it was indeed untested...
[reactos.git] / reactos / subsystems / mvdm / ntvdm / dos / dem.c
1 /*
2 * COPYRIGHT: GPL - See COPYING in the top level directory
3 * PROJECT: ReactOS Virtual DOS Machine
4 * FILE: dem.c
5 * PURPOSE: DOS 32-bit Emulation Support Library -
6 * This library is used by the built-in NTVDM DOS32 and by
7 * the NT 16-bit DOS in Windows (via BOPs). It also exposes
8 * exported functions that can be used by VDDs.
9 * PROGRAMMERS: Aleksandar Andrejevic <theflash AT sdf DOT lonestar DOT org>
10 * Hermes Belusca-Maito (hermes.belusca@sfr.fr)
11 */
12
13 /* INCLUDES *******************************************************************/
14
15 #define NDEBUG
16
17 #include "ntvdm.h"
18 #include "emulator.h"
19 #include "utils.h"
20
21 #include "dem.h"
22 #include "dos/dos32krnl/device.h"
23 #include "dos/dos32krnl/process.h"
24 #include "cpu/bop.h"
25
26 #include "bios/bios.h"
27 #include "mouse32.h"
28
29 /* PRIVATE VARIABLES **********************************************************/
30
31 /**/extern BYTE CurrentDrive;/**/
32
33 /* PRIVATE FUNCTIONS **********************************************************/
34
35 static VOID WINAPI DosSystemBop(LPWORD Stack)
36 {
37 /* Get the Function Number and skip it */
38 BYTE FuncNum = *(PBYTE)SEG_OFF_TO_PTR(getCS(), getIP());
39 setIP(getIP() + 1);
40
41 switch (FuncNum)
42 {
43 case 0x11: // Load the DOS kernel
44 {
45 BOOLEAN Success = FALSE;
46 HANDLE hDosKernel;
47 ULONG ulDosKernelSize = 0;
48
49 DPRINT1("You are loading Windows NT DOS!\n");
50
51 /* Open the DOS kernel file */
52 hDosKernel = FileOpen("ntdos.sys", &ulDosKernelSize);
53
54 /* If we failed, bail out */
55 if (hDosKernel == NULL) goto Quit;
56
57 /*
58 * Attempt to load the DOS kernel into memory.
59 * The segment where to load the DOS kernel is defined
60 * by the DOS BIOS and is found in DI:0000 .
61 */
62 Success = FileLoadByHandle(hDosKernel,
63 REAL_TO_PHYS(TO_LINEAR(getDI(), 0x0000)),
64 ulDosKernelSize,
65 &ulDosKernelSize);
66
67 DPRINT1("Windows NT DOS loading %s at %04X:%04X, size 0x%X ; GetLastError() = %u\n",
68 (Success ? "succeeded" : "failed"),
69 getDI(), 0x0000,
70 ulDosKernelSize,
71 GetLastError());
72
73 /* Close the DOS kernel file */
74 FileClose(hDosKernel);
75
76 Quit:
77 if (!Success)
78 {
79 /* We failed everything, stop the VDM */
80 EmulatorTerminate();
81 }
82
83 break;
84 }
85
86 /* Call 32-bit Driver Strategy Routine */
87 case BOP_DRV_STRATEGY:
88 {
89 DeviceStrategyBop();
90 break;
91 }
92
93 /* Call 32-bit Driver Interrupt Routine */
94 case BOP_DRV_INTERRUPT:
95 {
96 DeviceInterruptBop();
97 break;
98 }
99
100 default:
101 {
102 DPRINT1("Unknown DOS System BOP Function: 0x%02X\n", FuncNum);
103 // setCF(1); // Disable, otherwise we enter an infinite loop
104 break;
105 }
106 }
107 }
108
109 static VOID WINAPI DosCmdInterpreterBop(LPWORD Stack)
110 {
111 /* Get the Function Number and skip it */
112 BYTE FuncNum = *(PBYTE)SEG_OFF_TO_PTR(getCS(), getIP());
113 setIP(getIP() + 1);
114
115 switch (FuncNum)
116 {
117 case 0x08: // Launch external command
118 {
119 BOOL Result;
120 DWORD dwExitCode;
121
122 LPSTR Command = (LPSTR)SEG_OFF_TO_PTR(getDS(), getSI());
123 CHAR CmdLine[sizeof("cmd.exe /c ") + DOS_CMDLINE_LENGTH + 1] = "";
124 LPSTR CmdLinePtr;
125 ULONG CmdLineLen;
126 STARTUPINFOA StartupInfo;
127 PROCESS_INFORMATION ProcessInformation;
128
129 /* Spawn a user-defined 32-bit command preprocessor */
130
131 // FIXME: Use COMSPEC env var!!
132 CmdLinePtr = CmdLine;
133 strcpy(CmdLinePtr, "cmd.exe /c ");
134 CmdLinePtr += strlen(CmdLinePtr);
135
136 /* Build a Win32-compatible command-line */
137 CmdLineLen = min(strlen(Command), sizeof(CmdLine) - strlen(CmdLinePtr) - 1);
138 RtlCopyMemory(CmdLinePtr, Command, CmdLineLen);
139 CmdLinePtr[CmdLineLen] = '\0';
140
141 /* Remove any trailing return carriage character and NULL-terminate the command line */
142 while (*CmdLinePtr && *CmdLinePtr != '\r' && *CmdLinePtr != '\n') CmdLinePtr++;
143 *CmdLinePtr = '\0';
144
145 DPRINT1("CMD Run Command '%s' ('%s')\n", Command, CmdLine);
146
147 RtlZeroMemory(&StartupInfo, sizeof(StartupInfo));
148 RtlZeroMemory(&ProcessInformation, sizeof(ProcessInformation));
149
150 StartupInfo.cb = sizeof(StartupInfo);
151
152 VidBiosDetachFromConsole();
153
154 Result = CreateProcessA(NULL,
155 CmdLine,
156 NULL,
157 NULL,
158 TRUE,
159 0,
160 NULL,
161 NULL,
162 &StartupInfo,
163 &ProcessInformation);
164 if (Result)
165 {
166 DPRINT1("Command '%s' ('%s') launched successfully\n", Command, CmdLine);
167
168 /* Wait for process termination */
169 WaitForSingleObject(ProcessInformation.hProcess, INFINITE);
170
171 /* Get the exit code */
172 GetExitCodeProcess(ProcessInformation.hProcess, &dwExitCode);
173
174 /* Close handles */
175 CloseHandle(ProcessInformation.hThread);
176 CloseHandle(ProcessInformation.hProcess);
177 }
178 else
179 {
180 DPRINT1("Failed when launched command '%s' ('%s')\n", Command, CmdLine);
181 dwExitCode = GetLastError();
182 }
183
184 VidBiosAttachToConsole();
185
186 setAL((UCHAR)dwExitCode);
187
188 break;
189 }
190
191 default:
192 {
193 DPRINT1("Unknown DOS CMD Interpreter BOP Function: 0x%02X\n", FuncNum);
194 // setCF(1); // Disable, otherwise we enter an infinite loop
195 break;
196 }
197 }
198 }
199
200 #ifndef STANDALONE
201 static DWORD
202 WINAPI
203 CommandThreadProc(LPVOID Parameter)
204 {
205 BOOLEAN First = TRUE;
206 DWORD Result;
207 VDM_COMMAND_INFO CommandInfo;
208 CHAR CmdLine[MAX_PATH];
209 CHAR AppName[MAX_PATH];
210 CHAR PifFile[MAX_PATH];
211 CHAR Desktop[MAX_PATH];
212 CHAR Title[MAX_PATH];
213 ULONG EnvSize = 256;
214 PVOID Env = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, EnvSize);
215
216 UNREFERENCED_PARAMETER(Parameter);
217 ASSERT(Env);
218
219 do
220 {
221 /* Clear the structure */
222 RtlZeroMemory(&CommandInfo, sizeof(CommandInfo));
223
224 /* Initialize the structure members */
225 CommandInfo.TaskId = SessionId;
226 CommandInfo.VDMState = VDM_FLAG_DOS;
227 CommandInfo.CmdLine = CmdLine;
228 CommandInfo.CmdLen = sizeof(CmdLine);
229 CommandInfo.AppName = AppName;
230 CommandInfo.AppLen = sizeof(AppName);
231 CommandInfo.PifFile = PifFile;
232 CommandInfo.PifLen = sizeof(PifFile);
233 CommandInfo.Desktop = Desktop;
234 CommandInfo.DesktopLen = sizeof(Desktop);
235 CommandInfo.Title = Title;
236 CommandInfo.TitleLen = sizeof(Title);
237 CommandInfo.Env = Env;
238 CommandInfo.EnvLen = EnvSize;
239
240 if (First) CommandInfo.VDMState |= VDM_FLAG_FIRST_TASK;
241
242 Command:
243 if (!GetNextVDMCommand(&CommandInfo))
244 {
245 if (CommandInfo.EnvLen > EnvSize)
246 {
247 /* Expand the environment size */
248 EnvSize = CommandInfo.EnvLen;
249 CommandInfo.Env = Env = RtlReAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, Env, EnvSize);
250
251 /* Repeat the request */
252 CommandInfo.VDMState |= VDM_FLAG_RETRY;
253 goto Command;
254 }
255
256 break;
257 }
258
259 /* Start the process from the command line */
260 Result = DosStartProcess(AppName, CmdLine, Env);
261 if (Result != ERROR_SUCCESS)
262 {
263 DisplayMessage(L"Could not start '%S'. Error: %u", AppName, Result);
264 // break;
265 continue;
266 }
267
268 First = FALSE;
269 }
270 while (AcceptCommands);
271
272 RtlFreeHeap(RtlGetProcessHeap(), 0, Env);
273 return 0;
274 }
275 #endif
276
277 /* PUBLIC VARIABLES ***********************************************************/
278
279 #ifndef STANDALONE
280 BOOLEAN AcceptCommands = TRUE;
281 HANDLE CommandThread = NULL;
282 ULONG SessionId = 0;
283 #endif
284
285 /* PUBLIC FUNCTIONS ***********************************************************/
286
287 //
288 // This function (equivalent of the DOS bootsector) is called by the bootstrap
289 // loader *BEFORE* jumping at 0000:7C00. What we should do is to write at 0000:7C00
290 // a BOP call that calls DosInitialize back. Then the bootstrap loader jumps at
291 // 0000:7C00, our BOP gets called and then we can initialize the 32-bit part of the DOS.
292 //
293
294 /* 16-bit bootstrap code at 0000:7C00 */
295 /* Of course, this is not in real bootsector format, because we don't care */
296 static BYTE Bootsector1[] =
297 {
298 LOBYTE(EMULATOR_BOP), HIBYTE(EMULATOR_BOP), BOP_LOAD_DOS, // Call DOS Loading
299 };
300 /* This portion of code is run if we failed to load the DOS */
301 static BYTE Bootsector2[] =
302 {
303 0xEA, // jmp far ptr
304 0x5B, 0xE0, 0x00, 0xF0, // F000:E05B /** HACK! What to do instead?? **/
305 };
306
307 static VOID WINAPI DosInitialize(LPWORD Stack);
308
309 VOID DosBootsectorInitialize(VOID)
310 {
311 /* We write the bootsector at 0000:7C00 */
312 ULONG_PTR Address = (ULONG_PTR)SEG_OFF_TO_PTR(0x0000, 0x7C00);
313 CHAR DosKernelFileName[] = ""; // No DOS file name, therefore we'll load DOS32
314
315 DPRINT("DosBootsectorInitialize\n");
316
317 /* Write the "bootsector" */
318 RtlCopyMemory((PVOID)Address, Bootsector1, sizeof(Bootsector1));
319 Address += sizeof(Bootsector1);
320 RtlCopyMemory((PVOID)Address, DosKernelFileName, sizeof(DosKernelFileName));
321 Address += sizeof(DosKernelFileName);
322 RtlCopyMemory((PVOID)Address, Bootsector2, sizeof(Bootsector2));
323
324 /* Register the DOS Loading BOP */
325 RegisterBop(BOP_LOAD_DOS, DosInitialize);
326 }
327
328
329 //
330 // This function is called by the DOS bootsector. We finish to load
331 // the DOS, then we jump to 0070:0000.
332 //
333
334 /* 16-bit startup code at 0070:0000 */
335 static BYTE Startup[] =
336 {
337 LOBYTE(EMULATOR_BOP), HIBYTE(EMULATOR_BOP), BOP_START_DOS, // Call DOS Start
338 };
339
340 static VOID WINAPI DosStart(LPWORD Stack);
341
342 static VOID WINAPI DosInitialize(LPWORD Stack)
343 {
344 BOOLEAN Success = FALSE;
345
346 /* Get the DOS kernel file name (NULL-terminated) */
347 // FIXME: Isn't it possible to use some DS:SI instead??
348 LPCSTR DosKernelFileName = (LPCSTR)SEG_OFF_TO_PTR(getCS(), getIP());
349 setIP(getIP() + strlen(DosKernelFileName) + 1); // Skip it
350
351 DPRINT("DosInitialize('%s')\n", DosKernelFileName);
352
353 /* Register the DOS BOPs */
354 RegisterBop(BOP_DOS, DosSystemBop );
355 RegisterBop(BOP_CMD, DosCmdInterpreterBop);
356
357 if (DosKernelFileName && DosKernelFileName[0] != '\0')
358 {
359 HANDLE hDosBios;
360 ULONG ulDosBiosSize = 0;
361
362 /* Open the DOS BIOS file */
363 hDosBios = FileOpen(DosKernelFileName, &ulDosBiosSize);
364
365 /* If we failed, bail out */
366 if (hDosBios == NULL) goto QuitCustom;
367
368 /* Attempt to load the DOS BIOS into memory */
369 Success = FileLoadByHandle(hDosBios,
370 REAL_TO_PHYS(TO_LINEAR(0x0070, 0x0000)),
371 ulDosBiosSize,
372 &ulDosBiosSize);
373
374 DPRINT1("DOS BIOS loading %s at %04X:%04X, size 0x%X ; GetLastError() = %u\n",
375 (Success ? "succeeded" : "failed"),
376 0x0070, 0x0000,
377 ulDosBiosSize,
378 GetLastError());
379
380 /* Close the DOS BIOS file */
381 FileClose(hDosBios);
382
383 if (!Success) goto QuitCustom;
384
385 /* Position execution pointers and return */
386 setCS(0x0070);
387 setIP(0x0000);
388
389 /* Return control */
390 QuitCustom:
391 if (!Success)
392 DisplayMessage(L"Custom DOS '%S' loading failed, what to do??", DosKernelFileName);
393 }
394 else
395 {
396 Success = DosBIOSInitialize();
397 // Success &= DosKRNLInitialize();
398
399 if (!Success) goto Quit32;
400
401 /* Write the "bootsector" */
402 RtlCopyMemory(SEG_OFF_TO_PTR(0x0070, 0x0000), Startup, sizeof(Startup));
403
404 /* Register the DOS Starting BOP */
405 RegisterBop(BOP_START_DOS, DosStart);
406
407 /* Position execution pointers and return */
408 setCS(0x0070);
409 setIP(0x0000);
410
411 /* Return control */
412 Quit32:
413 if (!Success)
414 DisplayMessage(L"DOS32 loading failed, what to do??");
415 }
416
417 if (Success)
418 {
419 /*
420 * We succeeded, deregister the DOS Loading BOP
421 * so that no app will be able to call us back.
422 */
423 RegisterBop(BOP_LOAD_DOS, NULL);
424 }
425 }
426
427 static VOID WINAPI DosStart(LPWORD Stack)
428 {
429 #ifdef STANDALONE
430 DWORD Result;
431 CHAR ApplicationName[MAX_PATH];
432 CHAR CommandLine[DOS_CMDLINE_LENGTH];
433 #else
434 INT i;
435 #endif
436
437 DPRINT("DosStart\n");
438
439 /*
440 * We succeeded, deregister the DOS Starting BOP
441 * so that no app will be able to call us back.
442 */
443 RegisterBop(BOP_START_DOS, NULL);
444
445 /* Load the mouse driver */
446 DosMouseInitialize();
447
448 #ifndef STANDALONE
449
450 /* Parse the command line arguments */
451 for (i = 1; i < NtVdmArgc; i++)
452 {
453 if (wcsncmp(NtVdmArgv[i], L"-i", 2) == 0)
454 {
455 /* This is the session ID */
456 SessionId = wcstoul(NtVdmArgv[i] + 2, NULL, 10);
457
458 /* The VDM hasn't been started from a console, so quit when the task is done */
459 AcceptCommands = FALSE;
460 }
461 }
462
463 /* Create the GetNextVDMCommand thread */
464 CommandThread = CreateThread(NULL, 0, &CommandThreadProc, NULL, 0, NULL);
465 if (CommandThread == NULL)
466 {
467 wprintf(L"FATAL: Failed to create the command processing thread: %d\n", GetLastError());
468 goto Quit;
469 }
470
471 /* Wait for the command thread to exit */
472 WaitForSingleObject(CommandThread, INFINITE);
473
474 /* Close the thread handle */
475 CloseHandle(CommandThread);
476
477 #else
478
479 if (NtVdmArgc >= 2)
480 {
481 WideCharToMultiByte(CP_ACP, 0, NtVdmArgv[1], -1, ApplicationName, sizeof(ApplicationName), NULL, NULL);
482
483 if (NtVdmArgc >= 3)
484 WideCharToMultiByte(CP_ACP, 0, NtVdmArgv[2], -1, CommandLine, sizeof(CommandLine), NULL, NULL);
485 else
486 strcpy(CommandLine, "");
487 }
488 else
489 {
490 DisplayMessage(L"Invalid DOS command line\n");
491 goto Quit;
492 }
493
494 /* Start the process from the command line */
495 Result = DosStartProcess(ApplicationName, CommandLine,
496 SEG_OFF_TO_PTR(SYSTEM_ENV_BLOCK, 0));
497 if (Result != ERROR_SUCCESS)
498 {
499 DisplayMessage(L"Could not start '%S'. Error: %u", ApplicationName, Result);
500 goto Quit;
501 }
502
503 #endif
504
505 Quit:
506 /* Stop the VDM */
507 EmulatorTerminate();
508 }
509
510 /* PUBLIC EXPORTED APIS *******************************************************/
511
512 // demLFNCleanup
513 // demLFNGetCurrentDirectory
514
515 // demGetFileTimeByHandle_WOW
516 // demWOWLFNAllocateSearchHandle
517 // demWOWLFNCloseSearchHandle
518 // demWOWLFNEntry
519 // demWOWLFNGetSearchHandle
520 // demWOWLFNInit
521
522 DWORD
523 WINAPI
524 demClientErrorEx(IN HANDLE FileHandle,
525 IN CHAR Unknown,
526 IN BOOL Flag)
527 {
528 UNIMPLEMENTED;
529 return GetLastError();
530 }
531
532 DWORD
533 WINAPI
534 demFileDelete(IN LPCSTR FileName)
535 {
536 if (DeleteFileA(FileName)) SetLastError(ERROR_SUCCESS);
537
538 return GetLastError();
539 }
540
541 DWORD
542 WINAPI
543 demFileFindFirst(OUT PVOID lpFindFileData,
544 IN LPCSTR FileName,
545 IN WORD AttribMask)
546 {
547 BOOLEAN Success = TRUE;
548 WIN32_FIND_DATAA FindData;
549 HANDLE SearchHandle;
550 PDOS_FIND_FILE_BLOCK FindFileBlock = (PDOS_FIND_FILE_BLOCK)lpFindFileData;
551
552 /* Start a search */
553 SearchHandle = FindFirstFileA(FileName, &FindData);
554 if (SearchHandle == INVALID_HANDLE_VALUE) return GetLastError();
555
556 do
557 {
558 /* Check the attributes and retry as long as we haven't found a matching file */
559 if (((FindData.dwFileAttributes & (FILE_ATTRIBUTE_HIDDEN |
560 FILE_ATTRIBUTE_SYSTEM |
561 FILE_ATTRIBUTE_DIRECTORY))
562 & ~AttribMask))
563 {
564 break;
565 }
566 }
567 while ((Success = FindNextFileA(SearchHandle, &FindData)));
568
569 /* If we failed at some point, close the search and return an error */
570 if (!Success)
571 {
572 FindClose(SearchHandle);
573 return GetLastError();
574 }
575
576 /* Fill the block */
577 FindFileBlock->DriveLetter = CurrentDrive + 'A';
578 FindFileBlock->AttribMask = AttribMask;
579 FindFileBlock->SearchHandle = SearchHandle;
580 FindFileBlock->Attributes = LOBYTE(FindData.dwFileAttributes);
581 FileTimeToDosDateTime(&FindData.ftLastWriteTime,
582 &FindFileBlock->FileDate,
583 &FindFileBlock->FileTime);
584 FindFileBlock->FileSize = FindData.nFileSizeHigh ? 0xFFFFFFFF
585 : FindData.nFileSizeLow;
586 /* Build a short path name */
587 if (*FindData.cAlternateFileName)
588 strncpy(FindFileBlock->FileName, FindData.cAlternateFileName, sizeof(FindFileBlock->FileName));
589 else
590 GetShortPathNameA(FindData.cFileName, FindFileBlock->FileName, sizeof(FindFileBlock->FileName));
591
592 return ERROR_SUCCESS;
593 }
594
595 DWORD
596 WINAPI
597 demFileFindNext(OUT PVOID lpFindFileData)
598 {
599 WIN32_FIND_DATAA FindData;
600 PDOS_FIND_FILE_BLOCK FindFileBlock = (PDOS_FIND_FILE_BLOCK)lpFindFileData;
601
602 do
603 {
604 /* Continue searching as long as we haven't found a matching file */
605
606 /* If we failed at some point, close the search and return an error */
607 if (!FindNextFileA(FindFileBlock->SearchHandle, &FindData))
608 {
609 FindClose(FindFileBlock->SearchHandle);
610 return GetLastError();
611 }
612 }
613 while ((FindData.dwFileAttributes & (FILE_ATTRIBUTE_HIDDEN |
614 FILE_ATTRIBUTE_SYSTEM |
615 FILE_ATTRIBUTE_DIRECTORY))
616 & ~FindFileBlock->AttribMask);
617
618 /* Update the block */
619 FindFileBlock->Attributes = LOBYTE(FindData.dwFileAttributes);
620 FileTimeToDosDateTime(&FindData.ftLastWriteTime,
621 &FindFileBlock->FileDate,
622 &FindFileBlock->FileTime);
623 FindFileBlock->FileSize = FindData.nFileSizeHigh ? 0xFFFFFFFF
624 : FindData.nFileSizeLow;
625 /* Build a short path name */
626 if (*FindData.cAlternateFileName)
627 strncpy(FindFileBlock->FileName, FindData.cAlternateFileName, sizeof(FindFileBlock->FileName));
628 else
629 GetShortPathNameA(FindData.cFileName, FindFileBlock->FileName, sizeof(FindFileBlock->FileName));
630
631 return ERROR_SUCCESS;
632 }
633
634 UCHAR
635 WINAPI
636 demGetPhysicalDriveType(IN UCHAR DriveNumber)
637 {
638 UNIMPLEMENTED;
639 return DOSDEVICE_DRIVE_UNKNOWN;
640 }
641
642 BOOL
643 WINAPI
644 demIsShortPathName(IN LPCSTR Path,
645 IN BOOL Unknown)
646 {
647 UNIMPLEMENTED;
648 return FALSE;
649 }
650
651 DWORD
652 WINAPI
653 demSetCurrentDirectoryGetDrive(IN LPCSTR CurrentDirectory,
654 OUT PUCHAR DriveNumber)
655 {
656 UNIMPLEMENTED;
657 return ERROR_SUCCESS;
658 }
659
660 /* EOF */