subsystems/ntvdm/ntvdm.c

   1 /*
   2  * COPYRIGHT:       GPL - See COPYING in the top level directory
   3  * PROJECT:         ReactOS Virtual DOS Machine
   4  * FILE:            ntvdm.c
   5  * PURPOSE:         Virtual DOS Machine
   6  * PROGRAMMERS:     Aleksandar Andrejevic <theflash AT sdf DOT lonestar DOT org>
   7  */
   8
   9 /* INCLUDES *******************************************************************/
  10
  11 #define NDEBUG
  12
  13 #include "ntvdm.h"
  14 #include "emulator.h"
  15
  16 #include "clock.h"
  17 #include "hardware/ps2.h"
  18 #include "hardware/vga.h"
  19 #include "bios/bios.h"
  20 #include "dos/dem.h"
  21
  22 #include "resource.h"
  23
  24 /*
  25  * Activate this line if you want to run NTVDM in standalone mode with:
  26  * ntvdm.exe <program>
  27  */
  28 // #define STANDALONE
  29
  30 /* VARIABLES ******************************************************************/
  31
  32 static HANDLE ConsoleInput  = INVALID_HANDLE_VALUE;
  33 static HANDLE ConsoleOutput = INVALID_HANDLE_VALUE;
  34 static DWORD  OrgConsoleInputMode, OrgConsoleOutputMode;
  35 static CONSOLE_CURSOR_INFO         OrgConsoleCursorInfo;
  36 static CONSOLE_SCREEN_BUFFER_INFO  OrgConsoleBufferInfo;
  37 static BOOLEAN AcceptCommands = TRUE;
  38 static HANDLE CommandThread = NULL;
  39
  40 static HMENU hConsoleMenu  = NULL;
  41 static INT   VdmMenuPos    = -1;
  42 static BOOLEAN ShowPointer = FALSE;
  43
  44 /*
  45  * Those menu helpers were taken from the GUI frontend in winsrv.dll
  46  */
  47 typedef struct _VDM_MENUITEM
  48 {
  49     UINT uID;
  50     const struct _VDM_MENUITEM *SubMenu;
  51     WORD wCmdID;
  52 } VDM_MENUITEM, *PVDM_MENUITEM;
  53
  54 static const VDM_MENUITEM VdmMenuItems[] =
  55 {
  56     { IDS_VDM_QUIT, NULL, ID_VDM_QUIT },
  57
  58     { 0, NULL, 0 }      /* End of list */
  59 };
  60
  61 static const VDM_MENUITEM VdmMainMenuItems[] =
  62 {
  63     { -1, NULL, 0 },    /* Separator */
  64     { IDS_HIDE_MOUSE,   NULL, ID_SHOWHIDE_MOUSE },  /* Hide mouse; can be renamed to Show mouse */
  65     { IDS_VDM_MENU  ,   VdmMenuItems,         0 },  /* ReactOS VDM Menu */
  66
  67     { 0, NULL, 0 }      /* End of list */
  68 };
  69
  70 static VOID
  71 AppendMenuItems(HMENU hMenu,
  72                 const VDM_MENUITEM *Items)
  73 {
  74     UINT i = 0;
  75     WCHAR szMenuString[255];
  76     HMENU hSubMenu;
  77
  78     do
  79     {
  80         if (Items[i].uID != (UINT)-1)
  81         {
  82             if (LoadStringW(GetModuleHandle(NULL),
  83                             Items[i].uID,
  84                             szMenuString,
  85                             sizeof(szMenuString) / sizeof(szMenuString[0])) > 0)
  86             {
  87                 if (Items[i].SubMenu != NULL)
  88                 {
  89                     hSubMenu = CreatePopupMenu();
  90                     if (hSubMenu != NULL)
  91                     {
  92                         AppendMenuItems(hSubMenu, Items[i].SubMenu);
  93
  94                         if (!AppendMenuW(hMenu,
  95                                          MF_STRING | MF_POPUP,
  96                                          (UINT_PTR)hSubMenu,
  97                                          szMenuString))
  98                         {
  99                             DestroyMenu(hSubMenu);
 100                         }
 101                     }
 102                 }
 103                 else
 104                 {
 105                     AppendMenuW(hMenu,
 106                                 MF_STRING,
 107                                 Items[i].wCmdID,
 108                                 szMenuString);
 109                 }
 110             }
 111         }
 112         else
 113         {
 114             AppendMenuW(hMenu,
 115                         MF_SEPARATOR,
 116                         0,
 117                         NULL);
 118         }
 119         i++;
 120     } while (!(Items[i].uID == 0 && Items[i].SubMenu == NULL && Items[i].wCmdID == 0));
 121 }
 122
 123 static VOID
 124 CreateVdmMenu(HANDLE ConOutHandle)
 125 {
 126     hConsoleMenu = ConsoleMenuControl(ConsoleOutput,
 127                                       ID_SHOWHIDE_MOUSE,
 128                                       ID_VDM_QUIT);
 129     if (hConsoleMenu == NULL) return;
 130
 131     VdmMenuPos = GetMenuItemCount(hConsoleMenu);
 132     AppendMenuItems(hConsoleMenu, VdmMainMenuItems);
 133     DrawMenuBar(GetConsoleWindow());
 134 }
 135
 136 static VOID
 137 DestroyVdmMenu(VOID)
 138 {
 139     UINT i = 0;
 140     const VDM_MENUITEM *Items = VdmMainMenuItems;
 141
 142     do
 143     {
 144         DeleteMenu(hConsoleMenu, VdmMenuPos, MF_BYPOSITION);
 145         i++;
 146     } while (!(Items[i].uID == 0 && Items[i].SubMenu == NULL && Items[i].wCmdID == 0));
 147
 148     DrawMenuBar(GetConsoleWindow());
 149 }
 150
 151 static VOID ShowHideMousePointer(HANDLE ConOutHandle, BOOLEAN ShowPtr)
 152 {
 153     WCHAR szMenuString[255] = L"";
 154
 155     if (ShowPtr)
 156     {
 157         /* Be sure the cursor will be shown */
 158         while (ShowConsoleCursor(ConOutHandle, TRUE) < 0) ;
 159     }
 160     else
 161     {
 162         /* Be sure the cursor will be hidden */
 163         while (ShowConsoleCursor(ConOutHandle, FALSE) >= 0) ;
 164     }
 165
 166     if (LoadStringW(GetModuleHandle(NULL),
 167                     (!ShowPtr ? IDS_SHOW_MOUSE : IDS_HIDE_MOUSE),
 168                     szMenuString,
 169                     sizeof(szMenuString) / sizeof(szMenuString[0])) > 0)
 170     {
 171         ModifyMenu(hConsoleMenu, ID_SHOWHIDE_MOUSE,
 172                    MF_BYCOMMAND, ID_SHOWHIDE_MOUSE, szMenuString);
 173     }
 174 }
 175
 176 /* PUBLIC FUNCTIONS ***********************************************************/
 177
 178 VOID DisplayMessage(LPCWSTR Format, ...)
 179 {
 180     WCHAR Buffer[256];
 181     va_list Parameters;
 182
 183     va_start(Parameters, Format);
 184     _vsnwprintf(Buffer, 256, Format, Parameters);
 185     DPRINT1("\n\nNTVDM Subsystem\n%S\n\n", Buffer);
 186     MessageBoxW(NULL, Buffer, L"NTVDM Subsystem", MB_OK);
 187     va_end(Parameters);
 188 }
 189
 190 BOOL WINAPI ConsoleCtrlHandler(DWORD ControlType)
 191 {
 192     switch (ControlType)
 193     {
 194         case CTRL_C_EVENT:
 195         case CTRL_BREAK_EVENT:
 196         {
 197             /* Call INT 23h */
 198             EmulatorInterrupt(0x23);
 199             break;
 200         }
 201         case CTRL_LAST_CLOSE_EVENT:
 202         {
 203             if (!VdmRunning)
 204             {
 205                 /* Exit immediately */
 206                 if (CommandThread) TerminateThread(CommandThread, 0);
 207             }
 208             else
 209             {
 210                 /* Stop accepting new commands */
 211                 AcceptCommands = FALSE;
 212             }
 213
 214             break;
 215         }
 216         default:
 217         {
 218             /* Stop the VDM if the user logs out or closes the console */
 219             EmulatorTerminate();
 220         }
 221     }
 222     return TRUE;
 223 }
 224
 225 VOID ConsoleInitUI(VOID)
 226 {
 227     CreateVdmMenu(ConsoleOutput);
 228 }
 229
 230 VOID ConsoleCleanupUI(VOID)
 231 {
 232     /* Display again properly the mouse pointer */
 233     if (ShowPointer) ShowHideMousePointer(ConsoleOutput, ShowPointer);
 234
 235     DestroyVdmMenu();
 236 }
 237
 238 DWORD WINAPI PumpConsoleInput(LPVOID Parameter)
 239 {
 240     HANDLE ConsoleInput = (HANDLE)Parameter;
 241     INPUT_RECORD InputRecord;
 242     DWORD Count;
 243
 244     while (VdmRunning)
 245     {
 246         /* Wait for an input record */
 247         if (!ReadConsoleInput(ConsoleInput, &InputRecord, 1, &Count))
 248         {
 249             DWORD LastError = GetLastError();
 250             DPRINT1("Error reading console input (0x%p, %lu) - Error %lu\n", ConsoleInput, Count, LastError);
 251             return LastError;
 252         }
 253
 254         ASSERT(Count != 0);
 255
 256         /* Check the event type */
 257         switch (InputRecord.EventType)
 258         {
 259             case KEY_EVENT:
 260             case MOUSE_EVENT:
 261                 /* Send it to the PS/2 controller */
 262                 PS2Dispatch(&InputRecord);
 263                 break;
 264
 265             case MENU_EVENT:
 266             {
 267                 switch (InputRecord.Event.MenuEvent.dwCommandId)
 268                 {
 269                     case ID_SHOWHIDE_MOUSE:
 270                         ShowHideMousePointer(ConsoleOutput, ShowPointer);
 271                         ShowPointer = !ShowPointer;
 272                         break;
 273
 274                     case ID_VDM_QUIT:
 275                         /* Stop the VDM */
 276                         EmulatorTerminate();
 277                         break;
 278
 279                     default:
 280                         break;
 281                 }
 282
 283                 break;
 284             }
 285
 286             default:
 287                 break;
 288         }
 289     }
 290
 291     return 0;
 292 }
 293
 294 BOOL ConsoleInit(VOID)
 295 {
 296     /* Set the handler routine */
 297     SetConsoleCtrlHandler(ConsoleCtrlHandler, TRUE);
 298
 299     /* Enable the CTRL_LAST_CLOSE_EVENT */
 300     SetLastConsoleEventActive();
 301
 302     /* Get the input handle to the real console, and check for success */
 303     ConsoleInput = CreateFileW(L"CONIN$",
 304                                GENERIC_READ | GENERIC_WRITE,
 305                                FILE_SHARE_READ | FILE_SHARE_WRITE,
 306                                NULL,
 307                                OPEN_EXISTING,
 308                                0,
 309                                NULL);
 310     if (ConsoleInput == INVALID_HANDLE_VALUE)
 311     {
 312         wprintf(L"FATAL: Cannot retrieve a handle to the console input\n");
 313         return FALSE;
 314     }
 315
 316     /* Get the output handle to the real console, and check for success */
 317     ConsoleOutput = CreateFileW(L"CONOUT$",
 318                                 GENERIC_READ | GENERIC_WRITE,
 319                                 FILE_SHARE_READ | FILE_SHARE_WRITE,
 320                                 NULL,
 321                                 OPEN_EXISTING,
 322                                 0,
 323                                 NULL);
 324     if (ConsoleOutput == INVALID_HANDLE_VALUE)
 325     {
 326         CloseHandle(ConsoleInput);
 327         wprintf(L"FATAL: Cannot retrieve a handle to the console output\n");
 328         return FALSE;
 329     }
 330
 331     /* Save the original input and output console modes */
 332     if (!GetConsoleMode(ConsoleInput , &OrgConsoleInputMode ) ||
 333         !GetConsoleMode(ConsoleOutput, &OrgConsoleOutputMode))
 334     {
 335         CloseHandle(ConsoleOutput);
 336         CloseHandle(ConsoleInput);
 337         wprintf(L"FATAL: Cannot save console in/out modes\n");
 338         return FALSE;
 339     }
 340
 341     /* Save the original cursor and console screen buffer information */
 342     if (!GetConsoleCursorInfo(ConsoleOutput, &OrgConsoleCursorInfo) ||
 343         !GetConsoleScreenBufferInfo(ConsoleOutput, &OrgConsoleBufferInfo))
 344     {
 345         CloseHandle(ConsoleOutput);
 346         CloseHandle(ConsoleInput);
 347         wprintf(L"FATAL: Cannot save console cursor/screen-buffer info\n");
 348         return FALSE;
 349     }
 350
 351     /* Initialize the UI */
 352     ConsoleInitUI();
 353
 354     return TRUE;
 355 }
 356
 357 VOID ConsoleCleanup(VOID)
 358 {
 359     SMALL_RECT ConRect;
 360
 361     /* Restore the old screen buffer */
 362     SetConsoleActiveScreenBuffer(ConsoleOutput);
 363
 364     /* Restore the original console size */
 365     ConRect.Left   = 0;
 366     ConRect.Top    = 0;
 367     ConRect.Right  = ConRect.Left + OrgConsoleBufferInfo.srWindow.Right  - OrgConsoleBufferInfo.srWindow.Left;
 368     ConRect.Bottom = ConRect.Top  + OrgConsoleBufferInfo.srWindow.Bottom - OrgConsoleBufferInfo.srWindow.Top ;
 369     /*
 370      * See the following trick explanation in vga.c:VgaEnterTextMode() .
 371      */
 372     SetConsoleScreenBufferSize(ConsoleOutput, OrgConsoleBufferInfo.dwSize);
 373     SetConsoleWindowInfo(ConsoleOutput, TRUE, &ConRect);
 374     SetConsoleScreenBufferSize(ConsoleOutput, OrgConsoleBufferInfo.dwSize);
 375
 376     /* Restore the original cursor shape */
 377     SetConsoleCursorInfo(ConsoleOutput, &OrgConsoleCursorInfo);
 378
 379     /* Restore the original input and output console modes */
 380     SetConsoleMode(ConsoleOutput, OrgConsoleOutputMode);
 381     SetConsoleMode(ConsoleInput , OrgConsoleInputMode );
 382
 383     /* Cleanup the UI */
 384     ConsoleCleanupUI();
 385
 386     /* Close the console handles */
 387     if (ConsoleOutput != INVALID_HANDLE_VALUE) CloseHandle(ConsoleOutput);
 388     if (ConsoleInput  != INVALID_HANDLE_VALUE) CloseHandle(ConsoleInput);
 389 }
 390
 391 DWORD WINAPI CommandThreadProc(LPVOID Parameter)
 392 {
 393     BOOLEAN First = TRUE;
 394     DWORD Result;
 395     VDM_COMMAND_INFO CommandInfo;
 396     CHAR CmdLine[MAX_PATH];
 397     CHAR AppName[MAX_PATH];
 398     CHAR PifFile[MAX_PATH];
 399     CHAR Desktop[MAX_PATH];
 400     CHAR Title[MAX_PATH];
 401     CHAR Env[MAX_PATH];
 402
 403     UNREFERENCED_PARAMETER(Parameter);
 404
 405     while (AcceptCommands)
 406     {
 407         /* Clear the structure */
 408         ZeroMemory(&CommandInfo, sizeof(CommandInfo));
 409
 410         /* Initialize the structure members */
 411         CommandInfo.VDMState = VDM_FLAG_DOS;
 412         CommandInfo.CmdLine = CmdLine;
 413         CommandInfo.CmdLen = sizeof(CmdLine);
 414         CommandInfo.AppName = AppName;
 415         CommandInfo.AppLen = sizeof(AppName);
 416         CommandInfo.PifFile = PifFile;
 417         CommandInfo.PifLen = sizeof(PifFile);
 418         CommandInfo.Desktop = Desktop;
 419         CommandInfo.DesktopLen = sizeof(Desktop);
 420         CommandInfo.Title = Title;
 421         CommandInfo.TitleLen = sizeof(Title);
 422         CommandInfo.Env = Env;
 423         CommandInfo.EnvLen = sizeof(Env);
 424
 425         if (First)
 426         {
 427             CommandInfo.VDMState |= VDM_FLAG_FIRST_TASK;
 428             First = FALSE;
 429         }
 430
 431         /* Wait for the next available VDM */
 432         if (!GetNextVDMCommand(&CommandInfo)) break;
 433
 434         /* Start the process from the command line */
 435         DPRINT1("Starting '%s'...\n", AppName);
 436
 437         Result = DosLoadExecutable(DOS_LOAD_AND_EXECUTE, AppName, CmdLine, Env, NULL, NULL);
 438         if (Result != ERROR_SUCCESS)
 439         {
 440             DisplayMessage(L"Could not start '%S'. Error: %u", AppName, Result);
 441             break;
 442         }
 443
 444         /* Start simulation */
 445         EmulatorSimulate();
 446
 447         /* Perform another screen refresh */
 448         VgaRefreshDisplay();
 449     }
 450
 451     return 0;
 452 }
 453
 454 INT wmain(INT argc, WCHAR *argv[])
 455 {
 456 #ifdef STANDALONE
 457
 458     DWORD Result;
 459     CHAR ApplicationName[MAX_PATH];
 460     CHAR CommandLine[DOS_CMDLINE_LENGTH];
 461
 462     if (argc >= 2)
 463     {
 464         WideCharToMultiByte(CP_ACP, 0, argv[1], -1, ApplicationName, sizeof(ApplicationName), NULL, NULL);
 465
 466         if (argc >= 3) WideCharToMultiByte(CP_ACP, 0, argv[2], -1, CommandLine, sizeof(CommandLine), NULL, NULL);
 467         else strcpy(CommandLine, "");
 468     }
 469     else
 470     {
 471         wprintf(L"\nReactOS Virtual DOS Machine\n\n"
 472                 L"Usage: NTVDM <executable> [<parameters>]\n");
 473         return 0;
 474     }
 475
 476 #endif
 477
 478     DPRINT1("\n\n\nNTVDM - Starting...\n\n\n");
 479
 480     /* Initialize the console */
 481     if (!ConsoleInit())
 482     {
 483         wprintf(L"FATAL: A problem occurred when trying to initialize the console\n");
 484         goto Cleanup;
 485     }
 486
 487     /* Initialize the emulator */
 488     if (!EmulatorInitialize(ConsoleInput, ConsoleOutput))
 489     {
 490         wprintf(L"FATAL: Failed to initialize the emulator\n");
 491         goto Cleanup;
 492     }
 493
 494     /* Initialize the system BIOS */
 495     if (!BiosInitialize(NULL))
 496     {
 497         wprintf(L"FATAL: Failed to initialize the VDM BIOS.\n");
 498         goto Cleanup;
 499     }
 500
 501     /* Initialize the VDM DOS kernel */
 502     if (!DosInitialize(NULL))
 503     {
 504         wprintf(L"FATAL: Failed to initialize the VDM DOS kernel.\n");
 505         goto Cleanup;
 506     }
 507
 508 #ifndef STANDALONE
 509
 510     /* Create the GetNextVDMCommand thread */
 511     CommandThread = CreateThread(NULL, 0, &CommandThreadProc, NULL, 0, NULL);
 512     if (CommandThread == NULL)
 513     {
 514         wprintf(L"FATAL: Failed to create the command processing thread: %d\n", GetLastError());
 515         goto Cleanup;
 516     }
 517
 518     /* Wait for the command thread to exit */
 519     WaitForSingleObject(CommandThread, INFINITE);
 520
 521     /* Close the thread handle */
 522     CloseHandle(CommandThread);
 523
 524 #else
 525
 526     /* Start the process from the command line */
 527     DPRINT1("Starting '%s'...\n", ApplicationName);
 528
 529     Result = DosLoadExecutable(DOS_LOAD_AND_EXECUTE,
 530                                ApplicationName,
 531                                CommandLine,
 532                                GetEnvironmentStrings(),
 533                                NULL,
 534                                NULL);
 535     if (Result != ERROR_SUCCESS)
 536     {
 537         DisplayMessage(L"Could not start '%S'. Error: %u", ApplicationName, Result);
 538         goto Cleanup;
 539     }
 540
 541     /* Start simulation */
 542     EmulatorSimulate();
 543
 544     /* Perform another screen refresh */
 545     VgaRefreshDisplay();
 546
 547 #endif
 548
 549 Cleanup:
 550     BiosCleanup();
 551     EmulatorCleanup();
 552     ConsoleCleanup();
 553
 554 #ifndef STANDALONE
 555     ExitVDM(FALSE, 0);
 556 #endif
 557
 558     /* Quit the VDM */
 559     DPRINT1("\n\n\nNTVDM - Exiting...\n\n\n");
 560
 561     return 0;
 562 }
 563
 564 /* EOF */