projects / reactos.git / blob
? search:


115cbff9155d15cad1a596152d6cebcc995b142d
[reactos.git] / subsystems / ntvdm / dos.c
1 /*
2 * COPYRIGHT: GPL - See COPYING in the top level directory
3 * PROJECT: ReactOS Virtual DOS Machine
4 * FILE: dos.c
5 * PURPOSE: VDM DOS Kernel
6 * PROGRAMMERS: Aleksandar Andrejevic <theflash AT sdf DOT lonestar DOT org>
7 */
8
9 /* INCLUDES *******************************************************************/
10
11 #define NDEBUG
12
13 #include "dos.h"
14 #include "bios.h"
15 #include "emulator.h"
16
17 #include "registers.h"
18
19 /* PRIVATE VARIABLES **********************************************************/
20
21 static WORD CurrentPsp = SYSTEM_PSP;
22 static WORD DosLastError = 0;
23 static DWORD DiskTransferArea;
24 static BYTE CurrentDrive;
25 static CHAR LastDrive = 'E';
26 static CHAR CurrentDirectories[NUM_DRIVES][DOS_DIR_LENGTH];
27 static HANDLE DosSystemFileTable[DOS_SFT_SIZE];
28 static WORD DosSftRefCount[DOS_SFT_SIZE];
29 static BYTE DosAllocStrategy = DOS_ALLOC_BEST_FIT;
30 static BOOLEAN DosUmbLinked = FALSE;
31 static WORD DosErrorLevel = 0x0000;
32
33 /* PRIVATE FUNCTIONS **********************************************************/
34
35 /* Taken from base/shell/cmd/console.c */
36 static BOOL IsConsoleHandle(HANDLE hHandle)
37 {
38 DWORD dwMode;
39
40 /* Check whether the handle may be that of a console... */
41 if ((GetFileType(hHandle) & FILE_TYPE_CHAR) == 0) return FALSE;
42
43 /*
44 * It may be. Perform another test... The idea comes from the
45 * MSDN description of the WriteConsole API:
46 *
47 * "WriteConsole fails if it is used with a standard handle
48 * that is redirected to a file. If an application processes
49 * multilingual output that can be redirected, determine whether
50 * the output handle is a console handle (one method is to call
51 * the GetConsoleMode function and check whether it succeeds).
52 * If the handle is a console handle, call WriteConsole. If the
53 * handle is not a console handle, the output is redirected and
54 * you should call WriteFile to perform the I/O."
55 */
56 return GetConsoleMode(hHandle, &dwMode);
57 }
58
59 static VOID DosCombineFreeBlocks(WORD StartBlock)
60 {
61 PDOS_MCB CurrentMcb = SEGMENT_TO_MCB(StartBlock), NextMcb;
62
63 /* If this is the last block or it's not free, quit */
64 if (CurrentMcb->BlockType == 'Z' || CurrentMcb->OwnerPsp != 0) return;
65
66 while (TRUE)
67 {
68 /* Get a pointer to the next MCB */
69 NextMcb = SEGMENT_TO_MCB(StartBlock + CurrentMcb->Size + 1);
70
71 /* Check if the next MCB is free */
72 if (NextMcb->OwnerPsp == 0)
73 {
74 /* Combine them */
75 CurrentMcb->Size += NextMcb->Size + 1;
76 CurrentMcb->BlockType = NextMcb->BlockType;
77 NextMcb->BlockType = 'I';
78 }
79 else
80 {
81 /* No more adjoining free blocks */
82 break;
83 }
84 }
85 }
86
87 static WORD DosCopyEnvironmentBlock(WORD SourceSegment, LPCSTR ProgramName)
88 {
89 PCHAR Ptr, SourceBuffer, DestBuffer = NULL;
90 ULONG TotalSize = 0;
91 WORD DestSegment;
92
93 Ptr = SourceBuffer = (PCHAR)SEG_OFF_TO_PTR(SourceSegment, 0);
94
95 /* Calculate the size of the environment block */
96 while (*Ptr)
97 {
98 TotalSize += strlen(Ptr) + 1;
99 Ptr += strlen(Ptr) + 1;
100 }
101 TotalSize++;
102
103 /* Add the string buffer size */
104 TotalSize += strlen(ProgramName) + 1;
105
106 /* Allocate the memory for the environment block */
107 DestSegment = DosAllocateMemory((WORD)((TotalSize + 0x0F) >> 4), NULL);
108 if (!DestSegment) return 0;
109
110 Ptr = SourceBuffer;
111
112 DestBuffer = (PCHAR)SEG_OFF_TO_PTR(DestSegment, 0);
113 while (*Ptr)
114 {
115 /* Copy the string */
116 strcpy(DestBuffer, Ptr);
117
118 /* Advance to the next string */
119 DestBuffer += strlen(Ptr);
120 Ptr += strlen(Ptr) + 1;
121
122 /* Put a zero after the string */
123 *(DestBuffer++) = 0;
124 }
125
126 /* Set the final zero */
127 *(DestBuffer++) = 0;
128
129 /* Copy the program name after the environment block */
130 strcpy(DestBuffer, ProgramName);
131
132 return DestSegment;
133 }
134
135 static VOID DosChangeMemoryOwner(WORD Segment, WORD NewOwner)
136 {
137 PDOS_MCB Mcb = SEGMENT_TO_MCB(Segment - 1);
138
139 /* Just set the owner */
140 Mcb->OwnerPsp = NewOwner;
141 }
142
143 static WORD DosOpenHandle(HANDLE Handle)
144 {
145 BYTE i;
146 WORD DosHandle;
147 PDOS_PSP PspBlock;
148 LPBYTE HandleTable;
149
150 /* The system PSP has no handle table */
151 if (CurrentPsp == SYSTEM_PSP) return INVALID_DOS_HANDLE;
152
153 /* Get a pointer to the handle table */
154 PspBlock = SEGMENT_TO_PSP(CurrentPsp);
155 HandleTable = (LPBYTE)FAR_POINTER(PspBlock->HandleTablePtr);
156
157 /* Find a free entry in the JFT */
158 for (DosHandle = 0; DosHandle < PspBlock->HandleTableSize; DosHandle++)
159 {
160 if (HandleTable[DosHandle] == 0xFF) break;
161 }
162
163 /* If there are no free entries, fail */
164 if (DosHandle == PspBlock->HandleTableSize) return INVALID_DOS_HANDLE;
165
166 /* Check if the handle is already in the SFT */
167 for (i = 0; i < DOS_SFT_SIZE; i++)
168 {
169 /* Check if this is the same handle */
170 if (DosSystemFileTable[i] != Handle) continue;
171
172 /* Already in the table, reference it */
173 DosSftRefCount[i]++;
174
175 /* Set the JFT entry to that SFT index */
176 HandleTable[DosHandle] = i;
177
178 /* Return the new handle */
179 return DosHandle;
180 }
181
182 /* Add the handle to the SFT */
183 for (i = 0; i < DOS_SFT_SIZE; i++)
184 {
185 /* Make sure this is an empty table entry */
186 if (DosSystemFileTable[i] != INVALID_HANDLE_VALUE) continue;
187
188 /* Initialize the empty table entry */
189 DosSystemFileTable[i] = Handle;
190 DosSftRefCount[i] = 1;
191
192 /* Set the JFT entry to that SFT index */
193 HandleTable[DosHandle] = i;
194
195 /* Return the new handle */
196 return DosHandle;
197 }
198
199 /* The SFT is full */
200 return INVALID_DOS_HANDLE;
201 }
202
203 static HANDLE DosGetRealHandle(WORD DosHandle)
204 {
205 PDOS_PSP PspBlock;
206 LPBYTE HandleTable;
207
208 /* The system PSP has no handle table */
209 if (CurrentPsp == SYSTEM_PSP) return INVALID_HANDLE_VALUE;
210
211 /* Get a pointer to the handle table */
212 PspBlock = SEGMENT_TO_PSP(CurrentPsp);
213 HandleTable = (LPBYTE)FAR_POINTER(PspBlock->HandleTablePtr);
214
215 /* Make sure the handle is open */
216 if (HandleTable[DosHandle] == 0xFF) return INVALID_HANDLE_VALUE;
217
218 /* Return the Win32 handle */
219 return DosSystemFileTable[HandleTable[DosHandle]];
220 }
221
222 static VOID DosCopyHandleTable(LPBYTE DestinationTable)
223 {
224 INT i;
225 PDOS_PSP PspBlock;
226 LPBYTE SourceTable;
227
228 /* Clear the table first */
229 for (i = 0; i < 20; i++) DestinationTable[i] = 0xFF;
230
231 /* Check if this is the initial process */
232 if (CurrentPsp == SYSTEM_PSP)
233 {
234 /* Set up the standard I/O devices */
235 for (i = 0; i <= 2; i++)
236 {
237 /* Set the index in the SFT */
238 DestinationTable[i] = (BYTE)i;
239
240 /* Increase the reference count */
241 DosSftRefCount[i]++;
242 }
243
244 /* Done */
245 return;
246 }
247
248 /* Get the parent PSP block and handle table */
249 PspBlock = SEGMENT_TO_PSP(CurrentPsp);
250 SourceTable = (LPBYTE)FAR_POINTER(PspBlock->HandleTablePtr);
251
252 /* Copy the first 20 handles into the new table */
253 for (i = 0; i < 20; i++)
254 {
255 DestinationTable[i] = SourceTable[i];
256
257 /* Increase the reference count */
258 DosSftRefCount[SourceTable[i]]++;
259 }
260 }
261
262 /* PUBLIC FUNCTIONS ***********************************************************/
263
264 WORD DosAllocateMemory(WORD Size, WORD *MaxAvailable)
265 {
266 WORD Result = 0, Segment = FIRST_MCB_SEGMENT, MaxSize = 0;
267 PDOS_MCB CurrentMcb, NextMcb;
268 BOOLEAN SearchUmb = FALSE;
269
270 DPRINT("DosAllocateMemory: Size 0x%04X\n", Size);
271
272 if (DosUmbLinked && (DosAllocStrategy & (DOS_ALLOC_HIGH | DOS_ALLOC_HIGH_LOW)))
273 {
274 /* Search UMB first */
275 Segment = UMB_START_SEGMENT;
276 SearchUmb = TRUE;
277 }
278
279 while (TRUE)
280 {
281 /* Get a pointer to the MCB */
282 CurrentMcb = SEGMENT_TO_MCB(Segment);
283
284 /* Make sure it's valid */
285 if (CurrentMcb->BlockType != 'M' && CurrentMcb->BlockType != 'Z')
286 {
287 DPRINT("The DOS memory arena is corrupted!\n");
288 DosLastError = ERROR_ARENA_TRASHED;
289 return 0;
290 }
291
292 /* Only check free blocks */
293 if (CurrentMcb->OwnerPsp != 0) goto Next;
294
295 /* Combine this free block with adjoining free blocks */
296 DosCombineFreeBlocks(Segment);
297
298 /* Update the maximum block size */
299 if (CurrentMcb->Size > MaxSize) MaxSize = CurrentMcb->Size;
300
301 /* Check if this block is big enough */
302 if (CurrentMcb->Size < Size) goto Next;
303
304 switch (DosAllocStrategy & 0x3F)
305 {
306 case DOS_ALLOC_FIRST_FIT:
307 {
308 /* For first fit, stop immediately */
309 Result = Segment;
310 goto Done;
311 }
312
313 case DOS_ALLOC_BEST_FIT:
314 {
315 /* For best fit, update the smallest block found so far */
316 if ((Result == 0) || (CurrentMcb->Size < SEGMENT_TO_MCB(Result)->Size))
317 {
318 Result = Segment;
319 }
320
321 break;
322 }
323
324 case DOS_ALLOC_LAST_FIT:
325 {
326 /* For last fit, make the current block the result, but keep searching */
327 Result = Segment;
328 break;
329 }
330 }
331
332 Next:
333 /* If this was the last MCB in the chain, quit */
334 if (CurrentMcb->BlockType == 'Z')
335 {
336 /* Check if nothing was found while searching through UMBs */
337 if ((Result == 0) && SearchUmb && (DosAllocStrategy & DOS_ALLOC_HIGH_LOW))
338 {
339 /* Search low memory */
340 Segment = FIRST_MCB_SEGMENT;
341 continue;
342 }
343
344 break;
345 }
346
347 /* Otherwise, update the segment and continue */
348 Segment += CurrentMcb->Size + 1;
349 }
350
351 Done:
352
353 /* If we didn't find a free block, return 0 */
354 if (Result == 0)
355 {
356 DosLastError = ERROR_NOT_ENOUGH_MEMORY;
357 if (MaxAvailable) *MaxAvailable = MaxSize;
358 return 0;
359 }
360
361 /* Get a pointer to the MCB */
362 CurrentMcb = SEGMENT_TO_MCB(Result);
363
364 /* Check if the block is larger than requested */
365 if (CurrentMcb->Size > Size)
366 {
367 /* It is, split it into two blocks */
368 NextMcb = SEGMENT_TO_MCB(Result + Size + 1);
369
370 /* Initialize the new MCB structure */
371 NextMcb->BlockType = CurrentMcb->BlockType;
372 NextMcb->Size = CurrentMcb->Size - Size - 1;
373 NextMcb->OwnerPsp = 0;
374
375 /* Update the current block */
376 CurrentMcb->BlockType = 'M';
377 CurrentMcb->Size = Size;
378 }
379
380 /* Take ownership of the block */
381 CurrentMcb->OwnerPsp = CurrentPsp;
382
383 /* Return the segment of the data portion of the block */
384 return Result + 1;
385 }
386
387 BOOLEAN DosResizeMemory(WORD BlockData, WORD NewSize, WORD *MaxAvailable)
388 {
389 BOOLEAN Success = TRUE;
390 WORD Segment = BlockData - 1, ReturnSize = 0, NextSegment;
391 PDOS_MCB Mcb = SEGMENT_TO_MCB(Segment), NextMcb;
392
393 DPRINT("DosResizeMemory: BlockData 0x%04X, NewSize 0x%04X\n",
394 BlockData,
395 NewSize);
396
397 /* Make sure this is a valid, allocated block */
398 if ((Mcb->BlockType != 'M' && Mcb->BlockType != 'Z') || Mcb->OwnerPsp == 0)
399 {
400 Success = FALSE;
401 DosLastError = ERROR_INVALID_HANDLE;
402 goto Done;
403 }
404
405 ReturnSize = Mcb->Size;
406
407 /* Check if we need to expand or contract the block */
408 if (NewSize > Mcb->Size)
409 {
410 /* We can't expand the last block */
411 if (Mcb->BlockType != 'M')
412 {
413 Success = FALSE;
414 goto Done;
415 }
416
417 /* Get the pointer and segment of the next MCB */
418 NextSegment = Segment + Mcb->Size + 1;
419 NextMcb = SEGMENT_TO_MCB(NextSegment);
420
421 /* Make sure the next segment is free */
422 if (NextMcb->OwnerPsp != 0)
423 {
424 DPRINT("Cannot expand memory block: next segment is not free!\n");
425 DosLastError = ERROR_NOT_ENOUGH_MEMORY;
426 Success = FALSE;
427 goto Done;
428 }
429
430 /* Combine this free block with adjoining free blocks */
431 DosCombineFreeBlocks(NextSegment);
432
433 /* Set the maximum possible size of the block */
434 ReturnSize += NextMcb->Size + 1;
435
436 /* Maximize the current block */
437 Mcb->Size = ReturnSize;
438 Mcb->BlockType = NextMcb->BlockType;
439
440 /* Invalidate the next block */
441 NextMcb->BlockType = 'I';
442
443 /* Check if the block is larger than requested */
444 if (Mcb->Size > NewSize)
445 {
446 DPRINT("Block too large, reducing size from 0x%04X to 0x%04X\n",
447 Mcb->Size,
448 NewSize);
449
450 /* It is, split it into two blocks */
451 NextMcb = SEGMENT_TO_MCB(Segment + NewSize + 1);
452
453 /* Initialize the new MCB structure */
454 NextMcb->BlockType = Mcb->BlockType;
455 NextMcb->Size = Mcb->Size - NewSize - 1;
456 NextMcb->OwnerPsp = 0;
457
458 /* Update the current block */
459 Mcb->BlockType = 'M';
460 Mcb->Size = NewSize;
461 }
462 }
463 else if (NewSize < Mcb->Size)
464 {
465 DPRINT("Shrinking block from 0x%04X to 0x%04X\n",
466 Mcb->Size,
467 NewSize);
468
469 /* Just split the block */
470 NextMcb = SEGMENT_TO_MCB(Segment + NewSize + 1);
471 NextMcb->BlockType = Mcb->BlockType;
472 NextMcb->Size = Mcb->Size - NewSize - 1;
473 NextMcb->OwnerPsp = 0;
474
475 /* Update the MCB */
476 Mcb->BlockType = 'M';
477 Mcb->Size = NewSize;
478 }
479
480 Done:
481 /* Check if the operation failed */
482 if (!Success)
483 {
484 DPRINT("DosResizeMemory FAILED. Maximum available: 0x%04X\n",
485 ReturnSize);
486
487 /* Return the maximum possible size */
488 if (MaxAvailable) *MaxAvailable = ReturnSize;
489 }
490
491 return Success;
492 }
493
494 BOOLEAN DosFreeMemory(WORD BlockData)
495 {
496 PDOS_MCB Mcb = SEGMENT_TO_MCB(BlockData - 1);
497
498 DPRINT("DosFreeMemory: BlockData 0x%04X\n", BlockData);
499
500 /* Make sure the MCB is valid */
501 if (Mcb->BlockType != 'M' && Mcb->BlockType != 'Z')
502 {
503 DPRINT("MCB block type '%c' not valid!\n", Mcb->BlockType);
504 return FALSE;
505 }
506
507 /* Mark the block as free */
508 Mcb->OwnerPsp = 0;
509
510 return TRUE;
511 }
512
513 BOOLEAN DosLinkUmb(VOID)
514 {
515 DWORD Segment = FIRST_MCB_SEGMENT;
516 PDOS_MCB Mcb = SEGMENT_TO_MCB(Segment);
517
518 DPRINT("Linking UMB\n");
519
520 /* Check if UMBs are already linked */
521 if (DosUmbLinked) return FALSE;
522
523 /* Find the last block */
524 while ((Mcb->BlockType == 'M') && (Segment <= 0xFFFF))
525 {
526 Segment += Mcb->Size + 1;
527 Mcb = SEGMENT_TO_MCB(Segment);
528 }
529
530 /* Make sure it's valid */
531 if (Mcb->BlockType != 'Z') return FALSE;
532
533 /* Connect the MCB with the UMB chain */
534 Mcb->BlockType = 'M';
535
536 DosUmbLinked = TRUE;
537 return TRUE;
538 }
539
540 BOOLEAN DosUnlinkUmb(VOID)
541 {
542 DWORD Segment = FIRST_MCB_SEGMENT;
543 PDOS_MCB Mcb = SEGMENT_TO_MCB(Segment);
544
545 DPRINT("Unlinking UMB\n");
546
547 /* Check if UMBs are already unlinked */
548 if (!DosUmbLinked) return FALSE;
549
550 /* Find the block preceding the MCB that links it with the UMB chain */
551 while (Segment <= 0xFFFF)
552 {
553 if ((Segment + Mcb->Size) == (FIRST_MCB_SEGMENT + USER_MEMORY_SIZE))
554 {
555 /* This is the last non-UMB segment */
556 break;
557 }
558
559 /* Advance to the next MCB */
560 Segment += Mcb->Size + 1;
561 Mcb = SEGMENT_TO_MCB(Segment);
562 }
563
564 /* Mark the MCB as the last MCB */
565 Mcb->BlockType = 'Z';
566
567 DosUmbLinked = FALSE;
568 return TRUE;
569 }
570
571 WORD DosCreateFile(LPWORD Handle, LPCSTR FilePath, WORD Attributes)
572 {
573 HANDLE FileHandle;
574 WORD DosHandle;
575
576 DPRINT("DosCreateFile: FilePath \"%s\", Attributes 0x%04X\n",
577 FilePath,
578 Attributes);
579
580 /* Create the file */
581 FileHandle = CreateFileA(FilePath,
582 GENERIC_READ | GENERIC_WRITE,
583 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
584 NULL,
585 CREATE_ALWAYS,
586 Attributes,
587 NULL);
588
589 if (FileHandle == INVALID_HANDLE_VALUE)
590 {
591 /* Return the error code */
592 return (WORD)GetLastError();
593 }
594
595 /* Open the DOS handle */
596 DosHandle = DosOpenHandle(FileHandle);
597
598 if (DosHandle == INVALID_DOS_HANDLE)
599 {
600 /* Close the handle */
601 CloseHandle(FileHandle);
602
603 /* Return the error code */
604 return ERROR_TOO_MANY_OPEN_FILES;
605 }
606
607 /* It was successful */
608 *Handle = DosHandle;
609 return ERROR_SUCCESS;
610 }
611
612 WORD DosOpenFile(LPWORD Handle, LPCSTR FilePath, BYTE AccessMode)
613 {
614 HANDLE FileHandle;
615 ACCESS_MASK Access = 0;
616 WORD DosHandle;
617
618 DPRINT("DosOpenFile: FilePath \"%s\", AccessMode 0x%04X\n",
619 FilePath,
620 AccessMode);
621
622 /* Parse the access mode */
623 switch (AccessMode & 3)
624 {
625 case 0:
626 {
627 /* Read-only */
628 Access = GENERIC_READ;
629 break;
630 }
631
632 case 1:
633 {
634 /* Write only */
635 Access = GENERIC_WRITE;
636 break;
637 }
638
639 case 2:
640 {
641 /* Read and write */
642 Access = GENERIC_READ | GENERIC_WRITE;
643 break;
644 }
645
646 default:
647 {
648 /* Invalid */
649 return ERROR_INVALID_PARAMETER;
650 }
651 }
652
653 /* Open the file */
654 FileHandle = CreateFileA(FilePath,
655 Access,
656 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
657 NULL,
658 OPEN_EXISTING,
659 FILE_ATTRIBUTE_NORMAL,
660 NULL);
661
662 if (FileHandle == INVALID_HANDLE_VALUE)
663 {
664 /* Return the error code */
665 return (WORD)GetLastError();
666 }
667
668 /* Open the DOS handle */
669 DosHandle = DosOpenHandle(FileHandle);
670
671 if (DosHandle == INVALID_DOS_HANDLE)
672 {
673 /* Close the handle */
674 CloseHandle(FileHandle);
675
676 /* Return the error code */
677 return ERROR_TOO_MANY_OPEN_FILES;
678 }
679
680 /* It was successful */
681 *Handle = DosHandle;
682 return ERROR_SUCCESS;
683 }
684
685 WORD DosReadFile(WORD FileHandle, LPVOID Buffer, WORD Count, LPWORD BytesRead)
686 {
687 WORD Result = ERROR_SUCCESS;
688 DWORD BytesRead32 = 0;
689 HANDLE Handle = DosGetRealHandle(FileHandle);
690
691 DPRINT("DosReadFile: FileHandle 0x%04X, Count 0x%04X\n", FileHandle, Count);
692
693 /* Make sure the handle is valid */
694 if (Handle == INVALID_HANDLE_VALUE) return ERROR_INVALID_HANDLE;
695
696 /* Read the file */
697 if (!ReadFile(Handle, Buffer, Count, &BytesRead32, NULL))
698 {
699 /* Store the error code */
700 Result = (WORD)GetLastError();
701 }
702
703 /* The number of bytes read is always 16-bit */
704 *BytesRead = LOWORD(BytesRead32);
705
706 /* Return the error code */
707 return Result;
708 }
709
710 WORD DosWriteFile(WORD FileHandle, LPVOID Buffer, WORD Count, LPWORD BytesWritten)
711 {
712 WORD Result = ERROR_SUCCESS;
713 DWORD BytesWritten32 = 0;
714 HANDLE Handle = DosGetRealHandle(FileHandle);
715 WORD i;
716
717 DPRINT("DosWriteFile: FileHandle 0x%04X, Count 0x%04X\n",
718 FileHandle,
719 Count);
720
721 /* Make sure the handle is valid */
722 if (Handle == INVALID_HANDLE_VALUE) return ERROR_INVALID_HANDLE;
723
724 if (IsConsoleHandle(Handle))
725 {
726 for (i = 0; i < Count; i++)
727 {
728 /* Call the BIOS to print the character */
729 BiosPrintCharacter(((LPBYTE)Buffer)[i], DOS_CHAR_ATTRIBUTE, Bda->VideoPage);
730 BytesWritten32++;
731 }
732 }
733 else
734 {
735 /* Write the file */
736 if (!WriteFile(Handle, Buffer, Count, &BytesWritten32, NULL))
737 {
738 /* Store the error code */
739 Result = (WORD)GetLastError();
740 }
741 }
742
743 /* The number of bytes written is always 16-bit */
744 *BytesWritten = LOWORD(BytesWritten32);
745
746 /* Return the error code */
747 return Result;
748 }
749
750 WORD DosSeekFile(WORD FileHandle, LONG Offset, BYTE Origin, LPDWORD NewOffset)
751 {
752 WORD Result = ERROR_SUCCESS;
753 DWORD FilePointer;
754 HANDLE Handle = DosGetRealHandle(FileHandle);
755
756 DPRINT("DosSeekFile: FileHandle 0x%04X, Offset 0x%08X, Origin 0x%02X\n",
757 FileHandle,
758 Offset,
759 Origin);
760
761 /* Make sure the handle is valid */
762 if (Handle == INVALID_HANDLE_VALUE) return ERROR_INVALID_HANDLE;
763
764 /* Check if the origin is valid */
765 if (Origin != FILE_BEGIN && Origin != FILE_CURRENT && Origin != FILE_END)
766 {
767 return ERROR_INVALID_FUNCTION;
768 }
769
770 /* Move the file pointer */
771 FilePointer = SetFilePointer(Handle, Offset, NULL, Origin);
772
773 /* Check if there's a possibility the operation failed */
774 if (FilePointer == INVALID_SET_FILE_POINTER)
775 {
776 /* Get the real error code */
777 Result = (WORD)GetLastError();
778 }
779
780 if (Result != ERROR_SUCCESS)
781 {
782 /* The operation did fail */
783 return Result;
784 }
785
786 /* Return the file pointer, if requested */
787 if (NewOffset) *NewOffset = FilePointer;
788
789 /* Return success */
790 return ERROR_SUCCESS;
791 }
792
793 BOOLEAN DosFlushFileBuffers(WORD FileHandle)
794 {
795 HANDLE Handle = DosGetRealHandle(FileHandle);
796
797 /* Make sure the handle is valid */
798 if (Handle == INVALID_HANDLE_VALUE) return FALSE;
799
800 /*
801 * No need to check whether the handle is a console handle since
802 * FlushFileBuffers() automatically does this check and calls
803 * FlushConsoleInputBuffer() for us.
804 */
805 // if (IsConsoleHandle(Handle))
806 // return (BOOLEAN)FlushConsoleInputBuffer(Handle);
807 // else
808 return (BOOLEAN)FlushFileBuffers(Handle);
809 }
810
811 BOOLEAN DosDuplicateHandle(WORD OldHandle, WORD NewHandle)
812 {
813 BYTE SftIndex;
814 PDOS_PSP PspBlock;
815 LPBYTE HandleTable;
816
817 DPRINT("DosDuplicateHandle: OldHandle 0x%04X, NewHandle 0x%04X\n",
818 OldHandle,
819 NewHandle);
820
821 /* The system PSP has no handle table */
822 if (CurrentPsp == SYSTEM_PSP) return FALSE;
823
824 /* Get a pointer to the handle table */
825 PspBlock = SEGMENT_TO_PSP(CurrentPsp);
826 HandleTable = (LPBYTE)FAR_POINTER(PspBlock->HandleTablePtr);
827
828 /* Make sure the old handle is open */
829 if (HandleTable[OldHandle] == 0xFF) return FALSE;
830
831 /* Check if the new handle is open */
832 if (HandleTable[NewHandle] != 0xFF)
833 {
834 /* Close it */
835 DosCloseHandle(NewHandle);
836 }
837
838 /* Increment the reference count of the SFT entry */
839 SftIndex = HandleTable[OldHandle];
840 DosSftRefCount[SftIndex]++;
841
842 /* Make the new handle point to that SFT entry */
843 HandleTable[NewHandle] = SftIndex;
844
845 /* Return success */
846 return TRUE;
847 }
848
849 BOOLEAN DosCloseHandle(WORD DosHandle)
850 {
851 BYTE SftIndex;
852 PDOS_PSP PspBlock;
853 LPBYTE HandleTable;
854
855 DPRINT("DosCloseHandle: DosHandle 0x%04X\n", DosHandle);
856
857 /* The system PSP has no handle table */
858 if (CurrentPsp == SYSTEM_PSP) return FALSE;
859
860 /* Get a pointer to the handle table */
861 PspBlock = SEGMENT_TO_PSP(CurrentPsp);
862 HandleTable = (LPBYTE)FAR_POINTER(PspBlock->HandleTablePtr);
863
864 /* Make sure the handle is open */
865 if (HandleTable[DosHandle] == 0xFF) return FALSE;
866
867 /* Decrement the reference count of the SFT entry */
868 SftIndex = HandleTable[DosHandle];
869 DosSftRefCount[SftIndex]--;
870
871 /* Check if the reference count fell to zero */
872 if (!DosSftRefCount[SftIndex])
873 {
874 /* Close the file, it's no longer needed */
875 CloseHandle(DosSystemFileTable[SftIndex]);
876
877 /* Clear the handle */
878 DosSystemFileTable[SftIndex] = INVALID_HANDLE_VALUE;
879 }
880
881 /* Clear the entry in the JFT */
882 HandleTable[DosHandle] = 0xFF;
883
884 return TRUE;
885 }
886
887 BOOLEAN DosChangeDrive(BYTE Drive)
888 {
889 WCHAR DirectoryPath[DOS_CMDLINE_LENGTH];
890
891 /* Make sure the drive exists */
892 if (Drive > (LastDrive - 'A')) return FALSE;
893
894 /* Find the path to the new current directory */
895 swprintf(DirectoryPath, L"%c\\%S", Drive + 'A', CurrentDirectories[Drive]);
896
897 /* Change the current directory of the process */
898 if (!SetCurrentDirectory(DirectoryPath)) return FALSE;
899
900 /* Set the current drive */
901 CurrentDrive = Drive;
902
903 /* Return success */
904 return TRUE;
905 }
906
907 BOOLEAN DosChangeDirectory(LPSTR Directory)
908 {
909 BYTE DriveNumber;
910 DWORD Attributes;
911 LPSTR Path;
912
913 /* Make sure the directory path is not too long */
914 if (strlen(Directory) >= DOS_DIR_LENGTH)
915 {
916 DosLastError = ERROR_PATH_NOT_FOUND;
917 return FALSE;
918 }
919
920 /* Get the drive number */
921 DriveNumber = Directory[0] - 'A';
922
923 /* Make sure the drive exists */
924 if (DriveNumber > (LastDrive - 'A'))
925 {
926 DosLastError = ERROR_PATH_NOT_FOUND;
927 return FALSE;
928 }
929
930 /* Get the file attributes */
931 Attributes = GetFileAttributesA(Directory);
932
933 /* Make sure the path exists and is a directory */
934 if ((Attributes == INVALID_FILE_ATTRIBUTES)
935 || !(Attributes & FILE_ATTRIBUTE_DIRECTORY))
936 {
937 DosLastError = ERROR_PATH_NOT_FOUND;
938 return FALSE;
939 }
940
941 /* Check if this is the current drive */
942 if (DriveNumber == CurrentDrive)
943 {
944 /* Change the directory */
945 if (!SetCurrentDirectoryA(Directory))
946 {
947 DosLastError = LOWORD(GetLastError());
948 return FALSE;
949 }
950 }
951
952 /* Get the directory part of the path */
953 Path = strchr(Directory, '\\');
954 if (Path != NULL)
955 {
956 /* Skip the backslash */
957 Path++;
958 }
959
960 /* Set the directory for the drive */
961 if (Path != NULL)
962 {
963 strncpy(CurrentDirectories[DriveNumber], Path, DOS_DIR_LENGTH);
964 }
965 else
966 {
967 CurrentDirectories[DriveNumber][0] = '\0';
968 }
969
970 /* Return success */
971 return TRUE;
972 }
973
974 VOID DosInitializePsp(WORD PspSegment, LPCSTR CommandLine, WORD ProgramSize, WORD Environment)
975 {
976 PDOS_PSP PspBlock = SEGMENT_TO_PSP(PspSegment);
977 LPDWORD IntVecTable = (LPDWORD)((ULONG_PTR)BaseAddress);
978
979 ZeroMemory(PspBlock, sizeof(DOS_PSP));
980
981 /* Set the exit interrupt */
982 PspBlock->Exit[0] = 0xCD; // int 0x20
983 PspBlock->Exit[1] = 0x20;
984
985 /* Set the number of the last paragraph */
986 PspBlock->LastParagraph = PspSegment + ProgramSize - 1;
987
988 /* Save the interrupt vectors */
989 PspBlock->TerminateAddress = IntVecTable[0x22];
990 PspBlock->BreakAddress = IntVecTable[0x23];
991 PspBlock->CriticalAddress = IntVecTable[0x24];
992
993 /* Set the parent PSP */
994 PspBlock->ParentPsp = CurrentPsp;
995
996 /* Copy the parent handle table */
997 DosCopyHandleTable(PspBlock->HandleTable);
998
999 /* Set the environment block */
1000 PspBlock->EnvBlock = Environment;
1001
1002 /* Set the handle table pointers to the internal handle table */
1003 PspBlock->HandleTableSize = 20;
1004 PspBlock->HandleTablePtr = MAKELONG(0x18, PspSegment);
1005
1006 /* Set the DOS version */
1007 PspBlock->DosVersion = DOS_VERSION;
1008
1009 /* Set the far call opcodes */
1010 PspBlock->FarCall[0] = 0xCD; // int 0x21
1011 PspBlock->FarCall[1] = 0x21;
1012 PspBlock->FarCall[2] = 0xCB; // retf
1013
1014 /* Set the command line */
1015 PspBlock->CommandLineSize = (BYTE)min(strlen(CommandLine), DOS_CMDLINE_LENGTH - 1);
1016 RtlCopyMemory(PspBlock->CommandLine, CommandLine, PspBlock->CommandLineSize);
1017 PspBlock->CommandLine[PspBlock->CommandLineSize] = '\r';
1018 }
1019
1020 BOOLEAN DosCreateProcess(LPCSTR CommandLine, WORD EnvBlock)
1021 {
1022 BOOLEAN Success = FALSE, AllocatedEnvBlock = FALSE;
1023 HANDLE FileHandle = INVALID_HANDLE_VALUE, FileMapping = NULL;
1024 LPBYTE Address = NULL;
1025 LPSTR ProgramFilePath, Parameters[256];
1026 CHAR CommandLineCopy[DOS_CMDLINE_LENGTH];
1027 INT ParamCount = 0;
1028 WORD Segment = 0;
1029 WORD MaxAllocSize;
1030 DWORD i, FileSize, ExeSize;
1031 PIMAGE_DOS_HEADER Header;
1032 PDWORD RelocationTable;
1033 PWORD RelocWord;
1034
1035 DPRINT("DosCreateProcess: CommandLine \"%s\", EnvBlock 0x%04X\n",
1036 CommandLine,
1037 EnvBlock);
1038
1039 /* Save a copy of the command line */
1040 strcpy(CommandLineCopy, CommandLine);
1041
1042 // FIXME: Improve parsing (especially: "some_path\with spaces\program.exe" options)
1043
1044 /* Get the file name of the executable */
1045 ProgramFilePath = strtok(CommandLineCopy, " \t");
1046
1047 /* Load the parameters in the local array */
1048 while ((ParamCount < sizeof(Parameters)/sizeof(Parameters[0]))
1049 && ((Parameters[ParamCount] = strtok(NULL, " \t")) != NULL))
1050 {
1051 ParamCount++;
1052 }
1053
1054 /* Open a handle to the executable */
1055 FileHandle = CreateFileA(ProgramFilePath,
1056 GENERIC_READ,
1057 0,
1058 NULL,
1059 OPEN_EXISTING,
1060 FILE_ATTRIBUTE_NORMAL,
1061 NULL);
1062 if (FileHandle == INVALID_HANDLE_VALUE) goto Cleanup;
1063
1064 /* Get the file size */
1065 FileSize = GetFileSize(FileHandle, NULL);
1066
1067 /* Create a mapping object for the file */
1068 FileMapping = CreateFileMapping(FileHandle,
1069 NULL,
1070 PAGE_READONLY,
1071 0,
1072 0,
1073 NULL);
1074 if (FileMapping == NULL) goto Cleanup;
1075
1076 /* Map the file into memory */
1077 Address = (LPBYTE)MapViewOfFile(FileMapping, FILE_MAP_READ, 0, 0, 0);
1078 if (Address == NULL) goto Cleanup;
1079
1080 /* Did we get an environment segment? */
1081 if (!EnvBlock)
1082 {
1083 /* Set a flag to know if the environment block was allocated here */
1084 AllocatedEnvBlock = TRUE;
1085
1086 /* No, copy the one from the parent */
1087 EnvBlock = DosCopyEnvironmentBlock((CurrentPsp != SYSTEM_PSP)
1088 ? SEGMENT_TO_PSP(CurrentPsp)->EnvBlock
1089 : SYSTEM_ENV_BLOCK,
1090 ProgramFilePath);
1091 }
1092
1093 /* Check if this is an EXE file or a COM file */
1094 if (Address[0] == 'M' && Address[1] == 'Z')
1095 {
1096 /* EXE file */
1097
1098 /* Get the MZ header */
1099 Header = (PIMAGE_DOS_HEADER)Address;
1100
1101 /* Get the base size of the file, in paragraphs (rounded up) */
1102 ExeSize = (((Header->e_cp - 1) * 512) + Header->e_cblp + 0x0F) >> 4;
1103
1104 /* Add the PSP size, in paragraphs */
1105 ExeSize += sizeof(DOS_PSP) >> 4;
1106
1107 /* Add the maximum size that should be allocated */
1108 ExeSize += Header->e_maxalloc;
1109
1110 /* Make sure it does not pass 0xFFFF */
1111 if (ExeSize > 0xFFFF) ExeSize = 0xFFFF;
1112
1113 /* Reduce the size one by one until the allocation is successful */
1114 for (i = Header->e_maxalloc; i >= Header->e_minalloc; i--, ExeSize--)
1115 {
1116 /* Try to allocate that much memory */
1117 Segment = DosAllocateMemory((WORD)ExeSize, NULL);
1118 if (Segment != 0) break;
1119 }
1120
1121 /* Check if at least the lowest allocation was successful */
1122 if (Segment == 0) goto Cleanup;
1123
1124 /* Initialize the PSP */
1125 DosInitializePsp(Segment,
1126 CommandLine,
1127 (WORD)ExeSize,
1128 EnvBlock);
1129
1130 /* The process owns its own memory */
1131 DosChangeMemoryOwner(Segment, Segment);
1132 DosChangeMemoryOwner(EnvBlock, Segment);
1133
1134 /* Copy the program to Segment:0100 */
1135 RtlCopyMemory(SEG_OFF_TO_PTR(Segment, 0x100),
1136 Address + (Header->e_cparhdr << 4),
1137 min(FileSize - (Header->e_cparhdr << 4),
1138 (ExeSize << 4) - sizeof(DOS_PSP)));
1139
1140 /* Get the relocation table */
1141 RelocationTable = (PDWORD)(Address + Header->e_lfarlc);
1142
1143 /* Perform relocations */
1144 for (i = 0; i < Header->e_crlc; i++)
1145 {
1146 /* Get a pointer to the word that needs to be patched */
1147 RelocWord = (PWORD)SEG_OFF_TO_PTR(Segment + HIWORD(RelocationTable[i]),
1148 0x100 + LOWORD(RelocationTable[i]));
1149
1150 /* Add the number of the EXE segment to it */
1151 *RelocWord += Segment + (sizeof(DOS_PSP) >> 4);
1152 }
1153
1154 /* Set the initial segment registers */
1155 setDS(Segment);
1156 setES(Segment);
1157
1158 /* Set the stack to the location from the header */
1159 EmulatorSetStack(Segment + (sizeof(DOS_PSP) >> 4) + Header->e_ss,
1160 Header->e_sp);
1161
1162 /* Execute */
1163 CurrentPsp = Segment;
1164 DiskTransferArea = MAKELONG(0x80, Segment);
1165 EmulatorExecute(Segment + Header->e_cs + (sizeof(DOS_PSP) >> 4),
1166 Header->e_ip);
1167
1168 Success = TRUE;
1169 }
1170 else
1171 {
1172 /* COM file */
1173
1174 /* Find the maximum amount of memory that can be allocated */
1175 DosAllocateMemory(0xFFFF, &MaxAllocSize);
1176
1177 /* Make sure it's enough for the whole program and the PSP */
1178 if (((DWORD)MaxAllocSize << 4) < (FileSize + sizeof(DOS_PSP))) goto Cleanup;
1179
1180 /* Allocate all of it */
1181 Segment = DosAllocateMemory(MaxAllocSize, NULL);
1182 if (Segment == 0) goto Cleanup;
1183
1184 /* The process owns its own memory */
1185 DosChangeMemoryOwner(Segment, Segment);
1186 DosChangeMemoryOwner(EnvBlock, Segment);
1187
1188 /* Copy the program to Segment:0100 */
1189 RtlCopyMemory(SEG_OFF_TO_PTR(Segment, 0x100),
1190 Address,
1191 FileSize);
1192
1193 /* Initialize the PSP */
1194 DosInitializePsp(Segment,
1195 CommandLine,
1196 (WORD)((FileSize + sizeof(DOS_PSP)) >> 4),
1197 EnvBlock);
1198
1199 /* Set the initial segment registers */
1200 setDS(Segment);
1201 setES(Segment);
1202
1203 /* Set the stack to the last word of the segment */
1204 EmulatorSetStack(Segment, 0xFFFE);
1205
1206 /* Execute */
1207 CurrentPsp = Segment;
1208 DiskTransferArea = MAKELONG(0x80, Segment);
1209 EmulatorExecute(Segment, 0x100);
1210
1211 Success = TRUE;
1212 }
1213
1214 Cleanup:
1215 if (!Success)
1216 {
1217 /* It was not successful, cleanup the DOS memory */
1218 if (AllocatedEnvBlock) DosFreeMemory(EnvBlock);
1219 if (Segment) DosFreeMemory(Segment);
1220 }
1221
1222 /* Unmap the file*/
1223 if (Address != NULL) UnmapViewOfFile(Address);
1224
1225 /* Close the file mapping object */
1226 if (FileMapping != NULL) CloseHandle(FileMapping);
1227
1228 /* Close the file handle */
1229 if (FileHandle != INVALID_HANDLE_VALUE) CloseHandle(FileHandle);
1230
1231 return Success;
1232 }
1233
1234 VOID DosTerminateProcess(WORD Psp, BYTE ReturnCode)
1235 {
1236 WORD i;
1237 WORD McbSegment = FIRST_MCB_SEGMENT;
1238 PDOS_MCB CurrentMcb;
1239 LPDWORD IntVecTable = (LPDWORD)((ULONG_PTR)BaseAddress);
1240 PDOS_PSP PspBlock = SEGMENT_TO_PSP(Psp);
1241
1242 DPRINT("DosTerminateProcess: Psp 0x%04X, ReturnCode 0x%02X\n",
1243 Psp,
1244 ReturnCode);
1245
1246 /* Check if this PSP is it's own parent */
1247 if (PspBlock->ParentPsp == Psp) goto Done;
1248
1249 for (i = 0; i < PspBlock->HandleTableSize; i++)
1250 {
1251 /* Close the handle */
1252 DosCloseHandle(i);
1253 }
1254
1255 /* Free the memory used by the process */
1256 while (TRUE)
1257 {
1258 /* Get a pointer to the MCB */
1259 CurrentMcb = SEGMENT_TO_MCB(McbSegment);
1260
1261 /* Make sure the MCB is valid */
1262 if (CurrentMcb->BlockType != 'M' && CurrentMcb->BlockType !='Z') break;
1263
1264 /* If this block was allocated by the process, free it */
1265 if (CurrentMcb->OwnerPsp == Psp) DosFreeMemory(McbSegment + 1);
1266
1267 /* If this was the last block, quit */
1268 if (CurrentMcb->BlockType == 'Z') break;
1269
1270 /* Update the segment and continue */
1271 McbSegment += CurrentMcb->Size + 1;
1272 }
1273
1274 Done:
1275 /* Restore the interrupt vectors */
1276 IntVecTable[0x22] = PspBlock->TerminateAddress;
1277 IntVecTable[0x23] = PspBlock->BreakAddress;
1278 IntVecTable[0x24] = PspBlock->CriticalAddress;
1279
1280 /* Update the current PSP */
1281 if (Psp == CurrentPsp)
1282 {
1283 CurrentPsp = PspBlock->ParentPsp;
1284 if (CurrentPsp == SYSTEM_PSP) VdmRunning = FALSE;
1285 }
1286
1287 /* Save the return code - Normal termination */
1288 DosErrorLevel = MAKEWORD(ReturnCode, 0x00);
1289
1290 /* Return control to the parent process */
1291 EmulatorExecute(HIWORD(PspBlock->TerminateAddress),
1292 LOWORD(PspBlock->TerminateAddress));
1293 }
1294
1295 CHAR DosReadCharacter(VOID)
1296 {
1297 CHAR Character = '\0';
1298 WORD BytesRead;
1299
1300 if (IsConsoleHandle(DosGetRealHandle(DOS_INPUT_HANDLE)))
1301 {
1302 /* Call the BIOS */
1303 Character = LOBYTE(BiosGetCharacter());
1304 }
1305 else
1306 {
1307 /* Use the file reading function */
1308 DosReadFile(DOS_INPUT_HANDLE, &Character, sizeof(CHAR), &BytesRead);
1309 }
1310
1311 return Character;
1312 }
1313
1314 BOOLEAN DosCheckInput(VOID)
1315 {
1316 HANDLE Handle = DosGetRealHandle(DOS_INPUT_HANDLE);
1317
1318 if (IsConsoleHandle(Handle))
1319 {
1320 /* Call the BIOS */
1321 return (BiosPeekCharacter() != 0xFFFF);
1322 }
1323 else
1324 {
1325 DWORD FileSizeHigh;
1326 DWORD FileSize = GetFileSize(Handle, &FileSizeHigh);
1327 LONG LocationHigh = 0;
1328 DWORD Location = SetFilePointer(Handle, 0, &LocationHigh, FILE_CURRENT);
1329
1330 return ((Location != FileSize) || (LocationHigh != FileSizeHigh));
1331 }
1332 }
1333
1334 VOID DosPrintCharacter(CHAR Character)
1335 {
1336 WORD BytesWritten;
1337
1338 /* Use the file writing function */
1339 DosWriteFile(DOS_OUTPUT_HANDLE, &Character, sizeof(CHAR), &BytesWritten);
1340 }
1341
1342 BOOLEAN DosHandleIoctl(BYTE ControlCode, WORD FileHandle)
1343 {
1344 HANDLE Handle = DosGetRealHandle(FileHandle);
1345
1346 if (Handle == INVALID_HANDLE_VALUE)
1347 {
1348 /* Doesn't exist */
1349 DosLastError = ERROR_FILE_NOT_FOUND;
1350 return FALSE;
1351 }
1352
1353 switch (ControlCode)
1354 {
1355 /* Get Device Information */
1356 case 0x00:
1357 {
1358 WORD InfoWord = 0;
1359
1360 if (Handle == DosSystemFileTable[0])
1361 {
1362 /* Console input */
1363 InfoWord |= 1 << 0;
1364 }
1365 else if (Handle == DosSystemFileTable[1])
1366 {
1367 /* Console output */
1368 InfoWord |= 1 << 1;
1369 }
1370
1371 /* It is a character device */
1372 InfoWord |= 1 << 7;
1373
1374 /* Return the device information word */
1375 setDX(InfoWord);
1376 return TRUE;
1377 }
1378
1379 /* Unsupported control code */
1380 default:
1381 {
1382 DPRINT1("Unsupported IOCTL: 0x%02X\n", ControlCode);
1383
1384 DosLastError = ERROR_INVALID_PARAMETER;
1385 return FALSE;
1386 }
1387 }
1388 }
1389
1390 VOID DosInt20h(LPWORD Stack)
1391 {
1392 /* This is the exit interrupt */
1393 DosTerminateProcess(Stack[STACK_CS], 0);
1394 }
1395
1396 VOID DosInt21h(LPWORD Stack)
1397 {
1398 BYTE Character;
1399 SYSTEMTIME SystemTime;
1400 PCHAR String;
1401 PDOS_INPUT_BUFFER InputBuffer;
1402
1403 /* Check the value in the AH register */
1404 switch (getAH())
1405 {
1406 /* Terminate Program */
1407 case 0x00:
1408 {
1409 DosTerminateProcess(Stack[STACK_CS], 0);
1410 break;
1411 }
1412
1413 /* Read Character from STDIN with Echo */
1414 case 0x01:
1415 {
1416 Character = DosReadCharacter();
1417 DosPrintCharacter(Character);
1418
1419 /* Let the BOP repeat if needed */
1420 if (getCF()) break;
1421
1422 setAL(Character);
1423 break;
1424 }
1425
1426 /* Write Character to STDOUT */
1427 case 0x02:
1428 {
1429 Character = getDL();
1430 DosPrintCharacter(Character);
1431
1432 /*
1433 * We return the output character (DOS 2.1+).
1434 * Also, if we're going to output a TAB, then
1435 * don't return a TAB but a SPACE instead.
1436 * See Ralf Brown: http://www.ctyme.com/intr/rb-2554.htm
1437 * for more information.
1438 */
1439 setAL(Character == '\t' ? ' ' : Character);
1440 break;
1441 }
1442
1443 /* Read Character from STDAUX */
1444 case 0x03:
1445 {
1446 // FIXME: Really read it from STDAUX!
1447 DPRINT1("INT 16h, 03h: Read character from STDAUX is HALFPLEMENTED\n");
1448 setAL(DosReadCharacter());
1449 break;
1450 }
1451
1452 /* Write Character to STDAUX */
1453 case 0x04:
1454 {
1455 // FIXME: Really write it to STDAUX!
1456 DPRINT1("INT 16h, 04h: Write character to STDAUX is HALFPLEMENTED\n");
1457 DosPrintCharacter(getDL());
1458 break;
1459 }
1460
1461 /* Write Character to Printer */
1462 case 0x05:
1463 {
1464 // FIXME: Really write it to printer!
1465 DPRINT1("INT 16h, 05h: Write character to printer is HALFPLEMENTED -\n\n");
1466 DPRINT1("0x%p\n", getDL());
1467 DPRINT1("\n\n-----------\n\n");
1468 break;
1469 }
1470
1471 /* Direct Console I/O */
1472 case 0x06:
1473 {
1474 Character = getDL();
1475
1476 if (Character != 0xFF)
1477 {
1478 /* Output */
1479 DosPrintCharacter(Character);
1480
1481 /*
1482 * We return the output character (DOS 2.1+).
1483 * See Ralf Brown: http://www.ctyme.com/intr/rb-2558.htm
1484 * for more information.
1485 */
1486 setAL(Character);
1487 }
1488 else
1489 {
1490 /* Input */
1491 if (DosCheckInput())
1492 {
1493 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_ZF;
1494 setAL(DosReadCharacter());
1495 }
1496 else
1497 {
1498 /* No character available */
1499 Stack[STACK_FLAGS] |= EMULATOR_FLAG_ZF;
1500 setAL(0x00);
1501 }
1502 }
1503
1504 break;
1505 }
1506
1507 /* Character Input without Echo */
1508 case 0x07:
1509 case 0x08:
1510 {
1511 Character = DosReadCharacter();
1512
1513 /* Let the BOP repeat if needed */
1514 if (getCF()) break;
1515
1516 setAL(Character);
1517 break;
1518 }
1519
1520 /* Write string to STDOUT */
1521 case 0x09:
1522 {
1523 String = (PCHAR)SEG_OFF_TO_PTR(getDS(), getDX());
1524
1525 while (*String != '$')
1526 {
1527 DosPrintCharacter(*String);
1528 String++;
1529 }
1530
1531 /*
1532 * We return the terminating character (DOS 2.1+).
1533 * See Ralf Brown: http://www.ctyme.com/intr/rb-2562.htm
1534 * for more information.
1535 */
1536 setAL('$');
1537 break;
1538 }
1539
1540 /* Read Buffered Input */
1541 case 0x0A:
1542 {
1543 InputBuffer = (PDOS_INPUT_BUFFER)SEG_OFF_TO_PTR(getDS(), getDX());
1544
1545 while (Stack[STACK_COUNTER] < InputBuffer->MaxLength)
1546 {
1547 /* Try to read a character */
1548 Character = DosReadCharacter();
1549
1550 /* If it's not ready yet, let the BOP repeat */
1551 if (getCF()) break;
1552
1553 /* Echo the character and append it to the buffer */
1554 DosPrintCharacter(Character);
1555 InputBuffer->Buffer[Stack[STACK_COUNTER]] = Character;
1556
1557 if (Character == '\r') break;
1558 Stack[STACK_COUNTER]++;
1559 }
1560
1561 /* Update the length */
1562 InputBuffer->Length = Stack[STACK_COUNTER];
1563 break;
1564 }
1565
1566 /* Get STDIN Status */
1567 case 0x0B:
1568 {
1569 setAL(DosCheckInput() ? 0xFF : 0x00);
1570 break;
1571 }
1572
1573 /* Flush Buffer and Read STDIN */
1574 case 0x0C:
1575 {
1576 BYTE InputFunction = getAL();
1577
1578 /* Flush STDIN buffer */
1579 DosFlushFileBuffers(DOS_INPUT_HANDLE); // Maybe just create a DosFlushInputBuffer...
1580
1581 /*
1582 * If the input function number contained in AL is valid, i.e.
1583 * AL == 0x01 or 0x06 or 0x07 or 0x08 or 0x0A, call ourselves
1584 * recursively with AL == AH.
1585 */
1586 if (InputFunction == 0x01 || InputFunction == 0x06 ||
1587 InputFunction == 0x07 || InputFunction == 0x08 ||
1588 InputFunction == 0x0A)
1589 {
1590 setAH(InputFunction);
1591 /*
1592 * Instead of calling ourselves really recursively as in:
1593 * DosInt21h(Stack);
1594 * prefer resetting the CF flag to let the BOP repeat.
1595 */
1596 setCF(1);
1597 }
1598 break;
1599 }
1600
1601 /* Disk Reset */
1602 case 0x0D:
1603 {
1604 PDOS_PSP PspBlock = SEGMENT_TO_PSP(CurrentPsp);
1605
1606 // TODO: Flush what's needed.
1607 DPRINT1("INT 21h, 0Dh is UNIMPLEMENTED\n");
1608
1609 /* Clear CF in DOS 6 only */
1610 if (PspBlock->DosVersion == 0x0006)
1611 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
1612
1613 break;
1614 }
1615
1616 /* Set Default Drive */
1617 case 0x0E:
1618 {
1619 DosChangeDrive(getDL());
1620 setAL(LastDrive - 'A' + 1);
1621 break;
1622 }
1623
1624 /* NULL Function for CP/M Compatibility */
1625 case 0x18:
1626 {
1627 /*
1628 * This function corresponds to the CP/M BDOS function
1629 * "get bit map of logged drives", which is meaningless
1630 * under MS-DOS.
1631 *
1632 * For: PTS-DOS 6.51 & S/DOS 1.0 - EXTENDED RENAME FILE USING FCB
1633 * See Ralf Brown: http://www.ctyme.com/intr/rb-2584.htm
1634 * for more information.
1635 */
1636 setAL(0x00);
1637 break;
1638 }
1639
1640 /* Get Default Drive */
1641 case 0x19:
1642 {
1643 setAL(CurrentDrive);
1644 break;
1645 }
1646
1647 /* Set Disk Transfer Area */
1648 case 0x1A:
1649 {
1650 DiskTransferArea = MAKELONG(getDX(), getDS());
1651 break;
1652 }
1653
1654 /* NULL Function for CP/M Compatibility */
1655 case 0x1D:
1656 case 0x1E:
1657 {
1658 /*
1659 * Function 0x1D corresponds to the CP/M BDOS function
1660 * "get bit map of read-only drives", which is meaningless
1661 * under MS-DOS.
1662 * See Ralf Brown: http://www.ctyme.com/intr/rb-2592.htm
1663 * for more information.
1664 *
1665 * Function 0x1E corresponds to the CP/M BDOS function
1666 * "set file attributes", which was meaningless under MS-DOS 1.x.
1667 * See Ralf Brown: http://www.ctyme.com/intr/rb-2593.htm
1668 * for more information.
1669 */
1670 setAL(0x00);
1671 break;
1672 }
1673
1674 /* NULL Function for CP/M Compatibility */
1675 case 0x20:
1676 {
1677 /*
1678 * This function corresponds to the CP/M BDOS function
1679 * "get/set default user (sublibrary) number", which is meaningless
1680 * under MS-DOS.
1681 *
1682 * For: S/DOS 1.0+ & PTS-DOS 6.51+ - GET OEM REVISION
1683 * See Ralf Brown: http://www.ctyme.com/intr/rb-2596.htm
1684 * for more information.
1685 */
1686 setAL(0x00);
1687 break;
1688 }
1689
1690 /* Set Interrupt Vector */
1691 case 0x25:
1692 {
1693 DWORD FarPointer = MAKELONG(getDX(), getDS());
1694
1695 /* Write the new far pointer to the IDT */
1696 ((PDWORD)BaseAddress)[getAL()] = FarPointer;
1697 break;
1698 }
1699
1700 /* Create New PSP */
1701 case 0x26:
1702 {
1703 DPRINT1("INT 21h, 26h - Create New PSP is UNIMPLEMENTED\n");
1704 break;
1705 }
1706
1707 /* Get System Date */
1708 case 0x2A:
1709 {
1710 GetLocalTime(&SystemTime);
1711 setCX(SystemTime.wYear);
1712 setDX(MAKEWORD(SystemTime.wDay, SystemTime.wMonth));
1713 setAL(SystemTime.wDayOfWeek);
1714 break;
1715 }
1716
1717 /* Set System Date */
1718 case 0x2B:
1719 {
1720 GetLocalTime(&SystemTime);
1721 SystemTime.wYear = getCX();
1722 SystemTime.wMonth = getDH();
1723 SystemTime.wDay = getDL();
1724
1725 /* Return success or failure */
1726 setAL(SetLocalTime(&SystemTime) ? 0x00 : 0xFF);
1727 break;
1728 }
1729
1730 /* Get System Time */
1731 case 0x2C:
1732 {
1733 GetLocalTime(&SystemTime);
1734 setCX(MAKEWORD(SystemTime.wMinute, SystemTime.wHour));
1735 setDX(MAKEWORD(SystemTime.wMilliseconds / 10, SystemTime.wSecond));
1736 break;
1737 }
1738
1739 /* Set System Time */
1740 case 0x2D:
1741 {
1742 GetLocalTime(&SystemTime);
1743 SystemTime.wHour = getCH();
1744 SystemTime.wMinute = getCL();
1745 SystemTime.wSecond = getDH();
1746 SystemTime.wMilliseconds = getDL() * 10; // In hundredths of seconds
1747
1748 /* Return success or failure */
1749 setAL(SetLocalTime(&SystemTime) ? 0x00 : 0xFF);
1750 break;
1751 }
1752
1753 /* Get Disk Transfer Area */
1754 case 0x2F:
1755 {
1756 setES(HIWORD(DiskTransferArea));
1757 setBX(LOWORD(DiskTransferArea));
1758 break;
1759 }
1760
1761 /* Get DOS Version */
1762 case 0x30:
1763 {
1764 PDOS_PSP PspBlock = SEGMENT_TO_PSP(CurrentPsp);
1765
1766 /*
1767 * See Ralf Brown: http://www.ctyme.com/intr/rb-2711.htm
1768 * for more information.
1769 */
1770
1771 if (LOBYTE(PspBlock->DosVersion) < 5 || getAL() == 0x00)
1772 {
1773 /*
1774 * Return DOS OEM number:
1775 * 0x00 for IBM PC-DOS
1776 * 0x02 for packaged MS-DOS
1777 */
1778 setBH(0x02);
1779 }
1780
1781 if (LOBYTE(PspBlock->DosVersion) >= 5 && getAL() == 0x01)
1782 {
1783 /*
1784 * Return version flag:
1785 * 1 << 3 if DOS is in ROM,
1786 * 0 (reserved) if not.
1787 */
1788 setBH(0x00);
1789 }
1790
1791 /* Return DOS 24-bit user serial number in BL:CX */
1792 setBL(0x00);
1793 setCX(0x0000);
1794
1795 /* Return DOS version: Minor:Major in AH:AL */
1796 setAX(PspBlock->DosVersion);
1797
1798 break;
1799 }
1800
1801 /* Get Interrupt Vector */
1802 case 0x35:
1803 {
1804 DWORD FarPointer = ((PDWORD)BaseAddress)[getAL()];
1805
1806 /* Read the address from the IDT into ES:BX */
1807 setES(HIWORD(FarPointer));
1808 setBX(LOWORD(FarPointer));
1809 break;
1810 }
1811
1812 /* SWITCH character - AVAILDEV */
1813 case 0x37:
1814 {
1815 if (getAL() == 0x00)
1816 {
1817 /*
1818 * DOS 2+ - "SWITCHAR" - GET SWITCH CHARACTER
1819 * This setting is ignored by MS-DOS 4.0+.
1820 * MS-DOS 5+ always return AL=00h/DL=2Fh.
1821 * See Ralf Brown: http://www.ctyme.com/intr/rb-2752.htm
1822 * for more information.
1823 */
1824 setDL('/');
1825 setAL(0x00);
1826 }
1827 else if (getAL() == 0x01)
1828 {
1829 /*
1830 * DOS 2+ - "SWITCHAR" - SET SWITCH CHARACTER
1831 * This setting is ignored by MS-DOS 5+.
1832 * See Ralf Brown: http://www.ctyme.com/intr/rb-2753.htm
1833 * for more information.
1834 */
1835 // getDL();
1836 setAL(0xFF);
1837 }
1838 else if (getAL() == 0x02)
1839 {
1840 /*
1841 * DOS 2.x and 3.3+ only - "AVAILDEV" - SPECIFY \DEV\ PREFIX USE
1842 * See Ralf Brown: http://www.ctyme.com/intr/rb-2754.htm
1843 * for more information.
1844 */
1845 // setDL();
1846 setAL(0xFF);
1847 }
1848 else if (getAL() == 0x03)
1849 {
1850 /*
1851 * DOS 2.x and 3.3+ only - "AVAILDEV" - SPECIFY \DEV\ PREFIX USE
1852 * See Ralf Brown: http://www.ctyme.com/intr/rb-2754.htm
1853 * for more information.
1854 */
1855 // getDL();
1856 setAL(0xFF);
1857 }
1858 else
1859 {
1860 setAL(0xFF);
1861 }
1862
1863 break;
1864 }
1865
1866 /* Create Directory */
1867 case 0x39:
1868 {
1869 String = (PCHAR)SEG_OFF_TO_PTR(getDS(), getDX());
1870
1871 if (CreateDirectoryA(String, NULL))
1872 {
1873 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
1874 }
1875 else
1876 {
1877 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
1878 setAX(LOWORD(GetLastError()));
1879 }
1880
1881 break;
1882 }
1883
1884 /* Remove Directory */
1885 case 0x3A:
1886 {
1887 String = (PCHAR)SEG_OFF_TO_PTR(getDS(), getDX());
1888
1889 if (RemoveDirectoryA(String))
1890 {
1891 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
1892 }
1893 else
1894 {
1895 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
1896 setAX(LOWORD(GetLastError()));
1897 }
1898
1899 break;
1900 }
1901
1902 /* Set Current Directory */
1903 case 0x3B:
1904 {
1905 String = (PCHAR)SEG_OFF_TO_PTR(getDS(), getDX());
1906
1907 if (DosChangeDirectory(String))
1908 {
1909 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
1910 }
1911 else
1912 {
1913 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
1914 setAX(DosLastError);
1915 }
1916
1917 break;
1918 }
1919
1920 /* Create File */
1921 case 0x3C:
1922 {
1923 WORD FileHandle;
1924 WORD ErrorCode = DosCreateFile(&FileHandle,
1925 (LPCSTR)SEG_OFF_TO_PTR(getDS(), getDX()),
1926 getCX());
1927
1928 if (ErrorCode == 0)
1929 {
1930 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
1931 setAX(FileHandle);
1932 }
1933 else
1934 {
1935 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
1936 setAX(ErrorCode);
1937 }
1938
1939 break;
1940 }
1941
1942 /* Open File */
1943 case 0x3D:
1944 {
1945 WORD FileHandle;
1946 WORD ErrorCode = DosOpenFile(&FileHandle,
1947 (LPCSTR)SEG_OFF_TO_PTR(getDS(), getDX()),
1948 getAL());
1949
1950 if (ErrorCode == 0)
1951 {
1952 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
1953 setAX(FileHandle);
1954 }
1955 else
1956 {
1957 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
1958 setAX(ErrorCode);
1959 }
1960
1961 break;
1962 }
1963
1964 /* Close File */
1965 case 0x3E:
1966 {
1967 if (DosCloseHandle(getBX()))
1968 {
1969 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
1970 }
1971 else
1972 {
1973 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
1974 setAX(ERROR_INVALID_HANDLE);
1975 }
1976
1977 break;
1978 }
1979
1980 /* Read from File or Device */
1981 case 0x3F:
1982 {
1983 WORD Handle = getBX();
1984 LPBYTE Buffer = (LPBYTE)SEG_OFF_TO_PTR(getDS(), getDX());
1985 WORD Count = getCX();
1986 WORD BytesRead = 0;
1987 WORD ErrorCode = ERROR_SUCCESS;
1988
1989 if (IsConsoleHandle(DosGetRealHandle(Handle)))
1990 {
1991 while (Stack[STACK_COUNTER] < Count)
1992 {
1993 /* Read a character from the BIOS */
1994 // FIXME: Security checks!
1995 Buffer[Stack[STACK_COUNTER]] = LOBYTE(BiosGetCharacter());
1996
1997 /* Stop if the BOP needs to be repeated */
1998 if (getCF()) break;
1999
2000 /* Increment the counter */
2001 Stack[STACK_COUNTER]++;
2002 }
2003
2004 if (Stack[STACK_COUNTER] < Count)
2005 ErrorCode = ERROR_NOT_READY;
2006 else
2007 BytesRead = Count;
2008 }
2009 else
2010 {
2011 /* Use the file reading function */
2012 ErrorCode = DosReadFile(Handle, Buffer, Count, &BytesRead);
2013 }
2014
2015 if (ErrorCode == ERROR_SUCCESS)
2016 {
2017 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2018 setAX(BytesRead);
2019 }
2020 else if (ErrorCode != ERROR_NOT_READY)
2021 {
2022 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2023 setAX(ErrorCode);
2024 }
2025 break;
2026 }
2027
2028 /* Write to File or Device */
2029 case 0x40:
2030 {
2031 WORD BytesWritten = 0;
2032 WORD ErrorCode = DosWriteFile(getBX(),
2033 SEG_OFF_TO_PTR(getDS(), getDX()),
2034 getCX(),
2035 &BytesWritten);
2036
2037 if (ErrorCode == ERROR_SUCCESS)
2038 {
2039 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2040 setAX(BytesWritten);
2041 }
2042 else
2043 {
2044 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2045 setAX(ErrorCode);
2046 }
2047
2048 break;
2049 }
2050
2051 /* Delete File */
2052 case 0x41:
2053 {
2054 LPSTR FileName = (LPSTR)SEG_OFF_TO_PTR(getDS(), getDX());
2055
2056 /* Call the API function */
2057 if (DeleteFileA(FileName))
2058 {
2059 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2060 /*
2061 * See Ralf Brown: http://www.ctyme.com/intr/rb-2797.htm
2062 * "AX destroyed (DOS 3.3) AL seems to be drive of deleted file."
2063 */
2064 setAL(FileName[0] - 'A');
2065 }
2066 else
2067 {
2068 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2069 setAX(GetLastError());
2070 }
2071
2072 break;
2073 }
2074
2075 /* Seek File */
2076 case 0x42:
2077 {
2078 DWORD NewLocation;
2079 WORD ErrorCode = DosSeekFile(getBX(),
2080 MAKELONG(getDX(), getCX()),
2081 getAL(),
2082 &NewLocation);
2083
2084 if (ErrorCode == ERROR_SUCCESS)
2085 {
2086 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2087
2088 /* Return the new offset in DX:AX */
2089 setDX(HIWORD(NewLocation));
2090 setAX(LOWORD(NewLocation));
2091 }
2092 else
2093 {
2094 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2095 setAX(ErrorCode);
2096 }
2097
2098 break;
2099 }
2100
2101 /* Get/Set File Attributes */
2102 case 0x43:
2103 {
2104 DWORD Attributes;
2105 LPSTR FileName = (LPSTR)SEG_OFF_TO_PTR(getDS(), getDX());
2106
2107 if (getAL() == 0x00)
2108 {
2109 /* Get the attributes */
2110 Attributes = GetFileAttributesA(FileName);
2111
2112 /* Check if it failed */
2113 if (Attributes == INVALID_FILE_ATTRIBUTES)
2114 {
2115 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2116 setAX(GetLastError());
2117 }
2118 else
2119 {
2120 /* Return the attributes that DOS can understand */
2121 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2122 setCX(Attributes & 0x00FF);
2123 }
2124 }
2125 else if (getAL() == 0x01)
2126 {
2127 /* Try to set the attributes */
2128 if (SetFileAttributesA(FileName, getCL()))
2129 {
2130 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2131 }
2132 else
2133 {
2134 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2135 setAX(GetLastError());
2136 }
2137 }
2138 else
2139 {
2140 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2141 setAX(ERROR_INVALID_FUNCTION);
2142 }
2143
2144 break;
2145 }
2146
2147 /* IOCTL */
2148 case 0x44:
2149 {
2150 if (DosHandleIoctl(getAL(), getBX()))
2151 {
2152 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2153 }
2154 else
2155 {
2156 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2157 setAX(DosLastError);
2158 }
2159
2160 break;
2161 }
2162
2163 /* Duplicate Handle */
2164 case 0x45:
2165 {
2166 WORD NewHandle;
2167 HANDLE Handle = DosGetRealHandle(getBX());
2168
2169 if (Handle != INVALID_HANDLE_VALUE)
2170 {
2171 /* The handle is invalid */
2172 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2173 setAX(ERROR_INVALID_HANDLE);
2174 break;
2175 }
2176
2177 /* Open a new handle to the same entry */
2178 NewHandle = DosOpenHandle(Handle);
2179
2180 if (NewHandle == INVALID_DOS_HANDLE)
2181 {
2182 /* Too many files open */
2183 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2184 setAX(ERROR_TOO_MANY_OPEN_FILES);
2185 break;
2186 }
2187
2188 /* Return the result */
2189 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2190 setAX(NewHandle);
2191 break;
2192 }
2193
2194 /* Force Duplicate Handle */
2195 case 0x46:
2196 {
2197 if (DosDuplicateHandle(getBX(), getCX()))
2198 {
2199 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2200 }
2201 else
2202 {
2203 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2204 setAX(ERROR_INVALID_HANDLE);
2205 }
2206
2207 break;
2208 }
2209
2210 /* Get Current Directory */
2211 case 0x47:
2212 {
2213 BYTE DriveNumber = getDL();
2214 String = (PCHAR)SEG_OFF_TO_PTR(getDS(), getSI());
2215
2216 /* Get the real drive number */
2217 if (DriveNumber == 0)
2218 {
2219 DriveNumber = CurrentDrive;
2220 }
2221 else
2222 {
2223 /* Decrement DriveNumber since it was 1-based */
2224 DriveNumber--;
2225 }
2226
2227 if (DriveNumber <= LastDrive - 'A')
2228 {
2229 /*
2230 * Copy the current directory into the target buffer.
2231 * It doesn't contain the drive letter and the backslash.
2232 */
2233 strncpy(String, CurrentDirectories[DriveNumber], DOS_DIR_LENGTH);
2234 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2235 setAX(0x0100); // Undocumented, see Ralf Brown: http://www.ctyme.com/intr/rb-2933.htm
2236 }
2237 else
2238 {
2239 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2240 setAX(ERROR_INVALID_DRIVE);
2241 }
2242
2243 break;
2244 }
2245
2246 /* Allocate Memory */
2247 case 0x48:
2248 {
2249 WORD MaxAvailable = 0;
2250 WORD Segment = DosAllocateMemory(getBX(), &MaxAvailable);
2251
2252 if (Segment != 0)
2253 {
2254 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2255 setAX(Segment);
2256 }
2257 else
2258 {
2259 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2260 setAX(DosLastError);
2261 setBX(MaxAvailable);
2262 }
2263
2264 break;
2265 }
2266
2267 /* Free Memory */
2268 case 0x49:
2269 {
2270 if (DosFreeMemory(getES()))
2271 {
2272 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2273 }
2274 else
2275 {
2276 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2277 setAX(ERROR_ARENA_TRASHED);
2278 }
2279
2280 break;
2281 }
2282
2283 /* Resize Memory Block */
2284 case 0x4A:
2285 {
2286 WORD Size;
2287
2288 if (DosResizeMemory(getES(), getBX(), &Size))
2289 {
2290 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2291 }
2292 else
2293 {
2294 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2295 setAX(DosLastError);
2296 setBX(Size);
2297 }
2298
2299 break;
2300 }
2301
2302 /* Terminate With Return Code */
2303 case 0x4C:
2304 {
2305 DosTerminateProcess(CurrentPsp, getAL());
2306 break;
2307 }
2308
2309 /* Get Return Code (ERRORLEVEL) */
2310 case 0x4D:
2311 {
2312 /*
2313 * According to Ralf Brown: http://www.ctyme.com/intr/rb-2976.htm
2314 * DosErrorLevel is cleared after being read by this function.
2315 */
2316 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2317 setAX(DosErrorLevel);
2318 DosErrorLevel = 0x0000; // Clear it
2319 break;
2320 }
2321
2322 /* Internal - Set Current Process ID (Set PSP Address) */
2323 case 0x50:
2324 {
2325 // FIXME: Is it really what it's done ??
2326 CurrentPsp = getBX();
2327 break;
2328 }
2329
2330 /* Get Current Process ID (Get PSP Address) */
2331 case 0x51:
2332 {
2333 setBX(CurrentPsp);
2334 break;
2335 }
2336
2337 /* Get/Set Memory Management Options */
2338 case 0x58:
2339 {
2340 if (getAL() == 0x00)
2341 {
2342 /* Get allocation strategy */
2343 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2344 setAX(DosAllocStrategy);
2345 }
2346 else if (getAL() == 0x01)
2347 {
2348 /* Set allocation strategy */
2349
2350 if ((getBL() & (DOS_ALLOC_HIGH | DOS_ALLOC_HIGH_LOW))
2351 == (DOS_ALLOC_HIGH | DOS_ALLOC_HIGH_LOW))
2352 {
2353 /* Can't set both */
2354 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2355 setAX(ERROR_INVALID_PARAMETER);
2356 break;
2357 }
2358
2359 if ((getBL() & 0x3F) > DOS_ALLOC_LAST_FIT)
2360 {
2361 /* Invalid allocation strategy */
2362 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2363 setAX(ERROR_INVALID_PARAMETER);
2364 break;
2365 }
2366
2367 DosAllocStrategy = getBL();
2368 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2369 }
2370 else if (getAL() == 0x02)
2371 {
2372 /* Get UMB link state */
2373 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2374 setAL(DosUmbLinked ? 0x01 : 0x00);
2375 }
2376 else if (getAL() == 0x03)
2377 {
2378 /* Set UMB link state */
2379 if (getBX()) DosLinkUmb();
2380 else DosUnlinkUmb();
2381 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2382 }
2383 else
2384 {
2385 /* Invalid or unsupported function */
2386 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2387 setAX(ERROR_INVALID_FUNCTION);
2388 }
2389
2390 break;
2391 }
2392
2393 /* Unsupported */
2394 default:
2395 {
2396 DPRINT1("DOS Function INT 0x21, AH = 0x%02X NOT IMPLEMENTED!\n", getAH());
2397 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2398 }
2399 }
2400 }
2401
2402 VOID DosBreakInterrupt(LPWORD Stack)
2403 {
2404 UNREFERENCED_PARAMETER(Stack);
2405
2406 VdmRunning = FALSE;
2407 }
2408
2409 BOOLEAN DosInitialize(VOID)
2410 {
2411 BYTE i;
2412 PDOS_MCB Mcb = SEGMENT_TO_MCB(FIRST_MCB_SEGMENT);
2413 FILE *Stream;
2414 WCHAR Buffer[256];
2415 LPWSTR SourcePtr, Environment;
2416 LPSTR AsciiString;
2417 LPSTR DestPtr = (LPSTR)SEG_OFF_TO_PTR(SYSTEM_ENV_BLOCK, 0);
2418 DWORD AsciiSize;
2419 CHAR CurrentDirectory[MAX_PATH];
2420 CHAR DosDirectory[DOS_DIR_LENGTH];
2421 LPSTR Path;
2422
2423 /* Initialize the MCB */
2424 Mcb->BlockType = 'Z';
2425 Mcb->Size = USER_MEMORY_SIZE;
2426 Mcb->OwnerPsp = 0;
2427
2428 /* Initialize the link MCB to the UMB area */
2429 Mcb = SEGMENT_TO_MCB(FIRST_MCB_SEGMENT + USER_MEMORY_SIZE + 1);
2430 Mcb->BlockType = 'M';
2431 Mcb->Size = UMB_START_SEGMENT - FIRST_MCB_SEGMENT - USER_MEMORY_SIZE - 2;
2432 Mcb->OwnerPsp = SYSTEM_PSP;
2433
2434 /* Initialize the UMB area */
2435 Mcb = SEGMENT_TO_MCB(UMB_START_SEGMENT);
2436 Mcb->BlockType = 'Z';
2437 Mcb->Size = UMB_END_SEGMENT - UMB_START_SEGMENT;
2438 Mcb->OwnerPsp = 0;
2439
2440 /* Get the environment strings */
2441 SourcePtr = Environment = GetEnvironmentStringsW();
2442 if (Environment == NULL) return FALSE;
2443
2444 /* Fill the DOS system environment block */
2445 while (*SourcePtr)
2446 {
2447 /* Get the size of the ASCII string */
2448 AsciiSize = WideCharToMultiByte(CP_ACP,
2449 0,
2450 SourcePtr,
2451 -1,
2452 NULL,
2453 0,
2454 NULL,
2455 NULL);
2456
2457 /* Allocate memory for the ASCII string */
2458 AsciiString = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, AsciiSize);
2459 if (AsciiString == NULL)
2460 {
2461 FreeEnvironmentStringsW(Environment);
2462 return FALSE;
2463 }
2464
2465 /* Convert to ASCII */
2466 WideCharToMultiByte(CP_ACP,
2467 0,
2468 SourcePtr,
2469 -1,
2470 AsciiString,
2471 AsciiSize,
2472 NULL,
2473 NULL);
2474
2475 /* Copy the string into DOS memory */
2476 strcpy(DestPtr, AsciiString);
2477
2478 /* Move to the next string */
2479 SourcePtr += wcslen(SourcePtr) + 1;
2480 DestPtr += strlen(AsciiString);
2481 *(DestPtr++) = 0;
2482
2483 /* Free the memory */
2484 HeapFree(GetProcessHeap(), 0, AsciiString);
2485 }
2486 *DestPtr = 0;
2487
2488 /* Free the memory allocated for environment strings */
2489 FreeEnvironmentStringsW(Environment);
2490
2491 /* Clear the current directory buffer */
2492 ZeroMemory(CurrentDirectories, sizeof(CurrentDirectories));
2493
2494 /* Get the current directory */
2495 if (!GetCurrentDirectoryA(MAX_PATH, CurrentDirectory))
2496 {
2497 // TODO: Use some kind of default path?
2498 return FALSE;
2499 }
2500
2501 /* Convert that to a DOS path */
2502 if (!GetShortPathNameA(CurrentDirectory, DosDirectory, DOS_DIR_LENGTH))
2503 {
2504 // TODO: Use some kind of default path?
2505 return FALSE;
2506 }
2507
2508 /* Set the drive */
2509 CurrentDrive = DosDirectory[0] - 'A';
2510
2511 /* Get the directory part of the path */
2512 Path = strchr(DosDirectory, '\\');
2513 if (Path != NULL)
2514 {
2515 /* Skip the backslash */
2516 Path++;
2517 }
2518
2519 /* Set the directory */
2520 if (Path != NULL)
2521 {
2522 strncpy(CurrentDirectories[CurrentDrive], Path, DOS_DIR_LENGTH);
2523 }
2524
2525 /* Read CONFIG.SYS */
2526 Stream = _wfopen(DOS_CONFIG_PATH, L"r");
2527 if (Stream != NULL)
2528 {
2529 while (fgetws(Buffer, 256, Stream))
2530 {
2531 // TODO: Parse the line
2532 }
2533 fclose(Stream);
2534 }
2535
2536 /* Initialize the SFT */
2537 for (i = 0; i < DOS_SFT_SIZE; i++)
2538 {
2539 DosSystemFileTable[i] = INVALID_HANDLE_VALUE;
2540 DosSftRefCount[i] = 0;
2541 }
2542
2543 /* Get handles to standard I/O devices */
2544 DosSystemFileTable[0] = GetStdHandle(STD_INPUT_HANDLE);
2545 DosSystemFileTable[1] = GetStdHandle(STD_OUTPUT_HANDLE);
2546 DosSystemFileTable[2] = GetStdHandle(STD_ERROR_HANDLE);
2547
2548 return TRUE;
2549 }
2550
2551 /* EOF */
A free Windows-compatible Operating System