?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Migrate create/open file functions to winedos.
[wine/multimedia.git] / dlls / winedos / int21.c
blobf050be04bf006e346722a18e8c85badc743a7018
1 /*
2 * DOS interrupt 21h handler
3 *
4 * Copyright 1993, 1994 Erik Bos
5 * Copyright 1996 Alexandre Julliard
6 * Copyright 1997 Andreas Mohr
7 * Copyright 1998 Uwe Bonnes
8 * Copyright 1998, 1999 Ove Kaaven
9 * Copyright 2003 Thomas Mertes
10 *
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
15 *
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 */
25
26 #include "config.h"
27
28 #include "windef.h"
29 #include "winbase.h"
30 #include "winternl.h"
31 #include "wine/winbase16.h"
32 #include "dosexe.h"
33 #include "miscemu.h"
34 #include "msdos.h"
35 #include "file.h"
36 #include "task.h"
37 #include "winerror.h"
38 #include "winuser.h"
39 #include "wine/unicode.h"
40 #include "wine/debug.h"
41
42 /*
43 * FIXME: Delete this reference when all int21 code has been moved to winedos.
44 */
45 extern void WINAPI INT_Int21Handler( CONTEXT86 *context );
46
47 /*
48 * Forward declarations.
49 */
50 static BOOL INT21_RenameFile( CONTEXT86 *context );
51
52 WINE_DEFAULT_DEBUG_CHANNEL(int21);
53
54
55 #include "pshpack1.h"
56
57 /*
58 * Structure for DOS data that can be accessed directly from applications.
59 * Real and protected mode pointers will be returned to this structure so
60 * the structure must be correctly packed.
61 */
62 typedef struct _INT21_HEAP {
63 WORD uppercase_size; /* Size of the following table in bytes */
64 BYTE uppercase_table[128]; /* Uppercase equivalents of chars from 0x80 to 0xff. */
65
66 WORD lowercase_size; /* Size of the following table in bytes */
67 BYTE lowercase_table[256]; /* Lowercase equivalents of chars from 0x00 to 0xff. */
68
69 WORD collating_size; /* Size of the following table in bytes */
70 BYTE collating_table[256]; /* Values used to sort characters from 0x00 to 0xff. */
71
72 WORD filename_size; /* Size of the following filename data in bytes */
73 BYTE filename_reserved1; /* 0x01 for MS-DOS 3.30-6.00 */
74 BYTE filename_lowest; /* Lowest permissible character value for filename */
75 BYTE filename_highest; /* Highest permissible character value for filename */
76 BYTE filename_reserved2; /* 0x00 for MS-DOS 3.30-6.00 */
77 BYTE filename_exclude_first; /* First illegal character in permissible range */
78 BYTE filename_exclude_last; /* Last illegal character in permissible range */
79 BYTE filename_reserved3; /* 0x02 for MS-DOS 3.30-6.00 */
80 BYTE filename_illegal_size; /* Number of terminators in the following table */
81 BYTE filename_illegal_table[16]; /* Characters which terminate a filename */
82
83 WORD dbcs_size; /* Number of valid ranges in the following table */
84 BYTE dbcs_table[16]; /* Start/end bytes for N ranges and 00/00 as terminator */
85
86 BYTE misc_indos; /* Interrupt 21 nesting flag */
87 } INT21_HEAP;
88
89
90 struct FCB {
91 BYTE drive_number;
92 CHAR file_name[8];
93 CHAR file_extension[3];
94 WORD current_block_number;
95 WORD logical_record_size;
96 DWORD file_size;
97 WORD date_of_last_write;
98 WORD time_of_last_write;
99 BYTE file_number;
100 BYTE attributes;
101 WORD starting_cluster;
102 WORD sequence_number;
103 BYTE file_attributes;
104 BYTE unused;
105 BYTE record_within_current_block;
106 BYTE random_access_record_number[4];
107 };
108
109
110 struct XFCB {
111 BYTE xfcb_signature;
112 BYTE reserved[5];
113 BYTE xfcb_file_attribute;
114 BYTE fcb[37];
115 };
116
117 #include "poppack.h"
118
119
120 /***********************************************************************
121 * INT21_GetCurrentDrive
122 *
123 * Return current drive using scheme (0=A:, 1=B:, 2=C:, ...) or
124 * MAX_DOS_DRIVES on error.
125 */
126 static BYTE INT21_GetCurrentDrive()
127 {
128 WCHAR current_directory[MAX_PATH];
129
130 if (!GetCurrentDirectoryW( MAX_PATH, current_directory ) ||
131 current_directory[1] != ':')
132 {
133 TRACE( "Failed to get current drive.\n" );
134 return MAX_DOS_DRIVES;
135 }
136
137 return toupperW( current_directory[0] ) - 'A';
138 }
139
140
141 /***********************************************************************
142 * INT21_MapDrive
143 *
144 * Convert drive number from scheme (0=default, 1=A:, 2=B:, ...) into
145 * scheme (0=A:, 1=B:, 2=C:, ...) or MAX_DOS_DRIVES on error.
146 */
147 static BYTE INT21_MapDrive( BYTE drive )
148 {
149 if (drive)
150 {
151 WCHAR drivespec[3] = {'A', ':', 0};
152 UINT drivetype;
153
154 drivespec[0] += drive - 1;
155 drivetype = GetDriveTypeW( drivespec );
156
157 if (drivetype == DRIVE_UNKNOWN || drivetype == DRIVE_NO_ROOT_DIR)
158 return MAX_DOS_DRIVES;
159
160 return drive - 1;
161 }
162
163 return INT21_GetCurrentDrive();
164 }
165
166
167 /***********************************************************************
168 * INT21_SetCurrentDrive
169 *
170 * Set current drive. Uses scheme (0=A:, 1=B:, 2=C:, ...).
171 */
172 static void INT21_SetCurrentDrive( BYTE drive )
173 {
174 WCHAR drivespec[3] = {'A', ':', 0};
175
176 drivespec[0] += drive;
177
178 if (!SetCurrentDirectoryW( drivespec ))
179 TRACE( "Failed to set current drive.\n" );
180 }
181
182
183 /***********************************************************************
184 * INT21_ReadChar
185 *
186 * Reads a character from the standard input.
187 * Extended keycodes will be returned as two separate characters.
188 */
189 static BOOL INT21_ReadChar( BYTE *input, CONTEXT86 *waitctx )
190 {
191 static BYTE pending_scan = 0;
192
193 if (pending_scan)
194 {
195 if (input)
196 *input = pending_scan;
197 if (waitctx)
198 pending_scan = 0;
199 return TRUE;
200 }
201 else
202 {
203 BYTE ascii;
204 BYTE scan;
205 if (!DOSVM_Int16ReadChar( &ascii, &scan, waitctx ))
206 return FALSE;
207
208 if (input)
209 *input = ascii;
210 if (waitctx && !ascii)
211 pending_scan = scan;
212 return TRUE;
213 }
214 }
215
216
217 /***********************************************************************
218 * INT21_GetSystemCountryCode
219 *
220 * Return DOS country code for default system locale.
221 */
222 static WORD INT21_GetSystemCountryCode( void )
223 {
224 /*
225 * FIXME: Determine country code. We should probably use
226 * DOSCONF structure for that.
227 */
228 return GetSystemDefaultLangID();
229 }
230
231
232 /***********************************************************************
233 * INT21_FillCountryInformation
234 *
235 * Fill 34-byte buffer with country information data using
236 * default system locale.
237 */
238 static void INT21_FillCountryInformation( BYTE *buffer )
239 {
240 /* 00 - WORD: date format
241 * 00 = mm/dd/yy
242 * 01 = dd/mm/yy
243 * 02 = yy/mm/dd
244 */
245 *(WORD*)(buffer + 0) = 0; /* FIXME: Get from locale */
246
247 /* 02 - BYTE[5]: ASCIIZ currency symbol string */
248 buffer[2] = '$'; /* FIXME: Get from locale */
249 buffer[3] = 0;
250
251 /* 07 - BYTE[2]: ASCIIZ thousands separator */
252 buffer[7] = 0; /* FIXME: Get from locale */
253 buffer[8] = 0;
254
255 /* 09 - BYTE[2]: ASCIIZ decimal separator */
256 buffer[9] = '.'; /* FIXME: Get from locale */
257 buffer[10] = 0;
258
259 /* 11 - BYTE[2]: ASCIIZ date separator */
260 buffer[11] = '/'; /* FIXME: Get from locale */
261 buffer[12] = 0;
262
263 /* 13 - BYTE[2]: ASCIIZ time separator */
264 buffer[13] = ':'; /* FIXME: Get from locale */
265 buffer[14] = 0;
266
267 /* 15 - BYTE: Currency format
268 * bit 2 = set if currency symbol replaces decimal point
269 * bit 1 = number of spaces between value and currency symbol
270 * bit 0 = 0 if currency symbol precedes value
271 * 1 if currency symbol follows value
272 */
273 buffer[15] = 0; /* FIXME: Get from locale */
274
275 /* 16 - BYTE: Number of digits after decimal in currency */
276 buffer[16] = 0; /* FIXME: Get from locale */
277
278 /* 17 - BYTE: Time format
279 * bit 0 = 0 if 12-hour clock
280 * 1 if 24-hour clock
281 */
282 buffer[17] = 1; /* FIXME: Get from locale */
283
284 /* 18 - DWORD: Address of case map routine */
285 *(DWORD*)(buffer + 18) = 0; /* FIXME: ptr to case map routine */
286
287 /* 22 - BYTE[2]: ASCIIZ data-list separator */
288 buffer[22] = ','; /* FIXME: Get from locale */
289 buffer[23] = 0;
290
291 /* 24 - BYTE[10]: Reserved */
292 memset( buffer + 24, 0, 10 );
293 }
294
295
296 /***********************************************************************
297 * INT21_FillHeap
298 *
299 * Initialize DOS heap.
300 */
301 static void INT21_FillHeap( INT21_HEAP *heap )
302 {
303 static const char terminators[] = "\"\\./[]:|<>+=;,";
304 int i;
305
306 /*
307 * Uppercase table.
308 */
309 heap->uppercase_size = 128;
310 for (i = 0; i < 128; i++)
311 heap->uppercase_table[i] = toupper( 128 + i );
312
313 /*
314 * Lowercase table.
315 */
316 heap->lowercase_size = 256;
317 for (i = 0; i < 256; i++)
318 heap->lowercase_table[i] = tolower( i );
319
320 /*
321 * Collating table.
322 */
323 heap->collating_size = 256;
324 for (i = 0; i < 256; i++)
325 heap->collating_table[i] = i;
326
327 /*
328 * Filename table.
329 */
330 heap->filename_size = 8 + strlen(terminators);
331 heap->filename_illegal_size = strlen(terminators);
332 strcpy( heap->filename_illegal_table, terminators );
333
334 heap->filename_reserved1 = 0x01;
335 heap->filename_lowest = 0; /* FIXME: correct value? */
336 heap->filename_highest = 0xff; /* FIXME: correct value? */
337 heap->filename_reserved2 = 0x00;
338 heap->filename_exclude_first = 0x00; /* FIXME: correct value? */
339 heap->filename_exclude_last = 0x00; /* FIXME: correct value? */
340 heap->filename_reserved3 = 0x02;
341
342 /*
343 * DBCS lead byte table. This table is empty.
344 */
345 heap->dbcs_size = 0;
346 memset( heap->dbcs_table, 0, sizeof(heap->dbcs_table) );
347
348 /*
349 * Initialize InDos flag.
350 */
351 heap->misc_indos = 0;
352 }
353
354
355 /***********************************************************************
356 * INT21_GetHeapSelector
357 *
358 * Get segment/selector for DOS heap (INT21_HEAP).
359 * Creates and initializes heap on first call.
360 */
361 static WORD INT21_GetHeapSelector( CONTEXT86 *context )
362 {
363 static WORD heap_segment = 0;
364 static WORD heap_selector = 0;
365 static BOOL heap_initialized = FALSE;
366
367 if (!heap_initialized)
368 {
369 INT21_HEAP *ptr = DOSVM_AllocDataUMB( sizeof(INT21_HEAP),
370 &heap_segment,
371 &heap_selector );
372 INT21_FillHeap( ptr );
373 heap_initialized = TRUE;
374 }
375
376 if (!ISV86(context) && DOSVM_IsWin16())
377 return heap_selector;
378 else
379 return heap_segment;
380 }
381
382
383 /***********************************************************************
384 * INT21_GetCurrentDirectory
385 *
386 * Handler for:
387 * - function 0x47
388 * - subfunction 0x47 of function 0x71
389 */
390 static BOOL INT21_GetCurrentDirectory( CONTEXT86 *context, BOOL islong )
391 {
392 char *buffer = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Esi);
393 BYTE new_drive = INT21_MapDrive( DL_reg(context) );
394 BYTE old_drive = INT21_GetCurrentDrive();
395 WCHAR pathW[MAX_PATH];
396 char pathA[MAX_PATH];
397 WCHAR *ptr = pathW;
398
399 TRACE( "drive %d\n", DL_reg(context) );
400
401 if (new_drive == MAX_DOS_DRIVES)
402 {
403 SetLastError(ERROR_INVALID_DRIVE);
404 return FALSE;
405 }
406
407 /*
408 * Grab current directory.
409 */
410
411 INT21_SetCurrentDrive( new_drive );
412 if (!GetCurrentDirectoryW( MAX_PATH, pathW ))
413 {
414 INT21_SetCurrentDrive( old_drive );
415 return FALSE;
416 }
417 INT21_SetCurrentDrive( old_drive );
418
419 /*
420 * Convert into short format.
421 */
422
423 if (!islong)
424 {
425 DWORD result = GetShortPathNameW( pathW, pathW, MAX_PATH );
426 if (!result)
427 return FALSE;
428 if (result > MAX_PATH)
429 {
430 WARN( "Short path too long!\n" );
431 SetLastError(ERROR_NETWORK_BUSY); /* Internal Wine error. */
432 return FALSE;
433 }
434 }
435
436 /*
437 * The returned pathname does not include
438 * the drive letter, colon or leading backslash.
439 */
440
441 if (ptr[0] == '\\')
442 {
443 /*
444 * FIXME: We should probably just strip host part from name...
445 */
446 FIXME( "UNC names are not supported.\n" );
447 SetLastError(ERROR_NETWORK_BUSY); /* Internal Wine error. */
448 return FALSE;
449 }
450 else if (!ptr[0] || ptr[1] != ':' || ptr[2] != '\\')
451 {
452 WARN( "Path is neither UNC nor DOS path: %s\n",
453 wine_dbgstr_w(ptr) );
454 SetLastError(ERROR_NETWORK_BUSY); /* Internal Wine error. */
455 return FALSE;
456 }
457 else
458 {
459 /* Remove drive letter, colon and leading backslash. */
460 ptr += 3;
461 }
462
463 /*
464 * Convert into OEM string.
465 */
466
467 if (!WideCharToMultiByte(CP_OEMCP, 0, ptr, -1, pathA,
468 MAX_PATH, NULL, NULL))
469 {
470 WARN( "Cannot convert path!\n" );
471 SetLastError(ERROR_NETWORK_BUSY); /* Internal Wine error. */
472 return FALSE;
473 }
474
475 /*
476 * Success.
477 */
478
479 if (!islong)
480 {
481 /* Undocumented success code. */
482 SET_AX( context, 0x0100 );
483
484 /* Truncate buffer to 64 bytes. */
485 pathA[63] = 0;
486 }
487
488 TRACE( "%c:=%s\n", 'A' + new_drive, pathA );
489
490 strcpy( buffer, pathA );
491 return TRUE;
492 }
493
494
495 /***********************************************************************
496 * INT21_SetCurrentDirectory
497 *
498 * Handler for:
499 * - function 0x3b
500 * - subfunction 0x3b of function 0x71
501 */
502 static BOOL INT21_SetCurrentDirectory( CONTEXT86 *context )
503 {
504 WCHAR dirW[MAX_PATH];
505 char *dirA = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
506 BYTE drive = INT21_GetCurrentDrive();
507 BOOL result;
508
509 TRACE( "SET CURRENT DIRECTORY %s\n", dirA );
510
511 MultiByteToWideChar(CP_OEMCP, 0, dirA, -1, dirW, MAX_PATH);
512 result = SetCurrentDirectoryW( dirW );
513
514 /* This function must not change current drive. */
515 INT21_SetCurrentDrive( drive );
516
517 return result;
518 }
519
520
521 /***********************************************************************
522 * INT21_CreateFile
523 *
524 * Handler for:
525 * - function 0x3c
526 * - function 0x3d
527 * - function 0x5b
528 * - function 0x6c
529 * - subfunction 0x6c of function 0x71
530 */
531 static BOOL INT21_CreateFile( CONTEXT86 *context,
532 DWORD pathSegOff,
533 BOOL returnStatus,
534 WORD dosAccessShare,
535 BYTE dosAction )
536 {
537 WORD dosStatus;
538 char *pathA = CTX_SEG_OFF_TO_LIN(context, context->SegDs, pathSegOff);
539 WCHAR pathW[MAX_PATH];
540 DWORD winAccess;
541 DWORD winAttributes;
542 HANDLE winHandle;
543 DWORD winMode;
544 DWORD winSharing;
545
546 TRACE( "CreateFile called: function=%02x, action=%02x, access/share=%04x, "
547 "create flags=%04x, file=%s.\n",
548 AH_reg(context), dosAction, dosAccessShare, CX_reg(context), pathA );
549
550 /*
551 * Application tried to create/open a file whose name
552 * ends with a backslash. This is not allowed.
553 *
554 * FIXME: This needs to be validated, especially the return value.
555 */
556 if (pathA[strlen(pathA) - 1] == '/')
557 {
558 SetLastError( ERROR_FILE_NOT_FOUND );
559 return FALSE;
560 }
561
562 /*
563 * Convert DOS action flags into Win32 creation disposition parameter.
564 */
565 switch(dosAction)
566 {
567 case 0x01:
568 winMode = OPEN_EXISTING;
569 break;
570 case 0x02:
571 winMode = TRUNCATE_EXISTING;
572 break;
573 case 0x10:
574 winMode = CREATE_NEW;
575 break;
576 case 0x11:
577 winMode = OPEN_ALWAYS;
578 break;
579 case 0x12:
580 winMode = CREATE_ALWAYS;
581 break;
582 default:
583 SetLastError( ERROR_INVALID_PARAMETER );
584 return FALSE;
585 }
586
587 /*
588 * Convert DOS access/share flags into Win32 desired access parameter.
589 */
590 switch(dosAccessShare & 0x07)
591 {
592 case OF_READ:
593 winAccess = GENERIC_READ;
594 break;
595 case OF_WRITE:
596 winAccess = GENERIC_WRITE;
597 break;
598 case OF_READWRITE:
599 winAccess = GENERIC_READ | GENERIC_WRITE;
600 break;
601 case 0x04:
602 /*
603 * Read-only, do not modify file's last-access time (DOS7).
604 *
605 * FIXME: How to prevent modification of last-access time?
606 */
607 winAccess = GENERIC_READ;
608 break;
609 default:
610 winAccess = 0;
611 }
612
613 /*
614 * Convert DOS access/share flags into Win32 share mode parameter.
615 */
616 switch(dosAccessShare & 0x70)
617 {
618 case OF_SHARE_EXCLUSIVE:
619 winSharing = 0;
620 break;
621 case OF_SHARE_DENY_WRITE:
622 winSharing = FILE_SHARE_READ;
623 break;
624 case OF_SHARE_DENY_READ:
625 winSharing = FILE_SHARE_WRITE;
626 break;
627 case OF_SHARE_DENY_NONE:
628 case OF_SHARE_COMPAT:
629 default:
630 winSharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
631 }
632
633 /*
634 * FIXME: Bit (dosAccessShare & 0x80) represents inheritance.
635 * What to do with this bit?
636 * FIXME: Bits in the high byte of dosAccessShare are not supported.
637 * See both function 0x6c and subfunction 0x6c of function 0x71 for
638 * definition of these bits.
639 */
640
641 /*
642 * Convert DOS create attributes into Win32 flags and attributes parameter.
643 */
644 if (winMode == OPEN_EXISTING || winMode == TRUNCATE_EXISTING)
645 {
646 winAttributes = 0;
647 }
648 else
649 {
650 WORD dosAttributes = CX_reg(context);
651
652 if (dosAttributes & FILE_ATTRIBUTE_LABEL)
653 {
654 /*
655 * Application tried to create volume label entry.
656 * This is difficult to support so we do not allow it.
657 *
658 * FIXME: If volume does not already have a label,
659 * this function is supposed to succeed.
660 */
661 SetLastError( ERROR_ACCESS_DENIED );
662 return TRUE;
663 }
664
665 winAttributes = dosAttributes &
666 (FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN |
667 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_ARCHIVE);
668 }
669
670 /*
671 * Open the file.
672 */
673 MultiByteToWideChar(CP_OEMCP, 0, pathA, -1, pathW, MAX_PATH);
674
675 winHandle = CreateFileW( pathW, winAccess, winSharing, NULL,
676 winMode, winAttributes, 0 );
677
678 if (winHandle == INVALID_HANDLE_VALUE)
679 return FALSE;
680
681 /*
682 * Determine DOS file status.
683 *
684 * 1 = file opened
685 * 2 = file created
686 * 3 = file replaced
687 */
688 switch(winMode)
689 {
690 case OPEN_EXISTING:
691 dosStatus = 1;
692 break;
693 case TRUNCATE_EXISTING:
694 dosStatus = 3;
695 break;
696 case CREATE_NEW:
697 dosStatus = 2;
698 break;
699 case OPEN_ALWAYS:
700 dosStatus = (GetLastError() == ERROR_ALREADY_EXISTS) ? 1 : 2;
701 break;
702 case CREATE_ALWAYS:
703 dosStatus = (GetLastError() == ERROR_ALREADY_EXISTS) ? 3 : 2;
704 break;
705 default:
706 dosStatus = 0;
707 }
708
709 /*
710 * Return DOS file handle and DOS status.
711 */
712 SET_AX( context, Win32HandleToDosFileHandle(winHandle) );
713
714 if (returnStatus)
715 SET_CX( context, dosStatus );
716
717 TRACE( "CreateFile finished: handle=%d, status=%d.\n",
718 AX_reg(context), dosStatus );
719
720 return TRUE;
721 }
722
723
724 /***********************************************************************
725 * INT21_BufferedInput
726 *
727 * Handler for function 0x0a and reading from console using
728 * function 0x3f.
729 *
730 * Reads a string of characters from standard input until
731 * enter key is pressed. Returns either number of characters
732 * read from console including terminating CR or
733 * zero if capacity was zero.
734 */
735 static WORD INT21_BufferedInput( CONTEXT86 *context, BYTE *ptr, WORD capacity )
736 {
737 BYTE length = 0;
738
739 /*
740 * Return immediately if capacity is zero.
741 */
742 if (capacity == 0)
743 return 0;
744
745 while(TRUE)
746 {
747 BYTE ascii;
748 BYTE scan;
749
750 DOSVM_Int16ReadChar( &ascii, &scan, context );
751
752 if (ascii == '\r' || ascii == '\n')
753 {
754 /*
755 * FIXME: What should be echoed here?
756 */
757 DOSVM_PutChar( '\r' );
758 DOSVM_PutChar( '\n' );
759 ptr[length] = '\r';
760 return length + 1;
761 }
762
763 /*
764 * FIXME: This function is supposed to support
765 * DOS editing keys...
766 */
767
768 /*
769 * If the buffer becomes filled to within one byte of
770 * capacity, DOS rejects all further characters up to,
771 * but not including, the terminating carriage return.
772 */
773 if (ascii != 0 && length < capacity-1)
774 {
775 DOSVM_PutChar( ascii );
776 ptr[length] = ascii;
777 length++;
778 }
779 }
780 }
781
782
783 /***********************************************************************
784 * INT21_GetCurrentDTA
785 */
786 static BYTE *INT21_GetCurrentDTA( CONTEXT86 *context )
787 {
788 TDB *pTask = GlobalLock16(GetCurrentTask());
789
790 /* FIXME: This assumes DTA was set correctly! */
791 return (BYTE *)CTX_SEG_OFF_TO_LIN( context, SELECTOROF(pTask->dta),
792 (DWORD)OFFSETOF(pTask->dta) );
793 }
794
795
796 /***********************************************************************
797 * INT21_OpenFileUsingFCB
798 *
799 * Handler for function 0x0f.
800 *
801 * PARAMS
802 * DX:DX [I/O] File control block (FCB or XFCB) of unopened file
803 *
804 * RETURNS (in AL)
805 * 0x00: successful
806 * 0xff: failed
807 *
808 * NOTES
809 * Opens a FCB file for read/write in compatibility mode. Upon calling
810 * the FCB must have the drive_number, file_name, and file_extension
811 * fields filled and all other bytes cleared.
812 */
813 static void INT21_OpenFileUsingFCB( CONTEXT86 *context )
814 {
815 struct FCB *fcb;
816 struct XFCB *xfcb;
817 char file_path[16];
818 char *pos;
819 HANDLE handle;
820 HFILE16 hfile16;
821 BY_HANDLE_FILE_INFORMATION info;
822 BYTE AL_result;
823
824 fcb = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
825 if (fcb->drive_number == 0xff) {
826 xfcb = (struct XFCB *) fcb;
827 fcb = (struct FCB *) xfcb->fcb;
828 } /* if */
829
830 AL_result = 0;
831 file_path[0] = 'A' + INT21_MapDrive( fcb->drive_number );
832
833 if (AL_result == 0) {
834 file_path[1] = ':';
835 pos = &file_path[2];
836 memcpy(pos, fcb->file_name, 8);
837 pos[8] = ' ';
838 pos[9] = '\0';
839 pos = strchr(pos, ' ');
840 *pos = '.';
841 pos++;
842 memcpy(pos, fcb->file_extension, 3);
843 pos[3] = ' ';
844 pos[4] = '\0';
845 pos = strchr(pos, ' ');
846 *pos = '\0';
847
848 handle = (HANDLE) _lopen(file_path, OF_READWRITE);
849 if (handle == INVALID_HANDLE_VALUE) {
850 TRACE("_lopen(\"%s\") failed: INVALID_HANDLE_VALUE\n", file_path);
851 AL_result = 0xff; /* failed */
852 } else {
853 hfile16 = Win32HandleToDosFileHandle(handle);
854 if (hfile16 == HFILE_ERROR16) {
855 TRACE("Win32HandleToDosFileHandle(%p) failed: HFILE_ERROR\n", handle);
856 CloseHandle(handle);
857 AL_result = 0xff; /* failed */
858 } else if (hfile16 > 255) {
859 TRACE("hfile16 (=%d) larger than 255 for \"%s\"\n", hfile16, file_path);
860 _lclose16(hfile16);
861 AL_result = 0xff; /* failed */
862 } else {
863 if (!GetFileInformationByHandle(handle, &info)) {
864 TRACE("GetFileInformationByHandle(%d, %p) for \"%s\" failed\n",
865 hfile16, handle, file_path);
866 _lclose16(hfile16);
867 AL_result = 0xff; /* failed */
868 } else {
869 fcb->drive_number = file_path[0] - 'A' + 1;
870 fcb->current_block_number = 0;
871 fcb->logical_record_size = 128;
872 fcb->file_size = info.nFileSizeLow;
873 FileTimeToDosDateTime(&info.ftLastWriteTime,
874 &fcb->date_of_last_write, &fcb->time_of_last_write);
875 fcb->file_number = hfile16;
876 fcb->attributes = 0xc2;
877 fcb->starting_cluster = 0; /* don't know correct init value */
878 fcb->sequence_number = 0; /* don't know correct init value */
879 fcb->file_attributes = info.dwFileAttributes;
880 /* The following fields are not initialized */
881 /* by the native function: */
882 /* unused */
883 /* record_within_current_block */
884 /* random_access_record_number */
885
886 TRACE("successful opened file \"%s\" as %d (handle %p)\n",
887 file_path, hfile16, handle);
888 AL_result = 0x00; /* successful */
889 } /* if */
890 } /* if */
891 } /* if */
892 } /* if */
893 SET_AL(context, AL_result);
894 }
895
896
897 /***********************************************************************
898 * INT21_CloseFileUsingFCB
899 *
900 * Handler for function 0x10.
901 *
902 * PARAMS
903 * DX:DX [I/O] File control block (FCB or XFCB) of open file
904 *
905 * RETURNS (in AL)
906 * 0x00: successful
907 * 0xff: failed
908 *
909 * NOTES
910 * Closes a FCB file.
911 */
912 static void INT21_CloseFileUsingFCB( CONTEXT86 *context )
913 {
914 struct FCB *fcb;
915 struct XFCB *xfcb;
916 BYTE AL_result;
917
918 fcb = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
919 if (fcb->drive_number == 0xff) {
920 xfcb = (struct XFCB *) fcb;
921 fcb = (struct FCB *) xfcb->fcb;
922 } /* if */
923
924 if (_lclose16((HFILE16) fcb->file_number) != 0) {
925 TRACE("_lclose16(%d) failed\n", fcb->file_number);
926 AL_result = 0xff; /* failed */
927 } else {
928 TRACE("successful closed file %d\n", fcb->file_number);
929 AL_result = 0x00; /* successful */
930 } /* if */
931 SET_AL(context, AL_result);
932 }
933
934
935 /***********************************************************************
936 * INT21_SequentialReadFromFCB
937 *
938 * Handler for function 0x14.
939 *
940 * PARAMS
941 * DX:DX [I/O] File control block (FCB or XFCB) of open file
942 *
943 * RETURNS (in AL)
944 * 0: successful
945 * 1: end of file, no data read
946 * 2: segment wrap in DTA, no data read (not returned now)
947 * 3: end of file, partial record read
948 *
949 * NOTES
950 * Reads a record with the size FCB->logical_record_size from the FCB
951 * to the disk transfer area. The position of the record is specified
952 * with FCB->current_block_number and FCB->record_within_current_block.
953 * Then FCB->current_block_number and FCB->record_within_current_block
954 * are updated to point to the next record. If a partial record is
955 * read, it is filled with zeros up to the FCB->logical_record_size.
956 */
957 static void INT21_SequentialReadFromFCB( CONTEXT86 *context )
958 {
959 struct FCB *fcb;
960 struct XFCB *xfcb;
961 HANDLE handle;
962 DWORD record_number;
963 long position;
964 BYTE *disk_transfer_area;
965 UINT bytes_read;
966 BYTE AL_result;
967
968 fcb = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
969 if (fcb->drive_number == 0xff) {
970 xfcb = (struct XFCB *) fcb;
971 fcb = (struct FCB *) xfcb->fcb;
972 } /* if */
973
974 handle = DosFileHandleToWin32Handle((HFILE16) fcb->file_number);
975 if (handle == INVALID_HANDLE_VALUE) {
976 TRACE("DosFileHandleToWin32Handle(%d) failed: INVALID_HANDLE_VALUE\n",
977 fcb->file_number);
978 AL_result = 0x01; /* end of file, no data read */
979 } else {
980 record_number = 128 * fcb->current_block_number + fcb->record_within_current_block;
981 position = SetFilePointer(handle, record_number * fcb->logical_record_size, NULL, 0);
982 if (position != record_number * fcb->logical_record_size) {
983 TRACE("seek(%d, %ld, 0) failed with %ld\n",
984 fcb->file_number, record_number * fcb->logical_record_size, position);
985 AL_result = 0x01; /* end of file, no data read */
986 } else {
987 disk_transfer_area = INT21_GetCurrentDTA(context);
988 bytes_read = _lread((HFILE) handle, disk_transfer_area, fcb->logical_record_size);
989 if (bytes_read != fcb->logical_record_size) {
990 TRACE("_lread(%d, %p, %d) failed with %d\n",
991 fcb->file_number, disk_transfer_area, fcb->logical_record_size, bytes_read);
992 if (bytes_read == 0) {
993 AL_result = 0x01; /* end of file, no data read */
994 } else {
995 memset(&disk_transfer_area[bytes_read], 0, fcb->logical_record_size - bytes_read);
996 AL_result = 0x03; /* end of file, partial record read */
997 } /* if */
998 } else {
999 TRACE("successful read %d bytes from record %ld (position %ld) of file %d (handle %p)\n",
1000 bytes_read, record_number, position, fcb->file_number, handle);
1001 AL_result = 0x00; /* successful */
1002 } /* if */
1003 } /* if */
1004 } /* if */
1005 if (AL_result == 0x00 || AL_result == 0x03) {
1006 if (fcb->record_within_current_block == 127) {
1007 fcb->record_within_current_block = 0;
1008 fcb->current_block_number++;
1009 } else {
1010 fcb->record_within_current_block++;
1011 } /* if */
1012 } /* if */
1013 SET_AL(context, AL_result);
1014 }
1015
1016
1017 /***********************************************************************
1018 * INT21_SequentialWriteToFCB
1019 *
1020 * Handler for function 0x15.
1021 *
1022 * PARAMS
1023 * DX:DX [I/O] File control block (FCB or XFCB) of open file
1024 *
1025 * RETURNS (in AL)
1026 * 0: successful
1027 * 1: disk full
1028 * 2: segment wrap in DTA (not returned now)
1029 *
1030 * NOTES
1031 * Writes a record with the size FCB->logical_record_size from the disk
1032 * transfer area to the FCB. The position of the record is specified
1033 * with FCB->current_block_number and FCB->record_within_current_block.
1034 * Then FCB->current_block_number and FCB->record_within_current_block
1035 * are updated to point to the next record.
1036 */
1037 static void INT21_SequentialWriteToFCB( CONTEXT86 *context )
1038 {
1039 struct FCB *fcb;
1040 struct XFCB *xfcb;
1041 HANDLE handle;
1042 DWORD record_number;
1043 long position;
1044 BYTE *disk_transfer_area;
1045 UINT bytes_written;
1046 BYTE AL_result;
1047
1048 fcb = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
1049 if (fcb->drive_number == 0xff) {
1050 xfcb = (struct XFCB *) fcb;
1051 fcb = (struct FCB *) xfcb->fcb;
1052 } /* if */
1053
1054 handle = DosFileHandleToWin32Handle((HFILE16) fcb->file_number);
1055 if (handle == INVALID_HANDLE_VALUE) {
1056 TRACE("DosFileHandleToWin32Handle(%d) failed: INVALID_HANDLE_VALUE\n",
1057 fcb->file_number);
1058 AL_result = 0x01; /* disk full */
1059 } else {
1060 record_number = 128 * fcb->current_block_number + fcb->record_within_current_block;
1061 position = SetFilePointer(handle, record_number * fcb->logical_record_size, NULL, 0);
1062 if (position != record_number * fcb->logical_record_size) {
1063 TRACE("seek(%d, %ld, 0) failed with %ld\n",
1064 fcb->file_number, record_number * fcb->logical_record_size, position);
1065 AL_result = 0x01; /* disk full */
1066 } else {
1067 disk_transfer_area = INT21_GetCurrentDTA(context);
1068 bytes_written = _lwrite((HFILE) handle, disk_transfer_area, fcb->logical_record_size);
1069 if (bytes_written != fcb->logical_record_size) {
1070 TRACE("_lwrite(%d, %p, %d) failed with %d\n",
1071 fcb->file_number, disk_transfer_area, fcb->logical_record_size, bytes_written);
1072 AL_result = 0x01; /* disk full */
1073 } else {
1074 TRACE("successful written %d bytes from record %ld (position %ld) of file %d (handle %p)\n",
1075 bytes_written, record_number, position, fcb->file_number, handle);
1076 AL_result = 0x00; /* successful */
1077 } /* if */
1078 } /* if */
1079 } /* if */
1080 if (AL_result == 0x00) {
1081 if (fcb->record_within_current_block == 127) {
1082 fcb->record_within_current_block = 0;
1083 fcb->current_block_number++;
1084 } else {
1085 fcb->record_within_current_block++;
1086 } /* if */
1087 } /* if */
1088 SET_AL(context, AL_result);
1089 }
1090
1091
1092 /***********************************************************************
1093 * INT21_ReadRandomRecordFromFCB
1094 *
1095 * Handler for function 0x21.
1096 *
1097 * PARAMS
1098 * DX:DX [I/O] File control block (FCB or XFCB) of open file
1099 *
1100 * RETURNS (in AL)
1101 * 0: successful
1102 * 1: end of file, no data read
1103 * 2: segment wrap in DTA, no data read (not returned now)
1104 * 3: end of file, partial record read
1105 *
1106 * NOTES
1107 * Reads a record with the size FCB->logical_record_size from
1108 * the FCB to the disk transfer area. The position of the record
1109 * is specified with FCB->random_access_record_number. The
1110 * FCB->random_access_record_number is not updated. If a partial record
1111 * is read, it is filled with zeros up to the FCB->logical_record_size.
1112 */
1113 static void INT21_ReadRandomRecordFromFCB( CONTEXT86 *context )
1114 {
1115 struct FCB *fcb;
1116 struct XFCB *xfcb;
1117 HANDLE handle;
1118 DWORD record_number;
1119 long position;
1120 BYTE *disk_transfer_area;
1121 UINT bytes_read;
1122 BYTE AL_result;
1123
1124 fcb = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
1125 if (fcb->drive_number == 0xff) {
1126 xfcb = (struct XFCB *) fcb;
1127 fcb = (struct FCB *) xfcb->fcb;
1128 } /* if */
1129
1130 memcpy(&record_number, fcb->random_access_record_number, 4);
1131 handle = DosFileHandleToWin32Handle((HFILE16) fcb->file_number);
1132 if (handle == INVALID_HANDLE_VALUE) {
1133 TRACE("DosFileHandleToWin32Handle(%d) failed: INVALID_HANDLE_VALUE\n",
1134 fcb->file_number);
1135 AL_result = 0x01; /* end of file, no data read */
1136 } else {
1137 position = SetFilePointer(handle, record_number * fcb->logical_record_size, NULL, 0);
1138 if (position != record_number * fcb->logical_record_size) {
1139 TRACE("seek(%d, %ld, 0) failed with %ld\n",
1140 fcb->file_number, record_number * fcb->logical_record_size, position);
1141 AL_result = 0x01; /* end of file, no data read */
1142 } else {
1143 disk_transfer_area = INT21_GetCurrentDTA(context);
1144 bytes_read = _lread((HFILE) handle, disk_transfer_area, fcb->logical_record_size);
1145 if (bytes_read != fcb->logical_record_size) {
1146 TRACE("_lread(%d, %p, %d) failed with %d\n",
1147 fcb->file_number, disk_transfer_area, fcb->logical_record_size, bytes_read);
1148 if (bytes_read == 0) {
1149 AL_result = 0x01; /* end of file, no data read */
1150 } else {
1151 memset(&disk_transfer_area[bytes_read], 0, fcb->logical_record_size - bytes_read);
1152 AL_result = 0x03; /* end of file, partial record read */
1153 } /* if */
1154 } else {
1155 TRACE("successful read %d bytes from record %ld (position %ld) of file %d (handle %p)\n",
1156 bytes_read, record_number, position, fcb->file_number, handle);
1157 AL_result = 0x00; /* successful */
1158 } /* if */
1159 } /* if */
1160 } /* if */
1161 fcb->current_block_number = record_number / 128;
1162 fcb->record_within_current_block = record_number % 128;
1163 SET_AL(context, AL_result);
1164 }
1165
1166
1167 /***********************************************************************
1168 * INT21_WriteRandomRecordToFCB
1169 *
1170 * Handler for function 0x22.
1171 *
1172 * PARAMS
1173 * DX:DX [I/O] File control block (FCB or XFCB) of open file
1174 *
1175 * RETURNS (in AL)
1176 * 0: successful
1177 * 1: disk full
1178 * 2: segment wrap in DTA (not returned now)
1179 *
1180 * NOTES
1181 * Writes a record with the size FCB->logical_record_size from
1182 * the disk transfer area to the FCB. The position of the record
1183 * is specified with FCB->random_access_record_number. The
1184 * FCB->random_access_record_number is not updated.
1185 */
1186 static void INT21_WriteRandomRecordToFCB( CONTEXT86 *context )
1187 {
1188 struct FCB *fcb;
1189 struct XFCB *xfcb;
1190 HANDLE handle;
1191 DWORD record_number;
1192 long position;
1193 BYTE *disk_transfer_area;
1194 UINT bytes_written;
1195 BYTE AL_result;
1196
1197 fcb = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
1198 if (fcb->drive_number == 0xff) {
1199 xfcb = (struct XFCB *) fcb;
1200 fcb = (struct FCB *) xfcb->fcb;
1201 } /* if */
1202
1203 memcpy(&record_number, fcb->random_access_record_number, 4);
1204 handle = DosFileHandleToWin32Handle((HFILE16) fcb->file_number);
1205 if (handle == INVALID_HANDLE_VALUE) {
1206 TRACE("DosFileHandleToWin32Handle(%d) failed: INVALID_HANDLE_VALUE\n",
1207 fcb->file_number);
1208 AL_result = 0x01; /* disk full */
1209 } else {
1210 position = SetFilePointer(handle, record_number * fcb->logical_record_size, NULL, 0);
1211 if (position != record_number * fcb->logical_record_size) {
1212 TRACE("seek(%d, %ld, 0) failed with %ld\n",
1213 fcb->file_number, record_number * fcb->logical_record_size, position);
1214 AL_result = 0x01; /* disk full */
1215 } else {
1216 disk_transfer_area = INT21_GetCurrentDTA(context);
1217 bytes_written = _lwrite((HFILE) handle, disk_transfer_area, fcb->logical_record_size);
1218 if (bytes_written != fcb->logical_record_size) {
1219 TRACE("_lwrite(%d, %p, %d) failed with %d\n",
1220 fcb->file_number, disk_transfer_area, fcb->logical_record_size, bytes_written);
1221 AL_result = 0x01; /* disk full */
1222 } else {
1223 TRACE("successful written %d bytes from record %ld (position %ld) of file %d (handle %p)\n",
1224 bytes_written, record_number, position, fcb->file_number, handle);
1225 AL_result = 0x00; /* successful */
1226 } /* if */
1227 } /* if */
1228 } /* if */
1229 fcb->current_block_number = record_number / 128;
1230 fcb->record_within_current_block = record_number % 128;
1231 SET_AL(context, AL_result);
1232 }
1233
1234
1235 /***********************************************************************
1236 * INT21_RandomBlockReadFromFCB
1237 *
1238 * Handler for function 0x27.
1239 *
1240 * PARAMS
1241 * CX [I/O] Number of records to read
1242 * DX:DX [I/O] File control block (FCB or XFCB) of open file
1243 *
1244 * RETURNS (in AL)
1245 * 0: successful
1246 * 1: end of file, no data read
1247 * 2: segment wrap in DTA, no data read (not returned now)
1248 * 3: end of file, partial record read
1249 *
1250 * NOTES
1251 * Reads several records with the size FCB->logical_record_size from
1252 * the FCB to the disk transfer area. The number of records to be
1253 * read is specified in the CX register. The position of the first
1254 * record is specified with FCB->random_access_record_number. The
1255 * FCB->random_access_record_number, the FCB->current_block_number
1256 * and FCB->record_within_current_block are updated to point to the
1257 * next record after the records read. If a partial record is read,
1258 * it is filled with zeros up to the FCB->logical_record_size. The
1259 * CX register is set to the number of successfully read records.
1260 */
1261 static void INT21_RandomBlockReadFromFCB( CONTEXT86 *context )
1262 {
1263 struct FCB *fcb;
1264 struct XFCB *xfcb;
1265 HANDLE handle;
1266 DWORD record_number;
1267 long position;
1268 BYTE *disk_transfer_area;
1269 UINT records_requested;
1270 UINT bytes_requested;
1271 UINT bytes_read;
1272 UINT records_read;
1273 BYTE AL_result;
1274
1275 fcb = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
1276 if (fcb->drive_number == 0xff) {
1277 xfcb = (struct XFCB *) fcb;
1278 fcb = (struct FCB *) xfcb->fcb;
1279 } /* if */
1280
1281 memcpy(&record_number, fcb->random_access_record_number, 4);
1282 handle = DosFileHandleToWin32Handle((HFILE16) fcb->file_number);
1283 if (handle == INVALID_HANDLE_VALUE) {
1284 TRACE("DosFileHandleToWin32Handle(%d) failed: INVALID_HANDLE_VALUE\n",
1285 fcb->file_number);
1286 records_read = 0;
1287 AL_result = 0x01; /* end of file, no data read */
1288 } else {
1289 position = SetFilePointer(handle, record_number * fcb->logical_record_size, NULL, 0);
1290 if (position != record_number * fcb->logical_record_size) {
1291 TRACE("seek(%d, %ld, 0) failed with %ld\n",
1292 fcb->file_number, record_number * fcb->logical_record_size, position);
1293 records_read = 0;
1294 AL_result = 0x01; /* end of file, no data read */
1295 } else {
1296 disk_transfer_area = INT21_GetCurrentDTA(context);
1297 records_requested = CX_reg(context);
1298 bytes_requested = (UINT) records_requested * fcb->logical_record_size;
1299 bytes_read = _lread((HFILE) handle, disk_transfer_area, bytes_requested);
1300 if (bytes_read != bytes_requested) {
1301 TRACE("_lread(%d, %p, %d) failed with %d\n",
1302 fcb->file_number, disk_transfer_area, bytes_requested, bytes_read);
1303 records_read = bytes_read / fcb->logical_record_size;
1304 if (bytes_read % fcb->logical_record_size == 0) {
1305 AL_result = 0x01; /* end of file, no data read */
1306 } else {
1307 records_read++;
1308 memset(&disk_transfer_area[bytes_read], 0, records_read * fcb->logical_record_size - bytes_read);
1309 AL_result = 0x03; /* end of file, partial record read */
1310 } /* if */
1311 } else {
1312 TRACE("successful read %d bytes from record %ld (position %ld) of file %d (handle %p)\n",
1313 bytes_read, record_number, position, fcb->file_number, handle);
1314 records_read = records_requested;
1315 AL_result = 0x00; /* successful */
1316 } /* if */
1317 } /* if */
1318 } /* if */
1319 record_number += records_read;
1320 memcpy(fcb->random_access_record_number, &record_number, 4);
1321 fcb->current_block_number = record_number / 128;
1322 fcb->record_within_current_block = record_number % 128;
1323 SET_CX(context, records_read);
1324 SET_AL(context, AL_result);
1325 }
1326
1327
1328 /***********************************************************************
1329 * INT21_RandomBlockWriteToFCB
1330 *
1331 * Handler for function 0x28.
1332 *
1333 * PARAMS
1334 * CX [I/O] Number of records to write
1335 * DX:DX [I/O] File control block (FCB or XFCB) of open file
1336 *
1337 * RETURNS (in AL)
1338 * 0: successful
1339 * 1: disk full
1340 * 2: segment wrap in DTA (not returned now)
1341 *
1342 * NOTES
1343 * Writes several records with the size FCB->logical_record_size from
1344 * the disk transfer area to the FCB. The number of records to be
1345 * written is specified in the CX register. The position of the first
1346 * record is specified with FCB->random_access_record_number. The
1347 * FCB->random_access_record_number, the FCB->current_block_number
1348 * and FCB->record_within_current_block are updated to point to the
1349 * next record after the records written. The CX register is set to
1350 * the number of successfully written records.
1351 */
1352 static void INT21_RandomBlockWriteToFCB( CONTEXT86 *context )
1353 {
1354 struct FCB *fcb;
1355 struct XFCB *xfcb;
1356 HANDLE handle;
1357 DWORD record_number;
1358 long position;
1359 BYTE *disk_transfer_area;
1360 UINT records_requested;
1361 UINT bytes_requested;
1362 UINT bytes_written;
1363 UINT records_written;
1364 BYTE AL_result;
1365
1366 fcb = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
1367 if (fcb->drive_number == 0xff) {
1368 xfcb = (struct XFCB *) fcb;
1369 fcb = (struct FCB *) xfcb->fcb;
1370 } /* if */
1371
1372 memcpy(&record_number, fcb->random_access_record_number, 4);
1373 handle = DosFileHandleToWin32Handle((HFILE16) fcb->file_number);
1374 if (handle == INVALID_HANDLE_VALUE) {
1375 TRACE("DosFileHandleToWin32Handle(%d) failed: INVALID_HANDLE_VALUE\n",
1376 fcb->file_number);
1377 records_written = 0;
1378 AL_result = 0x01; /* disk full */
1379 } else {
1380 position = SetFilePointer(handle, record_number * fcb->logical_record_size, NULL, 0);
1381 if (position != record_number * fcb->logical_record_size) {
1382 TRACE("seek(%d, %ld, 0) failed with %ld\n",
1383 fcb->file_number, record_number * fcb->logical_record_size, position);
1384 records_written = 0;
1385 AL_result = 0x01; /* disk full */
1386 } else {
1387 disk_transfer_area = INT21_GetCurrentDTA(context);
1388 records_requested = CX_reg(context);
1389 bytes_requested = (UINT) records_requested * fcb->logical_record_size;
1390 bytes_written = _lwrite((HFILE) handle, disk_transfer_area, bytes_requested);
1391 if (bytes_written != bytes_requested) {
1392 TRACE("_lwrite(%d, %p, %d) failed with %d\n",
1393 fcb->file_number, disk_transfer_area, bytes_requested, bytes_written);
1394 records_written = bytes_written / fcb->logical_record_size;
1395 AL_result = 0x01; /* disk full */
1396 } else {
1397 TRACE("successful write %d bytes from record %ld (position %ld) of file %d (handle %p)\n",
1398 bytes_written, record_number, position, fcb->file_number, handle);
1399 records_written = records_requested;
1400 AL_result = 0x00; /* successful */
1401 } /* if */
1402 } /* if */
1403 } /* if */
1404 record_number += records_written;
1405 memcpy(fcb->random_access_record_number, &record_number, 4);
1406 fcb->current_block_number = record_number / 128;
1407 fcb->record_within_current_block = record_number % 128;
1408 SET_CX(context, records_written);
1409 SET_AL(context, AL_result);
1410 }
1411
1412
1413 /***********************************************************************
1414 * INT21_CreateDirectory
1415 *
1416 * Handler for:
1417 * - function 0x39
1418 * - subfunction 0x39 of function 0x71
1419 * - subfunction 0xff of function 0x43 (CL == 0x39)
1420 */
1421 static BOOL INT21_CreateDirectory( CONTEXT86 *context )
1422 {
1423 WCHAR dirW[MAX_PATH];
1424 char *dirA = CTX_SEG_OFF_TO_LIN(context,
1425 context->SegDs,
1426 context->Edx);
1427
1428 TRACE( "CREATE DIRECTORY %s\n", dirA );
1429
1430 MultiByteToWideChar(CP_OEMCP, 0, dirA, -1, dirW, MAX_PATH);
1431
1432 if (CreateDirectoryW(dirW, NULL))
1433 return TRUE;
1434
1435 /*
1436 * FIXME: CreateDirectory's LastErrors will clash with the ones
1437 * used by DOS. AH=39 only returns 3 (path not found) and
1438 * 5 (access denied), while CreateDirectory return several
1439 * ones. Remap some of them. -Marcus
1440 */
1441 switch (GetLastError())
1442 {
1443 case ERROR_ALREADY_EXISTS:
1444 case ERROR_FILENAME_EXCED_RANGE:
1445 case ERROR_DISK_FULL:
1446 SetLastError(ERROR_ACCESS_DENIED);
1447 break;
1448 default:
1449 break;
1450 }
1451
1452 return FALSE;
1453 }
1454
1455
1456 /***********************************************************************
1457 * INT21_ExtendedCountryInformation
1458 *
1459 * Handler for function 0x65.
1460 */
1461 static void INT21_ExtendedCountryInformation( CONTEXT86 *context )
1462 {
1463 BYTE *dataptr = CTX_SEG_OFF_TO_LIN( context, context->SegEs, context->Edi );
1464
1465 TRACE( "GET EXTENDED COUNTRY INFORMATION, subfunction %02x\n",
1466 AL_reg(context) );
1467
1468 /*
1469 * Check subfunctions that are passed country and code page.
1470 */
1471 if (AL_reg(context) >= 0x01 && AL_reg(context) <= 0x07)
1472 {
1473 WORD country = DX_reg(context);
1474 WORD codepage = BX_reg(context);
1475
1476 if (country != 0xffff && country != INT21_GetSystemCountryCode())
1477 FIXME( "Requested info on non-default country %04x\n", country );
1478
1479 if (codepage != 0xffff && codepage != GetOEMCP())
1480 FIXME( "Requested info on non-default code page %04x\n", codepage );
1481 }
1482
1483 switch (AL_reg(context)) {
1484 case 0x00: /* SET GENERAL INTERNATIONALIZATION INFO */
1485 INT_BARF( context, 0x21 );
1486 SET_CFLAG( context );
1487 break;
1488
1489 case 0x01: /* GET GENERAL INTERNATIONALIZATION INFO */
1490 TRACE( "Get general internationalization info\n" );
1491 dataptr[0] = 0x01; /* Info ID */
1492 *(WORD*)(dataptr+1) = 38; /* Size of the following info */
1493 *(WORD*)(dataptr+3) = INT21_GetSystemCountryCode(); /* Country ID */
1494 *(WORD*)(dataptr+5) = GetOEMCP(); /* Code page */
1495 INT21_FillCountryInformation( dataptr + 7 );
1496 SET_CX( context, 41 ); /* Size of returned info */
1497 break;
1498
1499 case 0x02: /* GET POINTER TO UPPERCASE TABLE */
1500 case 0x04: /* GET POINTER TO FILENAME UPPERCASE TABLE */
1501 TRACE( "Get pointer to uppercase table\n" );
1502 dataptr[0] = AL_reg(context); /* Info ID */
1503 *(DWORD*)(dataptr+1) = MAKESEGPTR( INT21_GetHeapSelector( context ),
1504 offsetof(INT21_HEAP, uppercase_size) );
1505 SET_CX( context, 5 ); /* Size of returned info */
1506 break;
1507
1508 case 0x03: /* GET POINTER TO LOWERCASE TABLE */
1509 TRACE( "Get pointer to lowercase table\n" );
1510 dataptr[0] = 0x03; /* Info ID */
1511 *(DWORD*)(dataptr+1) = MAKESEGPTR( INT21_GetHeapSelector( context ),
1512 offsetof(INT21_HEAP, lowercase_size) );
1513 SET_CX( context, 5 ); /* Size of returned info */
1514 break;
1515
1516 case 0x05: /* GET POINTER TO FILENAME TERMINATOR TABLE */
1517 TRACE("Get pointer to filename terminator table\n");
1518 dataptr[0] = 0x05; /* Info ID */
1519 *(DWORD*)(dataptr+1) = MAKESEGPTR( INT21_GetHeapSelector( context ),
1520 offsetof(INT21_HEAP, filename_size) );
1521 SET_CX( context, 5 ); /* Size of returned info */
1522 break;
1523
1524 case 0x06: /* GET POINTER TO COLLATING SEQUENCE TABLE */
1525 TRACE("Get pointer to collating sequence table\n");
1526 dataptr[0] = 0x06; /* Info ID */
1527 *(DWORD*)(dataptr+1) = MAKESEGPTR( INT21_GetHeapSelector( context ),
1528 offsetof(INT21_HEAP, collating_size) );
1529 SET_CX( context, 5 ); /* Size of returned info */
1530 break;
1531
1532 case 0x07: /* GET POINTER TO DBCS LEAD BYTE TABLE */
1533 TRACE("Get pointer to DBCS lead byte table\n");
1534 dataptr[0] = 0x07; /* Info ID */
1535 *(DWORD*)(dataptr+1) = MAKESEGPTR( INT21_GetHeapSelector( context ),
1536 offsetof(INT21_HEAP, dbcs_size) );
1537 SET_CX( context, 5 ); /* Size of returned info */
1538 break;
1539
1540 case 0x20: /* CAPITALIZE CHARACTER */
1541 case 0xa0: /* CAPITALIZE FILENAME CHARACTER */
1542 TRACE("Convert char to uppercase\n");
1543 SET_DL( context, toupper(DL_reg(context)) );
1544 break;
1545
1546 case 0x21: /* CAPITALIZE STRING */
1547 case 0xa1: /* CAPITALIZE COUNTED FILENAME STRING */
1548 TRACE("Convert string to uppercase with length\n");
1549 {
1550 char *ptr = (char *)CTX_SEG_OFF_TO_LIN( context,
1551 context->SegDs,
1552 context->Edx );
1553 WORD len = CX_reg(context);
1554 while (len--) { *ptr = toupper(*ptr); ptr++; }
1555 }
1556 break;
1557
1558 case 0x22: /* CAPITALIZE ASCIIZ STRING */
1559 case 0xa2: /* CAPITALIZE ASCIIZ FILENAME */
1560 TRACE("Convert ASCIIZ string to uppercase\n");
1561 _strupr( (LPSTR)CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx) );
1562 break;
1563
1564 case 0x23: /* DETERMINE IF CHARACTER REPRESENTS YES/NO RESPONSE */
1565 INT_BARF( context, 0x21 );
1566 SET_CFLAG( context );
1567 break;
1568
1569 default:
1570 INT_BARF( context, 0x21 );
1571 SET_CFLAG(context);
1572 break;
1573 }
1574 }
1575
1576
1577 /***********************************************************************
1578 * INT21_FileAttributes
1579 *
1580 * Handler for:
1581 * - function 0x43
1582 * - subfunction 0x43 of function 0x71
1583 */
1584 static BOOL INT21_FileAttributes( CONTEXT86 *context,
1585 BYTE subfunction,
1586 BOOL islong )
1587 {
1588 WCHAR fileW[MAX_PATH];
1589 char *fileA = CTX_SEG_OFF_TO_LIN(context,
1590 context->SegDs,
1591 context->Edx);
1592 HANDLE handle;
1593 BOOL status;
1594 FILETIME filetime;
1595 DWORD result;
1596 WORD date, time;
1597
1598 switch (subfunction)
1599 {
1600 case 0x00: /* GET FILE ATTRIBUTES */
1601 TRACE( "GET FILE ATTRIBUTES for %s\n", fileA );
1602 MultiByteToWideChar(CP_OEMCP, 0, fileA, -1, fileW, MAX_PATH);
1603
1604 result = GetFileAttributesW( fileW );
1605 if (result == -1)
1606 return FALSE;
1607 else
1608 {
1609 SET_CX( context, (WORD)result );
1610 if (!islong)
1611 SET_AX( context, (WORD)result ); /* DR DOS */
1612 }
1613 break;
1614
1615 case 0x01: /* SET FILE ATTRIBUTES */
1616 TRACE( "SET FILE ATTRIBUTES 0x%02x for %s\n",
1617 CX_reg(context), fileA );
1618 MultiByteToWideChar(CP_OEMCP, 0, fileA, -1, fileW, MAX_PATH);
1619
1620 if (!SetFileAttributesW( fileW, CX_reg(context) ))
1621 return FALSE;
1622 break;
1623
1624 case 0x02: /* GET COMPRESSED FILE SIZE */
1625 TRACE( "GET COMPRESSED FILE SIZE for %s\n", fileA );
1626 MultiByteToWideChar(CP_OEMCP, 0, fileA, -1, fileW, MAX_PATH);
1627
1628 result = GetCompressedFileSizeW( fileW, NULL );
1629 if (result == INVALID_FILE_SIZE)
1630 return FALSE;
1631 else
1632 {
1633 SET_AX( context, LOWORD(result) );
1634 SET_DX( context, HIWORD(result) );
1635 }
1636 break;
1637
1638 case 0x03: /* SET FILE LAST-WRITTEN DATE AND TIME */
1639 if (!islong)
1640 INT_BARF( context, 0x21 );
1641 else
1642 {
1643 TRACE( "SET FILE LAST-WRITTEN DATE AND TIME, file %s\n", fileA );
1644 MultiByteToWideChar(CP_OEMCP, 0, fileA, -1, fileW, MAX_PATH);
1645
1646 handle = CreateFileW( fileW, GENERIC_WRITE,
1647 FILE_SHARE_READ | FILE_SHARE_WRITE,
1648 NULL, OPEN_EXISTING, 0, 0 );
1649 if (handle == INVALID_HANDLE_VALUE)
1650 return FALSE;
1651
1652 DosDateTimeToFileTime( DI_reg(context),
1653 CX_reg(context),
1654 &filetime );
1655 status = SetFileTime( handle, NULL, NULL, &filetime );
1656
1657 CloseHandle( handle );
1658 return status;
1659 }
1660 break;
1661
1662 case 0x04: /* GET FILE LAST-WRITTEN DATE AND TIME */
1663 if (!islong)
1664 INT_BARF( context, 0x21 );
1665 else
1666 {
1667 TRACE( "GET FILE LAST-WRITTEN DATE AND TIME, file %s\n", fileA );
1668 MultiByteToWideChar(CP_OEMCP, 0, fileA, -1, fileW, MAX_PATH);
1669
1670 handle = CreateFileW( fileW, GENERIC_READ,
1671 FILE_SHARE_READ | FILE_SHARE_WRITE,
1672 NULL, OPEN_EXISTING, 0, 0 );
1673 if (handle == INVALID_HANDLE_VALUE)
1674 return FALSE;
1675
1676 status = GetFileTime( handle, NULL, NULL, &filetime );
1677 if (status)
1678 {
1679 FileTimeToDosDateTime( &filetime, &date, &time );
1680 SET_DI( context, date );
1681 SET_CX( context, time );
1682 }
1683
1684 CloseHandle( handle );
1685 return status;
1686 }
1687 break;
1688
1689 case 0x05: /* SET FILE LAST ACCESS DATE */
1690 if (!islong)
1691 INT_BARF( context, 0x21 );
1692 else
1693 {
1694 TRACE( "SET FILE LAST ACCESS DATE, file %s\n", fileA );
1695 MultiByteToWideChar(CP_OEMCP, 0, fileA, -1, fileW, MAX_PATH);
1696
1697 handle = CreateFileW( fileW, GENERIC_WRITE,
1698 FILE_SHARE_READ | FILE_SHARE_WRITE,
1699 NULL, OPEN_EXISTING, 0, 0 );
1700 if (handle == INVALID_HANDLE_VALUE)
1701 return FALSE;
1702
1703 DosDateTimeToFileTime( DI_reg(context),
1704 0,
1705 &filetime );
1706 status = SetFileTime( handle, NULL, &filetime, NULL );
1707
1708 CloseHandle( handle );
1709 return status;
1710 }
1711 break;
1712
1713 case 0x06: /* GET FILE LAST ACCESS DATE */
1714 if (!islong)
1715 INT_BARF( context, 0x21 );
1716 else
1717 {
1718 TRACE( "GET FILE LAST ACCESS DATE, file %s\n", fileA );
1719 MultiByteToWideChar(CP_OEMCP, 0, fileA, -1, fileW, MAX_PATH);
1720
1721 handle = CreateFileW( fileW, GENERIC_READ,
1722 FILE_SHARE_READ | FILE_SHARE_WRITE,
1723 NULL, OPEN_EXISTING, 0, 0 );
1724 if (handle == INVALID_HANDLE_VALUE)
1725 return FALSE;
1726
1727 status = GetFileTime( handle, NULL, &filetime, NULL );
1728 if (status)
1729 {
1730 FileTimeToDosDateTime( &filetime, &date, NULL );
1731 SET_DI( context, date );
1732 }
1733
1734 CloseHandle( handle );
1735 return status;
1736 }
1737 break;
1738
1739 case 0x07: /* SET FILE CREATION DATE AND TIME */
1740 if (!islong)
1741 INT_BARF( context, 0x21 );
1742 else
1743 {
1744 TRACE( "SET FILE CREATION DATE AND TIME, file %s\n", fileA );
1745
1746 handle = CreateFileW( fileW, GENERIC_WRITE,
1747 FILE_SHARE_READ | FILE_SHARE_WRITE,
1748 NULL, OPEN_EXISTING, 0, 0 );
1749 if (handle == INVALID_HANDLE_VALUE)
1750 return FALSE;
1751
1752 /*
1753 * FIXME: SI has number of 10-millisecond units past time in CX.
1754 */
1755 DosDateTimeToFileTime( DI_reg(context),
1756 CX_reg(context),
1757 &filetime );
1758 status = SetFileTime( handle, &filetime, NULL, NULL );
1759
1760 CloseHandle( handle );
1761 return status;
1762 }
1763 break;
1764
1765 case 0x08: /* GET FILE CREATION DATE AND TIME */
1766 if (!islong)
1767 INT_BARF( context, 0x21 );
1768 else
1769 {
1770 TRACE( "GET FILE CREATION DATE AND TIME, handle %d\n",
1771 BX_reg(context) );
1772
1773 handle = CreateFileW( fileW, GENERIC_READ,
1774 FILE_SHARE_READ | FILE_SHARE_WRITE,
1775 NULL, OPEN_EXISTING, 0, 0 );
1776 if (handle == INVALID_HANDLE_VALUE)
1777 return FALSE;
1778
1779 status = GetFileTime( handle, &filetime, NULL, NULL );
1780 if (status)
1781 {
1782 FileTimeToDosDateTime( &filetime, &date, &time );
1783 SET_DI( context, date );
1784 SET_CX( context, time );
1785 /*
1786 * FIXME: SI has number of 10-millisecond units past
1787 * time in CX.
1788 */
1789 SET_SI( context, 0 );
1790 }
1791
1792 CloseHandle(handle);
1793 return status;
1794 }
1795 break;
1796
1797 case 0xff: /* EXTENDED-LENGTH FILENAME OPERATIONS */
1798 if (islong || context->Ebp != 0x5053)
1799 INT_BARF( context, 0x21 );
1800 else
1801 {
1802 switch(CL_reg(context))
1803 {
1804 case 0x39:
1805 if (!INT21_CreateDirectory( context ))
1806 return FALSE;
1807 break;
1808
1809 case 0x56:
1810 if (!INT21_RenameFile( context ))
1811 return FALSE;
1812 break;
1813
1814 default:
1815 INT_BARF( context, 0x21 );
1816 }
1817 }
1818 break;
1819
1820 default:
1821 INT_BARF( context, 0x21 );
1822 }
1823
1824 return TRUE;
1825 }
1826
1827
1828 /***********************************************************************
1829 * INT21_FileDateTime
1830 *
1831 * Handler for function 0x57.
1832 */
1833 static BOOL INT21_FileDateTime( CONTEXT86 *context )
1834 {
1835 HANDLE handle = DosFileHandleToWin32Handle(BX_reg(context));
1836 FILETIME filetime;
1837 WORD date, time;
1838
1839 switch (AL_reg(context)) {
1840 case 0x00: /* Get last-written stamp */
1841 TRACE( "GET FILE LAST-WRITTEN DATE AND TIME, handle %d\n",
1842 BX_reg(context) );
1843 {
1844 if (!GetFileTime( handle, NULL, NULL, &filetime ))
1845 return FALSE;
1846 FileTimeToDosDateTime( &filetime, &date, &time );
1847 SET_DX( context, date );
1848 SET_CX( context, time );
1849 break;
1850 }
1851
1852 case 0x01: /* Set last-written stamp */
1853 TRACE( "SET FILE LAST-WRITTEN DATE AND TIME, handle %d\n",
1854 BX_reg(context) );
1855 {
1856 DosDateTimeToFileTime( DX_reg(context),
1857 CX_reg(context),
1858 &filetime );
1859 if (!SetFileTime( handle, NULL, NULL, &filetime ))
1860 return FALSE;
1861 break;
1862 }
1863
1864 case 0x04: /* Get last access stamp, DOS 7 */
1865 TRACE( "GET FILE LAST ACCESS DATE AND TIME, handle %d\n",
1866 BX_reg(context) );
1867 {
1868 if (!GetFileTime( handle, NULL, &filetime, NULL ))
1869 return FALSE;
1870 FileTimeToDosDateTime( &filetime, &date, &time );
1871 SET_DX( context, date );
1872 SET_CX( context, time );
1873 break;
1874 }
1875
1876 case 0x05: /* Set last access stamp, DOS 7 */
1877 TRACE( "SET FILE LAST ACCESS DATE AND TIME, handle %d\n",
1878 BX_reg(context) );
1879 {
1880 DosDateTimeToFileTime( DX_reg(context),
1881 CX_reg(context),
1882 &filetime );
1883 if (!SetFileTime( handle, NULL, &filetime, NULL ))
1884 return FALSE;
1885 break;
1886 }
1887
1888 case 0x06: /* Get creation stamp, DOS 7 */
1889 TRACE( "GET FILE CREATION DATE AND TIME, handle %d\n",
1890 BX_reg(context) );
1891 {
1892 if (!GetFileTime( handle, &filetime, NULL, NULL ))
1893 return FALSE;
1894 FileTimeToDosDateTime( &filetime, &date, &time );
1895 SET_DX( context, date );
1896 SET_CX( context, time );
1897 /*
1898 * FIXME: SI has number of 10-millisecond units past time in CX.
1899 */
1900 SET_SI( context, 0 );
1901 break;
1902 }
1903
1904 case 0x07: /* Set creation stamp, DOS 7 */
1905 TRACE( "SET FILE CREATION DATE AND TIME, handle %d\n",
1906 BX_reg(context) );
1907 {
1908 /*
1909 * FIXME: SI has number of 10-millisecond units past time in CX.
1910 */
1911 DosDateTimeToFileTime( DX_reg(context),
1912 CX_reg(context),
1913 &filetime );
1914 if (!SetFileTime( handle, &filetime, NULL, NULL ))
1915 return FALSE;
1916 break;
1917 }
1918
1919 default:
1920 INT_BARF( context, 0x21 );
1921 break;
1922 }
1923
1924 return TRUE;
1925 }
1926
1927
1928 /***********************************************************************
1929 * INT21_GetPSP
1930 *
1931 * Handler for functions 0x51 and 0x62.
1932 */
1933 static void INT21_GetPSP( CONTEXT86 *context )
1934 {
1935 TRACE( "GET CURRENT PSP ADDRESS (%02x)\n", AH_reg(context) );
1936
1937 /*
1938 * FIXME: should we return the original DOS PSP upon
1939 * Windows startup ?
1940 */
1941 if (!ISV86(context) && DOSVM_IsWin16())
1942 SET_BX( context, LOWORD(GetCurrentPDB16()) );
1943 else
1944 SET_BX( context, DOSVM_psp );
1945 }
1946
1947
1948 /***********************************************************************
1949 * INT21_Ioctl_Block
1950 *
1951 * Handler for block device IOCTLs.
1952 */
1953 static void INT21_Ioctl_Block( CONTEXT86 *context )
1954 {
1955 BYTE *dataptr;
1956 BYTE drive = INT21_MapDrive( BL_reg(context) );
1957 WCHAR drivespec[4] = {'A', ':', '\\', 0};
1958 UINT drivetype;
1959
1960 drivespec[0] += drive;
1961 drivetype = GetDriveTypeW( drivespec );
1962
1963 if (drivetype == DRIVE_UNKNOWN || drivetype == DRIVE_NO_ROOT_DIR)
1964 {
1965 TRACE( "IOCTL - SUBFUNCTION %d - INVALID DRIVE %c:\n",
1966 AL_reg(context), 'A' + drive );
1967 SetLastError( ERROR_INVALID_DRIVE );
1968 SET_AX( context, ERROR_INVALID_DRIVE );
1969 SET_CFLAG( context );
1970 return;
1971 }
1972
1973 switch (AL_reg(context))
1974 {
1975 case 0x04: /* READ FROM BLOCK DEVICE CONTROL CHANNEL */
1976 case 0x05: /* WRITE TO BLOCK DEVICE CONTROL CHANNEL */
1977 INT_BARF( context, 0x21 );
1978 break;
1979
1980 case 0x08: /* CHECK IF BLOCK DEVICE REMOVABLE */
1981 TRACE( "IOCTL - CHECK IF BLOCK DEVICE REMOVABLE - %c:\n",
1982 'A' + drive );
1983
1984 if (drivetype == DRIVE_REMOVABLE)
1985 SET_AX( context, 0 ); /* removable */
1986 else
1987 SET_AX( context, 1 ); /* not removable */
1988 break;
1989
1990 case 0x09: /* CHECK IF BLOCK DEVICE REMOTE */
1991 TRACE( "IOCTL - CHECK IF BLOCK DEVICE REMOTE - %c:\n",
1992 'A' + drive );
1993
1994 if (drivetype == DRIVE_REMOTE)
1995 SET_DX( context, (1<<9) | (1<<12) ); /* remote + no direct IO */
1996 else
1997 SET_DX( context, 0 ); /* FIXME: use driver attr here */
1998 break;
1999
2000 case 0x0d: /* GENERIC BLOCK DEVICE REQUEST */
2001 /* Get pointer to IOCTL parameter block. */
2002 dataptr = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
2003
2004 switch (CX_reg(context))
2005 {
2006 case 0x0841: /* write logical device track */
2007 TRACE( "GENERIC IOCTL - Write logical device track - %c:\n",
2008 'A' + drive);
2009 {
2010 WORD head = *(WORD *)dataptr+1;
2011 WORD cyl = *(WORD *)dataptr+3;
2012 WORD sect = *(WORD *)dataptr+5;
2013 WORD nrsect = *(WORD *)dataptr+7;
2014 BYTE *data = (BYTE *)dataptr+9; /* FIXME: is this correct? */
2015
2016 if (!DOSVM_RawWrite(drive, head*cyl*sect, nrsect, data, FALSE))
2017 {
2018 SET_AX( context, ERROR_WRITE_FAULT );
2019 SET_CFLAG(context);
2020 }
2021 }
2022 break;
2023
2024 case 0x084a: /* lock logical volume */
2025 TRACE( "GENERIC IOCTL - Lock logical volume, level %d mode %d - %c:\n",
2026 BH_reg(context), DX_reg(context), 'A' + drive );
2027 break;
2028
2029 case 0x0860: /* get device parameters */
2030 INT_Int21Handler( context );
2031 break;
2032
2033 case 0x0861: /* read logical device track */
2034 TRACE( "GENERIC IOCTL - Read logical device track - %c:\n",
2035 'A' + drive);
2036 {
2037 WORD head = *(WORD *)dataptr+1;
2038 WORD cyl = *(WORD *)dataptr+3;
2039 WORD sect = *(WORD *)dataptr+5;
2040 WORD nrsect = *(WORD *)dataptr+7;
2041 BYTE *data = (BYTE *)dataptr+9; /* FIXME: is this correct? */
2042
2043 if (!DOSVM_RawRead(drive, head*cyl*sect, nrsect, data, FALSE))
2044 {
2045 SET_AX( context, ERROR_READ_FAULT );
2046 SET_CFLAG(context);
2047 }
2048 }
2049 break;
2050
2051 case 0x0866: /* get volume serial number */
2052 INT_Int21Handler( context );
2053 break;
2054
2055 case 0x086a: /* unlock logical volume */
2056 TRACE( "GENERIC IOCTL - Logical volume unlocked - %c:\n",
2057 'A' + drive );
2058 break;
2059
2060 case 0x086f: /* get drive map information */
2061 INT_Int21Handler( context );
2062 break;
2063
2064 case 0x0872:
2065 INT_Int21Handler( context );
2066 break;
2067
2068 default:
2069 INT_BARF( context, 0x21 );
2070 }
2071 break;
2072
2073 case 0x0e: /* GET LOGICAL DRIVE MAP */
2074 TRACE( "IOCTL - GET LOGICAL DRIVE MAP - %c:\n",
2075 'A' + drive );
2076 /* FIXME: this is not correct if drive has mappings */
2077 SET_AL( context, 0 ); /* drive has no mapping */
2078 break;
2079
2080 case 0x0f: /* SET LOGICAL DRIVE MAP */
2081 INT_Int21Handler( context );
2082 break;
2083
2084 case 0x11: /* QUERY GENERIC IOCTL CAPABILITY */
2085 default:
2086 INT_BARF( context, 0x21 );
2087 }
2088 }
2089
2090
2091 /***********************************************************************
2092 * INT21_Ioctl_Char
2093 *
2094 * Handler for character device IOCTLs.
2095 */
2096 static void INT21_Ioctl_Char( CONTEXT86 *context )
2097 {
2098 static const WCHAR emmxxxx0W[] = {'E','M','M','X','X','X','X','0',0};
2099 static const WCHAR scsimgrW[] = {'S','C','S','I','M','G','R','$',0};
2100
2101 HANDLE handle = DosFileHandleToWin32Handle(BX_reg(context));
2102 const DOS_DEVICE *dev = DOSFS_GetDeviceByHandle(handle);
2103
2104 if (dev && !strcmpiW( dev->name, emmxxxx0W ))
2105 {
2106 EMS_Ioctl_Handler(context);
2107 return;
2108 }
2109
2110 if (dev && !strcmpiW( dev->name, scsimgrW ) && AL_reg(context) == 2)
2111 {
2112 DOSVM_ASPIHandler(context);
2113 return;
2114 }
2115
2116 switch (AL_reg(context))
2117 {
2118 case 0x00: /* GET DEVICE INFORMATION */
2119 TRACE( "IOCTL - GET DEVICE INFORMATION - %d\n", BX_reg(context) );
2120 if (dev)
2121 {
2122 /*
2123 * Returns attribute word in DX:
2124 * Bit 14 - Device driver can process IOCTL requests.
2125 * Bit 13 - Output until busy supported.
2126 * Bit 11 - Driver supports OPEN/CLOSE calls.
2127 * Bit 8 - Unknown.
2128 * Bit 7 - Set (indicates device).
2129 * Bit 6 - EOF on input.
2130 * Bit 5 - Raw (binary) mode.
2131 * Bit 4 - Device is special (uses int29).
2132 * Bit 3 - Clock device.
2133 * Bit 2 - NUL device.
2134 * Bit 1 - Standard output.
2135 * Bit 0 - Standard input.
2136 */
2137 SET_DX( context, dev->flags );
2138 }
2139 else
2140 {
2141 /*
2142 * Returns attribute word in DX:
2143 * Bit 15 - File is remote.
2144 * Bit 14 - Don't set file date/time on closing.
2145 * Bit 11 - Media not removable.
2146 * Bit 8 - Generate int24 if no disk space on write
2147 * or read past end of file
2148 * Bit 7 - Clear (indicates file).
2149 * Bit 6 - File has not been written.
2150 * Bit 5..0 - Drive number (0=A:,...)
2151 *
2152 * FIXME: Should check if file is on remote or removable drive.
2153 * FIXME: Should use drive file is located on (and not current).
2154 */
2155 SET_DX( context, 0x0140 + INT21_GetCurrentDrive() );
2156 }
2157 break;
2158
2159 case 0x01: /* SET DEVICE INFORMATION */
2160 case 0x02: /* READ FROM CHARACTER DEVICE CONTROL CHANNEL */
2161 case 0x03: /* WRITE TO CHARACTER DEVICE CONTROL CHANNEL */
2162 case 0x06: /* GET INPUT STATUS */
2163 case 0x07: /* GET OUTPUT STATUS */
2164 INT_BARF( context, 0x21 );
2165 break;
2166
2167 case 0x0a: /* CHECK IF HANDLE IS REMOTE */
2168 TRACE( "IOCTL - CHECK IF HANDLE IS REMOTE - %d\n", BX_reg(context) );
2169 /*
2170 * Returns attribute word in DX:
2171 * Bit 15 - Set if remote.
2172 * Bit 14 - Set if date/time not set on close.
2173 *
2174 * FIXME: Should check if file is on remote drive.
2175 */
2176 SET_DX( context, 0 );
2177 break;
2178
2179 case 0x0c: /* GENERIC CHARACTER DEVICE REQUEST */
2180 case 0x10: /* QUERY GENERIC IOCTL CAPABILITY */
2181 default:
2182 INT_BARF( context, 0x21 );
2183 }
2184 }
2185
2186
2187 /***********************************************************************
2188 * INT21_Ioctl
2189 *
2190 * Handler for function 0x44.
2191 */
2192 static void INT21_Ioctl( CONTEXT86 *context )
2193 {
2194 switch (AL_reg(context))
2195 {
2196 case 0x00:
2197 case 0x01:
2198 case 0x02:
2199 case 0x03:
2200 INT21_Ioctl_Char( context );
2201 break;
2202
2203 case 0x04:
2204 case 0x05:
2205 INT21_Ioctl_Block( context );
2206 break;
2207
2208 case 0x06:
2209 case 0x07:
2210 INT21_Ioctl_Char( context );
2211 break;
2212
2213 case 0x08:
2214 case 0x09:
2215 INT21_Ioctl_Block( context );
2216 break;
2217
2218 case 0x0a:
2219 INT21_Ioctl_Char( context );
2220 break;
2221
2222 case 0x0b: /* SET SHARING RETRY COUNT */
2223 TRACE( "SET SHARING RETRY COUNT: Pause %d, retries %d.\n",
2224 CX_reg(context), DX_reg(context) );
2225 if (!CX_reg(context))
2226 {
2227 SET_AX( context, 1 );
2228 SET_CFLAG( context );
2229 }
2230 else
2231 {
2232 DOSMEM_LOL()->sharing_retry_delay = CX_reg(context);
2233 if (DX_reg(context))
2234 DOSMEM_LOL()->sharing_retry_count = DX_reg(context);
2235 RESET_CFLAG( context );
2236 }
2237 break;
2238
2239 case 0x0c:
2240 INT21_Ioctl_Char( context );
2241 break;
2242
2243 case 0x0d:
2244 case 0x0e:
2245 case 0x0f:
2246 INT21_Ioctl_Block( context );
2247 break;
2248
2249 case 0x10:
2250 INT21_Ioctl_Char( context );
2251 break;
2252
2253 case 0x11:
2254 INT21_Ioctl_Block( context );
2255 break;
2256
2257 case 0x12: /* DR DOS - DETERMINE DOS TYPE (OBSOLETE FUNCTION) */
2258 TRACE( "DR DOS - DETERMINE DOS TYPE (OBSOLETE FUNCTION)\n" );
2259 SET_CFLAG(context); /* Error / This is not DR DOS. */
2260 SET_AX( context, 0x0001 ); /* Invalid function */
2261 break;
2262
2263 case 0x52: /* DR DOS - DETERMINE DOS TYPE */
2264 TRACE( "DR DOS - DETERMINE DOS TYPE\n" );
2265 SET_CFLAG(context); /* Error / This is not DR DOS. */
2266 SET_AX( context, 0x0001 ); /* Invalid function */
2267 break;
2268
2269 case 0xe0: /* Sun PC-NFS API */
2270 TRACE( "Sun PC-NFS API\n" );
2271 /* not installed */
2272 break;
2273
2274 default:
2275 INT_BARF( context, 0x21 );
2276 }
2277 }
2278
2279
2280 /***********************************************************************
2281 * INT21_LongFilename
2282 *
2283 * Handler for function 0x71.
2284 */
2285 static void INT21_LongFilename( CONTEXT86 *context )
2286 {
2287 BOOL bSetDOSExtendedError = FALSE;
2288
2289 if (HIBYTE(HIWORD(GetVersion16())) < 0x07)
2290 {
2291 TRACE( "LONG FILENAME - functions supported only under DOS7\n" );
2292 SET_CFLAG( context );
2293 SET_AL( context, 0 );
2294 return;
2295 }
2296
2297 switch (AL_reg(context))
2298 {
2299 case 0x0d: /* RESET DRIVE */
2300 INT_BARF( context, 0x21 );
2301 break;
2302
2303 case 0x39: /* LONG FILENAME - MAKE DIRECTORY */
2304 if (!INT21_CreateDirectory( context ))
2305 bSetDOSExtendedError = TRUE;
2306 break;
2307
2308 case 0x3a: /* LONG FILENAME - REMOVE DIRECTORY */
2309 {
2310 WCHAR dirW[MAX_PATH];
2311 char *dirA = CTX_SEG_OFF_TO_LIN(context,
2312 context->SegDs, context->Edx);
2313
2314 TRACE( "LONG FILENAME - REMOVE DIRECTORY %s\n", dirA );
2315 MultiByteToWideChar(CP_OEMCP, 0, dirA, -1, dirW, MAX_PATH);
2316
2317 if (!RemoveDirectoryW( dirW ))
2318 bSetDOSExtendedError = TRUE;
2319 }
2320 break;
2321
2322 case 0x3b: /* LONG FILENAME - CHANGE DIRECTORY */
2323 if (!INT21_SetCurrentDirectory( context ))
2324 bSetDOSExtendedError = TRUE;
2325 break;
2326
2327 case 0x41: /* LONG FILENAME - DELETE FILE */
2328 {
2329 WCHAR fileW[MAX_PATH];
2330 char *fileA = CTX_SEG_OFF_TO_LIN(context,
2331 context->SegDs, context->Edx);
2332
2333 TRACE( "LONG FILENAME - DELETE FILE %s\n", fileA );
2334 MultiByteToWideChar(CP_OEMCP, 0, fileA, -1, fileW, MAX_PATH);
2335
2336 if (!DeleteFileW( fileW ))
2337 bSetDOSExtendedError = TRUE;
2338 }
2339 break;
2340
2341 case 0x43: /* LONG FILENAME - EXTENDED GET/SET FILE ATTRIBUTES */
2342 if (!INT21_FileAttributes( context, BL_reg(context), TRUE ))
2343 bSetDOSExtendedError = TRUE;
2344 break;
2345
2346 case 0x47: /* LONG FILENAME - GET CURRENT DIRECTORY */
2347 if (!INT21_GetCurrentDirectory( context, TRUE ))
2348 bSetDOSExtendedError = TRUE;
2349 break;
2350
2351 case 0x4e: /* LONG FILENAME - FIND FIRST MATCHING FILE */
2352 case 0x4f: /* LONG FILENAME - FIND NEXT MATCHING FILE */
2353 INT_Int21Handler( context );
2354 break;
2355
2356 case 0x56: /* LONG FILENAME - RENAME FILE */
2357 if (!INT21_RenameFile(context))
2358 bSetDOSExtendedError = TRUE;
2359 break;
2360
2361 case 0x60: /* LONG FILENAME - CONVERT PATH */
2362 INT_Int21Handler( context );
2363 break;
2364
2365 case 0x6c: /* LONG FILENAME - CREATE OR OPEN FILE */
2366 if (!INT21_CreateFile( context, context->Esi, TRUE,
2367 BX_reg(context), DL_reg(context) ))
2368 bSetDOSExtendedError = TRUE;
2369 break;
2370
2371 case 0xa0: /* LONG FILENAME - GET VOLUME INFORMATION */
2372 case 0xa1: /* LONG FILENAME - "FindClose" - TERMINATE DIRECTORY SEARCH */
2373 INT_Int21Handler( context );
2374 break;
2375
2376 case 0xa6: /* LONG FILENAME - GET FILE INFO BY HANDLE */
2377 {
2378 HANDLE handle = DosFileHandleToWin32Handle(BX_reg(context));
2379 BY_HANDLE_FILE_INFORMATION *info =
2380 CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
2381
2382 TRACE( "LONG FILENAME - GET FILE INFO BY HANDLE\n" );
2383
2384 if (!GetFileInformationByHandle(handle, info))
2385 bSetDOSExtendedError = TRUE;
2386 }
2387 break;
2388
2389 case 0xa7: /* LONG FILENAME - CONVERT TIME */
2390 switch (BL_reg(context))
2391 {
2392 case 0x00: /* FILE TIME TO DOS TIME */
2393 {
2394 WORD date, time;
2395 FILETIME *filetime = CTX_SEG_OFF_TO_LIN(context,
2396 context->SegDs,
2397 context->Esi);
2398
2399 TRACE( "LONG FILENAME - FILE TIME TO DOS TIME\n" );
2400
2401 FileTimeToDosDateTime( filetime, &date, &time );
2402
2403 SET_DX( context, date );
2404 SET_CX( context, time );
2405
2406 /*
2407 * FIXME: BH has number of 10-millisecond units
2408 * past time in CX.
2409 */
2410 SET_BH( context, 0 );
2411 }
2412 break;
2413
2414 case 0x01: /* DOS TIME TO FILE TIME */
2415 {
2416 FILETIME *filetime = CTX_SEG_OFF_TO_LIN(context,
2417 context->SegEs,
2418 context->Edi);
2419
2420 TRACE( "LONG FILENAME - DOS TIME TO FILE TIME\n" );
2421
2422 /*
2423 * FIXME: BH has number of 10-millisecond units
2424 * past time in CX.
2425 */
2426 DosDateTimeToFileTime( DX_reg(context), CX_reg(context),
2427 filetime );
2428 }
2429 break;
2430
2431 default:
2432 INT_BARF( context, 0x21 );
2433 break;
2434 }
2435 break;
2436
2437 case 0xa8: /* LONG FILENAME - GENERATE SHORT FILENAME */
2438 case 0xa9: /* LONG FILENAME - SERVER CREATE OR OPEN FILE */
2439 case 0xaa: /* LONG FILENAME - SUBST */
2440 default:
2441 INT_BARF( context, 0x21 );
2442 }
2443
2444 if (bSetDOSExtendedError)
2445 {
2446 SET_AX( context, GetLastError() );
2447 SET_CFLAG( context );
2448 }
2449 }
2450
2451
2452 /***********************************************************************
2453 * INT21_RenameFile
2454 *
2455 * Handler for:
2456 * - function 0x56
2457 * - subfunction 0x56 of function 0x71
2458 * - subfunction 0xff of function 0x43 (CL == 0x56)
2459 */
2460 static BOOL INT21_RenameFile( CONTEXT86 *context )
2461 {
2462 WCHAR fromW[MAX_PATH];
2463 WCHAR toW[MAX_PATH];
2464 char *fromA = CTX_SEG_OFF_TO_LIN(context,
2465 context->SegDs,context->Edx);
2466 char *toA = CTX_SEG_OFF_TO_LIN(context,
2467 context->SegEs,context->Edi);
2468
2469 TRACE( "RENAME FILE %s to %s\n", fromA, toA );
2470 MultiByteToWideChar(CP_OEMCP, 0, fromA, -1, fromW, MAX_PATH);
2471 MultiByteToWideChar(CP_OEMCP, 0, toA, -1, toW, MAX_PATH);
2472
2473 return MoveFileW( fromW, toW );
2474 }
2475
2476
2477 /***********************************************************************
2478 * INT21_GetExtendedError
2479 */
2480 static void INT21_GetExtendedError( CONTEXT86 *context )
2481 {
2482 BYTE class, action, locus;
2483 WORD error = GetLastError();
2484
2485 switch(error)
2486 {
2487 case ERROR_SUCCESS:
2488 class = action = locus = 0;
2489 break;
2490 case ERROR_DIR_NOT_EMPTY:
2491 class = EC_Exists;
2492 action = SA_Ignore;
2493 locus = EL_Disk;
2494 break;
2495 case ERROR_ACCESS_DENIED:
2496 class = EC_AccessDenied;
2497 action = SA_Abort;
2498 locus = EL_Disk;
2499 break;
2500 case ERROR_CANNOT_MAKE:
2501 class = EC_AccessDenied;
2502 action = SA_Abort;
2503 locus = EL_Unknown;
2504 break;
2505 case ERROR_DISK_FULL:
2506 case ERROR_HANDLE_DISK_FULL:
2507 class = EC_MediaError;
2508 action = SA_Abort;
2509 locus = EL_Disk;
2510 break;
2511 case ERROR_FILE_EXISTS:
2512 case ERROR_ALREADY_EXISTS:
2513 class = EC_Exists;
2514 action = SA_Abort;
2515 locus = EL_Disk;
2516 break;
2517 case ERROR_FILE_NOT_FOUND:
2518 class = EC_NotFound;
2519 action = SA_Abort;
2520 locus = EL_Disk;
2521 break;
2522 case ER_GeneralFailure:
2523 class = EC_SystemFailure;
2524 action = SA_Abort;
2525 locus = EL_Unknown;
2526 break;
2527 case ERROR_INVALID_DRIVE:
2528 class = EC_MediaError;
2529 action = SA_Abort;
2530 locus = EL_Disk;
2531 break;
2532 case ERROR_INVALID_HANDLE:
2533 class = EC_ProgramError;
2534 action = SA_Abort;
2535 locus = EL_Disk;
2536 break;
2537 case ERROR_LOCK_VIOLATION:
2538 class = EC_AccessDenied;
2539 action = SA_Abort;
2540 locus = EL_Disk;
2541 break;
2542 case ERROR_NO_MORE_FILES:
2543 class = EC_MediaError;
2544 action = SA_Abort;
2545 locus = EL_Disk;
2546 break;
2547 case ER_NoNetwork:
2548 class = EC_NotFound;
2549 action = SA_Abort;
2550 locus = EL_Network;
2551 break;
2552 case ERROR_NOT_ENOUGH_MEMORY:
2553 class = EC_OutOfResource;
2554 action = SA_Abort;
2555 locus = EL_Memory;
2556 break;
2557 case ERROR_PATH_NOT_FOUND:
2558 class = EC_NotFound;
2559 action = SA_Abort;
2560 locus = EL_Disk;
2561 break;
2562 case ERROR_SEEK:
2563 class = EC_NotFound;
2564 action = SA_Ignore;
2565 locus = EL_Disk;
2566 break;
2567 case ERROR_SHARING_VIOLATION:
2568 class = EC_Temporary;
2569 action = SA_Retry;
2570 locus = EL_Disk;
2571 break;
2572 case ERROR_TOO_MANY_OPEN_FILES:
2573 class = EC_ProgramError;
2574 action = SA_Abort;
2575 locus = EL_Disk;
2576 break;
2577 default:
2578 FIXME("Unknown error %d\n", error );
2579 class = EC_SystemFailure;
2580 action = SA_Abort;
2581 locus = EL_Unknown;
2582 break;
2583 }
2584 TRACE("GET EXTENDED ERROR code 0x%02x class 0x%02x action 0x%02x locus %02x\n",
2585 error, class, action, locus );
2586 SET_AX( context, error );
2587 SET_BH( context, class );
2588 SET_BL( context, action );
2589 SET_CH( context, locus );
2590 }
2591
2592
2593 /***********************************************************************
2594 * DOSVM_Int21Handler
2595 *
2596 * Interrupt 0x21 handler.
2597 */
2598 void WINAPI DOSVM_Int21Handler( CONTEXT86 *context )
2599 {
2600 BOOL bSetDOSExtendedError = FALSE;
2601
2602 TRACE( "AX=%04x BX=%04x CX=%04x DX=%04x "
2603 "SI=%04x DI=%04x DS=%04x ES=%04x EFL=%08lx\n",
2604 AX_reg(context), BX_reg(context),
2605 CX_reg(context), DX_reg(context),
2606 SI_reg(context), DI_reg(context),
2607 (WORD)context->SegDs, (WORD)context->SegEs,
2608 context->EFlags );
2609
2610 /*
2611 * Extended error is used by (at least) functions 0x2f to 0x62.
2612 * Function 0x59 returns extended error and error should not
2613 * be cleared before handling the function.
2614 */
2615 if (AH_reg(context) >= 0x2f && AH_reg(context) != 0x59)
2616 SetLastError(0);
2617
2618 RESET_CFLAG(context); /* Not sure if this is a good idea. */
2619
2620 switch(AH_reg(context))
2621 {
2622 case 0x00: /* TERMINATE PROGRAM */
2623 TRACE("TERMINATE PROGRAM\n");
2624 if (DOSVM_IsWin16())
2625 ExitThread( 0 );
2626 else
2627 MZ_Exit( context, FALSE, 0 );
2628 break;
2629
2630 case 0x01: /* READ CHARACTER FROM STANDARD INPUT, WITH ECHO */
2631 {
2632 BYTE ascii;
2633 TRACE("DIRECT CHARACTER INPUT WITH ECHO\n");
2634 INT21_ReadChar( &ascii, context );
2635 SET_AL( context, ascii );
2636 /*
2637 * FIXME: What to echo when extended keycodes are read?
2638 */
2639 DOSVM_PutChar(AL_reg(context));
2640 }
2641 break;
2642
2643 case 0x02: /* WRITE CHARACTER TO STANDARD OUTPUT */
2644 TRACE("Write Character to Standard Output\n");
2645 DOSVM_PutChar(DL_reg(context));
2646 break;
2647
2648 case 0x03: /* READ CHARACTER FROM STDAUX */
2649 case 0x04: /* WRITE CHARACTER TO STDAUX */
2650 case 0x05: /* WRITE CHARACTER TO PRINTER */
2651 INT_BARF( context, 0x21 );
2652 break;
2653
2654 case 0x06: /* DIRECT CONSOLE IN/OUTPUT */
2655 if (DL_reg(context) == 0xff)
2656 {
2657 TRACE("Direct Console Input\n");
2658
2659 if (INT21_ReadChar( NULL, NULL ))
2660 {
2661 BYTE ascii;
2662 INT21_ReadChar( &ascii, context );
2663 SET_AL( context, ascii );
2664 RESET_ZFLAG( context );
2665 }
2666 else
2667 {
2668 /* no character available */
2669 SET_AL( context, 0 );
2670 SET_ZFLAG( context );
2671 }
2672 }
2673 else
2674 {
2675 TRACE("Direct Console Output\n");
2676 DOSVM_PutChar(DL_reg(context));
2677 /*
2678 * At least DOS versions 2.1-7.0 return character
2679 * that was written in AL register.
2680 */
2681 SET_AL( context, DL_reg(context) );
2682 }
2683 break;
2684
2685 case 0x07: /* DIRECT CHARACTER INPUT WITHOUT ECHO */
2686 {
2687 BYTE ascii;
2688 TRACE("DIRECT CHARACTER INPUT WITHOUT ECHO\n");
2689 INT21_ReadChar( &ascii, context );
2690 SET_AL( context, ascii );
2691 }
2692 break;
2693
2694 case 0x08: /* CHARACTER INPUT WITHOUT ECHO */
2695 {
2696 BYTE ascii;
2697 TRACE("CHARACTER INPUT WITHOUT ECHO\n");
2698 INT21_ReadChar( &ascii, context );
2699 SET_AL( context, ascii );
2700 }
2701 break;
2702
2703 case 0x09: /* WRITE STRING TO STANDARD OUTPUT */
2704 TRACE("WRITE '$'-terminated string from %04lX:%04X to stdout\n",
2705 context->SegDs, DX_reg(context) );
2706 {
2707 LPSTR data = CTX_SEG_OFF_TO_LIN( context,
2708 context->SegDs, context->Edx );
2709 LPSTR p = data;
2710
2711 /*
2712 * Do NOT use strchr() to calculate the string length,
2713 * as '\0' is valid string content, too!
2714 * Maybe we should check for non-'$' strings, but DOS doesn't.
2715 */
2716 while (*p != '$') p++;
2717
2718 if (DOSVM_IsWin16())
2719 WriteFile( DosFileHandleToWin32Handle(1),
2720 data, p - data, 0, 0 );
2721 else
2722 for(; data != p; data++)
2723 DOSVM_PutChar( *data );
2724
2725 SET_AL( context, '$' ); /* yes, '$' (0x24) gets returned in AL */
2726 }
2727 break;
2728
2729 case 0x0a: /* BUFFERED INPUT */
2730 {
2731 BYTE *ptr = CTX_SEG_OFF_TO_LIN(context,
2732 context->SegDs,
2733 context->Edx);
2734 WORD result;
2735
2736 TRACE( "BUFFERED INPUT (size=%d)\n", ptr[0] );
2737
2738 /*
2739 * FIXME: Some documents state that
2740 * ptr[1] holds number of chars from last input which
2741 * may be recalled on entry, other documents do not mention
2742 * this at all.
2743 */
2744 if (ptr[1])
2745 TRACE( "Handle old chars in buffer!\n" );
2746
2747 /*
2748 * ptr[0] - capacity (includes terminating CR)
2749 * ptr[1] - characters read (excludes terminating CR)
2750 */
2751 result = INT21_BufferedInput( context, ptr + 2, ptr[0] );
2752 if (result > 0)
2753 ptr[1] = (BYTE)result - 1;
2754 else
2755 ptr[1] = 0;
2756 }
2757 break;
2758
2759 case 0x0b: /* GET STDIN STATUS */
2760 TRACE( "GET STDIN STATUS\n" );
2761 {
2762 if (INT21_ReadChar( NULL, NULL ))
2763 SET_AL( context, 0xff ); /* character available */
2764 else
2765 SET_AL( context, 0 ); /* no character available */
2766 }
2767 break;
2768
2769 case 0x0c: /* FLUSH BUFFER AND READ STANDARD INPUT */
2770 {
2771 BYTE al = AL_reg(context); /* Input function to execute after flush. */
2772
2773 TRACE( "FLUSH BUFFER AND READ STANDARD INPUT - 0x%02x\n", al );
2774
2775 /* FIXME: buffers are not flushed */
2776
2777 /*
2778 * If AL is one of 0x01, 0x06, 0x07, 0x08, or 0x0a,
2779 * int21 function identified by AL will be called.
2780 */
2781 if(al == 0x01 || al == 0x06 || al == 0x07 || al == 0x08 || al == 0x0a)
2782 {
2783 SET_AH( context, al );
2784 DOSVM_Int21Handler( context );
2785 }
2786 }
2787 break;
2788
2789 case 0x0d: /* DISK BUFFER FLUSH */
2790 TRACE("DISK BUFFER FLUSH ignored\n");
2791 break;
2792
2793 case 0x0e: /* SELECT DEFAULT DRIVE */
2794 TRACE( "SELECT DEFAULT DRIVE - %c:\n", 'A' + DL_reg(context) );
2795 INT21_SetCurrentDrive( DL_reg(context) );
2796 SET_AL( context, MAX_DOS_DRIVES );
2797 break;
2798
2799 case 0x0f: /* OPEN FILE USING FCB */
2800 INT21_OpenFileUsingFCB( context );
2801 break;
2802
2803 case 0x10: /* CLOSE FILE USING FCB */
2804 INT21_CloseFileUsingFCB( context );
2805 break;
2806
2807 case 0x11: /* FIND FIRST MATCHING FILE USING FCB */
2808 case 0x12: /* FIND NEXT MATCHING FILE USING FCB */
2809 INT_Int21Handler( context );
2810 break;
2811
2812 case 0x13: /* DELETE FILE USING FCB */
2813 INT_BARF( context, 0x21 );
2814 break;
2815
2816 case 0x14: /* SEQUENTIAL READ FROM FCB FILE */
2817 INT21_SequentialReadFromFCB( context );
2818 break;
2819
2820 case 0x15: /* SEQUENTIAL WRITE TO FCB FILE */
2821 INT21_SequentialWriteToFCB( context );
2822 break;
2823
2824 case 0x16: /* CREATE OR TRUNCATE FILE USING FCB */
2825 case 0x17: /* RENAME FILE USING FCB */
2826 INT_BARF( context, 0x21 );
2827 break;
2828
2829 case 0x18: /* NULL FUNCTION FOR CP/M COMPATIBILITY */
2830 SET_AL( context, 0 );
2831 break;
2832
2833 case 0x19: /* GET CURRENT DEFAULT DRIVE */
2834 SET_AL( context, INT21_GetCurrentDrive() );
2835 TRACE( "GET CURRENT DRIVE -> %c:\n", 'A' + AL_reg( context ) );
2836 break;
2837
2838 case 0x1a: /* SET DISK TRANSFER AREA ADDRESS */
2839 TRACE( "SET DISK TRANSFER AREA ADDRESS %04lX:%04X\n",
2840 context->SegDs, DX_reg(context) );
2841 {
2842 TDB *task = GlobalLock16( GetCurrentTask() );
2843 task->dta = MAKESEGPTR( context->SegDs, DX_reg(context) );
2844 }
2845 break;
2846
2847 case 0x1b: /* GET ALLOCATION INFORMATION FOR DEFAULT DRIVE */
2848 case 0x1c: /* GET ALLOCATION INFORMATION FOR SPECIFIC DRIVE */
2849 INT_Int21Handler( context );
2850 break;
2851
2852 case 0x1d: /* NULL FUNCTION FOR CP/M COMPATIBILITY */
2853 case 0x1e: /* NULL FUNCTION FOR CP/M COMPATIBILITY */
2854 SET_AL( context, 0 );
2855 break;
2856
2857 case 0x1f: /* GET DRIVE PARAMETER BLOCK FOR DEFAULT DRIVE */
2858 INT_Int21Handler( context );
2859 break;
2860
2861 case 0x20: /* NULL FUNCTION FOR CP/M COMPATIBILITY */
2862 SET_AL( context, 0 );
2863 break;
2864
2865 case 0x21: /* READ RANDOM RECORD FROM FCB FILE */
2866 INT21_ReadRandomRecordFromFCB( context );
2867 break;
2868
2869 case 0x22: /* WRITE RANDOM RECORD TO FCB FILE */
2870 INT21_WriteRandomRecordToFCB( context );
2871 break;
2872
2873 case 0x23: /* GET FILE SIZE FOR FCB */
2874 case 0x24: /* SET RANDOM RECORD NUMBER FOR FCB */
2875 INT_BARF( context, 0x21 );
2876 break;
2877
2878 case 0x25: /* SET INTERRUPT VECTOR */
2879 TRACE("SET INTERRUPT VECTOR 0x%02x\n",AL_reg(context));
2880 {
2881 FARPROC16 ptr = (FARPROC16)MAKESEGPTR( context->SegDs, DX_reg(context) );
2882 if (!ISV86(context) && DOSVM_IsWin16())
2883 DOSVM_SetPMHandler16( AL_reg(context), ptr );
2884 else
2885 DOSVM_SetRMHandler( AL_reg(context), ptr );
2886 }
2887 break;
2888
2889 case 0x26: /* CREATE NEW PROGRAM SEGMENT PREFIX */
2890 INT_BARF( context, 0x21 );
2891 break;
2892
2893 case 0x27: /* RANDOM BLOCK READ FROM FCB FILE */
2894 INT21_RandomBlockReadFromFCB( context );
2895 break;
2896
2897 case 0x28: /* RANDOM BLOCK WRITE TO FCB FILE */
2898 INT21_RandomBlockWriteToFCB( context );
2899 break;
2900
2901 case 0x29: /* PARSE FILENAME INTO FCB */
2902 INT_Int21Handler( context );
2903 break;
2904
2905 case 0x2a: /* GET SYSTEM DATE */
2906 TRACE( "GET SYSTEM DATE\n" );
2907 {
2908 SYSTEMTIME systime;
2909 GetLocalTime( &systime );
2910 SET_CX( context, systime.wYear );
2911 SET_DH( context, systime.wMonth );
2912 SET_DL( context, systime.wDay );
2913 SET_AL( context, systime.wDayOfWeek );
2914 }
2915 break;
2916
2917 case 0x2b: /* SET SYSTEM DATE */
2918 TRACE( "SET SYSTEM DATE\n" );
2919 {
2920 WORD year = CX_reg(context);
2921 BYTE month = DH_reg(context);
2922 BYTE day = DL_reg(context);
2923
2924 if (year >= 1980 && year <= 2099 &&
2925 month >= 1 && month <= 12 &&
2926 day >= 1 && day <= 31)
2927 {
2928 FIXME( "SetSystemDate(%02d/%02d/%04d): not allowed\n",
2929 day, month, year );
2930 SET_AL( context, 0 ); /* Let's pretend we succeeded */
2931 }
2932 else
2933 {
2934 SET_AL( context, 0xff ); /* invalid date */
2935 }
2936 }
2937 break;
2938
2939 case 0x2c: /* GET SYSTEM TIME */
2940 TRACE( "GET SYSTEM TIME\n" );
2941 {
2942 SYSTEMTIME systime;
2943 GetLocalTime( &systime );
2944 SET_CH( context, systime.wHour );
2945 SET_CL( context, systime.wMinute );
2946 SET_DH( context, systime.wSecond );
2947 SET_DL( context, systime.wMilliseconds / 10 );
2948 }
2949 break;
2950
2951 case 0x2d: /* SET SYSTEM TIME */
2952 FIXME("SetSystemTime(%02d:%02d:%02d.%02d): not allowed\n",
2953 CH_reg(context), CL_reg(context),
2954 DH_reg(context), DL_reg(context) );
2955 SET_AL( context, 0 ); /* Let's pretend we succeeded */
2956 break;
2957
2958 case 0x2e: /* SET VERIFY FLAG */
2959 TRACE("SET VERIFY FLAG ignored\n");
2960 /* we cannot change the behaviour anyway, so just ignore it */
2961 break;
2962
2963 case 0x2f: /* GET DISK TRANSFER AREA ADDRESS */
2964 TRACE( "GET DISK TRANSFER AREA ADDRESS\n" );
2965 {
2966 TDB *task = GlobalLock16( GetCurrentTask() );
2967 context->SegEs = SELECTOROF( task->dta );
2968 SET_BX( context, OFFSETOF( task->dta ) );
2969 }
2970 break;
2971
2972 case 0x30: /* GET DOS VERSION */
2973 TRACE( "GET DOS VERSION - %s requested\n",
2974 (AL_reg(context) == 0x00) ? "OEM number" : "version flag" );
2975
2976 if (AL_reg(context) == 0x00)
2977 SET_BH( context, 0xff ); /* OEM number => undefined */
2978 else
2979 SET_BH( context, 0x08 ); /* version flag => DOS is in ROM */
2980
2981 SET_AL( context, HIBYTE(HIWORD(GetVersion16())) ); /* major version */
2982 SET_AH( context, LOBYTE(HIWORD(GetVersion16())) ); /* minor version */
2983
2984 SET_BL( context, 0x12 ); /* 0x123456 is 24-bit Wine's serial # */
2985 SET_CX( context, 0x3456 );
2986 break;
2987
2988 case 0x31: /* TERMINATE AND STAY RESIDENT */
2989 FIXME("TERMINATE AND STAY RESIDENT stub\n");
2990 break;
2991
2992 case 0x32: /* GET DOS DRIVE PARAMETER BLOCK FOR SPECIFIC DRIVE */
2993 INT_Int21Handler( context );
2994 break;
2995
2996 case 0x33: /* MULTIPLEXED */
2997 switch (AL_reg(context))
2998 {
2999 case 0x00: /* GET CURRENT EXTENDED BREAK STATE */
3000 TRACE("GET CURRENT EXTENDED BREAK STATE\n");
3001 SET_DL( context, DOSCONF_GetConfig()->brk_flag );
3002 break;
3003
3004 case 0x01: /* SET EXTENDED BREAK STATE */
3005 TRACE("SET CURRENT EXTENDED BREAK STATE\n");
3006 DOSCONF_GetConfig()->brk_flag = (DL_reg(context) > 0) ? 1 : 0;
3007 break;
3008
3009 case 0x02: /* GET AND SET EXTENDED CONTROL-BREAK CHECKING STATE*/
3010 TRACE("GET AND SET EXTENDED CONTROL-BREAK CHECKING STATE\n");
3011 /* ugly coding in order to stay reentrant */
3012 if (DL_reg(context))
3013 {
3014 SET_DL( context, DOSCONF_GetConfig()->brk_flag );
3015 DOSCONF_GetConfig()->brk_flag = 1;
3016 }
3017 else
3018 {
3019 SET_DL( context, DOSCONF_GetConfig()->brk_flag );
3020 DOSCONF_GetConfig()->brk_flag = 0;
3021 }
3022 break;
3023
3024 case 0x05: /* GET BOOT DRIVE */
3025 TRACE("GET BOOT DRIVE\n");
3026 SET_DL( context, 3 );
3027 /* c: is Wine's bootdrive (a: is 1)*/
3028 break;
3029
3030 case 0x06: /* GET TRUE VERSION NUMBER */
3031 TRACE("GET TRUE VERSION NUMBER\n");
3032 SET_BL( context, HIBYTE(HIWORD(GetVersion16())) ); /* major */
3033 SET_BH( context, LOBYTE(HIWORD(GetVersion16())) ); /* minor */
3034 SET_DL( context, 0x00 ); /* revision */
3035 SET_DH( context, 0x08 ); /* DOS is in ROM */
3036 break;
3037
3038 default:
3039 INT_BARF( context, 0x21 );
3040 break;
3041 }
3042 break;
3043
3044 case 0x34: /* GET ADDRESS OF INDOS FLAG */
3045 TRACE( "GET ADDRESS OF INDOS FLAG\n" );
3046 context->SegEs = INT21_GetHeapSelector( context );
3047 SET_BX( context, offsetof(INT21_HEAP, misc_indos) );
3048 break;
3049
3050 case 0x35: /* GET INTERRUPT VECTOR */
3051 TRACE("GET INTERRUPT VECTOR 0x%02x\n",AL_reg(context));
3052 {
3053 FARPROC16 addr;
3054 if (!ISV86(context) && DOSVM_IsWin16())
3055 addr = DOSVM_GetPMHandler16( AL_reg(context) );
3056 else
3057 addr = DOSVM_GetRMHandler( AL_reg(context) );
3058 context->SegEs = SELECTOROF(addr);
3059 SET_BX( context, OFFSETOF(addr) );
3060 }
3061 break;
3062
3063 case 0x36: /* GET FREE DISK SPACE */
3064 INT_Int21Handler( context );
3065 break;
3066
3067 case 0x37: /* SWITCHAR */
3068 {
3069 switch (AL_reg(context))
3070 {
3071 case 0x00: /* "SWITCHAR" - GET SWITCH CHARACTER */
3072 TRACE( "SWITCHAR - GET SWITCH CHARACTER\n" );
3073 SET_AL( context, 0x00 ); /* success*/
3074 SET_DL( context, '/' );
3075 break;
3076 case 0x01: /*"SWITCHAR" - SET SWITCH CHARACTER*/
3077 FIXME( "SWITCHAR - SET SWITCH CHARACTER: %c\n",
3078 DL_reg( context ));
3079 SET_AL( context, 0x00 ); /* success*/
3080 break;
3081 default:
3082 INT_BARF( context, 0x21 );
3083 break;
3084 }
3085 }
3086 break;
3087
3088 case 0x38: /* GET COUNTRY-SPECIFIC INFORMATION */
3089 TRACE( "GET COUNTRY-SPECIFIC INFORMATION\n" );
3090 if (AL_reg(context))
3091 {
3092 WORD country = AL_reg(context);
3093 if (country == 0xff)
3094 country = BX_reg(context);
3095 if (country != INT21_GetSystemCountryCode())
3096 FIXME( "Requested info on non-default country %04x\n", country );
3097 }
3098 INT21_FillCountryInformation( CTX_SEG_OFF_TO_LIN(context,
3099 context->SegDs,
3100 context->Edx) );
3101 SET_AX( context, INT21_GetSystemCountryCode() );
3102 SET_BX( context, INT21_GetSystemCountryCode() );
3103 break;
3104
3105 case 0x39: /* "MKDIR" - CREATE SUBDIRECTORY */
3106 if (!INT21_CreateDirectory( context ))
3107 bSetDOSExtendedError = TRUE;
3108 break;
3109
3110 case 0x3a: /* "RMDIR" - REMOVE DIRECTORY */
3111 {
3112 WCHAR dirW[MAX_PATH];
3113 char *dirA = CTX_SEG_OFF_TO_LIN(context,
3114 context->SegDs, context->Edx);
3115
3116 TRACE( "REMOVE DIRECTORY %s\n", dirA );
3117
3118 MultiByteToWideChar(CP_OEMCP, 0, dirA, -1, dirW, MAX_PATH);
3119
3120 if (!RemoveDirectoryW( dirW ))
3121 bSetDOSExtendedError = TRUE;
3122 }
3123 break;
3124
3125 case 0x3b: /* "CHDIR" - SET CURRENT DIRECTORY */
3126 if (!INT21_SetCurrentDirectory( context ))
3127 bSetDOSExtendedError = TRUE;
3128 break;
3129
3130 case 0x3c: /* "CREAT" - CREATE OR TRUNCATE FILE */
3131 if (!INT21_CreateFile( context, context->Edx, FALSE,
3132 OF_READWRITE | OF_SHARE_COMPAT, 0x12 ))
3133 bSetDOSExtendedError = TRUE;
3134 break;
3135
3136 case 0x3d: /* "OPEN" - OPEN EXISTING FILE */
3137 if (!INT21_CreateFile( context, context->Edx, FALSE,
3138 AL_reg(context), 0x01 ))
3139 bSetDOSExtendedError = TRUE;
3140 break;
3141
3142 case 0x3e: /* "CLOSE" - CLOSE FILE */
3143 TRACE( "CLOSE handle %d\n", BX_reg(context) );
3144 if (_lclose16( BX_reg(context) ) == HFILE_ERROR16)
3145 bSetDOSExtendedError = TRUE;
3146 break;
3147
3148 case 0x3f: /* "READ" - READ FROM FILE OR DEVICE */
3149 TRACE( "READ from %d to %04lX:%04X for %d bytes\n",
3150 BX_reg(context),
3151 context->SegDs,
3152 DX_reg(context),
3153 CX_reg(context) );
3154 {
3155 DWORD result;
3156 WORD count = CX_reg(context);
3157 BYTE *buffer = CTX_SEG_OFF_TO_LIN( context,
3158 context->SegDs,
3159 context->Edx );
3160
3161 /* Some programs pass a count larger than the allocated buffer */
3162 if (DOSVM_IsWin16())
3163 {
3164 WORD maxcount = GetSelectorLimit16( context->SegDs )
3165 - DX_reg(context) + 1;
3166 if (count > maxcount)
3167 count = maxcount;
3168 }
3169
3170 /*
3171 * FIXME: Reading from console (BX=1) in DOS mode
3172 * does not work as it is supposed to work.
3173 */
3174
3175 if (!DOSVM_IsWin16() && BX_reg(context) == 0)
3176 {
3177 result = INT21_BufferedInput( context, buffer, count );
3178 SET_AX( context, (WORD)result );
3179 }
3180 else if (ReadFile( DosFileHandleToWin32Handle(BX_reg(context)),
3181 buffer, count, &result, NULL ))
3182 SET_AX( context, (WORD)result );
3183 else
3184 bSetDOSExtendedError = TRUE;
3185 }
3186 break;
3187
3188 case 0x40: /* "WRITE" - WRITE TO FILE OR DEVICE */
3189 TRACE( "WRITE from %04lX:%04X to handle %d for %d byte\n",
3190 context->SegDs, DX_reg(context),
3191 BX_reg(context), CX_reg(context) );
3192 {
3193 BYTE *ptr = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
3194
3195 if (!DOSVM_IsWin16() &&
3196 (BX_reg(context) == 1 || BX_reg(context) == 2))
3197 {
3198 int i;
3199 for(i=0; i<CX_reg(context); i++)
3200 DOSVM_PutChar(ptr[i]);
3201 SET_AX(context, CX_reg(context));
3202 }
3203 else
3204 {
3205 HFILE handle = (HFILE)DosFileHandleToWin32Handle(BX_reg(context));
3206 LONG result = _hwrite( handle, ptr, CX_reg(context) );
3207 if (result == HFILE_ERROR)
3208 bSetDOSExtendedError = TRUE;
3209 else
3210 SET_AX( context, (WORD)result );
3211 }
3212 }
3213 break;
3214
3215 case 0x41: /* "UNLINK" - DELETE FILE */
3216 {
3217 WCHAR fileW[MAX_PATH];
3218 char *fileA = CTX_SEG_OFF_TO_LIN(context,
3219 context->SegDs,
3220 context->Edx);
3221
3222 TRACE( "UNLINK %s\n", fileA );
3223 MultiByteToWideChar(CP_OEMCP, 0, fileA, -1, fileW, MAX_PATH);
3224
3225 if (!DeleteFileW( fileW ))
3226 bSetDOSExtendedError = TRUE;
3227 }
3228 break;
3229
3230 case 0x42: /* "LSEEK" - SET CURRENT FILE POSITION */
3231 TRACE( "LSEEK handle %d offset %ld from %s\n",
3232 BX_reg(context),
3233 MAKELONG( DX_reg(context), CX_reg(context) ),
3234 (AL_reg(context) == 0) ?
3235 "start of file" : ((AL_reg(context) == 1) ?
3236 "current file position" : "end of file") );
3237 {
3238 HANDLE handle = DosFileHandleToWin32Handle(BX_reg(context));
3239 LONG offset = MAKELONG( DX_reg(context), CX_reg(context) );
3240 DWORD status = SetFilePointer( handle, offset,
3241 NULL, AL_reg(context) );
3242 if (status == INVALID_SET_FILE_POINTER)
3243 bSetDOSExtendedError = TRUE;
3244 else
3245 {
3246 SET_AX( context, LOWORD(status) );
3247 SET_DX( context, HIWORD(status) );
3248 }
3249 }
3250 break;
3251
3252 case 0x43: /* FILE ATTRIBUTES */
3253 if (!INT21_FileAttributes( context, AL_reg(context), FALSE ))
3254 bSetDOSExtendedError = TRUE;
3255 break;
3256
3257 case 0x44: /* IOCTL */
3258 INT21_Ioctl( context );
3259 break;
3260
3261 case 0x45: /* "DUP" - DUPLICATE FILE HANDLE */
3262 TRACE( "DUPLICATE FILE HANDLE %d\n", BX_reg(context) );
3263 {
3264 HANDLE handle32;
3265 HFILE handle16 = HFILE_ERROR;
3266
3267 if (DuplicateHandle( GetCurrentProcess(),
3268 DosFileHandleToWin32Handle(BX_reg(context)),
3269 GetCurrentProcess(),
3270 &handle32,
3271 0, TRUE, DUPLICATE_SAME_ACCESS ))
3272 handle16 = Win32HandleToDosFileHandle(handle32);
3273
3274 if (handle16 == HFILE_ERROR)
3275 bSetDOSExtendedError = TRUE;
3276 else
3277 SET_AX( context, handle16 );
3278 }
3279 break;
3280
3281 case 0x46: /* "DUP2", "FORCEDUP" - FORCE DUPLICATE FILE HANDLE */
3282 TRACE( "FORCEDUP - FORCE DUPLICATE FILE HANDLE %d to %d\n",
3283 BX_reg(context), CX_reg(context) );
3284 if (FILE_Dup2( BX_reg(context), CX_reg(context) ) == HFILE_ERROR16)
3285 bSetDOSExtendedError = TRUE;
3286 break;
3287
3288 case 0x47: /* "CWD" - GET CURRENT DIRECTORY */
3289 if (!INT21_GetCurrentDirectory( context, FALSE ))
3290 bSetDOSExtendedError = TRUE;
3291 break;
3292
3293 case 0x48: /* ALLOCATE MEMORY */
3294 TRACE( "ALLOCATE MEMORY for %d paragraphs\n", BX_reg(context) );
3295 {
3296 WORD selector = 0;
3297 DWORD bytes = (DWORD)BX_reg(context) << 4;
3298
3299 if (!ISV86(context) && DOSVM_IsWin16())
3300 {
3301 DWORD rv = GlobalDOSAlloc16( bytes );
3302 selector = LOWORD( rv );
3303 }
3304 else
3305 DOSMEM_GetBlock( bytes, &selector );
3306
3307 if (selector)
3308 SET_AX( context, selector );
3309 else
3310 {
3311 SET_CFLAG(context);
3312 SET_AX( context, 0x0008 ); /* insufficient memory */
3313 SET_BX( context, DOSMEM_Available() >> 4 );
3314 }
3315 }
3316 break;
3317
3318 case 0x49: /* FREE MEMORY */
3319 TRACE( "FREE MEMORY segment %04lX\n", context->SegEs );
3320 {
3321 BOOL ok;
3322
3323 if (!ISV86(context) && DOSVM_IsWin16())
3324 {
3325 ok = !GlobalDOSFree16( context->SegEs );
3326
3327 /* If we don't reset ES_reg, we will fail in the relay code */
3328 if (ok)
3329 context->SegEs = 0;
3330 }
3331 else
3332 ok = DOSMEM_FreeBlock( (void*)((DWORD)context->SegEs << 4) );
3333
3334 if (!ok)
3335 {
3336 TRACE("FREE MEMORY failed\n");
3337 SET_CFLAG(context);
3338 SET_AX( context, 0x0009 ); /* memory block address invalid */
3339 }
3340 }
3341 break;
3342
3343 case 0x4a: /* RESIZE MEMORY BLOCK */
3344 TRACE( "RESIZE MEMORY segment %04lX to %d paragraphs\n",
3345 context->SegEs, BX_reg(context) );
3346 {
3347 DWORD newsize = (DWORD)BX_reg(context) << 4;
3348
3349 if (!ISV86(context) && DOSVM_IsWin16())
3350 {
3351 FIXME( "Resize memory block - unsupported under Win16\n" );
3352 }
3353 else
3354 {
3355 LPVOID address = (void*)((DWORD)context->SegEs << 4);
3356 UINT blocksize = DOSMEM_ResizeBlock( address, newsize, FALSE );
3357
3358 if (blocksize == (UINT)-1)
3359 {
3360 SET_CFLAG( context );
3361 SET_AX( context, 0x0009 ); /* illegal address */
3362 }
3363 else if(blocksize != newsize)
3364 {
3365 SET_CFLAG( context );
3366 SET_AX( context, 0x0008 ); /* insufficient memory */
3367 SET_BX( context, blocksize >> 4 ); /* new block size */
3368 }
3369 }
3370 }
3371 break;
3372
3373 case 0x4b: /* "EXEC" - LOAD AND/OR EXECUTE PROGRAM */
3374 {
3375 BYTE *program = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
3376 BYTE *paramblk = CTX_SEG_OFF_TO_LIN(context, context->SegEs, context->Ebx);
3377
3378 TRACE( "EXEC %s\n", program );
3379
3380 if (DOSVM_IsWin16())
3381 {
3382 HINSTANCE16 instance = WinExec16( program, SW_NORMAL );
3383 if (instance < 32)
3384 {
3385 SET_CFLAG( context );
3386 SET_AX( context, instance );
3387 }
3388 }
3389 else
3390 {
3391 if (!MZ_Exec( context, program, AL_reg(context), paramblk))
3392 bSetDOSExtendedError = TRUE;
3393 }
3394 }
3395 break;
3396
3397 case 0x4c: /* "EXIT" - TERMINATE WITH RETURN CODE */
3398 TRACE( "EXIT with return code %d\n", AL_reg(context) );
3399 if (DOSVM_IsWin16())
3400 ExitThread( AL_reg(context) );
3401 else
3402 MZ_Exit( context, FALSE, AL_reg(context) );
3403 break;
3404
3405 case 0x4d: /* GET RETURN CODE */
3406 TRACE("GET RETURN CODE (ERRORLEVEL)\n");
3407 SET_AX( context, DOSVM_retval );
3408 DOSVM_retval = 0;
3409 break;
3410
3411 case 0x4e: /* "FINDFIRST" - FIND FIRST MATCHING FILE */
3412 case 0x4f: /* "FINDNEXT" - FIND NEXT MATCHING FILE */
3413 INT_Int21Handler( context );
3414 break;
3415
3416 case 0x50: /* SET CURRENT PROCESS ID (SET PSP ADDRESS) */
3417 TRACE("SET CURRENT PROCESS ID (SET PSP ADDRESS)\n");
3418 DOSVM_psp = BX_reg(context);
3419 break;
3420
3421 case 0x51: /* GET PSP ADDRESS */
3422 INT21_GetPSP( context );
3423 break;
3424
3425 case 0x52: /* "SYSVARS" - GET LIST OF LISTS */
3426 if (!ISV86(context) && DOSVM_IsWin16())
3427 {
3428 SEGPTR ptr = DOSMEM_LOL()->wine_pm_lol;
3429 context->SegEs = SELECTOROF(ptr);
3430 SET_BX( context, OFFSETOF(ptr) );
3431 }
3432 else
3433 {
3434 SEGPTR ptr = DOSMEM_LOL()->wine_rm_lol;
3435 context->SegEs = SELECTOROF(ptr);
3436 SET_BX( context, OFFSETOF(ptr) );
3437 }
3438 break;
3439
3440 case 0x54: /* Get Verify Flag */
3441 TRACE("Get Verify Flag - Not Supported\n");
3442 SET_AL( context, 0x00 ); /* pretend we can tell. 00h = off 01h = on */
3443 break;
3444
3445 case 0x56: /* "RENAME" - RENAME FILE */
3446 if (!INT21_RenameFile( context ))
3447 bSetDOSExtendedError = TRUE;
3448 break;
3449
3450 case 0x57: /* FILE DATE AND TIME */
3451 if (!INT21_FileDateTime( context ))
3452 bSetDOSExtendedError = TRUE;
3453 break;
3454
3455 case 0x58: /* GET OR SET MEMORY ALLOCATION STRATEGY */
3456 switch (AL_reg(context))
3457 {
3458 case 0x00: /* GET MEMORY ALLOCATION STRATEGY */
3459 TRACE( "GET MEMORY ALLOCATION STRATEGY\n" );
3460 SET_AX( context, 0 ); /* low memory first fit */
3461 break;
3462
3463 case 0x01: /* SET ALLOCATION STRATEGY */
3464 TRACE( "SET MEMORY ALLOCATION STRATEGY to %d - ignored\n",
3465 BL_reg(context) );
3466 break;
3467
3468 case 0x02: /* GET UMB LINK STATE */
3469 TRACE( "GET UMB LINK STATE\n" );
3470 SET_AL( context, 0 ); /* UMBs not part of DOS memory chain */
3471 break;
3472
3473 case 0x03: /* SET UMB LINK STATE */
3474 TRACE( "SET UMB LINK STATE to %d - ignored\n",
3475 BX_reg(context) );
3476 break;
3477
3478 default:
3479 INT_BARF( context, 0x21 );
3480 }
3481 break;
3482
3483 case 0x59: /* GET EXTENDED ERROR INFO */
3484 INT21_GetExtendedError( context );
3485 break;
3486
3487 case 0x5a: /* CREATE TEMPORARY FILE */
3488 INT_Int21Handler( context );
3489 break;
3490
3491 case 0x5b: /* CREATE NEW FILE */
3492 if (!INT21_CreateFile( context, context->Edx, FALSE,
3493 OF_READWRITE | OF_SHARE_COMPAT, 0x10 ))
3494 bSetDOSExtendedError = TRUE;
3495 break;
3496
3497 case 0x5c: /* "FLOCK" - RECORD LOCKING */
3498 {
3499 DWORD offset = MAKELONG(DX_reg(context), CX_reg(context));
3500 DWORD length = MAKELONG(DI_reg(context), SI_reg(context));
3501 HANDLE handle = DosFileHandleToWin32Handle(BX_reg(context));
3502
3503 switch (AL_reg(context))
3504 {
3505 case 0x00: /* LOCK */
3506 TRACE( "lock handle %d offset %ld length %ld\n",
3507 BX_reg(context), offset, length );
3508 if (!LockFile( handle, offset, 0, length, 0 ))
3509 bSetDOSExtendedError = TRUE;
3510 break;
3511
3512 case 0x01: /* UNLOCK */
3513 TRACE( "unlock handle %d offset %ld length %ld\n",
3514 BX_reg(context), offset, length );
3515 if (!UnlockFile( handle, offset, 0, length, 0 ))
3516 bSetDOSExtendedError = TRUE;
3517 break;
3518
3519 default:
3520 INT_BARF( context, 0x21 );
3521 }
3522 }
3523 break;
3524
3525 case 0x5d: /* NETWORK 5D */
3526 FIXME( "Network function 5D not implemented.\n" );
3527 SetLastError( ER_NoNetwork );
3528 bSetDOSExtendedError = TRUE;
3529 break;
3530
3531 case 0x5e: /* NETWORK 5E */
3532 case 0x5f: /* NETWORK 5F */
3533 case 0x60: /* "TRUENAME" - CANONICALIZE FILENAME OR PATH */
3534 INT_Int21Handler( context );
3535 break;
3536
3537 case 0x61: /* UNUSED */
3538 SET_AL( context, 0 );
3539 break;
3540
3541 case 0x62: /* GET PSP ADDRESS */
3542 INT21_GetPSP( context );
3543 break;
3544
3545 case 0x63: /* MISC. LANGUAGE SUPPORT */
3546 switch (AL_reg(context)) {
3547 case 0x00: /* GET DOUBLE BYTE CHARACTER SET LEAD-BYTE TABLE */
3548 TRACE( "GET DOUBLE BYTE CHARACTER SET LEAD-BYTE TABLE\n" );
3549 context->SegDs = INT21_GetHeapSelector( context );
3550 SET_SI( context, offsetof(INT21_HEAP, dbcs_table) );
3551 SET_AL( context, 0 ); /* success */
3552 break;
3553 }
3554 break;
3555
3556 case 0x64: /* OS/2 DOS BOX */
3557 INT_BARF( context, 0x21 );
3558 SET_CFLAG(context);
3559 break;
3560
3561 case 0x65: /* EXTENDED COUNTRY INFORMATION */
3562 INT21_ExtendedCountryInformation( context );
3563 break;
3564
3565 case 0x66: /* GLOBAL CODE PAGE TABLE */
3566 switch (AL_reg(context))
3567 {
3568 case 0x01:
3569 TRACE( "GET GLOBAL CODE PAGE TABLE\n" );
3570 SET_BX( context, GetOEMCP() );
3571 SET_DX( context, GetOEMCP() );
3572 break;
3573 case 0x02:
3574 FIXME( "SET GLOBAL CODE PAGE TABLE, active %d, system %d - ignored\n",
3575 BX_reg(context), DX_reg(context) );
3576 break;
3577 }
3578 break;
3579
3580 case 0x67: /* SET HANDLE COUNT */
3581 TRACE( "SET HANDLE COUNT to %d\n", BX_reg(context) );
3582 if (SetHandleCount( BX_reg(context) ) < BX_reg(context) )
3583 bSetDOSExtendedError = TRUE;
3584 break;
3585
3586 case 0x68: /* "FFLUSH" - COMMIT FILE */
3587 TRACE( "FFLUSH - handle %d\n", BX_reg(context) );
3588 if (!FlushFileBuffers( DosFileHandleToWin32Handle(BX_reg(context)) ))
3589 bSetDOSExtendedError = TRUE;
3590 break;
3591
3592 case 0x69: /* DISK SERIAL NUMBER */
3593 INT_Int21Handler( context );
3594 break;
3595
3596 case 0x6a: /* COMMIT FILE */
3597 TRACE( "COMMIT FILE - handle %d\n", BX_reg(context) );
3598 if (!FlushFileBuffers( DosFileHandleToWin32Handle(BX_reg(context)) ))
3599 bSetDOSExtendedError = TRUE;
3600 break;
3601
3602 case 0x6b: /* NULL FUNCTION FOR CP/M COMPATIBILITY */
3603 SET_AL( context, 0 );
3604 break;
3605
3606 case 0x6c: /* EXTENDED OPEN/CREATE */
3607 if (!INT21_CreateFile( context, context->Esi, TRUE,
3608 BX_reg(context), DL_reg(context) ))
3609 bSetDOSExtendedError = TRUE;
3610 break;
3611
3612 case 0x70: /* MSDOS 7 - GET/SET INTERNATIONALIZATION INFORMATION */
3613 FIXME( "MS-DOS 7 - GET/SET INTERNATIONALIZATION INFORMATION\n" );
3614 SET_CFLAG( context );
3615 SET_AL( context, 0 );
3616 break;
3617
3618 case 0x71: /* MSDOS 7 - LONG FILENAME FUNCTIONS */
3619 INT21_LongFilename( context );
3620 break;
3621
3622 case 0x73: /* MSDOS7 - FAT32 */
3623 INT_Int21Handler( context );
3624 break;
3625
3626 case 0xdc: /* CONNECTION SERVICES - GET CONNECTION NUMBER */
3627 TRACE( "CONNECTION SERVICES - GET CONNECTION NUMBER - ignored\n" );
3628 break;
3629
3630 case 0xea: /* NOVELL NETWARE - RETURN SHELL VERSION */
3631 TRACE( "NOVELL NETWARE - RETURN SHELL VERSION - ignored\n" );
3632 break;
3633
3634 default:
3635 INT_BARF( context, 0x21 );
3636 break;
3637
3638 } /* END OF SWITCH */
3639
3640 /* Set general error condition. */
3641 if (bSetDOSExtendedError)
3642 {
3643 SET_AX( context, GetLastError() );
3644 SET_CFLAG( context );
3645 }
3646
3647 /* Print error code if carry flag is set. */
3648 if (context->EFlags & 0x0001)
3649 TRACE("failed, error %ld\n", GetLastError() );
3650
3651 TRACE( "returning: AX=%04x BX=%04x CX=%04x DX=%04x "
3652 "SI=%04x DI=%04x DS=%04x ES=%04x EFL=%08lx\n",
3653 AX_reg(context), BX_reg(context),
3654 CX_reg(context), DX_reg(context),
3655 SI_reg(context), DI_reg(context),
3656 (WORD)context->SegDs, (WORD)context->SegEs,
3657 context->EFlags );
3658 }
Maarten's multimedia branch