projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[NTVDM]
[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 /*
1207 * Set the value on the stack to 0, so that a near return
1208 * jumps to PSP:0000 which has the exit code.
1209 */
1210 *((LPWORD)SEG_OFF_TO_PTR(Segment, 0xFFFE)) = 0;
1211
1212 /* Execute */
1213 CurrentPsp = Segment;
1214 DiskTransferArea = MAKELONG(0x80, Segment);
1215 EmulatorExecute(Segment, 0x100);
1216
1217 Success = TRUE;
1218 }
1219
1220 Cleanup:
1221 if (!Success)
1222 {
1223 /* It was not successful, cleanup the DOS memory */
1224 if (AllocatedEnvBlock) DosFreeMemory(EnvBlock);
1225 if (Segment) DosFreeMemory(Segment);
1226 }
1227
1228 /* Unmap the file*/
1229 if (Address != NULL) UnmapViewOfFile(Address);
1230
1231 /* Close the file mapping object */
1232 if (FileMapping != NULL) CloseHandle(FileMapping);
1233
1234 /* Close the file handle */
1235 if (FileHandle != INVALID_HANDLE_VALUE) CloseHandle(FileHandle);
1236
1237 return Success;
1238 }
1239
1240 VOID DosTerminateProcess(WORD Psp, BYTE ReturnCode)
1241 {
1242 WORD i;
1243 WORD McbSegment = FIRST_MCB_SEGMENT;
1244 PDOS_MCB CurrentMcb;
1245 LPDWORD IntVecTable = (LPDWORD)((ULONG_PTR)BaseAddress);
1246 PDOS_PSP PspBlock = SEGMENT_TO_PSP(Psp);
1247
1248 DPRINT("DosTerminateProcess: Psp 0x%04X, ReturnCode 0x%02X\n",
1249 Psp,
1250 ReturnCode);
1251
1252 /* Check if this PSP is it's own parent */
1253 if (PspBlock->ParentPsp == Psp) goto Done;
1254
1255 for (i = 0; i < PspBlock->HandleTableSize; i++)
1256 {
1257 /* Close the handle */
1258 DosCloseHandle(i);
1259 }
1260
1261 /* Free the memory used by the process */
1262 while (TRUE)
1263 {
1264 /* Get a pointer to the MCB */
1265 CurrentMcb = SEGMENT_TO_MCB(McbSegment);
1266
1267 /* Make sure the MCB is valid */
1268 if (CurrentMcb->BlockType != 'M' && CurrentMcb->BlockType !='Z') break;
1269
1270 /* If this block was allocated by the process, free it */
1271 if (CurrentMcb->OwnerPsp == Psp) DosFreeMemory(McbSegment + 1);
1272
1273 /* If this was the last block, quit */
1274 if (CurrentMcb->BlockType == 'Z') break;
1275
1276 /* Update the segment and continue */
1277 McbSegment += CurrentMcb->Size + 1;
1278 }
1279
1280 Done:
1281 /* Restore the interrupt vectors */
1282 IntVecTable[0x22] = PspBlock->TerminateAddress;
1283 IntVecTable[0x23] = PspBlock->BreakAddress;
1284 IntVecTable[0x24] = PspBlock->CriticalAddress;
1285
1286 /* Update the current PSP */
1287 if (Psp == CurrentPsp)
1288 {
1289 CurrentPsp = PspBlock->ParentPsp;
1290 if (CurrentPsp == SYSTEM_PSP) VdmRunning = FALSE;
1291 }
1292
1293 /* Save the return code - Normal termination */
1294 DosErrorLevel = MAKEWORD(ReturnCode, 0x00);
1295
1296 /* Return control to the parent process */
1297 EmulatorExecute(HIWORD(PspBlock->TerminateAddress),
1298 LOWORD(PspBlock->TerminateAddress));
1299 }
1300
1301 CHAR DosReadCharacter(VOID)
1302 {
1303 CHAR Character = '\0';
1304 WORD BytesRead;
1305
1306 if (IsConsoleHandle(DosGetRealHandle(DOS_INPUT_HANDLE)))
1307 {
1308 /* Call the BIOS */
1309 Character = LOBYTE(BiosGetCharacter());
1310 }
1311 else
1312 {
1313 /* Use the file reading function */
1314 DosReadFile(DOS_INPUT_HANDLE, &Character, sizeof(CHAR), &BytesRead);
1315 }
1316
1317 return Character;
1318 }
1319
1320 BOOLEAN DosCheckInput(VOID)
1321 {
1322 HANDLE Handle = DosGetRealHandle(DOS_INPUT_HANDLE);
1323
1324 if (IsConsoleHandle(Handle))
1325 {
1326 /* Call the BIOS */
1327 return (BiosPeekCharacter() != 0xFFFF);
1328 }
1329 else
1330 {
1331 DWORD FileSizeHigh;
1332 DWORD FileSize = GetFileSize(Handle, &FileSizeHigh);
1333 LONG LocationHigh = 0;
1334 DWORD Location = SetFilePointer(Handle, 0, &LocationHigh, FILE_CURRENT);
1335
1336 return ((Location != FileSize) || (LocationHigh != FileSizeHigh));
1337 }
1338 }
1339
1340 VOID DosPrintCharacter(CHAR Character)
1341 {
1342 WORD BytesWritten;
1343
1344 /* Use the file writing function */
1345 DosWriteFile(DOS_OUTPUT_HANDLE, &Character, sizeof(CHAR), &BytesWritten);
1346 }
1347
1348 BOOLEAN DosHandleIoctl(BYTE ControlCode, WORD FileHandle)
1349 {
1350 HANDLE Handle = DosGetRealHandle(FileHandle);
1351
1352 if (Handle == INVALID_HANDLE_VALUE)
1353 {
1354 /* Doesn't exist */
1355 DosLastError = ERROR_FILE_NOT_FOUND;
1356 return FALSE;
1357 }
1358
1359 switch (ControlCode)
1360 {
1361 /* Get Device Information */
1362 case 0x00:
1363 {
1364 WORD InfoWord = 0;
1365
1366 if (Handle == DosSystemFileTable[0])
1367 {
1368 /* Console input */
1369 InfoWord |= 1 << 0;
1370 }
1371 else if (Handle == DosSystemFileTable[1])
1372 {
1373 /* Console output */
1374 InfoWord |= 1 << 1;
1375 }
1376
1377 /* It is a character device */
1378 InfoWord |= 1 << 7;
1379
1380 /* Return the device information word */
1381 setDX(InfoWord);
1382 return TRUE;
1383 }
1384
1385 /* Unsupported control code */
1386 default:
1387 {
1388 DPRINT1("Unsupported IOCTL: 0x%02X\n", ControlCode);
1389
1390 DosLastError = ERROR_INVALID_PARAMETER;
1391 return FALSE;
1392 }
1393 }
1394 }
1395
1396 VOID DosInt20h(LPWORD Stack)
1397 {
1398 /* This is the exit interrupt */
1399 DosTerminateProcess(Stack[STACK_CS], 0);
1400 }
1401
1402 VOID DosInt21h(LPWORD Stack)
1403 {
1404 BYTE Character;
1405 SYSTEMTIME SystemTime;
1406 PCHAR String;
1407 PDOS_INPUT_BUFFER InputBuffer;
1408
1409 /* Check the value in the AH register */
1410 switch (getAH())
1411 {
1412 /* Terminate Program */
1413 case 0x00:
1414 {
1415 DosTerminateProcess(Stack[STACK_CS], 0);
1416 break;
1417 }
1418
1419 /* Read Character from STDIN with Echo */
1420 case 0x01:
1421 {
1422 Character = DosReadCharacter();
1423 DosPrintCharacter(Character);
1424
1425 /* Let the BOP repeat if needed */
1426 if (getCF()) break;
1427
1428 setAL(Character);
1429 break;
1430 }
1431
1432 /* Write Character to STDOUT */
1433 case 0x02:
1434 {
1435 Character = getDL();
1436 DosPrintCharacter(Character);
1437
1438 /*
1439 * We return the output character (DOS 2.1+).
1440 * Also, if we're going to output a TAB, then
1441 * don't return a TAB but a SPACE instead.
1442 * See Ralf Brown: http://www.ctyme.com/intr/rb-2554.htm
1443 * for more information.
1444 */
1445 setAL(Character == '\t' ? ' ' : Character);
1446 break;
1447 }
1448
1449 /* Read Character from STDAUX */
1450 case 0x03:
1451 {
1452 // FIXME: Really read it from STDAUX!
1453 DPRINT1("INT 16h, 03h: Read character from STDAUX is HALFPLEMENTED\n");
1454 setAL(DosReadCharacter());
1455 break;
1456 }
1457
1458 /* Write Character to STDAUX */
1459 case 0x04:
1460 {
1461 // FIXME: Really write it to STDAUX!
1462 DPRINT1("INT 16h, 04h: Write character to STDAUX is HALFPLEMENTED\n");
1463 DosPrintCharacter(getDL());
1464 break;
1465 }
1466
1467 /* Write Character to Printer */
1468 case 0x05:
1469 {
1470 // FIXME: Really write it to printer!
1471 DPRINT1("INT 16h, 05h: Write character to printer is HALFPLEMENTED -\n\n");
1472 DPRINT1("0x%p\n", getDL());
1473 DPRINT1("\n\n-----------\n\n");
1474 break;
1475 }
1476
1477 /* Direct Console I/O */
1478 case 0x06:
1479 {
1480 Character = getDL();
1481
1482 if (Character != 0xFF)
1483 {
1484 /* Output */
1485 DosPrintCharacter(Character);
1486
1487 /*
1488 * We return the output character (DOS 2.1+).
1489 * See Ralf Brown: http://www.ctyme.com/intr/rb-2558.htm
1490 * for more information.
1491 */
1492 setAL(Character);
1493 }
1494 else
1495 {
1496 /* Input */
1497 if (DosCheckInput())
1498 {
1499 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_ZF;
1500 setAL(DosReadCharacter());
1501 }
1502 else
1503 {
1504 /* No character available */
1505 Stack[STACK_FLAGS] |= EMULATOR_FLAG_ZF;
1506 setAL(0x00);
1507 }
1508 }
1509
1510 break;
1511 }
1512
1513 /* Character Input without Echo */
1514 case 0x07:
1515 case 0x08:
1516 {
1517 Character = DosReadCharacter();
1518
1519 /* Let the BOP repeat if needed */
1520 if (getCF()) break;
1521
1522 setAL(Character);
1523 break;
1524 }
1525
1526 /* Write string to STDOUT */
1527 case 0x09:
1528 {
1529 String = (PCHAR)SEG_OFF_TO_PTR(getDS(), getDX());
1530
1531 while (*String != '$')
1532 {
1533 DosPrintCharacter(*String);
1534 String++;
1535 }
1536
1537 /*
1538 * We return the terminating character (DOS 2.1+).
1539 * See Ralf Brown: http://www.ctyme.com/intr/rb-2562.htm
1540 * for more information.
1541 */
1542 setAL('$');
1543 break;
1544 }
1545
1546 /* Read Buffered Input */
1547 case 0x0A:
1548 {
1549 InputBuffer = (PDOS_INPUT_BUFFER)SEG_OFF_TO_PTR(getDS(), getDX());
1550
1551 while (Stack[STACK_COUNTER] < InputBuffer->MaxLength)
1552 {
1553 /* Try to read a character */
1554 Character = DosReadCharacter();
1555
1556 /* If it's not ready yet, let the BOP repeat */
1557 if (getCF()) break;
1558
1559 /* Echo the character and append it to the buffer */
1560 DosPrintCharacter(Character);
1561 InputBuffer->Buffer[Stack[STACK_COUNTER]] = Character;
1562
1563 if (Character == '\r') break;
1564 Stack[STACK_COUNTER]++;
1565 }
1566
1567 /* Update the length */
1568 InputBuffer->Length = Stack[STACK_COUNTER];
1569 break;
1570 }
1571
1572 /* Get STDIN Status */
1573 case 0x0B:
1574 {
1575 setAL(DosCheckInput() ? 0xFF : 0x00);
1576 break;
1577 }
1578
1579 /* Flush Buffer and Read STDIN */
1580 case 0x0C:
1581 {
1582 BYTE InputFunction = getAL();
1583
1584 /* Flush STDIN buffer */
1585 DosFlushFileBuffers(DOS_INPUT_HANDLE); // Maybe just create a DosFlushInputBuffer...
1586
1587 /*
1588 * If the input function number contained in AL is valid, i.e.
1589 * AL == 0x01 or 0x06 or 0x07 or 0x08 or 0x0A, call ourselves
1590 * recursively with AL == AH.
1591 */
1592 if (InputFunction == 0x01 || InputFunction == 0x06 ||
1593 InputFunction == 0x07 || InputFunction == 0x08 ||
1594 InputFunction == 0x0A)
1595 {
1596 setAH(InputFunction);
1597 /*
1598 * Instead of calling ourselves really recursively as in:
1599 * DosInt21h(Stack);
1600 * prefer resetting the CF flag to let the BOP repeat.
1601 */
1602 setCF(1);
1603 }
1604 break;
1605 }
1606
1607 /* Disk Reset */
1608 case 0x0D:
1609 {
1610 PDOS_PSP PspBlock = SEGMENT_TO_PSP(CurrentPsp);
1611
1612 // TODO: Flush what's needed.
1613 DPRINT1("INT 21h, 0Dh is UNIMPLEMENTED\n");
1614
1615 /* Clear CF in DOS 6 only */
1616 if (PspBlock->DosVersion == 0x0006)
1617 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
1618
1619 break;
1620 }
1621
1622 /* Set Default Drive */
1623 case 0x0E:
1624 {
1625 DosChangeDrive(getDL());
1626 setAL(LastDrive - 'A' + 1);
1627 break;
1628 }
1629
1630 /* NULL Function for CP/M Compatibility */
1631 case 0x18:
1632 {
1633 /*
1634 * This function corresponds to the CP/M BDOS function
1635 * "get bit map of logged drives", which is meaningless
1636 * under MS-DOS.
1637 *
1638 * For: PTS-DOS 6.51 & S/DOS 1.0 - EXTENDED RENAME FILE USING FCB
1639 * See Ralf Brown: http://www.ctyme.com/intr/rb-2584.htm
1640 * for more information.
1641 */
1642 setAL(0x00);
1643 break;
1644 }
1645
1646 /* Get Default Drive */
1647 case 0x19:
1648 {
1649 setAL(CurrentDrive);
1650 break;
1651 }
1652
1653 /* Set Disk Transfer Area */
1654 case 0x1A:
1655 {
1656 DiskTransferArea = MAKELONG(getDX(), getDS());
1657 break;
1658 }
1659
1660 /* NULL Function for CP/M Compatibility */
1661 case 0x1D:
1662 case 0x1E:
1663 {
1664 /*
1665 * Function 0x1D corresponds to the CP/M BDOS function
1666 * "get bit map of read-only drives", which is meaningless
1667 * under MS-DOS.
1668 * See Ralf Brown: http://www.ctyme.com/intr/rb-2592.htm
1669 * for more information.
1670 *
1671 * Function 0x1E corresponds to the CP/M BDOS function
1672 * "set file attributes", which was meaningless under MS-DOS 1.x.
1673 * See Ralf Brown: http://www.ctyme.com/intr/rb-2593.htm
1674 * for more information.
1675 */
1676 setAL(0x00);
1677 break;
1678 }
1679
1680 /* NULL Function for CP/M Compatibility */
1681 case 0x20:
1682 {
1683 /*
1684 * This function corresponds to the CP/M BDOS function
1685 * "get/set default user (sublibrary) number", which is meaningless
1686 * under MS-DOS.
1687 *
1688 * For: S/DOS 1.0+ & PTS-DOS 6.51+ - GET OEM REVISION
1689 * See Ralf Brown: http://www.ctyme.com/intr/rb-2596.htm
1690 * for more information.
1691 */
1692 setAL(0x00);
1693 break;
1694 }
1695
1696 /* Set Interrupt Vector */
1697 case 0x25:
1698 {
1699 DWORD FarPointer = MAKELONG(getDX(), getDS());
1700 DPRINT1("Setting interrupt 0x%x ...\n", getAL());
1701
1702 /* Write the new far pointer to the IDT */
1703 ((PDWORD)BaseAddress)[getAL()] = FarPointer;
1704 break;
1705 }
1706
1707 /* Create New PSP */
1708 case 0x26:
1709 {
1710 DPRINT1("INT 21h, 26h - Create New PSP is UNIMPLEMENTED\n");
1711 break;
1712 }
1713
1714 /* Get System Date */
1715 case 0x2A:
1716 {
1717 GetLocalTime(&SystemTime);
1718 setCX(SystemTime.wYear);
1719 setDX(MAKEWORD(SystemTime.wDay, SystemTime.wMonth));
1720 setAL(SystemTime.wDayOfWeek);
1721 break;
1722 }
1723
1724 /* Set System Date */
1725 case 0x2B:
1726 {
1727 GetLocalTime(&SystemTime);
1728 SystemTime.wYear = getCX();
1729 SystemTime.wMonth = getDH();
1730 SystemTime.wDay = getDL();
1731
1732 /* Return success or failure */
1733 setAL(SetLocalTime(&SystemTime) ? 0x00 : 0xFF);
1734 break;
1735 }
1736
1737 /* Get System Time */
1738 case 0x2C:
1739 {
1740 GetLocalTime(&SystemTime);
1741 setCX(MAKEWORD(SystemTime.wMinute, SystemTime.wHour));
1742 setDX(MAKEWORD(SystemTime.wMilliseconds / 10, SystemTime.wSecond));
1743 break;
1744 }
1745
1746 /* Set System Time */
1747 case 0x2D:
1748 {
1749 GetLocalTime(&SystemTime);
1750 SystemTime.wHour = getCH();
1751 SystemTime.wMinute = getCL();
1752 SystemTime.wSecond = getDH();
1753 SystemTime.wMilliseconds = getDL() * 10; // In hundredths of seconds
1754
1755 /* Return success or failure */
1756 setAL(SetLocalTime(&SystemTime) ? 0x00 : 0xFF);
1757 break;
1758 }
1759
1760 /* Get Disk Transfer Area */
1761 case 0x2F:
1762 {
1763 setES(HIWORD(DiskTransferArea));
1764 setBX(LOWORD(DiskTransferArea));
1765 break;
1766 }
1767
1768 /* Get DOS Version */
1769 case 0x30:
1770 {
1771 PDOS_PSP PspBlock = SEGMENT_TO_PSP(CurrentPsp);
1772
1773 /*
1774 * See Ralf Brown: http://www.ctyme.com/intr/rb-2711.htm
1775 * for more information.
1776 */
1777
1778 if (LOBYTE(PspBlock->DosVersion) < 5 || getAL() == 0x00)
1779 {
1780 /*
1781 * Return DOS OEM number:
1782 * 0x00 for IBM PC-DOS
1783 * 0x02 for packaged MS-DOS
1784 */
1785 setBH(0x02);
1786 }
1787
1788 if (LOBYTE(PspBlock->DosVersion) >= 5 && getAL() == 0x01)
1789 {
1790 /*
1791 * Return version flag:
1792 * 1 << 3 if DOS is in ROM,
1793 * 0 (reserved) if not.
1794 */
1795 setBH(0x00);
1796 }
1797
1798 /* Return DOS 24-bit user serial number in BL:CX */
1799 setBL(0x00);
1800 setCX(0x0000);
1801
1802 /* Return DOS version: Minor:Major in AH:AL */
1803 setAX(PspBlock->DosVersion);
1804
1805 break;
1806 }
1807
1808 /* Get Interrupt Vector */
1809 case 0x35:
1810 {
1811 DWORD FarPointer = ((PDWORD)BaseAddress)[getAL()];
1812
1813 /* Read the address from the IDT into ES:BX */
1814 setES(HIWORD(FarPointer));
1815 setBX(LOWORD(FarPointer));
1816 break;
1817 }
1818
1819 /* SWITCH character - AVAILDEV */
1820 case 0x37:
1821 {
1822 if (getAL() == 0x00)
1823 {
1824 /*
1825 * DOS 2+ - "SWITCHAR" - GET SWITCH CHARACTER
1826 * This setting is ignored by MS-DOS 4.0+.
1827 * MS-DOS 5+ always return AL=00h/DL=2Fh.
1828 * See Ralf Brown: http://www.ctyme.com/intr/rb-2752.htm
1829 * for more information.
1830 */
1831 setDL('/');
1832 setAL(0x00);
1833 }
1834 else if (getAL() == 0x01)
1835 {
1836 /*
1837 * DOS 2+ - "SWITCHAR" - SET SWITCH CHARACTER
1838 * This setting is ignored by MS-DOS 5+.
1839 * See Ralf Brown: http://www.ctyme.com/intr/rb-2753.htm
1840 * for more information.
1841 */
1842 // getDL();
1843 setAL(0xFF);
1844 }
1845 else if (getAL() == 0x02)
1846 {
1847 /*
1848 * DOS 2.x and 3.3+ only - "AVAILDEV" - SPECIFY \DEV\ PREFIX USE
1849 * See Ralf Brown: http://www.ctyme.com/intr/rb-2754.htm
1850 * for more information.
1851 */
1852 // setDL();
1853 setAL(0xFF);
1854 }
1855 else if (getAL() == 0x03)
1856 {
1857 /*
1858 * DOS 2.x and 3.3+ only - "AVAILDEV" - SPECIFY \DEV\ PREFIX USE
1859 * See Ralf Brown: http://www.ctyme.com/intr/rb-2754.htm
1860 * for more information.
1861 */
1862 // getDL();
1863 setAL(0xFF);
1864 }
1865 else
1866 {
1867 setAL(0xFF);
1868 }
1869
1870 break;
1871 }
1872
1873 /* Create Directory */
1874 case 0x39:
1875 {
1876 String = (PCHAR)SEG_OFF_TO_PTR(getDS(), getDX());
1877
1878 if (CreateDirectoryA(String, NULL))
1879 {
1880 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
1881 }
1882 else
1883 {
1884 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
1885 setAX(LOWORD(GetLastError()));
1886 }
1887
1888 break;
1889 }
1890
1891 /* Remove Directory */
1892 case 0x3A:
1893 {
1894 String = (PCHAR)SEG_OFF_TO_PTR(getDS(), getDX());
1895
1896 if (RemoveDirectoryA(String))
1897 {
1898 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
1899 }
1900 else
1901 {
1902 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
1903 setAX(LOWORD(GetLastError()));
1904 }
1905
1906 break;
1907 }
1908
1909 /* Set Current Directory */
1910 case 0x3B:
1911 {
1912 String = (PCHAR)SEG_OFF_TO_PTR(getDS(), getDX());
1913
1914 if (DosChangeDirectory(String))
1915 {
1916 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
1917 }
1918 else
1919 {
1920 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
1921 setAX(DosLastError);
1922 }
1923
1924 break;
1925 }
1926
1927 /* Create File */
1928 case 0x3C:
1929 {
1930 WORD FileHandle;
1931 WORD ErrorCode = DosCreateFile(&FileHandle,
1932 (LPCSTR)SEG_OFF_TO_PTR(getDS(), getDX()),
1933 getCX());
1934
1935 if (ErrorCode == 0)
1936 {
1937 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
1938 setAX(FileHandle);
1939 }
1940 else
1941 {
1942 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
1943 setAX(ErrorCode);
1944 }
1945
1946 break;
1947 }
1948
1949 /* Open File */
1950 case 0x3D:
1951 {
1952 WORD FileHandle;
1953 WORD ErrorCode = DosOpenFile(&FileHandle,
1954 (LPCSTR)SEG_OFF_TO_PTR(getDS(), getDX()),
1955 getAL());
1956
1957 if (ErrorCode == 0)
1958 {
1959 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
1960 setAX(FileHandle);
1961 }
1962 else
1963 {
1964 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
1965 setAX(ErrorCode);
1966 }
1967
1968 break;
1969 }
1970
1971 /* Close File */
1972 case 0x3E:
1973 {
1974 if (DosCloseHandle(getBX()))
1975 {
1976 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
1977 }
1978 else
1979 {
1980 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
1981 setAX(ERROR_INVALID_HANDLE);
1982 }
1983
1984 break;
1985 }
1986
1987 /* Read from File or Device */
1988 case 0x3F:
1989 {
1990 WORD Handle = getBX();
1991 LPBYTE Buffer = (LPBYTE)SEG_OFF_TO_PTR(getDS(), getDX());
1992 WORD Count = getCX();
1993 WORD BytesRead = 0;
1994 WORD ErrorCode = ERROR_SUCCESS;
1995
1996 if (IsConsoleHandle(DosGetRealHandle(Handle)))
1997 {
1998 while (Stack[STACK_COUNTER] < Count)
1999 {
2000 /* Read a character from the BIOS */
2001 // FIXME: Security checks!
2002 Buffer[Stack[STACK_COUNTER]] = LOBYTE(BiosGetCharacter());
2003
2004 /* Stop if the BOP needs to be repeated */
2005 if (getCF()) break;
2006
2007 /* Increment the counter */
2008 Stack[STACK_COUNTER]++;
2009 }
2010
2011 if (Stack[STACK_COUNTER] < Count)
2012 ErrorCode = ERROR_NOT_READY;
2013 else
2014 BytesRead = Count;
2015 }
2016 else
2017 {
2018 /* Use the file reading function */
2019 ErrorCode = DosReadFile(Handle, Buffer, Count, &BytesRead);
2020 }
2021
2022 if (ErrorCode == ERROR_SUCCESS)
2023 {
2024 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2025 setAX(BytesRead);
2026 }
2027 else if (ErrorCode != ERROR_NOT_READY)
2028 {
2029 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2030 setAX(ErrorCode);
2031 }
2032 break;
2033 }
2034
2035 /* Write to File or Device */
2036 case 0x40:
2037 {
2038 WORD BytesWritten = 0;
2039 WORD ErrorCode = DosWriteFile(getBX(),
2040 SEG_OFF_TO_PTR(getDS(), getDX()),
2041 getCX(),
2042 &BytesWritten);
2043
2044 if (ErrorCode == ERROR_SUCCESS)
2045 {
2046 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2047 setAX(BytesWritten);
2048 }
2049 else
2050 {
2051 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2052 setAX(ErrorCode);
2053 }
2054
2055 break;
2056 }
2057
2058 /* Delete File */
2059 case 0x41:
2060 {
2061 LPSTR FileName = (LPSTR)SEG_OFF_TO_PTR(getDS(), getDX());
2062
2063 /* Call the API function */
2064 if (DeleteFileA(FileName))
2065 {
2066 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2067 /*
2068 * See Ralf Brown: http://www.ctyme.com/intr/rb-2797.htm
2069 * "AX destroyed (DOS 3.3) AL seems to be drive of deleted file."
2070 */
2071 setAL(FileName[0] - 'A');
2072 }
2073 else
2074 {
2075 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2076 setAX(GetLastError());
2077 }
2078
2079 break;
2080 }
2081
2082 /* Seek File */
2083 case 0x42:
2084 {
2085 DWORD NewLocation;
2086 WORD ErrorCode = DosSeekFile(getBX(),
2087 MAKELONG(getDX(), getCX()),
2088 getAL(),
2089 &NewLocation);
2090
2091 if (ErrorCode == ERROR_SUCCESS)
2092 {
2093 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2094
2095 /* Return the new offset in DX:AX */
2096 setDX(HIWORD(NewLocation));
2097 setAX(LOWORD(NewLocation));
2098 }
2099 else
2100 {
2101 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2102 setAX(ErrorCode);
2103 }
2104
2105 break;
2106 }
2107
2108 /* Get/Set File Attributes */
2109 case 0x43:
2110 {
2111 DWORD Attributes;
2112 LPSTR FileName = (LPSTR)SEG_OFF_TO_PTR(getDS(), getDX());
2113
2114 if (getAL() == 0x00)
2115 {
2116 /* Get the attributes */
2117 Attributes = GetFileAttributesA(FileName);
2118
2119 /* Check if it failed */
2120 if (Attributes == INVALID_FILE_ATTRIBUTES)
2121 {
2122 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2123 setAX(GetLastError());
2124 }
2125 else
2126 {
2127 /* Return the attributes that DOS can understand */
2128 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2129 setCX(Attributes & 0x00FF);
2130 }
2131 }
2132 else if (getAL() == 0x01)
2133 {
2134 /* Try to set the attributes */
2135 if (SetFileAttributesA(FileName, getCL()))
2136 {
2137 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2138 }
2139 else
2140 {
2141 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2142 setAX(GetLastError());
2143 }
2144 }
2145 else
2146 {
2147 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2148 setAX(ERROR_INVALID_FUNCTION);
2149 }
2150
2151 break;
2152 }
2153
2154 /* IOCTL */
2155 case 0x44:
2156 {
2157 if (DosHandleIoctl(getAL(), getBX()))
2158 {
2159 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2160 }
2161 else
2162 {
2163 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2164 setAX(DosLastError);
2165 }
2166
2167 break;
2168 }
2169
2170 /* Duplicate Handle */
2171 case 0x45:
2172 {
2173 WORD NewHandle;
2174 HANDLE Handle = DosGetRealHandle(getBX());
2175
2176 if (Handle != INVALID_HANDLE_VALUE)
2177 {
2178 /* The handle is invalid */
2179 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2180 setAX(ERROR_INVALID_HANDLE);
2181 break;
2182 }
2183
2184 /* Open a new handle to the same entry */
2185 NewHandle = DosOpenHandle(Handle);
2186
2187 if (NewHandle == INVALID_DOS_HANDLE)
2188 {
2189 /* Too many files open */
2190 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2191 setAX(ERROR_TOO_MANY_OPEN_FILES);
2192 break;
2193 }
2194
2195 /* Return the result */
2196 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2197 setAX(NewHandle);
2198 break;
2199 }
2200
2201 /* Force Duplicate Handle */
2202 case 0x46:
2203 {
2204 if (DosDuplicateHandle(getBX(), getCX()))
2205 {
2206 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2207 }
2208 else
2209 {
2210 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2211 setAX(ERROR_INVALID_HANDLE);
2212 }
2213
2214 break;
2215 }
2216
2217 /* Get Current Directory */
2218 case 0x47:
2219 {
2220 BYTE DriveNumber = getDL();
2221 String = (PCHAR)SEG_OFF_TO_PTR(getDS(), getSI());
2222
2223 /* Get the real drive number */
2224 if (DriveNumber == 0)
2225 {
2226 DriveNumber = CurrentDrive;
2227 }
2228 else
2229 {
2230 /* Decrement DriveNumber since it was 1-based */
2231 DriveNumber--;
2232 }
2233
2234 if (DriveNumber <= LastDrive - 'A')
2235 {
2236 /*
2237 * Copy the current directory into the target buffer.
2238 * It doesn't contain the drive letter and the backslash.
2239 */
2240 strncpy(String, CurrentDirectories[DriveNumber], DOS_DIR_LENGTH);
2241 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2242 setAX(0x0100); // Undocumented, see Ralf Brown: http://www.ctyme.com/intr/rb-2933.htm
2243 }
2244 else
2245 {
2246 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2247 setAX(ERROR_INVALID_DRIVE);
2248 }
2249
2250 break;
2251 }
2252
2253 /* Allocate Memory */
2254 case 0x48:
2255 {
2256 WORD MaxAvailable = 0;
2257 WORD Segment = DosAllocateMemory(getBX(), &MaxAvailable);
2258
2259 if (Segment != 0)
2260 {
2261 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2262 setAX(Segment);
2263 }
2264 else
2265 {
2266 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2267 setAX(DosLastError);
2268 setBX(MaxAvailable);
2269 }
2270
2271 break;
2272 }
2273
2274 /* Free Memory */
2275 case 0x49:
2276 {
2277 if (DosFreeMemory(getES()))
2278 {
2279 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2280 }
2281 else
2282 {
2283 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2284 setAX(ERROR_ARENA_TRASHED);
2285 }
2286
2287 break;
2288 }
2289
2290 /* Resize Memory Block */
2291 case 0x4A:
2292 {
2293 WORD Size;
2294
2295 if (DosResizeMemory(getES(), getBX(), &Size))
2296 {
2297 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2298 }
2299 else
2300 {
2301 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2302 setAX(DosLastError);
2303 setBX(Size);
2304 }
2305
2306 break;
2307 }
2308
2309 /* Terminate With Return Code */
2310 case 0x4C:
2311 {
2312 DosTerminateProcess(CurrentPsp, getAL());
2313 break;
2314 }
2315
2316 /* Get Return Code (ERRORLEVEL) */
2317 case 0x4D:
2318 {
2319 /*
2320 * According to Ralf Brown: http://www.ctyme.com/intr/rb-2976.htm
2321 * DosErrorLevel is cleared after being read by this function.
2322 */
2323 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2324 setAX(DosErrorLevel);
2325 DosErrorLevel = 0x0000; // Clear it
2326 break;
2327 }
2328
2329 /* Internal - Set Current Process ID (Set PSP Address) */
2330 case 0x50:
2331 {
2332 // FIXME: Is it really what it's done ??
2333 CurrentPsp = getBX();
2334 break;
2335 }
2336
2337 /* Internal - Get Current Process ID (Get PSP Address) */
2338 case 0x51:
2339 /* Get Current PSP Address */
2340 case 0x62:
2341 {
2342 /*
2343 * Undocumented AH=51h is identical to the documented AH=62h.
2344 * See Ralf Brown: http://www.ctyme.com/intr/rb-2982.htm
2345 * and http://www.ctyme.com/intr/rb-3140.htm
2346 * for more information.
2347 */
2348 setBX(CurrentPsp);
2349 break;
2350 }
2351
2352 /* Get/Set Memory Management Options */
2353 case 0x58:
2354 {
2355 if (getAL() == 0x00)
2356 {
2357 /* Get allocation strategy */
2358 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2359 setAX(DosAllocStrategy);
2360 }
2361 else if (getAL() == 0x01)
2362 {
2363 /* Set allocation strategy */
2364
2365 if ((getBL() & (DOS_ALLOC_HIGH | DOS_ALLOC_HIGH_LOW))
2366 == (DOS_ALLOC_HIGH | DOS_ALLOC_HIGH_LOW))
2367 {
2368 /* Can't set both */
2369 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2370 setAX(ERROR_INVALID_PARAMETER);
2371 break;
2372 }
2373
2374 if ((getBL() & 0x3F) > DOS_ALLOC_LAST_FIT)
2375 {
2376 /* Invalid allocation strategy */
2377 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2378 setAX(ERROR_INVALID_PARAMETER);
2379 break;
2380 }
2381
2382 DosAllocStrategy = getBL();
2383 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2384 }
2385 else if (getAL() == 0x02)
2386 {
2387 /* Get UMB link state */
2388 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2389 setAL(DosUmbLinked ? 0x01 : 0x00);
2390 }
2391 else if (getAL() == 0x03)
2392 {
2393 /* Set UMB link state */
2394 if (getBX()) DosLinkUmb();
2395 else DosUnlinkUmb();
2396 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
2397 }
2398 else
2399 {
2400 /* Invalid or unsupported function */
2401 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2402 setAX(ERROR_INVALID_FUNCTION);
2403 }
2404
2405 break;
2406 }
2407
2408 /* Unsupported */
2409 default:
2410 {
2411 DPRINT1("DOS Function INT 0x21, AH = %xh, AL = %xh NOT IMPLEMENTED!\n",
2412 getAH(), getAL());
2413 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
2414 }
2415 }
2416 }
2417
2418 VOID DosBreakInterrupt(LPWORD Stack)
2419 {
2420 UNREFERENCED_PARAMETER(Stack);
2421
2422 VdmRunning = FALSE;
2423 }
2424
2425 BOOLEAN DosInitialize(VOID)
2426 {
2427 BYTE i;
2428 PDOS_MCB Mcb = SEGMENT_TO_MCB(FIRST_MCB_SEGMENT);
2429 FILE *Stream;
2430 WCHAR Buffer[256];
2431 LPWSTR SourcePtr, Environment;
2432 LPSTR AsciiString;
2433 LPSTR DestPtr = (LPSTR)SEG_OFF_TO_PTR(SYSTEM_ENV_BLOCK, 0);
2434 DWORD AsciiSize;
2435 CHAR CurrentDirectory[MAX_PATH];
2436 CHAR DosDirectory[DOS_DIR_LENGTH];
2437 LPSTR Path;
2438
2439 /* Initialize the MCB */
2440 Mcb->BlockType = 'Z';
2441 Mcb->Size = USER_MEMORY_SIZE;
2442 Mcb->OwnerPsp = 0;
2443
2444 /* Initialize the link MCB to the UMB area */
2445 Mcb = SEGMENT_TO_MCB(FIRST_MCB_SEGMENT + USER_MEMORY_SIZE + 1);
2446 Mcb->BlockType = 'M';
2447 Mcb->Size = UMB_START_SEGMENT - FIRST_MCB_SEGMENT - USER_MEMORY_SIZE - 2;
2448 Mcb->OwnerPsp = SYSTEM_PSP;
2449
2450 /* Initialize the UMB area */
2451 Mcb = SEGMENT_TO_MCB(UMB_START_SEGMENT);
2452 Mcb->BlockType = 'Z';
2453 Mcb->Size = UMB_END_SEGMENT - UMB_START_SEGMENT;
2454 Mcb->OwnerPsp = 0;
2455
2456 /* Get the environment strings */
2457 SourcePtr = Environment = GetEnvironmentStringsW();
2458 if (Environment == NULL) return FALSE;
2459
2460 /* Fill the DOS system environment block */
2461 while (*SourcePtr)
2462 {
2463 /* Get the size of the ASCII string */
2464 AsciiSize = WideCharToMultiByte(CP_ACP,
2465 0,
2466 SourcePtr,
2467 -1,
2468 NULL,
2469 0,
2470 NULL,
2471 NULL);
2472
2473 /* Allocate memory for the ASCII string */
2474 AsciiString = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, AsciiSize);
2475 if (AsciiString == NULL)
2476 {
2477 FreeEnvironmentStringsW(Environment);
2478 return FALSE;
2479 }
2480
2481 /* Convert to ASCII */
2482 WideCharToMultiByte(CP_ACP,
2483 0,
2484 SourcePtr,
2485 -1,
2486 AsciiString,
2487 AsciiSize,
2488 NULL,
2489 NULL);
2490
2491 /* Copy the string into DOS memory */
2492 strcpy(DestPtr, AsciiString);
2493
2494 /* Move to the next string */
2495 SourcePtr += wcslen(SourcePtr) + 1;
2496 DestPtr += strlen(AsciiString);
2497 *(DestPtr++) = 0;
2498
2499 /* Free the memory */
2500 HeapFree(GetProcessHeap(), 0, AsciiString);
2501 }
2502 *DestPtr = 0;
2503
2504 /* Free the memory allocated for environment strings */
2505 FreeEnvironmentStringsW(Environment);
2506
2507 /* Clear the current directory buffer */
2508 ZeroMemory(CurrentDirectories, sizeof(CurrentDirectories));
2509
2510 /* Get the current directory */
2511 if (!GetCurrentDirectoryA(MAX_PATH, CurrentDirectory))
2512 {
2513 // TODO: Use some kind of default path?
2514 return FALSE;
2515 }
2516
2517 /* Convert that to a DOS path */
2518 if (!GetShortPathNameA(CurrentDirectory, DosDirectory, DOS_DIR_LENGTH))
2519 {
2520 // TODO: Use some kind of default path?
2521 return FALSE;
2522 }
2523
2524 /* Set the drive */
2525 CurrentDrive = DosDirectory[0] - 'A';
2526
2527 /* Get the directory part of the path */
2528 Path = strchr(DosDirectory, '\\');
2529 if (Path != NULL)
2530 {
2531 /* Skip the backslash */
2532 Path++;
2533 }
2534
2535 /* Set the directory */
2536 if (Path != NULL)
2537 {
2538 strncpy(CurrentDirectories[CurrentDrive], Path, DOS_DIR_LENGTH);
2539 }
2540
2541 /* Read CONFIG.SYS */
2542 Stream = _wfopen(DOS_CONFIG_PATH, L"r");
2543 if (Stream != NULL)
2544 {
2545 while (fgetws(Buffer, 256, Stream))
2546 {
2547 // TODO: Parse the line
2548 }
2549 fclose(Stream);
2550 }
2551
2552 /* Initialize the SFT */
2553 for (i = 0; i < DOS_SFT_SIZE; i++)
2554 {
2555 DosSystemFileTable[i] = INVALID_HANDLE_VALUE;
2556 DosSftRefCount[i] = 0;
2557 }
2558
2559 /* Get handles to standard I/O devices */
2560 DosSystemFileTable[0] = GetStdHandle(STD_INPUT_HANDLE);
2561 DosSystemFileTable[1] = GetStdHandle(STD_OUTPUT_HANDLE);
2562 DosSystemFileTable[2] = GetStdHandle(STD_ERROR_HANDLE);
2563
2564 return TRUE;
2565 }
2566
2567 /* EOF */
A free Windows-compatible Operating System