?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
regedit: An English (United States) spelling fix.
[wine/multimedia.git] / dlls / krnl386.exe16 / int21.c
blobd59cd242b6ad2fc1beab2b42402d2c03f0ffcb25
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 */
25
26 #include "config.h"
27 #include "wine/port.h"
28
29 #include <stdarg.h>
30 #include <stdio.h>
31 #ifdef HAVE_SYS_STAT_H
32 # include <sys/stat.h>
33 #endif
34 #ifdef HAVE_UNISTD_H
35 # include <unistd.h>
36 #endif
37
38 #include "windef.h"
39 #include "winbase.h"
40 #include "winreg.h"
41 #include "winternl.h"
42 #include "wine/winbase16.h"
43 #include "kernel16_private.h"
44 #include "dosexe.h"
45 #include "winerror.h"
46 #include "winuser.h"
47 #include "wine/unicode.h"
48 #include "wine/server.h"
49 #include "wine/debug.h"
50 #include "wine/exception.h"
51
52 BOOL WINAPI VerifyConsoleIoHandle(HANDLE);
53 /*
54 * Note:
55 * - Most of the file related functions are wrong. NT's kernel32
56 * doesn't maintain a per drive current directory, while DOS does.
57 * We should in fact keep track in here of those per drive
58 * directories, and use this info while dealing with partial paths
59 * (drive defined, but only relative paths). This could even be
60 * created as an array of CDS (there should be an entry for that in
61 * the LOL)
62 */
63
64 /*
65 * Forward declarations.
66 */
67 static BOOL INT21_RenameFile( CONTEXT *context );
68
69 WINE_DEFAULT_DEBUG_CHANNEL(int21);
70
71
72 #include "pshpack1.h"
73
74 /*
75 * Extended Drive Parameter Block.
76 * This structure is compatible with standard DOS4+ DPB and
77 * extended DOS7 DPB.
78 */
79 typedef struct _INT21_DPB {
80 BYTE drive; /* 00 drive number (0=A, ...) */
81 BYTE unit; /* 01 unit number within device driver */
82 WORD sector_bytes; /* 02 bytes per sector */
83 BYTE cluster_sectors; /* 04 highest sector number within a cluster */
84 BYTE shift; /* 05 shift count to convert clusters into sectors */
85 WORD num_reserved; /* 06 reserved sectors at beginning of drive */
86 BYTE num_FAT; /* 08 number of FATs */
87 WORD num_root_entries; /* 09 number of root directory entries */
88 WORD first_data_sector; /* 0b number of first sector containing user data */
89 WORD num_clusters1; /* 0d highest cluster number (number of data clusters + 1) */
90 WORD sectors_per_FAT; /* 0f number of sectors per FAT */
91 WORD first_dir_sector; /* 11 sector number of first directory sector */
92 SEGPTR driver_header; /* 13 address of device driver header */
93 BYTE media_ID; /* 17 media ID byte */
94 BYTE access_flag; /* 18 0x00 if disk accessed, 0xff if not */
95 SEGPTR next; /* 19 pointer to next DPB */
96 WORD search_cluster1; /* 1d cluster at which to start search for free space */
97 WORD free_clusters_lo; /* 1f number of free clusters on drive or 0xffff if unknown */
98 WORD free_clusters_hi; /* 21 hiword of clusters_free */
99 WORD mirroring_flags; /* 23 active FAT/mirroring flags */
100 WORD info_sector; /* 25 sector number of file system info sector or 0xffff for none */
101 WORD spare_boot_sector; /* 27 sector number of backup boot sector or 0xffff for none */
102 DWORD first_cluster_sector; /* 29 sector number of the first cluster */
103 DWORD num_clusters2; /* 2d maximum cluster number */
104 DWORD fat_clusters; /* 31 number of clusters occupied by FAT */
105 DWORD root_cluster; /* 35 cluster number of start of root directory */
106 DWORD search_cluster2; /* 39 cluster at which to start searching for free space */
107 } INT21_DPB;
108
109
110 /*
111 * Structure for DOS data that can be accessed directly from applications.
112 * Real and protected mode pointers will be returned to this structure so
113 * the structure must be correctly packed.
114 */
115 typedef struct _INT21_HEAP {
116 WORD uppercase_size; /* Size of the following table in bytes */
117 BYTE uppercase_table[128]; /* Uppercase equivalents of chars from 0x80 to 0xff. */
118
119 WORD lowercase_size; /* Size of the following table in bytes */
120 BYTE lowercase_table[256]; /* Lowercase equivalents of chars from 0x00 to 0xff. */
121
122 WORD collating_size; /* Size of the following table in bytes */
123 BYTE collating_table[256]; /* Values used to sort characters from 0x00 to 0xff. */
124
125 WORD filename_size; /* Size of the following filename data in bytes */
126 BYTE filename_reserved1; /* 0x01 for MS-DOS 3.30-6.00 */
127 BYTE filename_lowest; /* Lowest permissible character value for filename */
128 BYTE filename_highest; /* Highest permissible character value for filename */
129 BYTE filename_reserved2; /* 0x00 for MS-DOS 3.30-6.00 */
130 BYTE filename_exclude_first; /* First illegal character in permissible range */
131 BYTE filename_exclude_last; /* Last illegal character in permissible range */
132 BYTE filename_reserved3; /* 0x02 for MS-DOS 3.30-6.00 */
133 BYTE filename_illegal_size; /* Number of terminators in the following table */
134 BYTE filename_illegal_table[16]; /* Characters which terminate a filename */
135
136 WORD dbcs_size; /* Number of valid ranges in the following table */
137 BYTE dbcs_table[16]; /* Start/end bytes for N ranges and 00/00 as terminator */
138
139 BYTE misc_indos; /* Interrupt 21 nesting flag */
140 WORD misc_segment; /* Real mode segment for INT21_HEAP */
141 WORD misc_selector; /* Protected mode selector for INT21_HEAP */
142 INT21_DPB misc_dpb_list[MAX_DOS_DRIVES]; /* Drive parameter blocks for all drives */
143
144 } INT21_HEAP;
145
146
147 struct FCB {
148 BYTE drive_number;
149 CHAR file_name[8];
150 CHAR file_extension[3];
151 WORD current_block_number;
152 WORD logical_record_size;
153 DWORD file_size;
154 WORD date_of_last_write;
155 WORD time_of_last_write;
156 BYTE file_number;
157 BYTE attributes;
158 WORD starting_cluster;
159 WORD sequence_number;
160 BYTE file_attributes;
161 BYTE unused;
162 BYTE record_within_current_block;
163 BYTE random_access_record_number[4];
164 };
165
166
167 struct XFCB {
168 BYTE xfcb_signature;
169 BYTE reserved[5];
170 BYTE xfcb_file_attribute;
171 BYTE fcb[37];
172 };
173
174 /* DTA layout for FindFirst/FindNext */
175 typedef struct
176 {
177 BYTE drive; /* 00 drive letter */
178 char mask[11]; /* 01 search template */
179 BYTE search_attr; /* 0c search attributes */
180 WORD count; /* 0d entry count within directory */
181 WORD cluster; /* 0f cluster of parent directory */
182 WCHAR *fullPath; /* 11 full path (was: reserved) */
183 BYTE fileattr; /* 15 file attributes */
184 WORD filetime; /* 16 file time */
185 WORD filedate; /* 18 file date */
186 DWORD filesize; /* 1a file size */
187 char filename[13]; /* 1e file name + extension */
188 } FINDFILE_DTA;
189
190 /* FCB layout for FindFirstFCB/FindNextFCB */
191 typedef struct
192 {
193 BYTE drive; /* 00 drive letter */
194 char filename[11]; /* 01 filename 8+3 format */
195 int count; /* 0c entry count (was: reserved) */
196 WCHAR *fullPath; /* 10 full path (was: reserved) */
197 } FINDFILE_FCB;
198
199 /* DOS directory entry for FindFirstFCB/FindNextFCB */
200 typedef struct
201 {
202 char filename[11]; /* 00 filename 8+3 format */
203 BYTE fileattr; /* 0b file attributes */
204 BYTE reserved[10]; /* 0c reserved */
205 WORD filetime; /* 16 file time */
206 WORD filedate; /* 18 file date */
207 WORD cluster; /* 1a file first cluster */
208 DWORD filesize; /* 1c file size */
209 } DOS_DIRENTRY_LAYOUT;
210
211 #include "poppack.h"
212
213 /* dos file attributes */
214 #define FA_NORMAL 0x00 /* Normal file, no attributes */
215 #define FA_RDONLY 0x01 /* Read only attribute */
216 #define FA_HIDDEN 0x02 /* Hidden file */
217 #define FA_SYSTEM 0x04 /* System file */
218 #define FA_LABEL 0x08 /* Volume label */
219 #define FA_DIRECTORY 0x10 /* Directory */
220 #define FA_ARCHIVE 0x20 /* Archive */
221 #define FA_UNUSED 0x40 /* Unused */
222
223 /* Error codes */
224 #define ER_NoNetwork 0x49
225
226 /* Error classes */
227 #define EC_OutOfResource 0x01
228 #define EC_Temporary 0x02
229 #define EC_AccessDenied 0x03
230 #define EC_InternalError 0x04
231 #define EC_HardwareFailure 0x05
232 #define EC_SystemFailure 0x06
233 #define EC_ProgramError 0x07
234 #define EC_NotFound 0x08
235 #define EC_MediaError 0x0b
236 #define EC_Exists 0x0c
237 #define EC_Unknown 0x0d
238
239 /* Suggested actions */
240 #define SA_Retry 0x01
241 #define SA_DelayedRetry 0x02
242 #define SA_Abort 0x04
243 #define SA_Ignore 0x06
244 #define SA_Ask4Retry 0x07
245
246 /* Error locus */
247 #define EL_Unknown 0x01
248 #define EL_Disk 0x02
249 #define EL_Network 0x03
250 #define EL_Serial 0x04
251 #define EL_Memory 0x05
252
253 /* BIOS Keyboard Scancodes */
254 #define KEY_LEFT 0x4B
255 #define KEY_RIGHT 0x4D
256 #define KEY_UP 0x48
257 #define KEY_DOWN 0x50
258 #define KEY_IC 0x52 /* insert char */
259 #define KEY_DC 0x53 /* delete char */
260 #define KEY_BACKSPACE 0x0E
261 #define KEY_HOME 0x47
262 #define KEY_END 0x4F
263 #define KEY_NPAGE 0x49
264 #define KEY_PPAGE 0x51
265
266 static int brk_flag;
267
268 struct magic_device
269 {
270 WCHAR name[10];
271 HANDLE handle;
272 LARGE_INTEGER index;
273 void (*ioctl_handler)(CONTEXT *);
274 };
275
276 static void INT21_IoctlScsiMgrHandler( CONTEXT * );
277 static void INT21_IoctlHPScanHandler( CONTEXT * );
278
279 static struct magic_device magic_devices[] =
280 {
281 { {'s','c','s','i','m','g','r','$',0}, NULL, { { 0, 0 } }, INT21_IoctlScsiMgrHandler },
282 { {'e','m','m','x','x','x','x','0',0}, NULL, { { 0, 0 } }, EMS_Ioctl_Handler },
283 { {'h','p','s','c','a','n',0}, NULL, { { 0, 0 } }, INT21_IoctlHPScanHandler },
284 };
285
286 #define NB_MAGIC_DEVICES (sizeof(magic_devices)/sizeof(magic_devices[0]))
287
288
289 /* Many calls translate a drive argument like this:
290 drive number (00h = default, 01h = A:, etc)
291 */
292 /******************************************************************
293 * INT21_DriveName
294 *
295 * Many calls translate a drive argument like this:
296 * drive number (00h = default, 01h = A:, etc)
297 */
298 static const char *INT21_DriveName(int drive)
299 {
300 if (drive > 0)
301 {
302 if (drive <= 26) return wine_dbg_sprintf("%c:", 'A' + drive - 1);
303 else return wine_dbg_sprintf( "<Bad drive: %d>", drive);
304 }
305 return "default";
306 }
307
308 /***********************************************************************
309 * INT21_GetCurrentDrive
310 *
311 * Return current drive using scheme (0=A:, 1=B:, 2=C:, ...) or
312 * MAX_DOS_DRIVES on error.
313 */
314 static BYTE INT21_GetCurrentDrive(void)
315 {
316 WCHAR current_directory[MAX_PATH];
317
318 if (!GetCurrentDirectoryW( MAX_PATH, current_directory ) ||
319 current_directory[1] != ':')
320 {
321 TRACE( "Failed to get current drive.\n" );
322 return MAX_DOS_DRIVES;
323 }
324
325 return toupperW( current_directory[0] ) - 'A';
326 }
327
328
329 /***********************************************************************
330 * INT21_MapDrive
331 *
332 * Convert drive number from scheme (0=default, 1=A:, 2=B:, ...) into
333 * scheme (0=A:, 1=B:, 2=C:, ...) or MAX_DOS_DRIVES on error.
334 */
335 static BYTE INT21_MapDrive( BYTE drive )
336 {
337 if (drive)
338 {
339 WCHAR drivespec[] = {'A', ':', 0};
340 UINT drivetype;
341
342 drivespec[0] += drive - 1;
343 drivetype = GetDriveTypeW( drivespec );
344
345 if (drivetype == DRIVE_UNKNOWN || drivetype == DRIVE_NO_ROOT_DIR)
346 return MAX_DOS_DRIVES;
347
348 return drive - 1;
349 }
350
351 return INT21_GetCurrentDrive();
352 }
353
354
355 /***********************************************************************
356 * INT21_SetCurrentDrive
357 *
358 * Set current drive. Uses scheme (0=A:, 1=B:, 2=C:, ...).
359 */
360 static void INT21_SetCurrentDrive( BYTE drive )
361 {
362 WCHAR drivespec[] = {'A', ':', 0};
363
364 drivespec[0] += drive;
365
366 if (!SetCurrentDirectoryW( drivespec ))
367 TRACE( "Failed to set current drive.\n" );
368 }
369
370
371 /***********************************************************************
372 * INT21_ReadChar
373 *
374 * Reads a character from the standard input.
375 * Extended keycodes will be returned as two separate characters.
376 */
377 static BOOL INT21_ReadChar( BYTE *input, CONTEXT *waitctx )
378 {
379 static BYTE pending_scan = 0;
380
381 if (pending_scan)
382 {
383 if (input)
384 *input = pending_scan;
385 if (waitctx)
386 pending_scan = 0;
387 return TRUE;
388 }
389 else
390 {
391 BYTE ascii;
392 BYTE scan;
393 if (!DOSVM_Int16ReadChar( &ascii, &scan, waitctx ))
394 return FALSE;
395
396 if (input)
397 *input = ascii;
398 if (waitctx && !ascii)
399 pending_scan = scan;
400 return TRUE;
401 }
402 }
403
404
405 /***********************************************************************
406 * INT21_GetSystemCountryCode
407 *
408 * Return DOS country code for default system locale.
409 */
410 static WORD INT21_GetSystemCountryCode( void )
411 {
412 return GetSystemDefaultLangID();
413 }
414
415
416 /***********************************************************************
417 * INT21_FillCountryInformation
418 *
419 * Fill 34-byte buffer with country information data using
420 * default system locale.
421 */
422 static void INT21_FillCountryInformation( BYTE *buffer )
423 {
424 /* 00 - WORD: date format
425 * 00 = mm/dd/yy
426 * 01 = dd/mm/yy
427 * 02 = yy/mm/dd
428 */
429 *(WORD*)(buffer + 0) = 0; /* FIXME: Get from locale */
430
431 /* 02 - BYTE[5]: ASCIIZ currency symbol string */
432 buffer[2] = '$'; /* FIXME: Get from locale */
433 buffer[3] = 0;
434
435 /* 07 - BYTE[2]: ASCIIZ thousands separator */
436 buffer[7] = 0; /* FIXME: Get from locale */
437 buffer[8] = 0;
438
439 /* 09 - BYTE[2]: ASCIIZ decimal separator */
440 buffer[9] = '.'; /* FIXME: Get from locale */
441 buffer[10] = 0;
442
443 /* 11 - BYTE[2]: ASCIIZ date separator */
444 buffer[11] = '/'; /* FIXME: Get from locale */
445 buffer[12] = 0;
446
447 /* 13 - BYTE[2]: ASCIIZ time separator */
448 buffer[13] = ':'; /* FIXME: Get from locale */
449 buffer[14] = 0;
450
451 /* 15 - BYTE: Currency format
452 * bit 2 = set if currency symbol replaces decimal point
453 * bit 1 = number of spaces between value and currency symbol
454 * bit 0 = 0 if currency symbol precedes value
455 * 1 if currency symbol follows value
456 */
457 buffer[15] = 0; /* FIXME: Get from locale */
458
459 /* 16 - BYTE: Number of digits after decimal in currency */
460 buffer[16] = 0; /* FIXME: Get from locale */
461
462 /* 17 - BYTE: Time format
463 * bit 0 = 0 if 12-hour clock
464 * 1 if 24-hour clock
465 */
466 buffer[17] = 1; /* FIXME: Get from locale */
467
468 /* 18 - DWORD: Address of case map routine */
469 *(DWORD*)(buffer + 18) = 0; /* FIXME: ptr to case map routine */
470
471 /* 22 - BYTE[2]: ASCIIZ data-list separator */
472 buffer[22] = ','; /* FIXME: Get from locale */
473 buffer[23] = 0;
474
475 /* 24 - BYTE[10]: Reserved */
476 memset( buffer + 24, 0, 10 );
477 }
478
479
480 /***********************************************************************
481 * INT21_FillHeap
482 *
483 * Initialize DOS heap.
484 *
485 * Filename Terminator Table of w2k DE NTVDM:
486 * 16 00 01 00 FF 00 00 20-02 0E 2E 22 2F 5C 5B 5D ....... ..."/\[]
487 * 3A 7C 3C 3E 2B 3D 3B 2C-00 :|<>+=;,
488 */
489 static void INT21_FillHeap( INT21_HEAP *heap )
490 {
491 static const char terminators[] = ".\"/\\[]:|<>+=;,";
492 int i;
493
494 /*
495 * Uppercase table.
496 */
497 heap->uppercase_size = 128;
498 for (i = 0; i < 128; i++)
499 heap->uppercase_table[i] = toupper( 128 + i );
500
501 /*
502 * Lowercase table.
503 */
504 heap->lowercase_size = 256;
505 for (i = 0; i < 256; i++)
506 heap->lowercase_table[i] = tolower( i );
507
508 /*
509 * Collating table.
510 */
511 heap->collating_size = 256;
512 for (i = 0; i < 256; i++)
513 heap->collating_table[i] = i;
514
515 /*
516 * Filename table.
517 */
518 heap->filename_size = 8 + strlen(terminators);
519 heap->filename_illegal_size = strlen(terminators);
520 memcpy( heap->filename_illegal_table, terminators, heap->filename_illegal_size );
521
522 heap->filename_reserved1 = 0x01;
523 heap->filename_lowest = 0x00;
524 heap->filename_highest = 0xff;
525 heap->filename_reserved2 = 0x00;
526 heap->filename_exclude_first = 0x00;
527 heap->filename_exclude_last = 0x20;
528 heap->filename_reserved3 = 0x02;
529
530 /*
531 * DBCS lead byte table. This table is empty.
532 */
533 heap->dbcs_size = 0;
534 memset( heap->dbcs_table, 0, sizeof(heap->dbcs_table) );
535
536 /*
537 * Initialize InDos flag.
538 */
539 heap->misc_indos = 0;
540
541 /*
542 * FIXME: Should drive parameter blocks (DPB) be
543 * initialized here and linked to DOS LOL?
544 */
545 }
546
547
548 /***********************************************************************
549 * INT21_GetHeapPointer
550 *
551 * Get pointer for DOS heap (INT21_HEAP).
552 * Creates and initializes heap on first call.
553 */
554 static INT21_HEAP *INT21_GetHeapPointer( void )
555 {
556 static INT21_HEAP *heap_pointer = NULL;
557
558 if (!heap_pointer)
559 {
560 WORD heap_segment;
561 WORD heap_selector;
562
563 heap_pointer = DOSVM_AllocDataUMB( sizeof(INT21_HEAP),
564 &heap_segment,
565 &heap_selector );
566
567 heap_pointer->misc_segment = heap_segment;
568 heap_pointer->misc_selector = heap_selector;
569 INT21_FillHeap( heap_pointer );
570 }
571
572 return heap_pointer;
573 }
574
575
576 /***********************************************************************
577 * INT21_GetHeapSelector
578 *
579 * Get segment/selector for DOS heap (INT21_HEAP).
580 * Creates and initializes heap on first call.
581 */
582 static WORD INT21_GetHeapSelector( CONTEXT *context )
583 {
584 INT21_HEAP *heap = INT21_GetHeapPointer();
585
586 if (!ISV86(context) && DOSVM_IsWin16())
587 return heap->misc_selector;
588 else
589 return heap->misc_segment;
590 }
591
592
593 /***********************************************************************
594 * INT21_FillDrivePB
595 *
596 * Fill DOS heap drive parameter block for the specified drive.
597 * Return TRUE if drive was valid and there were
598 * no errors while reading drive information.
599 */
600 static BOOL INT21_FillDrivePB( BYTE drive )
601 {
602 WCHAR drivespec[] = {'A', ':', 0};
603 INT21_HEAP *heap = INT21_GetHeapPointer();
604 INT21_DPB *dpb;
605 UINT drivetype;
606 DWORD cluster_sectors;
607 DWORD sector_bytes;
608 DWORD free_clusters;
609 DWORD total_clusters;
610
611 if (drive >= MAX_DOS_DRIVES)
612 return FALSE;
613
614 dpb = &heap->misc_dpb_list[drive];
615 drivespec[0] += drive;
616 drivetype = GetDriveTypeW( drivespec );
617
618 /*
619 * FIXME: Does this check work correctly with floppy/cdrom drives?
620 */
621 if (drivetype == DRIVE_NO_ROOT_DIR || drivetype == DRIVE_UNKNOWN)
622 return FALSE;
623
624 /*
625 * FIXME: Does this check work correctly with floppy/cdrom drives?
626 */
627 if (!GetDiskFreeSpaceW( drivespec, &cluster_sectors, &sector_bytes,
628 &free_clusters, &total_clusters ))
629 return FALSE;
630
631 /*
632 * FIXME: Most of the values listed below are incorrect.
633 * All values should be validated.
634 */
635
636 dpb->drive = drive;
637 dpb->unit = 0;
638 dpb->sector_bytes = sector_bytes;
639 dpb->cluster_sectors = cluster_sectors - 1;
640
641 dpb->shift = 0;
642 while (cluster_sectors > 1)
643 {
644 cluster_sectors /= 2;
645 dpb->shift++;
646 }
647
648 dpb->num_reserved = 0;
649 dpb->num_FAT = 1;
650 dpb->num_root_entries = 2;
651 dpb->first_data_sector = 2;
652 dpb->num_clusters1 = total_clusters;
653 dpb->sectors_per_FAT = 1;
654 dpb->first_dir_sector = 1;
655 dpb->driver_header = 0;
656 dpb->media_ID = (drivetype == DRIVE_FIXED) ? 0xF8 : 0xF0;
657 dpb->access_flag = 0;
658 dpb->next = 0;
659 dpb->search_cluster1 = 0;
660 dpb->free_clusters_lo = LOWORD(free_clusters);
661 dpb->free_clusters_hi = HIWORD(free_clusters);
662 dpb->mirroring_flags = 0;
663 dpb->info_sector = 0xffff;
664 dpb->spare_boot_sector = 0xffff;
665 dpb->first_cluster_sector = 0;
666 dpb->num_clusters2 = total_clusters;
667 dpb->fat_clusters = 32;
668 dpb->root_cluster = 0;
669 dpb->search_cluster2 = 0;
670
671 return TRUE;
672 }
673
674
675 /***********************************************************************
676 * INT21_GetCurrentDirectory
677 *
678 * Handler for:
679 * - function 0x47
680 * - subfunction 0x47 of function 0x71
681 */
682 static BOOL INT21_GetCurrentDirectory( CONTEXT *context, BOOL islong )
683 {
684 char *buffer = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Esi);
685 BYTE drive = INT21_MapDrive( DL_reg(context) );
686 WCHAR pathW[MAX_PATH];
687 char pathA[MAX_PATH];
688 WCHAR *ptr = pathW;
689
690 TRACE( "drive %d\n", DL_reg(context) );
691
692 if (drive == MAX_DOS_DRIVES)
693 {
694 SetLastError(ERROR_INVALID_DRIVE);
695 return FALSE;
696 }
697
698 /*
699 * Grab current directory.
700 */
701
702 if (!GetCurrentDirectoryW( MAX_PATH, pathW )) return FALSE;
703
704 if (toupperW(pathW[0]) - 'A' != drive || pathW[1] != ':')
705 {
706 /* cwd is not on the requested drive, get the environment string instead */
707
708 WCHAR env_var[4];
709
710 env_var[0] = '=';
711 env_var[1] = 'A' + drive;
712 env_var[2] = ':';
713 env_var[3] = 0;
714 if (!GetEnvironmentVariableW( env_var, pathW, MAX_PATH ))
715 {
716 /* return empty path */
717 buffer[0] = 0;
718 return TRUE;
719 }
720 }
721
722 /*
723 * Convert into short format.
724 */
725
726 if (!islong)
727 {
728 DWORD result = GetShortPathNameW( pathW, pathW, MAX_PATH );
729 if (!result)
730 return FALSE;
731 if (result > MAX_PATH)
732 {
733 WARN( "Short path too long!\n" );
734 SetLastError(ERROR_NETWORK_BUSY); /* Internal Wine error. */
735 return FALSE;
736 }
737 }
738
739 /*
740 * The returned pathname does not include
741 * the drive letter, colon or leading backslash.
742 */
743
744 if (ptr[0] == '\\')
745 {
746 /*
747 * FIXME: We should probably just strip host part from name...
748 */
749 FIXME( "UNC names are not supported.\n" );
750 SetLastError(ERROR_NETWORK_BUSY); /* Internal Wine error. */
751 return FALSE;
752 }
753 else if (!ptr[0] || ptr[1] != ':' || ptr[2] != '\\')
754 {
755 WARN( "Path is neither UNC nor DOS path: %s\n",
756 wine_dbgstr_w(ptr) );
757 SetLastError(ERROR_NETWORK_BUSY); /* Internal Wine error. */
758 return FALSE;
759 }
760 else
761 {
762 /* Remove drive letter, colon and leading backslash. */
763 ptr += 3;
764 }
765
766 /*
767 * Convert into OEM string.
768 */
769
770 if (!WideCharToMultiByte(CP_OEMCP, 0, ptr, -1, pathA,
771 MAX_PATH, NULL, NULL))
772 {
773 WARN( "Cannot convert path!\n" );
774 SetLastError(ERROR_NETWORK_BUSY); /* Internal Wine error. */
775 return FALSE;
776 }
777
778 /*
779 * Success.
780 */
781
782 if (!islong)
783 {
784 /* Undocumented success code. */
785 SET_AX( context, 0x0100 );
786
787 /* Truncate buffer to 64 bytes. */
788 pathA[63] = 0;
789 }
790
791 TRACE( "%c:=%s\n", 'A' + drive, pathA );
792
793 strcpy( buffer, pathA );
794 return TRUE;
795 }
796
797
798 /***********************************************************************
799 * INT21_SetCurrentDirectory
800 *
801 * Handler for:
802 * - function 0x3b
803 * - subfunction 0x3b of function 0x71
804 */
805 static BOOL INT21_SetCurrentDirectory( CONTEXT *context )
806 {
807 WCHAR dirW[MAX_PATH];
808 WCHAR env_var[4];
809 DWORD attr;
810 char *dirA = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
811 BYTE drive = INT21_GetCurrentDrive();
812 BOOL result;
813
814 TRACE( "SET CURRENT DIRECTORY %s\n", dirA );
815
816 MultiByteToWideChar(CP_OEMCP, 0, dirA, -1, dirW, MAX_PATH);
817 if (!GetFullPathNameW( dirW, MAX_PATH, dirW, NULL )) return FALSE;
818
819 attr = GetFileAttributesW( dirW );
820 if (attr == INVALID_FILE_ATTRIBUTES || !(attr & FILE_ATTRIBUTE_DIRECTORY))
821 {
822 SetLastError( ERROR_PATH_NOT_FOUND );
823 return FALSE;
824 }
825
826 env_var[0] = '=';
827 env_var[1] = dirW[0];
828 env_var[2] = ':';
829 env_var[3] = 0;
830 result = SetEnvironmentVariableW( env_var, dirW );
831
832 /* only set current directory if on the current drive */
833 if (result && (toupperW(dirW[0]) - 'A' == drive)) result = SetCurrentDirectoryW( dirW );
834
835 return result;
836 }
837
838 /***********************************************************************
839 * INT21_CreateMagicDeviceHandle
840 *
841 * Create a dummy file handle for a "magic" device.
842 */
843 static HANDLE INT21_CreateMagicDeviceHandle( LPCWSTR name )
844 {
845 static const WCHAR prefixW[] = {'\\','?','?','\\','u','n','i','x'};
846 const char *dir = wine_get_server_dir();
847 int len;
848 HANDLE ret;
849 NTSTATUS status;
850 OBJECT_ATTRIBUTES attr;
851 UNICODE_STRING nameW;
852 IO_STATUS_BLOCK io;
853
854 len = MultiByteToWideChar( CP_UNIXCP, 0, dir, -1, NULL, 0 );
855 nameW.Length = sizeof(prefixW) + (len + strlenW( name )) * sizeof(WCHAR);
856 nameW.MaximumLength = nameW.Length + sizeof(WCHAR);
857 if (!(nameW.Buffer = HeapAlloc( GetProcessHeap(), 0, nameW.MaximumLength )))
858 {
859 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
860 return 0;
861 }
862 memcpy( nameW.Buffer, prefixW, sizeof(prefixW) );
863 MultiByteToWideChar( CP_UNIXCP, 0, dir, -1, nameW.Buffer + sizeof(prefixW)/sizeof(WCHAR), len );
864 len += sizeof(prefixW) / sizeof(WCHAR);
865 nameW.Buffer[len-1] = '/';
866 strcpyW( nameW.Buffer + len, name );
867
868 attr.Length = sizeof(attr);
869 attr.RootDirectory = 0;
870 attr.Attributes = 0;
871 attr.ObjectName = &nameW;
872 attr.SecurityDescriptor = NULL;
873 attr.SecurityQualityOfService = NULL;
874
875 status = NtCreateFile( &ret, GENERIC_READ|GENERIC_WRITE, &attr, &io, NULL, 0,
876 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN_IF,
877 FILE_SYNCHRONOUS_IO_ALERT, NULL, 0 );
878 if (status)
879 {
880 ret = 0;
881 SetLastError( RtlNtStatusToDosError(status) );
882 }
883 RtlFreeUnicodeString( &nameW );
884 return ret;
885 }
886
887
888 /***********************************************************************
889 * INT21_OpenMagicDevice
890 *
891 * Open a file handle for "magic" devices like EMMXXXX0.
892 */
893 static HANDLE INT21_OpenMagicDevice( LPCWSTR name, DWORD access )
894 {
895 unsigned int i;
896 const WCHAR *p;
897 HANDLE handle;
898
899 if (name[0] && (name[1] == ':')) name += 2;
900 if ((p = strrchrW( name, '/' ))) name = p + 1;
901 if ((p = strrchrW( name, '\\' ))) name = p + 1;
902
903 for (i = 0; i < NB_MAGIC_DEVICES; i++)
904 {
905 int len = strlenW( magic_devices[i].name );
906 if (!strncmpiW( magic_devices[i].name, name, len ) &&
907 (!name[len] || name[len] == '.' || name[len] == ':')) break;
908 }
909 if (i == NB_MAGIC_DEVICES) return 0;
910
911 if (!magic_devices[i].handle) /* need to open it */
912 {
913 IO_STATUS_BLOCK io;
914 FILE_INTERNAL_INFORMATION info;
915
916 if (!(handle = INT21_CreateMagicDeviceHandle( magic_devices[i].name ))) return 0;
917
918 NtQueryInformationFile( handle, &io, &info, sizeof(info), FileInternalInformation );
919 magic_devices[i].index = info.IndexNumber;
920 magic_devices[i].handle = handle;
921 }
922 if (!DuplicateHandle( GetCurrentProcess(), magic_devices[i].handle,
923 GetCurrentProcess(), &handle, access, FALSE, 0 )) handle = 0;
924 return handle;
925 }
926
927
928 /***********************************************************************
929 * INT21_CreateFile
930 *
931 * Handler for:
932 * - function 0x3c
933 * - function 0x3d
934 * - function 0x5b
935 * - function 0x6c
936 * - subfunction 0x6c of function 0x71
937 */
938 static BOOL INT21_CreateFile( CONTEXT *context,
939 DWORD pathSegOff,
940 BOOL returnStatus,
941 WORD dosAccessShare,
942 BYTE dosAction )
943 {
944 WORD dosStatus;
945 char *pathA = CTX_SEG_OFF_TO_LIN(context, context->SegDs, pathSegOff);
946 WCHAR pathW[MAX_PATH];
947 DWORD winAccess;
948 DWORD winAttributes;
949 HANDLE winHandle;
950 DWORD winMode;
951 DWORD winSharing;
952
953 TRACE( "CreateFile called: function=%02x, action=%02x, access/share=%04x, "
954 "create flags=%04x, file=%s.\n",
955 AH_reg(context), dosAction, dosAccessShare, CX_reg(context), pathA );
956
957 /*
958 * Application tried to create/open a file whose name
959 * ends with a backslash. This is not allowed.
960 *
961 * FIXME: This needs to be validated, especially the return value.
962 */
963 if (pathA[strlen(pathA) - 1] == '/')
964 {
965 SetLastError( ERROR_FILE_NOT_FOUND );
966 return FALSE;
967 }
968
969 /*
970 * Convert DOS action flags into Win32 creation disposition parameter.
971 */
972 switch(dosAction)
973 {
974 case 0x01:
975 winMode = OPEN_EXISTING;
976 break;
977 case 0x02:
978 winMode = TRUNCATE_EXISTING;
979 break;
980 case 0x10:
981 winMode = CREATE_NEW;
982 break;
983 case 0x11:
984 winMode = OPEN_ALWAYS;
985 break;
986 case 0x12:
987 winMode = CREATE_ALWAYS;
988 break;
989 default:
990 SetLastError( ERROR_INVALID_PARAMETER );
991 return FALSE;
992 }
993
994 /*
995 * Convert DOS access/share flags into Win32 desired access parameter.
996 */
997 switch(dosAccessShare & 0x07)
998 {
999 case OF_READ:
1000 winAccess = GENERIC_READ;
1001 break;
1002 case OF_WRITE:
1003 winAccess = GENERIC_WRITE;
1004 break;
1005 case OF_READWRITE:
1006 winAccess = GENERIC_READ | GENERIC_WRITE;
1007 break;
1008 case 0x04:
1009 /*
1010 * Read-only, do not modify file's last-access time (DOS7).
1011 *
1012 * FIXME: How to prevent modification of last-access time?
1013 */
1014 winAccess = GENERIC_READ;
1015 break;
1016 default:
1017 winAccess = 0;
1018 }
1019
1020 /*
1021 * Convert DOS access/share flags into Win32 share mode parameter.
1022 */
1023 switch(dosAccessShare & 0x70)
1024 {
1025 case OF_SHARE_EXCLUSIVE:
1026 winSharing = 0;
1027 break;
1028 case OF_SHARE_DENY_WRITE:
1029 winSharing = FILE_SHARE_READ;
1030 break;
1031 case OF_SHARE_DENY_READ:
1032 winSharing = FILE_SHARE_WRITE;
1033 break;
1034 case OF_SHARE_DENY_NONE:
1035 case OF_SHARE_COMPAT:
1036 default:
1037 winSharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
1038 }
1039
1040 /*
1041 * FIXME: Bit (dosAccessShare & 0x80) represents inheritance.
1042 * What to do with this bit?
1043 * FIXME: Bits in the high byte of dosAccessShare are not supported.
1044 * See both function 0x6c and subfunction 0x6c of function 0x71 for
1045 * definition of these bits.
1046 */
1047
1048 /*
1049 * Convert DOS create attributes into Win32 flags and attributes parameter.
1050 */
1051 if (winMode == OPEN_EXISTING || winMode == TRUNCATE_EXISTING)
1052 {
1053 winAttributes = 0;
1054 }
1055 else
1056 {
1057 WORD dosAttributes = CX_reg(context);
1058
1059 if (dosAttributes & FA_LABEL)
1060 {
1061 /*
1062 * Application tried to create volume label entry.
1063 * This is difficult to support so we do not allow it.
1064 *
1065 * FIXME: If volume does not already have a label,
1066 * this function is supposed to succeed.
1067 */
1068 SetLastError( ERROR_ACCESS_DENIED );
1069 return TRUE;
1070 }
1071
1072 winAttributes = dosAttributes &
1073 (FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN |
1074 FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_ARCHIVE);
1075 }
1076
1077 /*
1078 * Open the file.
1079 */
1080 MultiByteToWideChar(CP_OEMCP, 0, pathA, -1, pathW, MAX_PATH);
1081
1082 if ((winHandle = INT21_OpenMagicDevice( pathW, winAccess )))
1083 {
1084 dosStatus = 1;
1085 }
1086 else
1087 {
1088 winHandle = CreateFileW( pathW, winAccess, winSharing, NULL,
1089 winMode, winAttributes, 0 );
1090 /* DOS allows to open files on a CDROM R/W */
1091 if( winHandle == INVALID_HANDLE_VALUE &&
1092 (GetLastError() == ERROR_WRITE_PROTECT ||
1093 GetLastError() == ERROR_ACCESS_DENIED)) {
1094 winHandle = CreateFileW( pathW, winAccess & ~GENERIC_WRITE,
1095 winSharing, NULL, winMode, winAttributes, 0 );
1096 }
1097
1098 if (winHandle == INVALID_HANDLE_VALUE)
1099 return FALSE;
1100
1101 /*
1102 * Determine DOS file status.
1103 *
1104 * 1 = file opened
1105 * 2 = file created
1106 * 3 = file replaced
1107 */
1108 switch(winMode)
1109 {
1110 case OPEN_EXISTING:
1111 dosStatus = 1;
1112 break;
1113 case TRUNCATE_EXISTING:
1114 dosStatus = 3;
1115 break;
1116 case CREATE_NEW:
1117 dosStatus = 2;
1118 break;
1119 case OPEN_ALWAYS:
1120 dosStatus = (GetLastError() == ERROR_ALREADY_EXISTS) ? 1 : 2;
1121 break;
1122 case CREATE_ALWAYS:
1123 dosStatus = (GetLastError() == ERROR_ALREADY_EXISTS) ? 3 : 2;
1124 break;
1125 default:
1126 dosStatus = 0;
1127 }
1128 }
1129
1130 /*
1131 * Return DOS file handle and DOS status.
1132 */
1133 SET_AX( context, Win32HandleToDosFileHandle(winHandle) );
1134
1135 if (returnStatus)
1136 SET_CX( context, dosStatus );
1137
1138 TRACE( "CreateFile finished: handle=%d, status=%d.\n",
1139 AX_reg(context), dosStatus );
1140
1141 return TRUE;
1142 }
1143
1144
1145 /***********************************************************************
1146 * INT21_BufferedInput
1147 *
1148 * Handler for function 0x0a and reading from console using
1149 * function 0x3f.
1150 *
1151 * Reads a string of characters from standard input until
1152 * enter key is pressed. Returns either number of characters
1153 * read from console including terminating CR or
1154 * zero if capacity was zero.
1155 */
1156 static WORD INT21_BufferedInput( CONTEXT *context, BYTE *ptr, WORD capacity )
1157 {
1158 BYTE length = 0;
1159
1160 /*
1161 * Return immediately if capacity is zero.
1162 */
1163 if (capacity == 0)
1164 return 0;
1165
1166 while(TRUE)
1167 {
1168 BYTE ascii;
1169 BYTE scan;
1170
1171 DOSVM_Int16ReadChar( &ascii, &scan, context );
1172
1173 if (ascii == '\r' || ascii == '\n')
1174 {
1175 ptr[length] = '\r';
1176 return length + 1;
1177 }
1178
1179 /*
1180 * DOS handles only backspace and KEY_LEFT
1181 * perhaps we should do more
1182 */
1183 if (ascii == '\b' || scan == KEY_LEFT)
1184 {
1185 if (length==0) continue;
1186 DOSVM_PutChar( '\b' );
1187 length--;
1188 continue;
1189 }
1190
1191 /*
1192 * If the buffer becomes filled to within one byte of
1193 * capacity, DOS rejects all further characters up to,
1194 * but not including, the terminating carriage return.
1195 */
1196 if (ascii != 0 && length < capacity-1)
1197 {
1198 DOSVM_PutChar( ascii );
1199 ptr[length] = ascii;
1200 length++;
1201 }
1202 }
1203 }
1204
1205
1206 /***********************************************************************
1207 * INT21_GetCurrentDTA
1208 */
1209 static BYTE *INT21_GetCurrentDTA( CONTEXT *context )
1210 {
1211 TDB *pTask = GlobalLock16(GetCurrentTask());
1212
1213 /* FIXME: This assumes DTA was set correctly! */
1214 return CTX_SEG_OFF_TO_LIN( context, SELECTOROF(pTask->dta),
1215 OFFSETOF(pTask->dta) );
1216 }
1217
1218
1219 /***********************************************************************
1220 * INT21_OpenFileUsingFCB
1221 *
1222 * Handler for function 0x0f.
1223 *
1224 * PARAMS
1225 * DX:DX [I/O] File control block (FCB or XFCB) of unopened file
1226 *
1227 * RETURNS (in AL)
1228 * 0x00: successful
1229 * 0xff: failed
1230 *
1231 * NOTES
1232 * Opens a FCB file for read/write in compatibility mode. Upon calling
1233 * the FCB must have the drive_number, file_name, and file_extension
1234 * fields filled and all other bytes cleared.
1235 */
1236 static void INT21_OpenFileUsingFCB( CONTEXT *context )
1237 {
1238 struct FCB *fcb;
1239 struct XFCB *xfcb;
1240 char file_path[16];
1241 char *pos;
1242 HANDLE handle;
1243 HFILE16 hfile16;
1244 BY_HANDLE_FILE_INFORMATION info;
1245 BYTE AL_result;
1246
1247 fcb = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
1248 if (fcb->drive_number == 0xff) {
1249 xfcb = (struct XFCB *) fcb;
1250 fcb = (struct FCB *) xfcb->fcb;
1251 } /* if */
1252
1253 AL_result = 0;
1254 file_path[0] = 'A' + INT21_MapDrive( fcb->drive_number );
1255
1256 if (AL_result == 0) {
1257 file_path[1] = ':';
1258 pos = &file_path[2];
1259 memcpy(pos, fcb->file_name, 8);
1260 pos[8] = ' ';
1261 pos[9] = '\0';
1262 pos = strchr(pos, ' ');
1263 *pos = '.';
1264 pos++;
1265 memcpy(pos, fcb->file_extension, 3);
1266 pos[3] = ' ';
1267 pos[4] = '\0';
1268 pos = strchr(pos, ' ');
1269 *pos = '\0';
1270
1271 handle = (HANDLE) _lopen(file_path, OF_READWRITE);
1272 if (handle == INVALID_HANDLE_VALUE) {
1273 TRACE("_lopen(\"%s\") failed: INVALID_HANDLE_VALUE\n", file_path);
1274 AL_result = 0xff; /* failed */
1275 } else {
1276 hfile16 = Win32HandleToDosFileHandle(handle);
1277 if (hfile16 == HFILE_ERROR16) {
1278 TRACE("Win32HandleToDosFileHandle(%p) failed: HFILE_ERROR\n", handle);
1279 CloseHandle(handle);
1280 AL_result = 0xff; /* failed */
1281 } else if (hfile16 > 255) {
1282 TRACE("hfile16 (=%d) larger than 255 for \"%s\"\n", hfile16, file_path);
1283 _lclose16(hfile16);
1284 AL_result = 0xff; /* failed */
1285 } else {
1286 if (!GetFileInformationByHandle(handle, &info)) {
1287 TRACE("GetFileInformationByHandle(%d, %p) for \"%s\" failed\n",
1288 hfile16, handle, file_path);
1289 _lclose16(hfile16);
1290 AL_result = 0xff; /* failed */
1291 } else {
1292 fcb->drive_number = file_path[0] - 'A' + 1;
1293 fcb->current_block_number = 0;
1294 fcb->logical_record_size = 128;
1295 fcb->file_size = info.nFileSizeLow;
1296 FileTimeToDosDateTime(&info.ftLastWriteTime,
1297 &fcb->date_of_last_write, &fcb->time_of_last_write);
1298 fcb->file_number = hfile16;
1299 fcb->attributes = 0xc2;
1300 fcb->starting_cluster = 0; /* don't know correct init value */
1301 fcb->sequence_number = 0; /* don't know correct init value */
1302 fcb->file_attributes = info.dwFileAttributes;
1303 /* The following fields are not initialized */
1304 /* by the native function: */
1305 /* unused */
1306 /* record_within_current_block */
1307 /* random_access_record_number */
1308
1309 TRACE("successful opened file \"%s\" as %d (handle %p)\n",
1310 file_path, hfile16, handle);
1311 AL_result = 0x00; /* successful */
1312 } /* if */
1313 } /* if */
1314 } /* if */
1315 } /* if */
1316 SET_AL(context, AL_result);
1317 }
1318
1319
1320 /***********************************************************************
1321 * INT21_CloseFileUsingFCB
1322 *
1323 * Handler for function 0x10.
1324 *
1325 * PARAMS
1326 * DX:DX [I/O] File control block (FCB or XFCB) of open file
1327 *
1328 * RETURNS (in AL)
1329 * 0x00: successful
1330 * 0xff: failed
1331 *
1332 * NOTES
1333 * Closes a FCB file.
1334 */
1335 static void INT21_CloseFileUsingFCB( CONTEXT *context )
1336 {
1337 struct FCB *fcb;
1338 struct XFCB *xfcb;
1339 BYTE AL_result;
1340
1341 fcb = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
1342 if (fcb->drive_number == 0xff) {
1343 xfcb = (struct XFCB *) fcb;
1344 fcb = (struct FCB *) xfcb->fcb;
1345 } /* if */
1346
1347 if (_lclose16((HFILE16) fcb->file_number) != 0) {
1348 TRACE("_lclose16(%d) failed\n", fcb->file_number);
1349 AL_result = 0xff; /* failed */
1350 } else {
1351 TRACE("successful closed file %d\n", fcb->file_number);
1352 AL_result = 0x00; /* successful */
1353 } /* if */
1354 SET_AL(context, AL_result);
1355 }
1356
1357
1358 /***********************************************************************
1359 * INT21_SequentialReadFromFCB
1360 *
1361 * Handler for function 0x14.
1362 *
1363 * PARAMS
1364 * DX:DX [I/O] File control block (FCB or XFCB) of open file
1365 *
1366 * RETURNS (in AL)
1367 * 0: successful
1368 * 1: end of file, no data read
1369 * 2: segment wrap in DTA, no data read (not returned now)
1370 * 3: end of file, partial record read
1371 *
1372 * NOTES
1373 * Reads a record with the size FCB->logical_record_size from the FCB
1374 * to the disk transfer area. The position of the record is specified
1375 * with FCB->current_block_number and FCB->record_within_current_block.
1376 * Then FCB->current_block_number and FCB->record_within_current_block
1377 * are updated to point to the next record. If a partial record is
1378 * read, it is filled with zeros up to the FCB->logical_record_size.
1379 */
1380 static void INT21_SequentialReadFromFCB( CONTEXT *context )
1381 {
1382 struct FCB *fcb;
1383 struct XFCB *xfcb;
1384 HANDLE handle;
1385 DWORD record_number;
1386 DWORD position;
1387 BYTE *disk_transfer_area;
1388 UINT bytes_read;
1389 BYTE AL_result;
1390
1391 fcb = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
1392 if (fcb->drive_number == 0xff) {
1393 xfcb = (struct XFCB *) fcb;
1394 fcb = (struct FCB *) xfcb->fcb;
1395 } /* if */
1396
1397 handle = DosFileHandleToWin32Handle((HFILE16) fcb->file_number);
1398 if (handle == INVALID_HANDLE_VALUE) {
1399 TRACE("DosFileHandleToWin32Handle(%d) failed: INVALID_HANDLE_VALUE\n",
1400 fcb->file_number);
1401 AL_result = 0x01; /* end of file, no data read */
1402 } else {
1403 record_number = 128 * fcb->current_block_number + fcb->record_within_current_block;
1404 position = SetFilePointer(handle, record_number * fcb->logical_record_size, NULL, 0);
1405 if (position != record_number * fcb->logical_record_size) {
1406 TRACE("seek(%d, %d, 0) failed with %u\n",
1407 fcb->file_number, record_number * fcb->logical_record_size, position);
1408 AL_result = 0x01; /* end of file, no data read */
1409 } else {
1410 disk_transfer_area = INT21_GetCurrentDTA(context);
1411 bytes_read = _lread((HFILE) handle, disk_transfer_area, fcb->logical_record_size);
1412 if (bytes_read != fcb->logical_record_size) {
1413 TRACE("_lread(%d, %p, %d) failed with %d\n",
1414 fcb->file_number, disk_transfer_area, fcb->logical_record_size, bytes_read);
1415 if (bytes_read == 0) {
1416 AL_result = 0x01; /* end of file, no data read */
1417 } else {
1418 memset(&disk_transfer_area[bytes_read], 0, fcb->logical_record_size - bytes_read);
1419 AL_result = 0x03; /* end of file, partial record read */
1420 } /* if */
1421 } else {
1422 TRACE("successful read %d bytes from record %d (position %u) of file %d (handle %p)\n",
1423 bytes_read, record_number, position, fcb->file_number, handle);
1424 AL_result = 0x00; /* successful */
1425 } /* if */
1426 } /* if */
1427 } /* if */
1428 if (AL_result == 0x00 || AL_result == 0x03) {
1429 if (fcb->record_within_current_block == 127) {
1430 fcb->record_within_current_block = 0;
1431 fcb->current_block_number++;
1432 } else {
1433 fcb->record_within_current_block++;
1434 } /* if */
1435 } /* if */
1436 SET_AL(context, AL_result);
1437 }
1438
1439
1440 /***********************************************************************
1441 * INT21_SequentialWriteToFCB
1442 *
1443 * Handler for function 0x15.
1444 *
1445 * PARAMS
1446 * DX:DX [I/O] File control block (FCB or XFCB) of open file
1447 *
1448 * RETURNS (in AL)
1449 * 0: successful
1450 * 1: disk full
1451 * 2: segment wrap in DTA (not returned now)
1452 *
1453 * NOTES
1454 * Writes a record with the size FCB->logical_record_size from the disk
1455 * transfer area to the FCB. The position of the record is specified
1456 * with FCB->current_block_number and FCB->record_within_current_block.
1457 * Then FCB->current_block_number and FCB->record_within_current_block
1458 * are updated to point to the next record.
1459 */
1460 static void INT21_SequentialWriteToFCB( CONTEXT *context )
1461 {
1462 struct FCB *fcb;
1463 struct XFCB *xfcb;
1464 HANDLE handle;
1465 DWORD record_number;
1466 DWORD position;
1467 BYTE *disk_transfer_area;
1468 UINT bytes_written;
1469 BYTE AL_result;
1470
1471 fcb = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
1472 if (fcb->drive_number == 0xff) {
1473 xfcb = (struct XFCB *) fcb;
1474 fcb = (struct FCB *) xfcb->fcb;
1475 } /* if */
1476
1477 handle = DosFileHandleToWin32Handle((HFILE16) fcb->file_number);
1478 if (handle == INVALID_HANDLE_VALUE) {
1479 TRACE("DosFileHandleToWin32Handle(%d) failed: INVALID_HANDLE_VALUE\n",
1480 fcb->file_number);
1481 AL_result = 0x01; /* disk full */
1482 } else {
1483 record_number = 128 * fcb->current_block_number + fcb->record_within_current_block;
1484 position = SetFilePointer(handle, record_number * fcb->logical_record_size, NULL, 0);
1485 if (position != record_number * fcb->logical_record_size) {
1486 TRACE("seek(%d, %d, 0) failed with %u\n",
1487 fcb->file_number, record_number * fcb->logical_record_size, position);
1488 AL_result = 0x01; /* disk full */
1489 } else {
1490 disk_transfer_area = INT21_GetCurrentDTA(context);
1491 bytes_written = _lwrite((HFILE) handle, (LPCSTR)disk_transfer_area, fcb->logical_record_size);
1492 if (bytes_written != fcb->logical_record_size) {
1493 TRACE("_lwrite(%d, %p, %d) failed with %d\n",
1494 fcb->file_number, disk_transfer_area, fcb->logical_record_size, bytes_written);
1495 AL_result = 0x01; /* disk full */
1496 } else {
1497 TRACE("successful written %d bytes from record %d (position %u) of file %d (handle %p)\n",
1498 bytes_written, record_number, position, fcb->file_number, handle);
1499 AL_result = 0x00; /* successful */
1500 } /* if */
1501 } /* if */
1502 } /* if */
1503 if (AL_result == 0x00) {
1504 if (fcb->record_within_current_block == 127) {
1505 fcb->record_within_current_block = 0;
1506 fcb->current_block_number++;
1507 } else {
1508 fcb->record_within_current_block++;
1509 } /* if */
1510 } /* if */
1511 SET_AL(context, AL_result);
1512 }
1513
1514
1515 /***********************************************************************
1516 * INT21_ReadRandomRecordFromFCB
1517 *
1518 * Handler for function 0x21.
1519 *
1520 * PARAMS
1521 * DX:DX [I/O] File control block (FCB or XFCB) of open file
1522 *
1523 * RETURNS (in AL)
1524 * 0: successful
1525 * 1: end of file, no data read
1526 * 2: segment wrap in DTA, no data read (not returned now)
1527 * 3: end of file, partial record read
1528 *
1529 * NOTES
1530 * Reads a record with the size FCB->logical_record_size from
1531 * the FCB to the disk transfer area. The position of the record
1532 * is specified with FCB->random_access_record_number. The
1533 * FCB->random_access_record_number is not updated. If a partial record
1534 * is read, it is filled with zeros up to the FCB->logical_record_size.
1535 */
1536 static void INT21_ReadRandomRecordFromFCB( CONTEXT *context )
1537 {
1538 struct FCB *fcb;
1539 struct XFCB *xfcb;
1540 HANDLE handle;
1541 DWORD record_number;
1542 DWORD position;
1543 BYTE *disk_transfer_area;
1544 UINT bytes_read;
1545 BYTE AL_result;
1546
1547 fcb = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
1548 if (fcb->drive_number == 0xff) {
1549 xfcb = (struct XFCB *) fcb;
1550 fcb = (struct FCB *) xfcb->fcb;
1551 } /* if */
1552
1553 memcpy(&record_number, fcb->random_access_record_number, 4);
1554 handle = DosFileHandleToWin32Handle((HFILE16) fcb->file_number);
1555 if (handle == INVALID_HANDLE_VALUE) {
1556 TRACE("DosFileHandleToWin32Handle(%d) failed: INVALID_HANDLE_VALUE\n",
1557 fcb->file_number);
1558 AL_result = 0x01; /* end of file, no data read */
1559 } else {
1560 position = SetFilePointer(handle, record_number * fcb->logical_record_size, NULL, 0);
1561 if (position != record_number * fcb->logical_record_size) {
1562 TRACE("seek(%d, %d, 0) failed with %u\n",
1563 fcb->file_number, record_number * fcb->logical_record_size, position);
1564 AL_result = 0x01; /* end of file, no data read */
1565 } else {
1566 disk_transfer_area = INT21_GetCurrentDTA(context);
1567 bytes_read = _lread((HFILE) handle, disk_transfer_area, fcb->logical_record_size);
1568 if (bytes_read != fcb->logical_record_size) {
1569 TRACE("_lread(%d, %p, %d) failed with %d\n",
1570 fcb->file_number, disk_transfer_area, fcb->logical_record_size, bytes_read);
1571 if (bytes_read == 0) {
1572 AL_result = 0x01; /* end of file, no data read */
1573 } else {
1574 memset(&disk_transfer_area[bytes_read], 0, fcb->logical_record_size - bytes_read);
1575 AL_result = 0x03; /* end of file, partial record read */
1576 } /* if */
1577 } else {
1578 TRACE("successful read %d bytes from record %d (position %u) of file %d (handle %p)\n",
1579 bytes_read, record_number, position, fcb->file_number, handle);
1580 AL_result = 0x00; /* successful */
1581 } /* if */
1582 } /* if */
1583 } /* if */
1584 fcb->current_block_number = record_number / 128;
1585 fcb->record_within_current_block = record_number % 128;
1586 SET_AL(context, AL_result);
1587 }
1588
1589
1590 /***********************************************************************
1591 * INT21_WriteRandomRecordToFCB
1592 *
1593 * Handler for function 0x22.
1594 *
1595 * PARAMS
1596 * DX:DX [I/O] File control block (FCB or XFCB) of open file
1597 *
1598 * RETURNS (in AL)
1599 * 0: successful
1600 * 1: disk full
1601 * 2: segment wrap in DTA (not returned now)
1602 *
1603 * NOTES
1604 * Writes a record with the size FCB->logical_record_size from
1605 * the disk transfer area to the FCB. The position of the record
1606 * is specified with FCB->random_access_record_number. The
1607 * FCB->random_access_record_number is not updated.
1608 */
1609 static void INT21_WriteRandomRecordToFCB( CONTEXT *context )
1610 {
1611 struct FCB *fcb;
1612 struct XFCB *xfcb;
1613 HANDLE handle;
1614 DWORD record_number;
1615 DWORD position;
1616 BYTE *disk_transfer_area;
1617 UINT bytes_written;
1618 BYTE AL_result;
1619
1620 fcb = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
1621 if (fcb->drive_number == 0xff) {
1622 xfcb = (struct XFCB *) fcb;
1623 fcb = (struct FCB *) xfcb->fcb;
1624 } /* if */
1625
1626 memcpy(&record_number, fcb->random_access_record_number, 4);
1627 handle = DosFileHandleToWin32Handle((HFILE16) fcb->file_number);
1628 if (handle == INVALID_HANDLE_VALUE) {
1629 TRACE("DosFileHandleToWin32Handle(%d) failed: INVALID_HANDLE_VALUE\n",
1630 fcb->file_number);
1631 AL_result = 0x01; /* disk full */
1632 } else {
1633 position = SetFilePointer(handle, record_number * fcb->logical_record_size, NULL, 0);
1634 if (position != record_number * fcb->logical_record_size) {
1635 TRACE("seek(%d, %d, 0) failed with %u\n",
1636 fcb->file_number, record_number * fcb->logical_record_size, position);
1637 AL_result = 0x01; /* disk full */
1638 } else {
1639 disk_transfer_area = INT21_GetCurrentDTA(context);
1640 bytes_written = _lwrite((HFILE) handle, (LPCSTR)disk_transfer_area, fcb->logical_record_size);
1641 if (bytes_written != fcb->logical_record_size) {
1642 TRACE("_lwrite(%d, %p, %d) failed with %d\n",
1643 fcb->file_number, disk_transfer_area, fcb->logical_record_size, bytes_written);
1644 AL_result = 0x01; /* disk full */
1645 } else {
1646 TRACE("successful written %d bytes from record %d (position %u) of file %d (handle %p)\n",
1647 bytes_written, record_number, position, fcb->file_number, handle);
1648 AL_result = 0x00; /* successful */
1649 } /* if */
1650 } /* if */
1651 } /* if */
1652 fcb->current_block_number = record_number / 128;
1653 fcb->record_within_current_block = record_number % 128;
1654 SET_AL(context, AL_result);
1655 }
1656
1657
1658 /***********************************************************************
1659 * INT21_RandomBlockReadFromFCB
1660 *
1661 * Handler for function 0x27.
1662 *
1663 * PARAMS
1664 * CX [I/O] Number of records to read
1665 * DX:DX [I/O] File control block (FCB or XFCB) of open file
1666 *
1667 * RETURNS (in AL)
1668 * 0: successful
1669 * 1: end of file, no data read
1670 * 2: segment wrap in DTA, no data read (not returned now)
1671 * 3: end of file, partial record read
1672 *
1673 * NOTES
1674 * Reads several records with the size FCB->logical_record_size from
1675 * the FCB to the disk transfer area. The number of records to be
1676 * read is specified in the CX register. The position of the first
1677 * record is specified with FCB->random_access_record_number. The
1678 * FCB->random_access_record_number, the FCB->current_block_number
1679 * and FCB->record_within_current_block are updated to point to the
1680 * next record after the records read. If a partial record is read,
1681 * it is filled with zeros up to the FCB->logical_record_size. The
1682 * CX register is set to the number of successfully read records.
1683 */
1684 static void INT21_RandomBlockReadFromFCB( CONTEXT *context )
1685 {
1686 struct FCB *fcb;
1687 struct XFCB *xfcb;
1688 HANDLE handle;
1689 DWORD record_number;
1690 DWORD position;
1691 BYTE *disk_transfer_area;
1692 UINT records_requested;
1693 UINT bytes_requested;
1694 UINT bytes_read;
1695 UINT records_read;
1696 BYTE AL_result;
1697
1698 fcb = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
1699 if (fcb->drive_number == 0xff) {
1700 xfcb = (struct XFCB *) fcb;
1701 fcb = (struct FCB *) xfcb->fcb;
1702 } /* if */
1703
1704 memcpy(&record_number, fcb->random_access_record_number, 4);
1705 handle = DosFileHandleToWin32Handle((HFILE16) fcb->file_number);
1706 if (handle == INVALID_HANDLE_VALUE) {
1707 TRACE("DosFileHandleToWin32Handle(%d) failed: INVALID_HANDLE_VALUE\n",
1708 fcb->file_number);
1709 records_read = 0;
1710 AL_result = 0x01; /* end of file, no data read */
1711 } else {
1712 position = SetFilePointer(handle, record_number * fcb->logical_record_size, NULL, 0);
1713 if (position != record_number * fcb->logical_record_size) {
1714 TRACE("seek(%d, %d, 0) failed with %u\n",
1715 fcb->file_number, record_number * fcb->logical_record_size, position);
1716 records_read = 0;
1717 AL_result = 0x01; /* end of file, no data read */
1718 } else {
1719 disk_transfer_area = INT21_GetCurrentDTA(context);
1720 records_requested = CX_reg(context);
1721 bytes_requested = records_requested * fcb->logical_record_size;
1722 bytes_read = _lread((HFILE) handle, disk_transfer_area, bytes_requested);
1723 if (bytes_read != bytes_requested) {
1724 TRACE("_lread(%d, %p, %d) failed with %d\n",
1725 fcb->file_number, disk_transfer_area, bytes_requested, bytes_read);
1726 records_read = bytes_read / fcb->logical_record_size;
1727 if (bytes_read % fcb->logical_record_size == 0) {
1728 AL_result = 0x01; /* end of file, no data read */
1729 } else {
1730 records_read++;
1731 memset(&disk_transfer_area[bytes_read], 0, records_read * fcb->logical_record_size - bytes_read);
1732 AL_result = 0x03; /* end of file, partial record read */
1733 } /* if */
1734 } else {
1735 TRACE("successful read %d bytes from record %d (position %u) of file %d (handle %p)\n",
1736 bytes_read, record_number, position, fcb->file_number, handle);
1737 records_read = records_requested;
1738 AL_result = 0x00; /* successful */
1739 } /* if */
1740 } /* if */
1741 } /* if */
1742 record_number += records_read;
1743 memcpy(fcb->random_access_record_number, &record_number, 4);
1744 fcb->current_block_number = record_number / 128;
1745 fcb->record_within_current_block = record_number % 128;
1746 SET_CX(context, records_read);
1747 SET_AL(context, AL_result);
1748 }
1749
1750
1751 /***********************************************************************
1752 * INT21_RandomBlockWriteToFCB
1753 *
1754 * Handler for function 0x28.
1755 *
1756 * PARAMS
1757 * CX [I/O] Number of records to write
1758 * DX:DX [I/O] File control block (FCB or XFCB) of open file
1759 *
1760 * RETURNS (in AL)
1761 * 0: successful
1762 * 1: disk full
1763 * 2: segment wrap in DTA (not returned now)
1764 *
1765 * NOTES
1766 * Writes several records with the size FCB->logical_record_size from
1767 * the disk transfer area to the FCB. The number of records to be
1768 * written is specified in the CX register. The position of the first
1769 * record is specified with FCB->random_access_record_number. The
1770 * FCB->random_access_record_number, the FCB->current_block_number
1771 * and FCB->record_within_current_block are updated to point to the
1772 * next record after the records written. The CX register is set to
1773 * the number of successfully written records.
1774 */
1775 static void INT21_RandomBlockWriteToFCB( CONTEXT *context )
1776 {
1777 struct FCB *fcb;
1778 struct XFCB *xfcb;
1779 HANDLE handle;
1780 DWORD record_number;
1781 DWORD position;
1782 BYTE *disk_transfer_area;
1783 UINT records_requested;
1784 UINT bytes_requested;
1785 UINT bytes_written;
1786 UINT records_written;
1787 BYTE AL_result;
1788
1789 fcb = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
1790 if (fcb->drive_number == 0xff) {
1791 xfcb = (struct XFCB *) fcb;
1792 fcb = (struct FCB *) xfcb->fcb;
1793 } /* if */
1794
1795 memcpy(&record_number, fcb->random_access_record_number, 4);
1796 handle = DosFileHandleToWin32Handle((HFILE16) fcb->file_number);
1797 if (handle == INVALID_HANDLE_VALUE) {
1798 TRACE("DosFileHandleToWin32Handle(%d) failed: INVALID_HANDLE_VALUE\n",
1799 fcb->file_number);
1800 records_written = 0;
1801 AL_result = 0x01; /* disk full */
1802 } else {
1803 position = SetFilePointer(handle, record_number * fcb->logical_record_size, NULL, 0);
1804 if (position != record_number * fcb->logical_record_size) {
1805 TRACE("seek(%d, %d, 0) failed with %u\n",
1806 fcb->file_number, record_number * fcb->logical_record_size, position);
1807 records_written = 0;
1808 AL_result = 0x01; /* disk full */
1809 } else {
1810 disk_transfer_area = INT21_GetCurrentDTA(context);
1811 records_requested = CX_reg(context);
1812 bytes_requested = records_requested * fcb->logical_record_size;
1813 bytes_written = _lwrite((HFILE) handle, (LPCSTR)disk_transfer_area, bytes_requested);
1814 if (bytes_written != bytes_requested) {
1815 TRACE("_lwrite(%d, %p, %d) failed with %d\n",
1816 fcb->file_number, disk_transfer_area, bytes_requested, bytes_written);
1817 records_written = bytes_written / fcb->logical_record_size;
1818 AL_result = 0x01; /* disk full */
1819 } else {
1820 TRACE("successful write %d bytes from record %d (position %u) of file %d (handle %p)\n",
1821 bytes_written, record_number, position, fcb->file_number, handle);
1822 records_written = records_requested;
1823 AL_result = 0x00; /* successful */
1824 } /* if */
1825 } /* if */
1826 } /* if */
1827 record_number += records_written;
1828 memcpy(fcb->random_access_record_number, &record_number, 4);
1829 fcb->current_block_number = record_number / 128;
1830 fcb->record_within_current_block = record_number % 128;
1831 SET_CX(context, records_written);
1832 SET_AL(context, AL_result);
1833 }
1834
1835
1836 /***********************************************************************
1837 * INT21_CreateDirectory
1838 *
1839 * Handler for:
1840 * - function 0x39
1841 * - subfunction 0x39 of function 0x71
1842 * - subfunction 0xff of function 0x43 (CL == 0x39)
1843 */
1844 static BOOL INT21_CreateDirectory( CONTEXT *context )
1845 {
1846 WCHAR dirW[MAX_PATH];
1847 char *dirA = CTX_SEG_OFF_TO_LIN(context,
1848 context->SegDs,
1849 context->Edx);
1850
1851 TRACE( "CREATE DIRECTORY %s\n", dirA );
1852
1853 MultiByteToWideChar(CP_OEMCP, 0, dirA, -1, dirW, MAX_PATH);
1854
1855 if (CreateDirectoryW(dirW, NULL))
1856 return TRUE;
1857
1858 /*
1859 * FIXME: CreateDirectory's LastErrors will clash with the ones
1860 * used by DOS. AH=39 only returns 3 (path not found) and
1861 * 5 (access denied), while CreateDirectory return several
1862 * ones. Remap some of them. -Marcus
1863 */
1864 switch (GetLastError())
1865 {
1866 case ERROR_ALREADY_EXISTS:
1867 case ERROR_FILENAME_EXCED_RANGE:
1868 case ERROR_DISK_FULL:
1869 SetLastError(ERROR_ACCESS_DENIED);
1870 break;
1871 default:
1872 break;
1873 }
1874
1875 return FALSE;
1876 }
1877
1878
1879 /***********************************************************************
1880 * INT21_ExtendedCountryInformation
1881 *
1882 * Handler for function 0x65.
1883 */
1884 static void INT21_ExtendedCountryInformation( CONTEXT *context )
1885 {
1886 BYTE *dataptr = CTX_SEG_OFF_TO_LIN( context, context->SegEs, context->Edi );
1887 BYTE buffsize = CX_reg (context);
1888
1889 TRACE( "GET EXTENDED COUNTRY INFORMATION, subfunction %02x\n",
1890 AL_reg(context) );
1891
1892 /*
1893 * Check subfunctions that are passed country and code page.
1894 */
1895 if (AL_reg(context) >= 0x01 && AL_reg(context) <= 0x07)
1896 {
1897 WORD country = DX_reg(context);
1898 WORD codepage = BX_reg(context);
1899
1900 if (country != 0xffff && country != INT21_GetSystemCountryCode())
1901 FIXME( "Requested info on non-default country %04x\n", country );
1902
1903 if (codepage != 0xffff && codepage != GetOEMCP())
1904 FIXME( "Requested info on non-default code page %04x\n", codepage );
1905 }
1906
1907 switch (AL_reg(context)) {
1908 case 0x00: /* SET GENERAL INTERNATIONALIZATION INFO */
1909 INT_BARF( context, 0x21 );
1910 SET_CFLAG( context );
1911 break;
1912
1913 case 0x01: /* GET GENERAL INTERNATIONALIZATION INFO */
1914 TRACE( "Get general internationalization info\n" );
1915 dataptr[0] = 0x01; /* Info ID */
1916 *(WORD*)(dataptr+1) = 38; /* Size of the following info */
1917 *(WORD*)(dataptr+3) = INT21_GetSystemCountryCode(); /* Country ID */
1918 *(WORD*)(dataptr+5) = GetOEMCP(); /* Code page */
1919 /* FIXME: fill buffer partially up to buffsize bytes*/
1920 if (buffsize >= 0x29){
1921 INT21_FillCountryInformation( dataptr + 7 );
1922 SET_CX( context, 0x29 ); /* Size of returned info */
1923 }else{
1924 SET_CX( context, 0x07 ); /* Size of returned info */
1925 }
1926 break;
1927
1928 case 0x02: /* GET POINTER TO UPPERCASE TABLE */
1929 case 0x04: /* GET POINTER TO FILENAME UPPERCASE TABLE */
1930 TRACE( "Get pointer to uppercase table\n" );
1931 dataptr[0] = AL_reg(context); /* Info ID */
1932 *(DWORD*)(dataptr+1) = MAKESEGPTR( INT21_GetHeapSelector( context ),
1933 offsetof(INT21_HEAP, uppercase_size) );
1934 SET_CX( context, 5 ); /* Size of returned info */
1935 break;
1936
1937 case 0x03: /* GET POINTER TO LOWERCASE TABLE */
1938 TRACE( "Get pointer to lowercase table\n" );
1939 dataptr[0] = 0x03; /* Info ID */
1940 *(DWORD*)(dataptr+1) = MAKESEGPTR( INT21_GetHeapSelector( context ),
1941 offsetof(INT21_HEAP, lowercase_size) );
1942 SET_CX( context, 5 ); /* Size of returned info */
1943 break;
1944
1945 case 0x05: /* GET POINTER TO FILENAME TERMINATOR TABLE */
1946 TRACE("Get pointer to filename terminator table\n");
1947 dataptr[0] = 0x05; /* Info ID */
1948 *(DWORD*)(dataptr+1) = MAKESEGPTR( INT21_GetHeapSelector( context ),
1949 offsetof(INT21_HEAP, filename_size) );
1950 SET_CX( context, 5 ); /* Size of returned info */
1951 break;
1952
1953 case 0x06: /* GET POINTER TO COLLATING SEQUENCE TABLE */
1954 TRACE("Get pointer to collating sequence table\n");
1955 dataptr[0] = 0x06; /* Info ID */
1956 *(DWORD*)(dataptr+1) = MAKESEGPTR( INT21_GetHeapSelector( context ),
1957 offsetof(INT21_HEAP, collating_size) );
1958 SET_CX( context, 5 ); /* Size of returned info */
1959 break;
1960
1961 case 0x07: /* GET POINTER TO DBCS LEAD BYTE TABLE */
1962 TRACE("Get pointer to DBCS lead byte table\n");
1963 dataptr[0] = 0x07; /* Info ID */
1964 *(DWORD*)(dataptr+1) = MAKESEGPTR( INT21_GetHeapSelector( context ),
1965 offsetof(INT21_HEAP, dbcs_size) );
1966 SET_CX( context, 5 ); /* Size of returned info */
1967 break;
1968
1969 case 0x20: /* CAPITALIZE CHARACTER */
1970 case 0xa0: /* CAPITALIZE FILENAME CHARACTER */
1971 TRACE("Convert char to uppercase\n");
1972 SET_DL( context, toupper(DL_reg(context)) );
1973 break;
1974
1975 case 0x21: /* CAPITALIZE STRING */
1976 case 0xa1: /* CAPITALIZE COUNTED FILENAME STRING */
1977 TRACE("Convert string to uppercase with length\n");
1978 {
1979 char *ptr = CTX_SEG_OFF_TO_LIN( context, context->SegDs,
1980 context->Edx );
1981 WORD len = CX_reg(context);
1982 while (len--) { *ptr = toupper(*ptr); ptr++; }
1983 }
1984 break;
1985
1986 case 0x22: /* CAPITALIZE ASCIIZ STRING */
1987 case 0xa2: /* CAPITALIZE ASCIIZ FILENAME */
1988 TRACE("Convert ASCIIZ string to uppercase\n");
1989 {
1990 char *p = CTX_SEG_OFF_TO_LIN( context, context->SegDs, context->Edx );
1991 for ( ; *p; p++) *p = toupper(*p);
1992 }
1993 break;
1994
1995 case 0x23: /* DETERMINE IF CHARACTER REPRESENTS YES/NO RESPONSE */
1996 INT_BARF( context, 0x21 );
1997 SET_CFLAG( context );
1998 break;
1999
2000 default:
2001 INT_BARF( context, 0x21 );
2002 SET_CFLAG(context);
2003 break;
2004 }
2005 }
2006
2007
2008 /***********************************************************************
2009 * INT21_FileAttributes
2010 *
2011 * Handler for:
2012 * - function 0x43
2013 * - subfunction 0x43 of function 0x71
2014 */
2015 static BOOL INT21_FileAttributes( CONTEXT *context,
2016 BYTE subfunction,
2017 BOOL islong )
2018 {
2019 WCHAR fileW[MAX_PATH];
2020 char *fileA = CTX_SEG_OFF_TO_LIN(context,
2021 context->SegDs,
2022 context->Edx);
2023 HANDLE handle;
2024 BOOL status;
2025 FILETIME filetime;
2026 DWORD result;
2027 WORD date, time;
2028 int len;
2029
2030 switch (subfunction)
2031 {
2032 case 0x00: /* GET FILE ATTRIBUTES */
2033 TRACE( "GET FILE ATTRIBUTES for %s\n", fileA );
2034 len = MultiByteToWideChar(CP_OEMCP, 0, fileA, -1, fileW, MAX_PATH);
2035
2036 /* Winbench 96 Disk Test fails if we don't complain
2037 * about a filename that ends in \
2038 */
2039 if (!len || (fileW[len-1] == '/') || (fileW[len-1] == '\\'))
2040 return FALSE;
2041
2042 result = GetFileAttributesW( fileW );
2043 if (result == INVALID_FILE_ATTRIBUTES)
2044 return FALSE;
2045 else
2046 {
2047 SET_CX( context, (WORD)result );
2048 if (!islong)
2049 SET_AX( context, (WORD)result ); /* DR DOS */
2050 }
2051 break;
2052
2053 case 0x01: /* SET FILE ATTRIBUTES */
2054 TRACE( "SET FILE ATTRIBUTES 0x%02x for %s\n",
2055 CX_reg(context), fileA );
2056 MultiByteToWideChar(CP_OEMCP, 0, fileA, -1, fileW, MAX_PATH);
2057
2058 if (!SetFileAttributesW( fileW, CX_reg(context) ))
2059 return FALSE;
2060 break;
2061
2062 case 0x02: /* GET COMPRESSED FILE SIZE */
2063 TRACE( "GET COMPRESSED FILE SIZE for %s\n", fileA );
2064 MultiByteToWideChar(CP_OEMCP, 0, fileA, -1, fileW, MAX_PATH);
2065
2066 result = GetCompressedFileSizeW( fileW, NULL );
2067 if (result == INVALID_FILE_SIZE)
2068 return FALSE;
2069 else
2070 {
2071 SET_AX( context, LOWORD(result) );
2072 SET_DX( context, HIWORD(result) );
2073 }
2074 break;
2075
2076 case 0x03: /* SET FILE LAST-WRITTEN DATE AND TIME */
2077 if (!islong)
2078 INT_BARF( context, 0x21 );
2079 else
2080 {
2081 TRACE( "SET FILE LAST-WRITTEN DATE AND TIME, file %s\n", fileA );
2082 MultiByteToWideChar(CP_OEMCP, 0, fileA, -1, fileW, MAX_PATH);
2083
2084 handle = CreateFileW( fileW, GENERIC_WRITE,
2085 FILE_SHARE_READ | FILE_SHARE_WRITE,
2086 NULL, OPEN_EXISTING, 0, 0 );
2087 if (handle == INVALID_HANDLE_VALUE)
2088 return FALSE;
2089
2090 DosDateTimeToFileTime( DI_reg(context),
2091 CX_reg(context),
2092 &filetime );
2093 status = SetFileTime( handle, NULL, NULL, &filetime );
2094
2095 CloseHandle( handle );
2096 return status;
2097 }
2098 break;
2099
2100 case 0x04: /* GET FILE LAST-WRITTEN DATE AND TIME */
2101 if (!islong)
2102 INT_BARF( context, 0x21 );
2103 else
2104 {
2105 TRACE( "GET FILE LAST-WRITTEN DATE AND TIME, file %s\n", fileA );
2106 MultiByteToWideChar(CP_OEMCP, 0, fileA, -1, fileW, MAX_PATH);
2107
2108 handle = CreateFileW( fileW, GENERIC_READ,
2109 FILE_SHARE_READ | FILE_SHARE_WRITE,
2110 NULL, OPEN_EXISTING, 0, 0 );
2111 if (handle == INVALID_HANDLE_VALUE)
2112 return FALSE;
2113
2114 status = GetFileTime( handle, NULL, NULL, &filetime );
2115 if (status)
2116 {
2117 FileTimeToDosDateTime( &filetime, &date, &time );
2118 SET_DI( context, date );
2119 SET_CX( context, time );
2120 }
2121
2122 CloseHandle( handle );
2123 return status;
2124 }
2125 break;
2126
2127 case 0x05: /* SET FILE LAST ACCESS DATE */
2128 if (!islong)
2129 INT_BARF( context, 0x21 );
2130 else
2131 {
2132 TRACE( "SET FILE LAST ACCESS DATE, file %s\n", fileA );
2133 MultiByteToWideChar(CP_OEMCP, 0, fileA, -1, fileW, MAX_PATH);
2134
2135 handle = CreateFileW( fileW, GENERIC_WRITE,
2136 FILE_SHARE_READ | FILE_SHARE_WRITE,
2137 NULL, OPEN_EXISTING, 0, 0 );
2138 if (handle == INVALID_HANDLE_VALUE)
2139 return FALSE;
2140
2141 DosDateTimeToFileTime( DI_reg(context),
2142 0,
2143 &filetime );
2144 status = SetFileTime( handle, NULL, &filetime, NULL );
2145
2146 CloseHandle( handle );
2147 return status;
2148 }
2149 break;
2150
2151 case 0x06: /* GET FILE LAST ACCESS DATE */
2152 if (!islong)
2153 INT_BARF( context, 0x21 );
2154 else
2155 {
2156 TRACE( "GET FILE LAST ACCESS DATE, file %s\n", fileA );
2157 MultiByteToWideChar(CP_OEMCP, 0, fileA, -1, fileW, MAX_PATH);
2158
2159 handle = CreateFileW( fileW, GENERIC_READ,
2160 FILE_SHARE_READ | FILE_SHARE_WRITE,
2161 NULL, OPEN_EXISTING, 0, 0 );
2162 if (handle == INVALID_HANDLE_VALUE)
2163 return FALSE;
2164
2165 status = GetFileTime( handle, NULL, &filetime, NULL );
2166 if (status)
2167 {
2168 FileTimeToDosDateTime( &filetime, &date, NULL );
2169 SET_DI( context, date );
2170 }
2171
2172 CloseHandle( handle );
2173 return status;
2174 }
2175 break;
2176
2177 case 0x07: /* SET FILE CREATION DATE AND TIME */
2178 if (!islong)
2179 INT_BARF( context, 0x21 );
2180 else
2181 {
2182 TRACE( "SET FILE CREATION DATE AND TIME, file %s\n", fileA );
2183 MultiByteToWideChar(CP_OEMCP, 0, fileA, -1, fileW, MAX_PATH);
2184
2185 handle = CreateFileW( fileW, GENERIC_WRITE,
2186 FILE_SHARE_READ | FILE_SHARE_WRITE,
2187 NULL, OPEN_EXISTING, 0, 0 );
2188 if (handle == INVALID_HANDLE_VALUE)
2189 return FALSE;
2190
2191 /*
2192 * FIXME: SI has number of 10-millisecond units past time in CX.
2193 */
2194 DosDateTimeToFileTime( DI_reg(context),
2195 CX_reg(context),
2196 &filetime );
2197 status = SetFileTime( handle, &filetime, NULL, NULL );
2198
2199 CloseHandle( handle );
2200 return status;
2201 }
2202 break;
2203
2204 case 0x08: /* GET FILE CREATION DATE AND TIME */
2205 if (!islong)
2206 INT_BARF( context, 0x21 );
2207 else
2208 {
2209 TRACE( "GET FILE CREATION DATE AND TIME, file %s\n", fileA );
2210 MultiByteToWideChar(CP_OEMCP, 0, fileA, -1, fileW, MAX_PATH);
2211
2212 handle = CreateFileW( fileW, GENERIC_READ,
2213 FILE_SHARE_READ | FILE_SHARE_WRITE,
2214 NULL, OPEN_EXISTING, 0, 0 );
2215 if (handle == INVALID_HANDLE_VALUE)
2216 return FALSE;
2217
2218 status = GetFileTime( handle, &filetime, NULL, NULL );
2219 if (status)
2220 {
2221 FileTimeToDosDateTime( &filetime, &date, &time );
2222 SET_DI( context, date );
2223 SET_CX( context, time );
2224 /*
2225 * FIXME: SI has number of 10-millisecond units past
2226 * time in CX.
2227 */
2228 SET_SI( context, 0 );
2229 }
2230
2231 CloseHandle(handle);
2232 return status;
2233 }
2234 break;
2235
2236 case 0xff: /* EXTENDED-LENGTH FILENAME OPERATIONS */
2237 if (islong || context->Ebp != 0x5053)
2238 INT_BARF( context, 0x21 );
2239 else
2240 {
2241 switch(CL_reg(context))
2242 {
2243 case 0x39:
2244 if (!INT21_CreateDirectory( context ))
2245 return FALSE;
2246 break;
2247
2248 case 0x56:
2249 if (!INT21_RenameFile( context ))
2250 return FALSE;
2251 break;
2252
2253 default:
2254 INT_BARF( context, 0x21 );
2255 }
2256 }
2257 break;
2258
2259 default:
2260 INT_BARF( context, 0x21 );
2261 }
2262
2263 return TRUE;
2264 }
2265
2266
2267 /***********************************************************************
2268 * INT21_FileDateTime
2269 *
2270 * Handler for function 0x57.
2271 */
2272 static BOOL INT21_FileDateTime( CONTEXT *context )
2273 {
2274 HANDLE handle = DosFileHandleToWin32Handle(BX_reg(context));
2275 FILETIME filetime;
2276 WORD date, time;
2277
2278 switch (AL_reg(context)) {
2279 case 0x00: /* Get last-written stamp */
2280 TRACE( "GET FILE LAST-WRITTEN DATE AND TIME, handle %d\n",
2281 BX_reg(context) );
2282 {
2283 if (!GetFileTime( handle, NULL, NULL, &filetime ))
2284 return FALSE;
2285 FileTimeToDosDateTime( &filetime, &date, &time );
2286 SET_DX( context, date );
2287 SET_CX( context, time );
2288 break;
2289 }
2290
2291 case 0x01: /* Set last-written stamp */
2292 TRACE( "SET FILE LAST-WRITTEN DATE AND TIME, handle %d\n",
2293 BX_reg(context) );
2294 {
2295 DosDateTimeToFileTime( DX_reg(context),
2296 CX_reg(context),
2297 &filetime );
2298 if (!SetFileTime( handle, NULL, NULL, &filetime ))
2299 return FALSE;
2300 break;
2301 }
2302
2303 case 0x04: /* Get last access stamp, DOS 7 */
2304 TRACE( "GET FILE LAST ACCESS DATE AND TIME, handle %d\n",
2305 BX_reg(context) );
2306 {
2307 if (!GetFileTime( handle, NULL, &filetime, NULL ))
2308 return FALSE;
2309 FileTimeToDosDateTime( &filetime, &date, &time );
2310 SET_DX( context, date );
2311 SET_CX( context, time );
2312 break;
2313 }
2314
2315 case 0x05: /* Set last access stamp, DOS 7 */
2316 TRACE( "SET FILE LAST ACCESS DATE AND TIME, handle %d\n",
2317 BX_reg(context) );
2318 {
2319 DosDateTimeToFileTime( DX_reg(context),
2320 CX_reg(context),
2321 &filetime );
2322 if (!SetFileTime( handle, NULL, &filetime, NULL ))
2323 return FALSE;
2324 break;
2325 }
2326
2327 case 0x06: /* Get creation stamp, DOS 7 */
2328 TRACE( "GET FILE CREATION DATE AND TIME, handle %d\n",
2329 BX_reg(context) );
2330 {
2331 if (!GetFileTime( handle, &filetime, NULL, NULL ))
2332 return FALSE;
2333 FileTimeToDosDateTime( &filetime, &date, &time );
2334 SET_DX( context, date );
2335 SET_CX( context, time );
2336 /*
2337 * FIXME: SI has number of 10-millisecond units past time in CX.
2338 */
2339 SET_SI( context, 0 );
2340 break;
2341 }
2342
2343 case 0x07: /* Set creation stamp, DOS 7 */
2344 TRACE( "SET FILE CREATION DATE AND TIME, handle %d\n",
2345 BX_reg(context) );
2346 {
2347 /*
2348 * FIXME: SI has number of 10-millisecond units past time in CX.
2349 */
2350 DosDateTimeToFileTime( DX_reg(context),
2351 CX_reg(context),
2352 &filetime );
2353 if (!SetFileTime( handle, &filetime, NULL, NULL ))
2354 return FALSE;
2355 break;
2356 }
2357
2358 default:
2359 INT_BARF( context, 0x21 );
2360 break;
2361 }
2362
2363 return TRUE;
2364 }
2365
2366
2367 /***********************************************************************
2368 * INT21_GetPSP
2369 *
2370 * Handler for functions 0x51 and 0x62.
2371 */
2372 static void INT21_GetPSP( CONTEXT *context )
2373 {
2374 TRACE( "GET CURRENT PSP ADDRESS (%02x)\n", AH_reg(context) );
2375
2376 /*
2377 * FIXME: should we return the original DOS PSP upon
2378 * Windows startup ?
2379 */
2380 if (!ISV86(context) && DOSVM_IsWin16())
2381 SET_BX( context, LOWORD(GetCurrentPDB16()) );
2382 else
2383 SET_BX( context, DOSVM_psp );
2384 }
2385
2386 static inline void setword( BYTE *ptr, WORD w )
2387 {
2388 ptr[0] = (BYTE)w;
2389 ptr[1] = (BYTE)(w >> 8);
2390 }
2391
2392 static void CreateBPB(int drive, BYTE *data, BOOL16 limited)
2393 /* limited == TRUE is used with INT 0x21/0x440d */
2394 {
2395 /* FIXME: we're forcing some values without checking that those are valid */
2396 if (drive > 1)
2397 {
2398 setword(data, 512);
2399 data[2] = 2;
2400 setword(&data[3], 0);
2401 data[5] = 2;
2402 setword(&data[6], 240);
2403 setword(&data[8], 64000);
2404 data[0x0a] = 0xf8;
2405 setword(&data[0x0b], 40);
2406 setword(&data[0x0d], 56);
2407 setword(&data[0x0f], 2);
2408 setword(&data[0x11], 0);
2409 if (!limited)
2410 {
2411 setword(&data[0x1f], 800);
2412 data[0x21] = 5;
2413 setword(&data[0x22], 1);
2414 }
2415 }
2416 else
2417 { /* 1.44mb */
2418 setword(data, 512);
2419 data[2] = 2;
2420 setword(&data[3], 0);
2421 data[5] = 2;
2422 setword(&data[6], 240);
2423 setword(&data[8], 2880);
2424 data[0x0a] = 0xf8;
2425 setword(&data[0x0b], 6);
2426 setword(&data[0x0d], 18);
2427 setword(&data[0x0f], 2);
2428 setword(&data[0x11], 0);
2429 if (!limited)
2430 {
2431 setword(&data[0x1f], 80);
2432 data[0x21] = 7;
2433 setword(&data[0x22], 2);
2434 }
2435 }
2436 }
2437
2438 static inline DWORD INT21_Ioctl_CylHeadSect2Lin(DWORD cyl, WORD head, WORD sec, WORD cyl_cnt,
2439 WORD head_cnt, WORD sec_cnt)
2440 {
2441 DWORD res = (cyl * head_cnt*sec_cnt + head * sec_cnt + sec);
2442 return res;
2443 }
2444
2445 /***********************************************************************
2446 * INT21_Ioctl_Block
2447 *
2448 * Handler for block device IOCTLs.
2449 */
2450 static void INT21_Ioctl_Block( CONTEXT *context )
2451 {
2452 BYTE *dataptr;
2453 BYTE drive = INT21_MapDrive( BL_reg(context) );
2454 WCHAR drivespec[] = {'A', ':', '\\', 0};
2455 UINT drivetype;
2456
2457 drivespec[0] += drive;
2458 drivetype = GetDriveTypeW( drivespec );
2459
2460 RESET_CFLAG(context);
2461 if (drivetype == DRIVE_UNKNOWN || drivetype == DRIVE_NO_ROOT_DIR)
2462 {
2463 TRACE( "IOCTL - SUBFUNCTION %d - INVALID DRIVE %c:\n",
2464 AL_reg(context), 'A' + drive );
2465 SetLastError( ERROR_INVALID_DRIVE );
2466 SET_AX( context, ERROR_INVALID_DRIVE );
2467 SET_CFLAG( context );
2468 return;
2469 }
2470
2471 switch (AL_reg(context))
2472 {
2473 case 0x04: /* READ FROM BLOCK DEVICE CONTROL CHANNEL */
2474 case 0x05: /* WRITE TO BLOCK DEVICE CONTROL CHANNEL */
2475 INT_BARF( context, 0x21 );
2476 break;
2477
2478 case 0x08: /* CHECK IF BLOCK DEVICE REMOVABLE */
2479 TRACE( "IOCTL - CHECK IF BLOCK DEVICE REMOVABLE - %c:\n",
2480 'A' + drive );
2481
2482 if (drivetype == DRIVE_REMOVABLE)
2483 SET_AX( context, 0 ); /* removable */
2484 else
2485 SET_AX( context, 1 ); /* not removable */
2486 break;
2487
2488 case 0x09: /* CHECK IF BLOCK DEVICE REMOTE */
2489 TRACE( "IOCTL - CHECK IF BLOCK DEVICE REMOTE - %c:\n",
2490 'A' + drive );
2491
2492 if (drivetype == DRIVE_REMOTE)
2493 SET_DX( context, (1<<9) | (1<<12) ); /* remote + no direct IO */
2494 else if (drivetype == DRIVE_CDROM)
2495 /* CDROM should be set to remote. If it set the app will
2496 * call int2f to check if it cdrom or remote drive. */
2497 SET_DX( context, (1<<12) );
2498 else if (drivetype == DRIVE_FIXED)
2499 /* This should define if drive support 0x0d, 0x0f and 0x08
2500 * requests. The local fixed drive should do. */
2501 SET_DX( context, (1<<11) );
2502 else
2503 SET_DX( context, 0 ); /* FIXME: use driver attr here */
2504 break;
2505
2506 case 0x0d: /* GENERIC BLOCK DEVICE REQUEST */
2507 /* Get pointer to IOCTL parameter block */
2508 dataptr = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
2509
2510 switch (CX_reg(context))
2511 {
2512 case 0x0841: /* write logical device track */
2513 TRACE( "GENERIC IOCTL - Write logical device track - %c:\n",
2514 'A' + drive);
2515 {
2516 WORD head = *(WORD *)(dataptr+1);
2517 WORD cyl = *(WORD *)(dataptr+3);
2518 WORD sect = *(WORD *)(dataptr+5);
2519 WORD nrsect = *(WORD *)(dataptr+7);
2520 BYTE *data = CTX_SEG_OFF_TO_LIN(context, *(WORD *)(dataptr+11), *(WORD *)(dataptr+9));
2521 WORD cyl_cnt, head_cnt, sec_cnt;
2522
2523 /* FIXME: we're faking some values here */
2524 if (drive > 1)
2525 {
2526 /* cyl_cnt = 0x300;
2527 head_cnt = 16;
2528 sec_cnt = 255; */
2529 SET_AX( context, ERROR_WRITE_FAULT );
2530 SET_CFLAG(context);
2531 break;
2532 }
2533 else
2534 { /* floppy */
2535 cyl_cnt = 80;
2536 head_cnt = 2;
2537 sec_cnt = 18;
2538 }
2539
2540 if (!DOSVM_RawWrite(drive, INT21_Ioctl_CylHeadSect2Lin(cyl, head, sect, cyl_cnt, head_cnt, sec_cnt), nrsect, data, FALSE))
2541 {
2542 SET_AX( context, ERROR_WRITE_FAULT );
2543 SET_CFLAG(context);
2544 }
2545 }
2546 break;
2547
2548 case 0x084a: /* lock logical volume */
2549 TRACE( "GENERIC IOCTL - Lock logical volume, level %d mode %d - %c:\n",
2550 BH_reg(context), DX_reg(context), 'A' + drive );
2551 break;
2552
2553 case 0x0860: /* get device parameters */
2554 /* FIXME: we're faking some values here */
2555 /* used by w4wgrp's winfile */
2556 memset(dataptr, 0, 0x20); /* DOS 6.22 uses 0x20 bytes */
2557 dataptr[0] = 0x04;
2558 dataptr[6] = 0; /* media type */
2559 if (drive > 1)
2560 {
2561 dataptr[1] = 0x05; /* fixed disk */
2562 setword(&dataptr[2], 0x01); /* non removable */
2563 setword(&dataptr[4], 0x300); /* # of cylinders */
2564 }
2565 else
2566 {
2567 dataptr[1] = 0x07; /* block dev, floppy */
2568 setword(&dataptr[2], 0x02); /* removable */
2569 setword(&dataptr[4], 80); /* # of cylinders */
2570 }
2571 CreateBPB(drive, &dataptr[7], TRUE);
2572 RESET_CFLAG(context);
2573 break;
2574
2575 case 0x0861: /* read logical device track */
2576 TRACE( "GENERIC IOCTL - Read logical device track - %c:\n",
2577 'A' + drive);
2578 {
2579 WORD head = *(WORD *)(dataptr+1);
2580 WORD cyl = *(WORD *)(dataptr+3);
2581 WORD sect = *(WORD *)(dataptr+5);
2582 WORD nrsect = *(WORD *)(dataptr+7);
2583 BYTE *data = CTX_SEG_OFF_TO_LIN(context, *(WORD *)(dataptr+11), *(WORD *)(dataptr+9));
2584 WORD cyl_cnt, head_cnt, sec_cnt;
2585
2586 /* FIXME: we're faking some values here */
2587 if (drive > 1)
2588 {
2589 cyl_cnt = 0x300;
2590 head_cnt = 16;
2591 sec_cnt = 255;
2592 }
2593 else
2594 { /* floppy */
2595 cyl_cnt = 80;
2596 head_cnt = 2;
2597 sec_cnt = 18;
2598 }
2599
2600 if (!DOSVM_RawRead(drive, INT21_Ioctl_CylHeadSect2Lin(cyl, head, sect, cyl_cnt, head_cnt, sec_cnt), nrsect, data, FALSE))
2601 {
2602 SET_AX( context, ERROR_READ_FAULT );
2603 SET_CFLAG(context);
2604 }
2605 }
2606 break;
2607
2608 case 0x0866: /* get volume serial number */
2609 {
2610 WCHAR label[12],fsname[9];
2611 DWORD serial;
2612 TRACE( "GENERIC IOCTL - Get media id - %c:\n",
2613 'A' + drive );
2614
2615 GetVolumeInformationW(drivespec, label, 12, &serial, NULL, NULL, fsname, 9);
2616 *(WORD*)dataptr = 0;
2617 memcpy(dataptr+2,&serial,4);
2618 WideCharToMultiByte(CP_OEMCP, 0, label, 11, (LPSTR)dataptr + 6, 11, NULL, NULL);
2619 WideCharToMultiByte(CP_OEMCP, 0, fsname, 8, (LPSTR)dataptr + 17, 8, NULL, NULL);
2620 }
2621 break;
2622
2623 case 0x086a: /* unlock logical volume */
2624 TRACE( "GENERIC IOCTL - Logical volume unlocked - %c:\n",
2625 'A' + drive );
2626 break;
2627
2628 case 0x086f: /* get drive map information */
2629 memset(dataptr+1, '\0', dataptr[0]-1);
2630 dataptr[1] = dataptr[0];
2631 dataptr[2] = 0x07; /* protected mode driver; no eject; no notification */
2632 dataptr[3] = 0xFF; /* no physical drive */
2633 break;
2634
2635 case 0x0872:
2636 /* Trial and error implementation */
2637 SET_AX( context, drivetype == DRIVE_UNKNOWN ? 0x0f : 0x01 );
2638 SET_CFLAG(context); /* Seems to be set all the time */
2639 break;
2640
2641 default:
2642 INT_BARF( context, 0x21 );
2643 }
2644 break;
2645
2646 case 0x0e: /* GET LOGICAL DRIVE MAP */
2647 TRACE( "IOCTL - GET LOGICAL DRIVE MAP - %c:\n",
2648 'A' + drive );
2649 /* FIXME: this is not correct if drive has mappings */
2650 SET_AL( context, 0 ); /* drive has no mapping */
2651 break;
2652
2653 case 0x0f: /* SET LOGICAL DRIVE MAP */
2654 TRACE("IOCTL - SET LOGICAL DRIVE MAP for drive %s\n",
2655 INT21_DriveName( BL_reg(context)));
2656 /* FIXME: as of today, we don't support logical drive mapping... */
2657 SET_AL( context, 0 );
2658 break;
2659
2660 case 0x11: /* QUERY GENERIC IOCTL CAPABILITY */
2661 default:
2662 INT_BARF( context, 0x21 );
2663 }
2664 }
2665
2666
2667 /***********************************************************************
2668 * INT21_IoctlScsiMgrHandler
2669 *
2670 * IOCTL handler for the SCSIMGR device.
2671 */
2672 static void INT21_IoctlScsiMgrHandler( CONTEXT *context )
2673 {
2674 switch (AL_reg(context))
2675 {
2676 case 0x00: /* GET DEVICE INFORMATION */
2677 SET_DX( context, 0xc0c0 );
2678 break;
2679
2680 case 0x02: /* READ FROM CHARACTER DEVICE CONTROL CHANNEL */
2681 DOSVM_ASPIHandler(context);
2682 break;
2683
2684 case 0x0a: /* CHECK IF HANDLE IS REMOTE */
2685 SET_DX( context, 0 );
2686 break;
2687
2688 case 0x01: /* SET DEVICE INFORMATION */
2689 case 0x03: /* WRITE TO CHARACTER DEVICE CONTROL CHANNEL */
2690 case 0x06: /* GET INPUT STATUS */
2691 case 0x07: /* GET OUTPUT STATUS */
2692 case 0x0c: /* GENERIC CHARACTER DEVICE REQUEST */
2693 case 0x10: /* QUERY GENERIC IOCTL CAPABILITY */
2694 default:
2695 INT_BARF( context, 0x21 );
2696 break;
2697 }
2698 }
2699
2700
2701 /***********************************************************************
2702 * INT21_IoctlHPScanHandler
2703 *
2704 * IOCTL handler for the HPSCAN device.
2705 */
2706 static void INT21_IoctlHPScanHandler( CONTEXT *context )
2707 {
2708 switch (AL_reg(context))
2709 {
2710 case 0x00: /* GET DEVICE INFORMATION */
2711 SET_DX( context, 0xc0c0 );
2712 break;
2713
2714 case 0x0a: /* CHECK IF HANDLE IS REMOTE */
2715 SET_DX( context, 0 );
2716 break;
2717
2718 case 0x01: /* SET DEVICE INFORMATION */
2719 case 0x02: /* READ FROM CHARACTER DEVICE CONTROL CHANNEL */
2720 case 0x03: /* WRITE TO CHARACTER DEVICE CONTROL CHANNEL */
2721 case 0x06: /* GET INPUT STATUS */
2722 case 0x07: /* GET OUTPUT STATUS */
2723 case 0x0c: /* GENERIC CHARACTER DEVICE REQUEST */
2724 case 0x10: /* QUERY GENERIC IOCTL CAPABILITY */
2725 default:
2726 INT_BARF( context, 0x21 );
2727 break;
2728 }
2729 }
2730
2731
2732 /***********************************************************************
2733 * INT21_Ioctl_Char
2734 *
2735 * Handler for character device IOCTLs.
2736 */
2737 static void INT21_Ioctl_Char( CONTEXT *context )
2738 {
2739 int status;
2740 int IsConsoleIOHandle = 0;
2741 IO_STATUS_BLOCK io;
2742 FILE_INTERNAL_INFORMATION info;
2743 HANDLE handle = DosFileHandleToWin32Handle(BX_reg(context));
2744
2745 status = NtQueryInformationFile( handle, &io, &info, sizeof(info), FileInternalInformation );
2746 if (status)
2747 {
2748 if( VerifyConsoleIoHandle( handle))
2749 IsConsoleIOHandle = 1;
2750 else {
2751 SET_AX( context, RtlNtStatusToDosError(status) );
2752 SET_CFLAG( context );
2753 return;
2754 }
2755 } else {
2756 UINT i;
2757 for (i = 0; i < NB_MAGIC_DEVICES; i++)
2758 {
2759 if (!magic_devices[i].handle) continue;
2760 if (magic_devices[i].index.QuadPart == info.IndexNumber.QuadPart)
2761 {
2762 /* found it */
2763 magic_devices[i].ioctl_handler( context );
2764 return;
2765 }
2766 }
2767 }
2768
2769 /* no magic device found, do default handling */
2770
2771 switch (AL_reg(context))
2772 {
2773 case 0x00: /* GET DEVICE INFORMATION */
2774 TRACE( "IOCTL - GET DEVICE INFORMATION - %d\n", BX_reg(context) );
2775 if (IsConsoleIOHandle || GetFileType(handle) == FILE_TYPE_CHAR)
2776 {
2777 /*
2778 * Returns attribute word in DX:
2779 * Bit 14 - Device driver can process IOCTL requests.
2780 * Bit 13 - Output until busy supported.
2781 * Bit 11 - Driver supports OPEN/CLOSE calls.
2782 * Bit 8 - Unknown.
2783 * Bit 7 - Set (indicates device).
2784 * Bit 6 - EOF on input.
2785 * Bit 5 - Raw (binary) mode.
2786 * Bit 4 - Device is special (uses int29).
2787 * Bit 3 - Clock device.
2788 * Bit 2 - NUL device.
2789 * Bit 1 - Console output device.
2790 * Bit 0 - Console input device.
2791 */
2792 SET_DX( context, IsConsoleIOHandle ? 0x80c3 : 0x80c0 /* FIXME */ );
2793 }
2794 else
2795 {
2796 /*
2797 * Returns attribute word in DX:
2798 * Bit 15 - File is remote.
2799 * Bit 14 - Don't set file date/time on closing.
2800 * Bit 11 - Media not removable.
2801 * Bit 8 - Generate int24 if no disk space on write
2802 * or read past end of file
2803 * Bit 7 - Clear (indicates file).
2804 * Bit 6 - File has not been written.
2805 * Bit 5..0 - Drive number (0=A:,...)
2806 *
2807 * FIXME: Should check if file is on remote or removable drive.
2808 * FIXME: Should use drive file is located on (and not current).
2809 */
2810 SET_DX( context, 0x0140 + INT21_GetCurrentDrive() );
2811 }
2812 break;
2813
2814 case 0x0a: /* CHECK IF HANDLE IS REMOTE */
2815 TRACE( "IOCTL - CHECK IF HANDLE IS REMOTE - %d\n", BX_reg(context) );
2816 /*
2817 * Returns attribute word in DX:
2818 * Bit 15 - Set if remote.
2819 * Bit 14 - Set if date/time not set on close.
2820 *
2821 * FIXME: Should check if file is on remote drive.
2822 */
2823 SET_DX( context, 0 );
2824 break;
2825
2826 case 0x01: /* SET DEVICE INFORMATION */
2827 case 0x02: /* READ FROM CHARACTER DEVICE CONTROL CHANNEL */
2828 case 0x03: /* WRITE TO CHARACTER DEVICE CONTROL CHANNEL */
2829 case 0x06: /* GET INPUT STATUS */
2830 case 0x07: /* GET OUTPUT STATUS */
2831 case 0x0c: /* GENERIC CHARACTER DEVICE REQUEST */
2832 case 0x10: /* QUERY GENERIC IOCTL CAPABILITY */
2833 default:
2834 INT_BARF( context, 0x21 );
2835 break;
2836 }
2837 }
2838
2839
2840 /***********************************************************************
2841 * INT21_Ioctl
2842 *
2843 * Handler for function 0x44.
2844 */
2845 static void INT21_Ioctl( CONTEXT *context )
2846 {
2847 switch (AL_reg(context))
2848 {
2849 case 0x00:
2850 case 0x01:
2851 case 0x02:
2852 case 0x03:
2853 INT21_Ioctl_Char( context );
2854 break;
2855
2856 case 0x04:
2857 case 0x05:
2858 INT21_Ioctl_Block( context );
2859 break;
2860
2861 case 0x06:
2862 case 0x07:
2863 INT21_Ioctl_Char( context );
2864 break;
2865
2866 case 0x08:
2867 case 0x09:
2868 INT21_Ioctl_Block( context );
2869 break;
2870
2871 case 0x0a:
2872 INT21_Ioctl_Char( context );
2873 break;
2874
2875 case 0x0b: /* SET SHARING RETRY COUNT */
2876 TRACE( "SET SHARING RETRY COUNT: Pause %d, retries %d.\n",
2877 CX_reg(context), DX_reg(context) );
2878 if (!CX_reg(context))
2879 {
2880 SET_AX( context, 1 );
2881 SET_CFLAG( context );
2882 }
2883 else
2884 {
2885 DOSDEV_SetSharingRetry( CX_reg(context), DX_reg(context) );
2886 RESET_CFLAG( context );
2887 }
2888 break;
2889
2890 case 0x0c:
2891 INT21_Ioctl_Char( context );
2892 break;
2893
2894 case 0x0d:
2895 case 0x0e:
2896 case 0x0f:
2897 INT21_Ioctl_Block( context );
2898 break;
2899
2900 case 0x10:
2901 INT21_Ioctl_Char( context );
2902 break;
2903
2904 case 0x11:
2905 INT21_Ioctl_Block( context );
2906 break;
2907
2908 case 0x12: /* DR DOS - DETERMINE DOS TYPE (OBSOLETE FUNCTION) */
2909 TRACE( "DR DOS - DETERMINE DOS TYPE (OBSOLETE FUNCTION)\n" );
2910 SET_CFLAG(context); /* Error / This is not DR DOS. */
2911 SET_AX( context, 0x0001 ); /* Invalid function */
2912 break;
2913
2914 case 0x52: /* DR DOS - DETERMINE DOS TYPE */
2915 TRACE( "DR DOS - DETERMINE DOS TYPE\n" );
2916 SET_CFLAG(context); /* Error / This is not DR DOS. */
2917 SET_AX( context, 0x0001 ); /* Invalid function */
2918 break;
2919
2920 case 0xe0: /* Sun PC-NFS API */
2921 TRACE( "Sun PC-NFS API\n" );
2922 /* not installed */
2923 break;
2924
2925 default:
2926 INT_BARF( context, 0x21 );
2927 }
2928 }
2929
2930
2931 /***********************************************************************
2932 * INT21_Fat32
2933 *
2934 * Handler for function 0x73.
2935 */
2936 static BOOL INT21_Fat32( CONTEXT *context )
2937 {
2938 switch (AL_reg(context))
2939 {
2940 case 0x02: /* FAT32 - GET EXTENDED DPB */
2941 {
2942 BYTE drive = INT21_MapDrive( DL_reg(context) );
2943 WORD *ptr = CTX_SEG_OFF_TO_LIN(context,
2944 context->SegEs, context->Edi);
2945 INT21_DPB *target = (INT21_DPB*)(ptr + 1);
2946 INT21_DPB *source;
2947
2948 TRACE( "FAT32 - GET EXTENDED DPB %d\n", DL_reg(context) );
2949
2950 if ( CX_reg(context) < sizeof(INT21_DPB) + 2 || *ptr < sizeof(INT21_DPB) )
2951 {
2952 SetLastError( ERROR_BAD_LENGTH );
2953 return FALSE;
2954 }
2955
2956 if ( !INT21_FillDrivePB( drive ) )
2957 {
2958 SetLastError( ERROR_INVALID_DRIVE );
2959 return FALSE;
2960 }
2961
2962 source = &INT21_GetHeapPointer()->misc_dpb_list[drive];
2963
2964 *ptr = sizeof(INT21_DPB);
2965 *target = *source;
2966
2967 if (LOWORD(context->Esi) != 0xF1A6)
2968 {
2969 target->driver_header = 0;
2970 target->next = 0;
2971 }
2972 else
2973 {
2974 FIXME( "Caller requested driver and next DPB pointers!\n" );
2975 }
2976 }
2977 break;
2978
2979 case 0x03: /* FAT32 - GET EXTENDED FREE SPACE ON DRIVE */
2980 {
2981 WCHAR dirW[MAX_PATH];
2982 char *dirA = CTX_SEG_OFF_TO_LIN( context,
2983 context->SegDs, context->Edx );
2984 BYTE *data = CTX_SEG_OFF_TO_LIN( context,
2985 context->SegEs, context->Edi );
2986 DWORD cluster_sectors;
2987 DWORD sector_bytes;
2988 DWORD free_clusters;
2989 DWORD total_clusters;
2990
2991 TRACE( "FAT32 - GET EXTENDED FREE SPACE ON DRIVE %s\n", dirA );
2992 MultiByteToWideChar(CP_OEMCP, 0, dirA, -1, dirW, MAX_PATH);
2993
2994 if (CX_reg(context) < 44)
2995 {
2996 SetLastError( ERROR_BAD_LENGTH );
2997 return FALSE;
2998 }
2999
3000 if (!GetDiskFreeSpaceW( dirW, &cluster_sectors, &sector_bytes,
3001 &free_clusters, &total_clusters ))
3002 return FALSE;
3003
3004 *(WORD*) (data + 0) = 44; /* size of structure */
3005 *(WORD*) (data + 2) = 0; /* version */
3006 *(DWORD*)(data + 4) = cluster_sectors;
3007 *(DWORD*)(data + 8) = sector_bytes;
3008 *(DWORD*)(data + 12) = free_clusters;
3009 *(DWORD*)(data + 16) = total_clusters;
3010
3011 /*
3012 * Below we have free/total sectors and
3013 * free/total allocation units without adjustment
3014 * for compression. We fake both using cluster information.
3015 */
3016 *(DWORD*)(data + 20) = free_clusters * cluster_sectors;
3017 *(DWORD*)(data + 24) = total_clusters * cluster_sectors;
3018 *(DWORD*)(data + 28) = free_clusters;
3019 *(DWORD*)(data + 32) = total_clusters;
3020
3021 /*
3022 * Between (data + 36) and (data + 43) there
3023 * are eight reserved bytes.
3024 */
3025 }
3026 break;
3027
3028 default:
3029 INT_BARF( context, 0x21 );
3030 }
3031
3032 return TRUE;
3033 }
3034
3035 static void INT21_ConvertFindDataWtoA(WIN32_FIND_DATAA *dataA,
3036 const WIN32_FIND_DATAW *dataW)
3037 {
3038 dataA->dwFileAttributes = dataW->dwFileAttributes;
3039 dataA->ftCreationTime = dataW->ftCreationTime;
3040 dataA->ftLastAccessTime = dataW->ftLastAccessTime;
3041 dataA->ftLastWriteTime = dataW->ftLastWriteTime;
3042 dataA->nFileSizeHigh = dataW->nFileSizeHigh;
3043 dataA->nFileSizeLow = dataW->nFileSizeLow;
3044 WideCharToMultiByte( CP_OEMCP, 0, dataW->cFileName, -1,
3045 dataA->cFileName, sizeof(dataA->cFileName), NULL, NULL );
3046 WideCharToMultiByte( CP_OEMCP, 0, dataW->cAlternateFileName, -1,
3047 dataA->cAlternateFileName, sizeof(dataA->cAlternateFileName), NULL, NULL );
3048 }
3049
3050 /***********************************************************************
3051 * INT21_LongFilename
3052 *
3053 * Handler for function 0x71.
3054 */
3055 static void INT21_LongFilename( CONTEXT *context )
3056 {
3057 BOOL bSetDOSExtendedError = FALSE;
3058 WCHAR pathW[MAX_PATH];
3059 char* pathA;
3060
3061 switch (AL_reg(context))
3062 {
3063 case 0x0d: /* RESET DRIVE */
3064 INT_BARF( context, 0x21 );
3065 break;
3066
3067 case 0x39: /* LONG FILENAME - MAKE DIRECTORY */
3068 if (!INT21_CreateDirectory( context ))
3069 bSetDOSExtendedError = TRUE;
3070 break;
3071
3072 case 0x3a: /* LONG FILENAME - REMOVE DIRECTORY */
3073 pathA = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
3074
3075 TRACE( "LONG FILENAME - REMOVE DIRECTORY %s\n", pathA);
3076 MultiByteToWideChar(CP_OEMCP, 0, pathA, -1, pathW, MAX_PATH);
3077 if (!RemoveDirectoryW( pathW )) bSetDOSExtendedError = TRUE;
3078 break;
3079
3080 case 0x3b: /* LONG FILENAME - CHANGE DIRECTORY */
3081 if (!INT21_SetCurrentDirectory( context ))
3082 bSetDOSExtendedError = TRUE;
3083 break;
3084
3085 case 0x41: /* LONG FILENAME - DELETE FILE */
3086 pathA = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
3087
3088 TRACE( "LONG FILENAME - DELETE FILE %s\n", pathA );
3089 MultiByteToWideChar(CP_OEMCP, 0, pathA, -1, pathW, MAX_PATH);
3090
3091 if (!DeleteFileW( pathW )) bSetDOSExtendedError = TRUE;
3092 break;
3093
3094 case 0x43: /* LONG FILENAME - EXTENDED GET/SET FILE ATTRIBUTES */
3095 if (!INT21_FileAttributes( context, BL_reg(context), TRUE ))
3096 bSetDOSExtendedError = TRUE;
3097 break;
3098
3099 case 0x47: /* LONG FILENAME - GET CURRENT DIRECTORY */
3100 if (!INT21_GetCurrentDirectory( context, TRUE ))
3101 bSetDOSExtendedError = TRUE;
3102 break;
3103
3104 case 0x4e: /* LONG FILENAME - FIND FIRST MATCHING FILE */
3105 {
3106 HANDLE handle;
3107 HGLOBAL16 h16;
3108 WIN32_FIND_DATAW dataW;
3109 WIN32_FIND_DATAA* dataA;
3110
3111 pathA = CTX_SEG_OFF_TO_LIN(context, context->SegDs,context->Edx);
3112 TRACE(" LONG FILENAME - FIND FIRST MATCHING FILE for %s\n", pathA);
3113
3114 MultiByteToWideChar(CP_OEMCP, 0, pathA, -1, pathW, MAX_PATH);
3115 handle = FindFirstFileW(pathW, &dataW);
3116
3117 dataA = CTX_SEG_OFF_TO_LIN(context, context->SegEs, context->Edi);
3118 if (handle != INVALID_HANDLE_VALUE &&
3119 (h16 = GlobalAlloc16(GMEM_MOVEABLE, sizeof(handle))))
3120 {
3121 HANDLE* ptr = GlobalLock16( h16 );
3122 *ptr = handle;
3123 GlobalUnlock16( h16 );
3124 SET_AX( context, h16 );
3125 INT21_ConvertFindDataWtoA(dataA, &dataW);
3126 }
3127 else
3128 {
3129 if (handle != INVALID_HANDLE_VALUE) FindClose(handle);
3130 SET_AX( context, INVALID_HANDLE_VALUE16);
3131 bSetDOSExtendedError = TRUE;
3132 }
3133 }
3134 break;
3135
3136 case 0x4f: /* LONG FILENAME - FIND NEXT MATCHING FILE */
3137 {
3138 HGLOBAL16 h16 = BX_reg(context);
3139 HANDLE* ptr;
3140 WIN32_FIND_DATAW dataW;
3141 WIN32_FIND_DATAA* dataA;
3142
3143 TRACE("LONG FILENAME - FIND NEXT MATCHING FILE for handle %d\n",
3144 BX_reg(context));
3145
3146 dataA = CTX_SEG_OFF_TO_LIN(context, context->SegEs, context->Edi);
3147
3148 if (h16 != INVALID_HANDLE_VALUE16 && (ptr = GlobalLock16( h16 )))
3149 {
3150 if (!FindNextFileW(*ptr, &dataW)) bSetDOSExtendedError = TRUE;
3151 else INT21_ConvertFindDataWtoA(dataA, &dataW);
3152 GlobalUnlock16( h16 );
3153 }
3154 else
3155 {
3156 SetLastError( ERROR_INVALID_HANDLE );
3157 bSetDOSExtendedError = TRUE;
3158 }
3159 }
3160 break;
3161
3162 case 0x56: /* LONG FILENAME - RENAME FILE */
3163 if (!INT21_RenameFile(context))
3164 bSetDOSExtendedError = TRUE;
3165 break;
3166
3167 case 0x60: /* LONG FILENAME - CONVERT PATH */
3168 {
3169 WCHAR res[MAX_PATH];
3170
3171 switch (CL_reg(context))
3172 {
3173 case 0x00: /* "truename" - Canonicalize path */
3174 /*
3175 * FIXME: This is not 100% equal to 0x01 case,
3176 * if you fix this, fix int21 subfunction 0x60, too.
3177 */
3178
3179 case 0x01: /* Get short filename or path */
3180 MultiByteToWideChar(CP_OEMCP, 0, CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Esi), -1, pathW, MAX_PATH);
3181 if (!GetShortPathNameW(pathW, res, 67))
3182 bSetDOSExtendedError = TRUE;
3183 else
3184 {
3185 SET_AX( context, 0 );
3186 WideCharToMultiByte(CP_OEMCP, 0, res, -1,
3187 CTX_SEG_OFF_TO_LIN(context, context->SegEs, context->Edi),
3188 67, NULL, NULL);
3189 }
3190 break;
3191
3192 case 0x02: /* Get canonical long filename or path */
3193 MultiByteToWideChar(CP_OEMCP, 0, CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Esi), -1, pathW, MAX_PATH);
3194 if (!GetFullPathNameW(pathW, 128, res, NULL))
3195 bSetDOSExtendedError = TRUE;
3196 else
3197 {
3198 SET_AX( context, 0 );
3199 WideCharToMultiByte(CP_OEMCP, 0, res, -1,
3200 CTX_SEG_OFF_TO_LIN(context, context->SegEs, context->Edi),
3201 128, NULL, NULL);
3202 }
3203 break;
3204 default:
3205 FIXME("Unimplemented long file name function:\n");
3206 INT_BARF( context, 0x21 );
3207 SET_CFLAG(context);
3208 SET_AL( context, 0 );
3209 break;
3210 }
3211 }
3212 break;
3213
3214 case 0x6c: /* LONG FILENAME - CREATE OR OPEN FILE */
3215 if (!INT21_CreateFile( context, context->Esi, TRUE,
3216 BX_reg(context), DL_reg(context) ))
3217 bSetDOSExtendedError = TRUE;
3218 break;
3219
3220 case 0xa0: /* LONG FILENAME - GET VOLUME INFORMATION */
3221 {
3222 DWORD filename_len, flags;
3223 WCHAR dstW[8];
3224
3225 pathA = CTX_SEG_OFF_TO_LIN(context, context->SegDs,context->Edx);
3226
3227 TRACE("LONG FILENAME - GET VOLUME INFORMATION for drive having root dir '%s'.\n", pathA);
3228 SET_AX( context, 0 );
3229 MultiByteToWideChar(CP_OEMCP, 0, pathA, -1, pathW, MAX_PATH);
3230 if (!GetVolumeInformationW( pathW, NULL, 0, NULL, &filename_len,
3231 &flags, dstW, 8 ))
3232 {
3233 INT_BARF( context, 0x21 );
3234 SET_CFLAG(context);
3235 break;
3236 }
3237 SET_BX( context, flags | 0x4000 ); /* support for LFN functions */
3238 SET_CX( context, filename_len );
3239 SET_DX( context, MAX_PATH ); /* FIXME: which len if DRIVE_SHORT_NAMES ? */
3240 WideCharToMultiByte(CP_OEMCP, 0, dstW, -1,
3241 CTX_SEG_OFF_TO_LIN(context, context->SegEs, context->Edi),
3242 8, NULL, NULL);
3243 }
3244 break;
3245
3246 case 0xa1: /* LONG FILENAME - "FindClose" - TERMINATE DIRECTORY SEARCH */
3247 {
3248 HGLOBAL16 h16 = BX_reg(context);
3249 HANDLE* ptr;
3250
3251 TRACE("LONG FILENAME - FINDCLOSE for handle %d\n",
3252 BX_reg(context));
3253 if (h16 != INVALID_HANDLE_VALUE16 && (ptr = GlobalLock16( h16 )))
3254 {
3255 if (!FindClose( *ptr )) bSetDOSExtendedError = TRUE;
3256 GlobalUnlock16( h16 );
3257 GlobalFree16( h16 );
3258 }
3259 else
3260 {
3261 SetLastError( ERROR_INVALID_HANDLE );
3262 bSetDOSExtendedError = TRUE;
3263 }
3264 }
3265 break;
3266
3267 case 0xa6: /* LONG FILENAME - GET FILE INFO BY HANDLE */
3268 {
3269 HANDLE handle = DosFileHandleToWin32Handle(BX_reg(context));
3270 BY_HANDLE_FILE_INFORMATION *info =
3271 CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
3272
3273 TRACE( "LONG FILENAME - GET FILE INFO BY HANDLE\n" );
3274
3275 if (!GetFileInformationByHandle(handle, info))
3276 bSetDOSExtendedError = TRUE;
3277 }
3278 break;
3279
3280 case 0xa7: /* LONG FILENAME - CONVERT TIME */
3281 switch (BL_reg(context))
3282 {
3283 case 0x00: /* FILE TIME TO DOS TIME */
3284 {
3285 WORD date, time;
3286 FILETIME *filetime = CTX_SEG_OFF_TO_LIN(context,
3287 context->SegDs,
3288 context->Esi);
3289
3290 TRACE( "LONG FILENAME - FILE TIME TO DOS TIME\n" );
3291
3292 FileTimeToDosDateTime( filetime, &date, &time );
3293
3294 SET_DX( context, date );
3295 SET_CX( context, time );
3296
3297 /*
3298 * FIXME: BH has number of 10-millisecond units
3299 * past time in CX.
3300 */
3301 SET_BH( context, 0 );
3302 }
3303 break;
3304
3305 case 0x01: /* DOS TIME TO FILE TIME */
3306 {
3307 FILETIME *filetime = CTX_SEG_OFF_TO_LIN(context,
3308 context->SegEs,
3309 context->Edi);
3310
3311 TRACE( "LONG FILENAME - DOS TIME TO FILE TIME\n" );
3312
3313 /*
3314 * FIXME: BH has number of 10-millisecond units
3315 * past time in CX.
3316 */
3317 DosDateTimeToFileTime( DX_reg(context), CX_reg(context),
3318 filetime );
3319 }
3320 break;
3321
3322 default:
3323 INT_BARF( context, 0x21 );
3324 break;
3325 }
3326 break;
3327
3328 case 0xa8: /* LONG FILENAME - GENERATE SHORT FILENAME */
3329 case 0xa9: /* LONG FILENAME - SERVER CREATE OR OPEN FILE */
3330 case 0xaa: /* LONG FILENAME - SUBST */
3331 default:
3332 FIXME("Unimplemented long file name function:\n");
3333 INT_BARF( context, 0x21 );
3334 SET_CFLAG(context);
3335 SET_AL( context, 0 );
3336 break;
3337 }
3338
3339 if (bSetDOSExtendedError)
3340 {
3341 SET_AX( context, GetLastError() );
3342 SET_CFLAG( context );
3343 }
3344 }
3345
3346
3347 /***********************************************************************
3348 * INT21_RenameFile
3349 *
3350 * Handler for:
3351 * - function 0x56
3352 * - subfunction 0x56 of function 0x71
3353 * - subfunction 0xff of function 0x43 (CL == 0x56)
3354 */
3355 static BOOL INT21_RenameFile( CONTEXT *context )
3356 {
3357 WCHAR fromW[MAX_PATH];
3358 WCHAR toW[MAX_PATH];
3359 char *fromA = CTX_SEG_OFF_TO_LIN(context,
3360 context->SegDs,context->Edx);
3361 char *toA = CTX_SEG_OFF_TO_LIN(context,
3362 context->SegEs,context->Edi);
3363
3364 TRACE( "RENAME FILE %s to %s\n", fromA, toA );
3365 MultiByteToWideChar(CP_OEMCP, 0, fromA, -1, fromW, MAX_PATH);
3366 MultiByteToWideChar(CP_OEMCP, 0, toA, -1, toW, MAX_PATH);
3367
3368 return MoveFileW( fromW, toW );
3369 }
3370
3371
3372 /***********************************************************************
3373 * INT21_NetworkFunc
3374 *
3375 * Handler for:
3376 * - function 0x5e
3377 */
3378 static BOOL INT21_NetworkFunc (CONTEXT *context)
3379 {
3380 switch (AL_reg(context))
3381 {
3382 case 0x00: /* Get machine name. */
3383 {
3384 WCHAR dstW[MAX_COMPUTERNAME_LENGTH + 1];
3385 DWORD s = sizeof(dstW) / sizeof(WCHAR);
3386 int len;
3387
3388 char *dst = CTX_SEG_OFF_TO_LIN (context,context->SegDs,context->Edx);
3389 TRACE("getting machine name to %p\n", dst);
3390 if (!GetComputerNameW(dstW, &s) ||
3391 !WideCharToMultiByte(CP_OEMCP, 0, dstW, -1, dst, 16, NULL, NULL))
3392 {
3393 WARN("failed!\n");
3394 SetLastError( ER_NoNetwork );
3395 return TRUE;
3396 }
3397 for (len = strlen(dst); len < 15; len++) dst[len] = ' ';
3398 dst[15] = 0;
3399 SET_CH( context, 1 ); /* Valid */
3400 SET_CL( context, 1 ); /* NETbios number??? */
3401 TRACE("returning %s\n", debugstr_an(dst, 16));
3402 return FALSE;
3403 }
3404
3405 default:
3406 SetLastError( ER_NoNetwork );
3407 return TRUE;
3408 }
3409 }
3410
3411 /******************************************************************
3412 * INT21_GetDiskSerialNumber
3413 *
3414 */
3415 static int INT21_GetDiskSerialNumber( CONTEXT *context )
3416 {
3417 BYTE *dataptr = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
3418 WCHAR path[] = {'A',':','\\',0}, label[11];
3419 DWORD serial;
3420
3421 path[0] += INT21_MapDrive(BL_reg(context));
3422 if (!GetVolumeInformationW( path, label, 11, &serial, NULL, NULL, NULL, 0))
3423 {
3424 SetLastError( ERROR_INVALID_DRIVE );
3425 return 0;
3426 }
3427
3428 *(WORD *)dataptr = 0;
3429 memcpy(dataptr + 2, &serial, sizeof(DWORD));
3430 WideCharToMultiByte(CP_OEMCP, 0, label, 11, (LPSTR)dataptr + 6, 11, NULL, NULL);
3431 memcpy(dataptr + 17, "FAT16 ", 8);
3432 return 1;
3433 }
3434
3435
3436 /******************************************************************
3437 * INT21_SetDiskSerialNumber
3438 *
3439 */
3440 static int INT21_SetDiskSerialNumber( CONTEXT *context )
3441 {
3442 #if 0
3443 BYTE *dataptr = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
3444 int drive = INT21_MapDrive(BL_reg(context));
3445
3446 if (!is_valid_drive(drive))
3447 {
3448 SetLastError( ERROR_INVALID_DRIVE );
3449 return 0;
3450 }
3451
3452 DRIVE_SetSerialNumber( drive, *(DWORD *)(dataptr + 2) );
3453 return 1;
3454 #else
3455 FIXME("Setting drive serial number is no longer supported\n");
3456 SetLastError( ERROR_NOT_SUPPORTED );
3457 return 0;
3458 #endif
3459 }
3460
3461
3462 /******************************************************************
3463 * INT21_GetFreeDiskSpace
3464 *
3465 */
3466 static int INT21_GetFreeDiskSpace( CONTEXT *context )
3467 {
3468 DWORD cluster_sectors, sector_bytes, free_clusters, total_clusters;
3469 WCHAR root[] = {'A',':','\\',0};
3470 const DWORD max_clusters = 0x3d83;
3471 const DWORD max_sectors_per_cluster = 0x7f;
3472 const DWORD max_bytes_per_sector = 0x200;
3473
3474 root[0] += INT21_MapDrive(DL_reg(context));
3475 if (!GetDiskFreeSpaceW( root, &cluster_sectors, &sector_bytes,
3476 &free_clusters, &total_clusters )) return 0;
3477
3478 /* Some old win31 apps (Lotus SmartSuite 5.1) crap out if there's too
3479 * much disk space, so Windows XP seems to apply the following limits:
3480 * cluster_sectors <= 0x7f
3481 * sector size <= 0x200
3482 * clusters <= 0x3D83
3483 * This means total reported space is limited to about 1GB.
3484 */
3485
3486 /* Make sure bytes-per-sector is in [, max] */
3487 while (sector_bytes > max_bytes_per_sector) {
3488 sector_bytes >>= 1;
3489 free_clusters <<= 1;
3490 total_clusters <<= 1;
3491 }
3492 /* Then make sure sectors-per-cluster is in [max/2, max]. */
3493 while (cluster_sectors <= max_sectors_per_cluster/2) {
3494 cluster_sectors <<= 1;
3495 free_clusters >>= 1;
3496 total_clusters >>= 1;
3497 }
3498 while (cluster_sectors > max_sectors_per_cluster) {
3499 cluster_sectors >>= 1;
3500 free_clusters <<= 1;
3501 total_clusters <<= 1;
3502 }
3503
3504 /* scale up sectors_per_cluster to exactly max_sectors_per_cluster.
3505 * We could skip this, but that would impose an artificially low
3506 * limit on reported disk space.
3507 * To avoid overflow, first apply a preliminary cap on sector count;
3508 * this will not affect the correctness of the final result,
3509 * because if the preliminary cap hits, the final one will, too.
3510 */
3511 if (total_clusters > 4 * max_clusters)
3512 total_clusters = 4 * max_clusters;
3513 if (free_clusters > 4 * max_clusters)
3514 free_clusters = 4 * max_clusters;
3515 if (cluster_sectors < max_sectors_per_cluster) {
3516 free_clusters *= cluster_sectors;
3517 free_clusters /= max_sectors_per_cluster;
3518 total_clusters *= cluster_sectors;
3519 total_clusters /= max_sectors_per_cluster;
3520 cluster_sectors = max_sectors_per_cluster;
3521 }
3522
3523 /* Finally, apply real cluster count cap. */
3524 if (total_clusters > max_clusters)
3525 total_clusters = max_clusters;
3526 if (free_clusters > max_clusters)
3527 free_clusters = max_clusters;
3528
3529 SET_AX( context, cluster_sectors );
3530 SET_BX( context, free_clusters );
3531 SET_CX( context, sector_bytes );
3532 SET_DX( context, total_clusters );
3533 return 1;
3534 }
3535
3536 /******************************************************************
3537 * INT21_GetDriveAllocInfo
3538 *
3539 */
3540 static int INT21_GetDriveAllocInfo( CONTEXT *context, BYTE drive )
3541 {
3542 INT21_DPB *dpb;
3543
3544 drive = INT21_MapDrive( drive );
3545 if (!INT21_FillDrivePB( drive )) return 0;
3546 dpb = &(INT21_GetHeapPointer()->misc_dpb_list[drive]);
3547 SET_AL( context, dpb->cluster_sectors + 1 );
3548 SET_CX( context, dpb->sector_bytes );
3549 SET_DX( context, dpb->num_clusters1 );
3550
3551 context->SegDs = INT21_GetHeapSelector( context );
3552 SET_BX( context, offsetof( INT21_HEAP, misc_dpb_list[drive].media_ID ) );
3553 return 1;
3554 }
3555
3556 /***********************************************************************
3557 * INT21_GetExtendedError
3558 */
3559 static void INT21_GetExtendedError( CONTEXT *context )
3560 {
3561 BYTE class, action, locus;
3562 WORD error = GetLastError();
3563
3564 switch(error)
3565 {
3566 case ERROR_SUCCESS:
3567 class = action = locus = 0;
3568 break;
3569 case ERROR_DIR_NOT_EMPTY:
3570 class = EC_Exists;
3571 action = SA_Ignore;
3572 locus = EL_Disk;
3573 break;
3574 case ERROR_ACCESS_DENIED:
3575 class = EC_AccessDenied;
3576 action = SA_Abort;
3577 locus = EL_Disk;
3578 break;
3579 case ERROR_CANNOT_MAKE:
3580 class = EC_AccessDenied;
3581 action = SA_Abort;
3582 locus = EL_Unknown;
3583 break;
3584 case ERROR_DISK_FULL:
3585 case ERROR_HANDLE_DISK_FULL:
3586 class = EC_MediaError;
3587 action = SA_Abort;
3588 locus = EL_Disk;
3589 break;
3590 case ERROR_FILE_EXISTS:
3591 case ERROR_ALREADY_EXISTS:
3592 class = EC_Exists;
3593 action = SA_Abort;
3594 locus = EL_Disk;
3595 break;
3596 case ERROR_FILE_NOT_FOUND:
3597 case ERROR_PATH_NOT_FOUND:
3598 case ERROR_INVALID_NAME:
3599 class = EC_NotFound;
3600 action = SA_Abort;
3601 locus = EL_Disk;
3602 break;
3603 case ERROR_GEN_FAILURE:
3604 class = EC_SystemFailure;
3605 action = SA_Abort;
3606 locus = EL_Unknown;
3607 break;
3608 case ERROR_INVALID_DRIVE:
3609 class = EC_MediaError;
3610 action = SA_Abort;
3611 locus = EL_Disk;
3612 break;
3613 case ERROR_INVALID_HANDLE:
3614 class = EC_ProgramError;
3615 action = SA_Abort;
3616 locus = EL_Disk;
3617 break;
3618 case ERROR_LOCK_VIOLATION:
3619 class = EC_AccessDenied;
3620 action = SA_Abort;
3621 locus = EL_Disk;
3622 break;
3623 case ERROR_NO_MORE_FILES:
3624 class = EC_MediaError;
3625 action = SA_Abort;
3626 locus = EL_Disk;
3627 break;
3628 case ER_NoNetwork:
3629 class = EC_NotFound;
3630 action = SA_Abort;
3631 locus = EL_Network;
3632 break;
3633 case ERROR_NOT_ENOUGH_MEMORY:
3634 class = EC_OutOfResource;
3635 action = SA_Abort;
3636 locus = EL_Memory;
3637 break;
3638 case ERROR_SEEK:
3639 class = EC_NotFound;
3640 action = SA_Ignore;
3641 locus = EL_Disk;
3642 break;
3643 case ERROR_SHARING_VIOLATION:
3644 class = EC_Temporary;
3645 action = SA_Retry;
3646 locus = EL_Disk;
3647 break;
3648 case ERROR_TOO_MANY_OPEN_FILES:
3649 class = EC_ProgramError;
3650 action = SA_Abort;
3651 locus = EL_Disk;
3652 break;
3653 default:
3654 FIXME("Unknown error %d\n", error );
3655 class = EC_SystemFailure;
3656 action = SA_Abort;
3657 locus = EL_Unknown;
3658 break;
3659 }
3660 TRACE("GET EXTENDED ERROR code 0x%02x class 0x%02x action 0x%02x locus %02x\n",
3661 error, class, action, locus );
3662 SET_AX( context, error );
3663 SET_BH( context, class );
3664 SET_BL( context, action );
3665 SET_CH( context, locus );
3666 }
3667
3668 static BOOL INT21_CreateTempFile( CONTEXT *context )
3669 {
3670 static int counter = 0;
3671 char *name = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx );
3672 char *p = name + strlen(name);
3673
3674 /* despite what Ralf Brown says, some programs seem to call without
3675 * ending backslash (DOS accepts that, so we accept it too) */
3676 if ((p == name) || (p[-1] != '\\')) *p++ = '\\';
3677
3678 for (;;)
3679 {
3680 sprintf( p, "wine%04x.%03d", (int)getpid(), counter );
3681 counter = (counter + 1) % 1000;
3682
3683 SET_AX( context,
3684 Win32HandleToDosFileHandle(
3685 CreateFileA( name, GENERIC_READ | GENERIC_WRITE,
3686 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
3687 CREATE_NEW, 0, 0 ) ) );
3688 if (AX_reg(context) != HFILE_ERROR16)
3689 {
3690 TRACE("created %s\n", name );
3691 return TRUE;
3692 }
3693 if (GetLastError() != ERROR_FILE_EXISTS) return FALSE;
3694 }
3695 }
3696
3697 /***********************************************************************
3698 * DOSFS_ToDosFCBFormat
3699 *
3700 * Convert a file name to DOS FCB format (8+3 chars, padded with blanks),
3701 * expanding wild cards and converting to upper-case in the process.
3702 * File name can be terminated by '\0', '\\' or '/'.
3703 * Return FALSE if the name is not a valid DOS name.
3704 * 'buffer' must be at least 12 characters long.
3705 */
3706 /* Chars we don't want to see in DOS file names */
3707 static BOOL INT21_ToDosFCBFormat( LPCWSTR name, LPWSTR buffer )
3708 {
3709 static const WCHAR invalid_chars[] = {'*','?','<','>','|','\\','"','+','=',',',';','[',']',' ','\345',0};
3710 LPCWSTR p = name;
3711 int i;
3712
3713 /* Check for "." and ".." */
3714 if (*p == '.')
3715 {
3716 p++;
3717 buffer[0] = '.';
3718 for(i = 1; i < 11; i++) buffer[i] = ' ';
3719 buffer[11] = 0;
3720 if (*p == '.')
3721 {
3722 buffer[1] = '.';
3723 p++;
3724 }
3725 return (!*p || (*p == '/') || (*p == '\\'));
3726 }
3727
3728 for (i = 0; i < 8; i++)
3729 {
3730 switch(*p)
3731 {
3732 case '\0':
3733 case '\\':
3734 case '/':
3735 case '.':
3736 buffer[i] = ' ';
3737 break;
3738 case '?':
3739 p++;
3740 /* fall through */
3741 case '*':
3742 buffer[i] = '?';
3743 break;
3744 default:
3745 if (strchrW( invalid_chars, *p )) return FALSE;
3746 buffer[i] = toupperW(*p);
3747 p++;
3748 break;
3749 }
3750 }
3751
3752 if (*p == '*')
3753 {
3754 /* Skip all chars after wildcard up to first dot */
3755 while (*p && (*p != '/') && (*p != '\\') && (*p != '.')) p++;
3756 }
3757 else
3758 {
3759 /* Check if name too long */
3760 if (*p && (*p != '/') && (*p != '\\') && (*p != '.')) return FALSE;
3761 }
3762 if (*p == '.') p++; /* Skip dot */
3763
3764 for (i = 8; i < 11; i++)
3765 {
3766 switch(*p)
3767 {
3768 case '\0':
3769 case '\\':
3770 case '/':
3771 buffer[i] = ' ';
3772 break;
3773 case '.':
3774 return FALSE; /* Second extension not allowed */
3775 case '?':
3776 p++;
3777 /* fall through */
3778 case '*':
3779 buffer[i] = '?';
3780 break;
3781 default:
3782 if (strchrW( invalid_chars, *p )) return FALSE;
3783 buffer[i] = toupperW(*p);
3784 p++;
3785 break;
3786 }
3787 }
3788 buffer[11] = '\0';
3789
3790 /* at most 3 character of the extension are processed
3791 * is something behind this ?
3792 */
3793 while (*p == '*' || *p == ' ') p++; /* skip wildcards and spaces */
3794 return (!*p || (*p == '/') || (*p == '\\'));
3795 }
3796
3797 static HANDLE INT21_FindHandle;
3798 static const WCHAR *INT21_FindPath; /* will point to current dta->fullPath search */
3799
3800 /******************************************************************
3801 * INT21_FindFirst
3802 */
3803 static int INT21_FindFirst( CONTEXT *context )
3804 {
3805 WCHAR *p, *q;
3806 const char *path;
3807 FINDFILE_DTA *dta = (FINDFILE_DTA *)INT21_GetCurrentDTA(context);
3808 WCHAR maskW[12], pathW[MAX_PATH];
3809 static const WCHAR wildcardW[] = {'*','.','*',0};
3810
3811 path = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
3812 MultiByteToWideChar(CP_OEMCP, 0, path, -1, pathW, MAX_PATH);
3813
3814 p = strrchrW( pathW, '\\');
3815 q = strrchrW( pathW, '/');
3816 if (q>p) p = q;
3817 if (!p)
3818 {
3819 if (pathW[0] && pathW[1] == ':') p = pathW + 2;
3820 else p = pathW;
3821 }
3822 else p++;
3823
3824 /* Note: terminating NULL in dta->mask overwrites dta->search_attr
3825 * (doesn't matter as it is set below anyway)
3826 */
3827 if (!INT21_ToDosFCBFormat( p, maskW ))
3828 {
3829 SetLastError( ERROR_FILE_NOT_FOUND );
3830 SET_AX( context, ERROR_FILE_NOT_FOUND );
3831 SET_CFLAG(context);
3832 return 0;
3833 }
3834 WideCharToMultiByte(CP_OEMCP, 0, maskW, 12, dta->mask, sizeof(dta->mask), NULL, NULL);
3835
3836 dta->fullPath = HeapAlloc( GetProcessHeap(), 0, sizeof(wildcardW) + (p - pathW)*sizeof(WCHAR) );
3837 memcpy( dta->fullPath, pathW, (p - pathW) * sizeof(WCHAR) );
3838 memcpy( dta->fullPath + (p - pathW), wildcardW, sizeof(wildcardW) );
3839 /* we must have a fully qualified file name in dta->fullPath
3840 * (we could have a UNC path, but this would lead to some errors later on)
3841 */
3842 dta->drive = toupperW(dta->fullPath[0]) - 'A';
3843 dta->count = 0;
3844 dta->search_attr = CL_reg(context);
3845 return 1;
3846 }
3847
3848 /******************************************************************
3849 * match_short
3850 *
3851 * Check is a short path name (DTA unicode) matches a mask (FCB ansi)
3852 */
3853 static BOOL match_short(LPCWSTR shortW, LPCSTR maskA)
3854 {
3855 WCHAR mask[11], file[12];
3856 int i;
3857
3858 if (!INT21_ToDosFCBFormat( shortW, file )) return FALSE;
3859 MultiByteToWideChar(CP_OEMCP, 0, maskA, 11, mask, 11);
3860 for (i = 0; i < 11; i++)
3861 if (mask[i] != '?' && mask[i] != file[i]) return FALSE;
3862 return TRUE;
3863 }
3864
3865 static unsigned INT21_FindHelper(LPCWSTR fullPath, unsigned drive, unsigned count,
3866 LPCSTR mask, unsigned search_attr,
3867 WIN32_FIND_DATAW* entry)
3868 {
3869 unsigned ncalls;
3870
3871 if ((search_attr & ~(FA_UNUSED | FA_ARCHIVE | FA_RDONLY)) == FA_LABEL)
3872 {
3873 WCHAR path[] = {' ',':','\\',0};
3874
3875 if (count) return 0;
3876 path[0] = drive + 'A';
3877 if (!GetVolumeInformationW(path, entry->cAlternateFileName, 13, NULL, NULL, NULL, NULL, 0)) return 0;
3878 RtlSecondsSince1970ToTime( 0, (LARGE_INTEGER *)&entry->ftCreationTime );
3879 RtlSecondsSince1970ToTime( 0, (LARGE_INTEGER *)&entry->ftLastAccessTime );
3880 RtlSecondsSince1970ToTime( 0, (LARGE_INTEGER *)&entry->ftLastWriteTime );
3881 entry->dwFileAttributes = FA_LABEL;
3882 entry->nFileSizeHigh = entry->nFileSizeLow = 0;
3883 TRACE("returning %s as label\n", debugstr_w(entry->cAlternateFileName));
3884 return 1;
3885 }
3886
3887 if (!INT21_FindHandle || INT21_FindPath != fullPath || count == 0)
3888 {
3889 if (INT21_FindHandle) FindClose(INT21_FindHandle);
3890 INT21_FindHandle = FindFirstFileW(fullPath, entry);
3891 if (INT21_FindHandle == INVALID_HANDLE_VALUE)
3892 {
3893 INT21_FindHandle = 0;
3894 return 0;
3895 }
3896 INT21_FindPath = fullPath;
3897 /* we need to resync search */
3898 ncalls = count;
3899 }
3900 else ncalls = 1;
3901
3902 while (ncalls-- != 0)
3903 {
3904 if (!FindNextFileW(INT21_FindHandle, entry))
3905 {
3906 FindClose(INT21_FindHandle); INT21_FindHandle = 0;
3907 return 0;
3908 }
3909 }
3910 while (count < 0xffff)
3911 {
3912 count++;
3913 /* Check the file attributes, and path */
3914 if (!(entry->dwFileAttributes & ~search_attr) &&
3915 match_short(entry->cAlternateFileName[0] ? entry->cAlternateFileName : entry->cFileName,
3916 mask))
3917 {
3918 return count;
3919 }
3920 if (!FindNextFileW(INT21_FindHandle, entry))
3921 {
3922 FindClose(INT21_FindHandle); INT21_FindHandle = 0;
3923 return 0;
3924 }
3925 }
3926 WARN("Too many directory entries in %s\n", debugstr_w(fullPath) );
3927 return 0;
3928 }
3929
3930 /******************************************************************
3931 * INT21_FindNext
3932 */
3933 static int INT21_FindNext( CONTEXT *context )
3934 {
3935 FINDFILE_DTA *dta = (FINDFILE_DTA *)INT21_GetCurrentDTA(context);
3936 DWORD attr = dta->search_attr | FA_UNUSED | FA_ARCHIVE | FA_RDONLY;
3937 WIN32_FIND_DATAW entry;
3938 int n;
3939
3940 if (!dta->fullPath) return 0;
3941
3942 n = INT21_FindHelper(dta->fullPath, dta->drive, dta->count,
3943 dta->mask, attr, &entry);
3944 if (n)
3945 {
3946 dta->fileattr = entry.dwFileAttributes;
3947 dta->filesize = entry.nFileSizeLow;
3948 FileTimeToDosDateTime( &entry.ftLastWriteTime, &dta->filedate, &dta->filetime );
3949 if (entry.cAlternateFileName[0])
3950 WideCharToMultiByte(CP_OEMCP, 0, entry.cAlternateFileName, -1,
3951 dta->filename, 13, NULL, NULL);
3952 else
3953 WideCharToMultiByte(CP_OEMCP, 0, entry.cFileName, -1, dta->filename, 13, NULL, NULL);
3954
3955 if (!memchr(dta->mask,'?',11))
3956 {
3957 /* wildcardless search, release resources in case no findnext will
3958 * be issued, and as a workaround in case file creation messes up
3959 * findnext, as sometimes happens with pkunzip
3960 */
3961 HeapFree( GetProcessHeap(), 0, dta->fullPath );
3962 INT21_FindPath = dta->fullPath = NULL;
3963 }
3964 dta->count = n;
3965 return 1;
3966 }
3967 HeapFree( GetProcessHeap(), 0, dta->fullPath );
3968 INT21_FindPath = dta->fullPath = NULL;
3969 return 0;
3970 }
3971
3972 /* microsoft's programmers should be shot for using CP/M style int21
3973 calls in Windows for Workgroup's winfile.exe */
3974
3975 /******************************************************************
3976 * INT21_FindFirstFCB
3977 *
3978 */
3979 static int INT21_FindFirstFCB( CONTEXT *context )
3980 {
3981 BYTE *fcb = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
3982 FINDFILE_FCB *pFCB;
3983 int drive;
3984 WCHAR p[] = {' ',':',};
3985
3986 if (*fcb == 0xff) pFCB = (FINDFILE_FCB *)(fcb + 7);
3987 else pFCB = (FINDFILE_FCB *)fcb;
3988 drive = INT21_MapDrive( pFCB->drive );
3989 if (drive == MAX_DOS_DRIVES) return 0;
3990
3991 p[0] = 'A' + drive;
3992 pFCB->fullPath = HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR));
3993 if (!pFCB->fullPath) return 0;
3994 GetLongPathNameW(p, pFCB->fullPath, MAX_PATH);
3995 pFCB->count = 0;
3996 return 1;
3997 }
3998
3999 /******************************************************************
4000 * INT21_FindNextFCB
4001 *
4002 */
4003 static int INT21_FindNextFCB( CONTEXT *context )
4004 {
4005 BYTE *fcb = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
4006 FINDFILE_FCB *pFCB;
4007 LPBYTE pResult = INT21_GetCurrentDTA(context);
4008 DOS_DIRENTRY_LAYOUT *ddl;
4009 WIN32_FIND_DATAW entry;
4010 BYTE attr;
4011 int n;
4012 WCHAR nameW[12];
4013
4014 if (*fcb == 0xff) /* extended FCB ? */
4015 {
4016 attr = fcb[6];
4017 pFCB = (FINDFILE_FCB *)(fcb + 7);
4018 }
4019 else
4020 {
4021 attr = 0;
4022 pFCB = (FINDFILE_FCB *)fcb;
4023 }
4024
4025 if (!pFCB->fullPath) return 0;
4026 n = INT21_FindHelper(pFCB->fullPath, INT21_MapDrive( pFCB->drive ),
4027 pFCB->count, pFCB->filename, attr, &entry);
4028 if (!n)
4029 {
4030 HeapFree( GetProcessHeap(), 0, pFCB->fullPath );
4031 INT21_FindPath = pFCB->fullPath = NULL;
4032 return 0;
4033 }
4034 pFCB->count += n;
4035
4036 if (*fcb == 0xff)
4037 {
4038 /* place extended FCB header before pResult if called with extended FCB */
4039 *pResult = 0xff;
4040 pResult += 6; /* leave reserved field behind */
4041 *pResult++ = entry.dwFileAttributes;
4042 }
4043 *pResult++ = INT21_MapDrive( pFCB->drive ); /* DOS_DIRENTRY_LAYOUT after current drive number */
4044 ddl = (DOS_DIRENTRY_LAYOUT*)pResult;
4045 ddl->fileattr = entry.dwFileAttributes;
4046 ddl->cluster = 0; /* what else? */
4047 ddl->filesize = entry.nFileSizeLow;
4048 memset( ddl->reserved, 0, sizeof(ddl->reserved) );
4049 FileTimeToDosDateTime( &entry.ftLastWriteTime,
4050 &ddl->filedate, &ddl->filetime );
4051
4052 /* Convert file name to FCB format */
4053 if (entry.cAlternateFileName[0])
4054 INT21_ToDosFCBFormat( entry.cAlternateFileName, nameW );
4055 else
4056 INT21_ToDosFCBFormat( entry.cFileName, nameW );
4057 WideCharToMultiByte(CP_OEMCP, 0, nameW, 11, ddl->filename, 11, NULL, NULL);
4058 return 1;
4059 }
4060
4061
4062 /******************************************************************
4063 * INT21_ParseFileNameIntoFCB
4064 *
4065 */
4066 static void INT21_ParseFileNameIntoFCB( CONTEXT *context )
4067 {
4068 char *filename =
4069 CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Esi );
4070 char *fcb =
4071 CTX_SEG_OFF_TO_LIN(context, context->SegEs, context->Edi );
4072 char *s;
4073 WCHAR *buffer;
4074 WCHAR fcbW[12];
4075 INT buffer_len, len;
4076
4077 SET_AL( context, 0xff ); /* failed */
4078
4079 TRACE("filename: '%s'\n", filename);
4080
4081 s = filename;
4082 while (*s && (*s != ' ') && (*s != '\r') && (*s != '\n'))
4083 s++;
4084 len = filename - s;
4085
4086 buffer_len = MultiByteToWideChar(CP_OEMCP, 0, filename, len, NULL, 0);
4087 buffer = HeapAlloc( GetProcessHeap(), 0, (buffer_len + 1) * sizeof(WCHAR));
4088 len = MultiByteToWideChar(CP_OEMCP, 0, filename, len, buffer, buffer_len);
4089 buffer[len] = 0;
4090 INT21_ToDosFCBFormat(buffer, fcbW);
4091 HeapFree(GetProcessHeap(), 0, buffer);
4092 WideCharToMultiByte(CP_OEMCP, 0, fcbW, 12, fcb + 1, 12, NULL, NULL);
4093 *fcb = 0;
4094 TRACE("FCB: '%s'\n", fcb + 1);
4095
4096 SET_AL( context, ((strchr(filename, '*')) || (strchr(filename, '$'))) != 0 );
4097
4098 /* point DS:SI to first unparsed character */
4099 SET_SI( context, context->Esi + (int)s - (int)filename );
4100 }
4101
4102 static BOOL INT21_Dup2(HFILE16 hFile1, HFILE16 hFile2)
4103 {
4104 HFILE16 res = HFILE_ERROR16;
4105 HANDLE handle, new_handle;
4106 #define DOS_TABLE_SIZE 256
4107 DWORD map[DOS_TABLE_SIZE / 32];
4108 int i;
4109
4110 handle = DosFileHandleToWin32Handle(hFile1);
4111 if (handle == INVALID_HANDLE_VALUE)
4112 return FALSE;
4113
4114 _lclose16(hFile2);
4115 /* now loop to allocate the same one... */
4116 memset(map, 0, sizeof(map));
4117 for (i = 0; i < DOS_TABLE_SIZE; i++)
4118 {
4119 if (!DuplicateHandle(GetCurrentProcess(), handle,
4120 GetCurrentProcess(), &new_handle,
4121 0, FALSE, DUPLICATE_SAME_ACCESS))
4122 {
4123 res = HFILE_ERROR16;
4124 break;
4125 }
4126 res = Win32HandleToDosFileHandle(new_handle);
4127 if (res == HFILE_ERROR16 || res == hFile2) break;
4128 map[res / 32] |= 1 << (res % 32);
4129 }
4130 /* clean up the allocated slots */
4131 for (i = 0; i < DOS_TABLE_SIZE; i++)
4132 {
4133 if (map[i / 32] & (1 << (i % 32)))
4134 _lclose16((HFILE16)i);
4135 }
4136 return res == hFile2;
4137 }
4138
4139
4140 /***********************************************************************
4141 * DOSVM_Int21Handler
4142 *
4143 * Interrupt 0x21 handler.
4144 */
4145 void WINAPI DOSVM_Int21Handler( CONTEXT *context )
4146 {
4147 BOOL bSetDOSExtendedError = FALSE;
4148
4149 TRACE( "AX=%04x BX=%04x CX=%04x DX=%04x "
4150 "SI=%04x DI=%04x DS=%04x ES=%04x EFL=%08x\n",
4151 AX_reg(context), BX_reg(context),
4152 CX_reg(context), DX_reg(context),
4153 SI_reg(context), DI_reg(context),
4154 (WORD)context->SegDs, (WORD)context->SegEs,
4155 context->EFlags );
4156
4157 /*
4158 * Extended error is used by (at least) functions 0x2f to 0x62.
4159 * Function 0x59 returns extended error and error should not
4160 * be cleared before handling the function.
4161 */
4162 if (AH_reg(context) >= 0x2f && AH_reg(context) != 0x59)
4163 SetLastError(0);
4164
4165 RESET_CFLAG(context); /* Not sure if this is a good idea. */
4166
4167 switch(AH_reg(context))
4168 {
4169 case 0x00: /* TERMINATE PROGRAM */
4170 TRACE("TERMINATE PROGRAM\n");
4171 if (DOSVM_IsWin16())
4172 DOSVM_Exit( 0 );
4173 else if(ISV86(context))
4174 MZ_Exit( context, FALSE, 0 );
4175 else
4176 ERR( "Called from DOS protected mode\n" );
4177 break;
4178
4179 case 0x01: /* READ CHARACTER FROM STANDARD INPUT, WITH ECHO */
4180 {
4181 BYTE ascii;
4182 TRACE("DIRECT CHARACTER INPUT WITH ECHO\n");
4183 INT21_ReadChar( &ascii, context );
4184 SET_AL( context, ascii );
4185 /*
4186 * FIXME: What to echo when extended keycodes are read?
4187 */
4188 DOSVM_PutChar(AL_reg(context));
4189 }
4190 break;
4191
4192 case 0x02: /* WRITE CHARACTER TO STANDARD OUTPUT */
4193 TRACE("Write Character to Standard Output\n");
4194 DOSVM_PutChar(DL_reg(context));
4195 break;
4196
4197 case 0x03: /* READ CHARACTER FROM STDAUX */
4198 case 0x04: /* WRITE CHARACTER TO STDAUX */
4199 case 0x05: /* WRITE CHARACTER TO PRINTER */
4200 INT_BARF( context, 0x21 );
4201 break;
4202
4203 case 0x06: /* DIRECT CONSOLE IN/OUTPUT */
4204 if (DL_reg(context) == 0xff)
4205 {
4206 TRACE("Direct Console Input\n");
4207
4208 if (INT21_ReadChar( NULL, NULL ))
4209 {
4210 BYTE ascii;
4211 INT21_ReadChar( &ascii, context );
4212 SET_AL( context, ascii );
4213 RESET_ZFLAG( context );
4214 }
4215 else
4216 {
4217 /* no character available */
4218 SET_AL( context, 0 );
4219 SET_ZFLAG( context );
4220 }
4221 }
4222 else
4223 {
4224 TRACE("Direct Console Output\n");
4225 DOSVM_PutChar(DL_reg(context));
4226 /*
4227 * At least DOS versions 2.1-7.0 return character
4228 * that was written in AL register.
4229 */
4230 SET_AL( context, DL_reg(context) );
4231 }
4232 break;
4233
4234 case 0x07: /* DIRECT CHARACTER INPUT WITHOUT ECHO */
4235 {
4236 BYTE ascii;
4237 TRACE("DIRECT CHARACTER INPUT WITHOUT ECHO\n");
4238 INT21_ReadChar( &ascii, context );
4239 SET_AL( context, ascii );
4240 }
4241 break;
4242
4243 case 0x08: /* CHARACTER INPUT WITHOUT ECHO */
4244 {
4245 BYTE ascii;
4246 TRACE("CHARACTER INPUT WITHOUT ECHO\n");
4247 INT21_ReadChar( &ascii, context );
4248 SET_AL( context, ascii );
4249 }
4250 break;
4251
4252 case 0x09: /* WRITE STRING TO STANDARD OUTPUT */
4253 TRACE("WRITE '$'-terminated string from %04X:%04X to stdout\n",
4254 context->SegDs, DX_reg(context) );
4255 {
4256 LPSTR data = CTX_SEG_OFF_TO_LIN( context,
4257 context->SegDs, context->Edx );
4258 LPSTR p = data;
4259 DWORD w;
4260 /*
4261 * Do NOT use strchr() to calculate the string length,
4262 * as '\0' is valid string content, too!
4263 * Maybe we should check for non-'$' strings, but DOS doesn't.
4264 */
4265 while (*p != '$') p++;
4266
4267 if (DOSVM_IsWin16())
4268 WriteFile( DosFileHandleToWin32Handle(1),
4269 data, p - data, &w, NULL );
4270 else
4271 for(; data != p; data++)
4272 DOSVM_PutChar( *data );
4273
4274 SET_AL( context, '$' ); /* yes, '$' (0x24) gets returned in AL */
4275 }
4276 break;
4277
4278 case 0x0a: /* BUFFERED INPUT */
4279 {
4280 BYTE *ptr = CTX_SEG_OFF_TO_LIN(context,
4281 context->SegDs,
4282 context->Edx);
4283 WORD result;
4284
4285 TRACE( "BUFFERED INPUT (size=%d)\n", ptr[0] );
4286
4287 /*
4288 * FIXME: Some documents state that
4289 * ptr[1] holds number of chars from last input which
4290 * may be recalled on entry, other documents do not mention
4291 * this at all.
4292 */
4293 if (ptr[1])
4294 TRACE( "Handle old chars in buffer!\n" );
4295
4296 /*
4297 * ptr[0] - capacity (includes terminating CR)
4298 * ptr[1] - characters read (excludes terminating CR)
4299 */
4300 result = INT21_BufferedInput( context, ptr + 2, ptr[0] );
4301 if (result > 0)
4302 ptr[1] = (BYTE)result - 1;
4303 else
4304 ptr[1] = 0;
4305 }
4306 break;
4307
4308 case 0x0b: /* GET STDIN STATUS */
4309 TRACE( "GET STDIN STATUS\n" );
4310 {
4311 if (INT21_ReadChar( NULL, NULL ))
4312 SET_AL( context, 0xff ); /* character available */
4313 else
4314 SET_AL( context, 0 ); /* no character available */
4315 }
4316 break;
4317
4318 case 0x0c: /* FLUSH BUFFER AND READ STANDARD INPUT */
4319 {
4320 BYTE al = AL_reg(context); /* Input function to execute after flush. */
4321
4322 TRACE( "FLUSH BUFFER AND READ STANDARD INPUT - 0x%02x\n", al );
4323
4324 /* FIXME: buffers are not flushed */
4325
4326 /*
4327 * If AL is one of 0x01, 0x06, 0x07, 0x08, or 0x0a,
4328 * int21 function identified by AL will be called.
4329 */
4330 if(al == 0x01 || al == 0x06 || al == 0x07 || al == 0x08 || al == 0x0a)
4331 {
4332 SET_AH( context, al );
4333 DOSVM_Int21Handler( context );
4334 }
4335 }
4336 break;
4337
4338 case 0x0d: /* DISK BUFFER FLUSH */
4339 TRACE("DISK BUFFER FLUSH ignored\n");
4340 break;
4341
4342 case 0x0e: /* SELECT DEFAULT DRIVE */
4343 TRACE( "SELECT DEFAULT DRIVE - %c:\n", 'A' + DL_reg(context) );
4344 INT21_SetCurrentDrive( DL_reg(context) );
4345 SET_AL( context, MAX_DOS_DRIVES );
4346 break;
4347
4348 case 0x0f: /* OPEN FILE USING FCB */
4349 INT21_OpenFileUsingFCB( context );
4350 break;
4351
4352 case 0x10: /* CLOSE FILE USING FCB */
4353 INT21_CloseFileUsingFCB( context );
4354 break;
4355
4356 case 0x11: /* FIND FIRST MATCHING FILE USING FCB */
4357 TRACE("FIND FIRST MATCHING FILE USING FCB %p\n",
4358 CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx));
4359 if (!INT21_FindFirstFCB(context))
4360 {
4361 SET_AL( context, 0xff );
4362 break;
4363 }
4364 /* else fall through */
4365
4366 case 0x12: /* FIND NEXT MATCHING FILE USING FCB */
4367 SET_AL( context, INT21_FindNextFCB(context) ? 0x00 : 0xff );
4368 break;
4369
4370 case 0x13: /* DELETE FILE USING FCB */
4371 INT_BARF( context, 0x21 );
4372 break;
4373
4374 case 0x14: /* SEQUENTIAL READ FROM FCB FILE */
4375 INT21_SequentialReadFromFCB( context );
4376 break;
4377
4378 case 0x15: /* SEQUENTIAL WRITE TO FCB FILE */
4379 INT21_SequentialWriteToFCB( context );
4380 break;
4381
4382 case 0x16: /* CREATE OR TRUNCATE FILE USING FCB */
4383 case 0x17: /* RENAME FILE USING FCB */
4384 INT_BARF( context, 0x21 );
4385 break;
4386
4387 case 0x18: /* NULL FUNCTION FOR CP/M COMPATIBILITY */
4388 SET_AL( context, 0 );
4389 break;
4390
4391 case 0x19: /* GET CURRENT DEFAULT DRIVE */
4392 SET_AL( context, INT21_GetCurrentDrive() );
4393 TRACE( "GET CURRENT DRIVE -> %c:\n", 'A' + AL_reg( context ) );
4394 break;
4395
4396 case 0x1a: /* SET DISK TRANSFER AREA ADDRESS */
4397 TRACE( "SET DISK TRANSFER AREA ADDRESS %04X:%04X\n",
4398 context->SegDs, DX_reg(context) );
4399 {
4400 TDB *task = GlobalLock16( GetCurrentTask() );
4401 task->dta = MAKESEGPTR( context->SegDs, DX_reg(context) );
4402 }
4403 break;
4404
4405 case 0x1b: /* GET ALLOCATION INFORMATION FOR DEFAULT DRIVE */
4406 if (!INT21_GetDriveAllocInfo(context, 0))
4407 SET_AX( context, 0xffff );
4408 break;
4409
4410 case 0x1c: /* GET ALLOCATION INFORMATION FOR SPECIFIC DRIVE */
4411 if (!INT21_GetDriveAllocInfo(context, DL_reg(context)))
4412 SET_AX( context, 0xffff );
4413 break;
4414
4415 case 0x1d: /* NULL FUNCTION FOR CP/M COMPATIBILITY */
4416 case 0x1e: /* NULL FUNCTION FOR CP/M COMPATIBILITY */
4417 SET_AL( context, 0 );
4418 break;
4419
4420 case 0x1f: /* GET DRIVE PARAMETER BLOCK FOR DEFAULT DRIVE */
4421 {
4422 BYTE drive = INT21_MapDrive( 0 );
4423 TRACE( "GET DPB FOR DEFAULT DRIVE\n" );
4424
4425 if (INT21_FillDrivePB( drive ))
4426 {
4427 SET_AL( context, 0x00 ); /* success */
4428 SET_BX( context, offsetof( INT21_HEAP, misc_dpb_list[drive] ) );
4429 context->SegDs = INT21_GetHeapSelector( context );
4430 }
4431 else
4432 {
4433 SET_AL( context, 0xff ); /* invalid or network drive */
4434 }
4435 }
4436 break;
4437
4438 case 0x20: /* NULL FUNCTION FOR CP/M COMPATIBILITY */
4439 SET_AL( context, 0 );
4440 break;
4441
4442 case 0x21: /* READ RANDOM RECORD FROM FCB FILE */
4443 INT21_ReadRandomRecordFromFCB( context );
4444 break;
4445
4446 case 0x22: /* WRITE RANDOM RECORD TO FCB FILE */
4447 INT21_WriteRandomRecordToFCB( context );
4448 break;
4449
4450 case 0x23: /* GET FILE SIZE FOR FCB */
4451 case 0x24: /* SET RANDOM RECORD NUMBER FOR FCB */
4452 INT_BARF( context, 0x21 );
4453 break;
4454
4455 case 0x25: /* SET INTERRUPT VECTOR */
4456 TRACE("SET INTERRUPT VECTOR 0x%02x\n",AL_reg(context));
4457 {
4458 FARPROC16 ptr = (FARPROC16)MAKESEGPTR( context->SegDs, DX_reg(context) );
4459 if (!ISV86(context) && DOSVM_IsWin16())
4460 DOSVM_SetPMHandler16( AL_reg(context), ptr );
4461 else
4462 DOSVM_SetRMHandler( AL_reg(context), ptr );
4463 }
4464 break;
4465
4466 case 0x26: /* CREATE NEW PROGRAM SEGMENT PREFIX */
4467 INT_BARF( context, 0x21 );
4468 break;
4469
4470 case 0x27: /* RANDOM BLOCK READ FROM FCB FILE */
4471 INT21_RandomBlockReadFromFCB( context );
4472 break;
4473
4474 case 0x28: /* RANDOM BLOCK WRITE TO FCB FILE */
4475 INT21_RandomBlockWriteToFCB( context );
4476 break;
4477
4478 case 0x29: /* PARSE FILENAME INTO FCB */
4479 INT21_ParseFileNameIntoFCB(context);
4480 break;
4481
4482 case 0x2a: /* GET SYSTEM DATE */
4483 TRACE( "GET SYSTEM DATE\n" );
4484 {
4485 SYSTEMTIME systime;
4486 GetLocalTime( &systime );
4487 SET_CX( context, systime.wYear );
4488 SET_DH( context, systime.wMonth );
4489 SET_DL( context, systime.wDay );
4490 SET_AL( context, systime.wDayOfWeek );
4491 }
4492 break;
4493
4494 case 0x2b: /* SET SYSTEM DATE */
4495 TRACE( "SET SYSTEM DATE\n" );
4496 {
4497 WORD year = CX_reg(context);
4498 BYTE month = DH_reg(context);
4499 BYTE day = DL_reg(context);
4500
4501 if (year >= 1980 && year <= 2099 &&
4502 month >= 1 && month <= 12 &&
4503 day >= 1 && day <= 31)
4504 {
4505 FIXME( "SetSystemDate(%02d/%02d/%04d): not allowed\n",
4506 day, month, year );
4507 SET_AL( context, 0 ); /* Let's pretend we succeeded */
4508 }
4509 else
4510 {
4511 SET_AL( context, 0xff ); /* invalid date */
4512 TRACE( "SetSystemDate(%02d/%02d/%04d): invalid date\n",
4513 day, month, year );
4514 }
4515 }
4516 break;
4517
4518 case 0x2c: /* GET SYSTEM TIME */
4519 TRACE( "GET SYSTEM TIME\n" );
4520 {
4521 SYSTEMTIME systime;
4522 GetLocalTime( &systime );
4523 SET_CH( context, systime.wHour );
4524 SET_CL( context, systime.wMinute );
4525 SET_DH( context, systime.wSecond );
4526 SET_DL( context, systime.wMilliseconds / 10 );
4527 }
4528 break;
4529
4530 case 0x2d: /* SET SYSTEM TIME */
4531 if( CH_reg(context) >= 24 || CL_reg(context) >= 60 || DH_reg(context) >= 60 || DL_reg(context) >= 100 ) {
4532 TRACE("SetSystemTime(%02d:%02d:%02d.%02d): wrong time\n",
4533 CH_reg(context), CL_reg(context),
4534 DH_reg(context), DL_reg(context) );
4535 SET_AL( context, 0xFF );
4536 }
4537 else
4538 {
4539 FIXME("SetSystemTime(%02d:%02d:%02d.%02d): not allowed\n",
4540 CH_reg(context), CL_reg(context),
4541 DH_reg(context), DL_reg(context) );
4542 SET_AL( context, 0 ); /* Let's pretend we succeeded */
4543 }
4544 break;
4545
4546 case 0x2e: /* SET VERIFY FLAG */
4547 TRACE("SET VERIFY FLAG ignored\n");
4548 /* we cannot change the behaviour anyway, so just ignore it */
4549 break;
4550
4551 case 0x2f: /* GET DISK TRANSFER AREA ADDRESS */
4552 TRACE( "GET DISK TRANSFER AREA ADDRESS\n" );
4553 {
4554 TDB *task = GlobalLock16( GetCurrentTask() );
4555 context->SegEs = SELECTOROF( task->dta );
4556 SET_BX( context, OFFSETOF( task->dta ) );
4557 }
4558 break;
4559
4560 case 0x30: /* GET DOS VERSION */
4561 TRACE( "GET DOS VERSION - %s requested\n",
4562 (AL_reg(context) == 0x00) ? "OEM number" : "version flag" );
4563
4564 if (AL_reg(context) == 0x00)
4565 SET_BH( context, 0xff ); /* OEM number => undefined */
4566 else
4567 SET_BH( context, 0x08 ); /* version flag => DOS is in ROM */
4568
4569 SET_AL( context, HIBYTE(HIWORD(GetVersion16())) ); /* major version */
4570 SET_AH( context, LOBYTE(HIWORD(GetVersion16())) ); /* minor version */
4571
4572 SET_BL( context, 0x12 ); /* 0x123456 is 24-bit Wine's serial # */
4573 SET_CX( context, 0x3456 );
4574 break;
4575
4576 case 0x31: /* TERMINATE AND STAY RESIDENT */
4577 FIXME("TERMINATE AND STAY RESIDENT stub\n");
4578 break;
4579
4580 case 0x32: /* GET DOS DRIVE PARAMETER BLOCK FOR SPECIFIC DRIVE */
4581 {
4582 BYTE drive = INT21_MapDrive( DL_reg(context) );
4583 TRACE( "GET DPB FOR SPECIFIC DRIVE %d\n", DL_reg(context) );
4584
4585 if (INT21_FillDrivePB( drive ))
4586 {
4587 SET_AL( context, 0x00 ); /* success */
4588 SET_BX( context, offsetof( INT21_HEAP, misc_dpb_list[drive] ) );
4589 context->SegDs = INT21_GetHeapSelector( context );
4590 }
4591 else
4592 {
4593 SET_AL( context, 0xff ); /* invalid or network drive */
4594 }
4595 }
4596 break;
4597
4598 case 0x33: /* MULTIPLEXED */
4599 switch (AL_reg(context))
4600 {
4601 case 0x00: /* GET CURRENT EXTENDED BREAK STATE */
4602 TRACE("GET CURRENT EXTENDED BREAK STATE\n");
4603 SET_DL( context, brk_flag );
4604 break;
4605
4606 case 0x01: /* SET EXTENDED BREAK STATE */
4607 TRACE("SET CURRENT EXTENDED BREAK STATE\n");
4608 brk_flag = (DL_reg(context) > 0) ? 1 : 0;
4609 break;
4610
4611 case 0x02: /* GET AND SET EXTENDED CONTROL-BREAK CHECKING STATE*/
4612 TRACE("GET AND SET EXTENDED CONTROL-BREAK CHECKING STATE\n");
4613 /* ugly coding in order to stay reentrant */
4614 if (DL_reg(context))
4615 {
4616 SET_DL( context, brk_flag );
4617 brk_flag = 1;
4618 }
4619 else
4620 {
4621 SET_DL( context, brk_flag );
4622 brk_flag = 0;
4623 }
4624 break;
4625
4626 case 0x05: /* GET BOOT DRIVE */
4627 TRACE("GET BOOT DRIVE\n");
4628 SET_DL( context, 3 );
4629 /* c: is Wine's bootdrive (a: is 1)*/
4630 break;
4631
4632 case 0x06: /* GET TRUE VERSION NUMBER */
4633 TRACE("GET TRUE VERSION NUMBER\n");
4634 SET_BL( context, HIBYTE(HIWORD(GetVersion16())) ); /* major */
4635 SET_BH( context, LOBYTE(HIWORD(GetVersion16())) ); /* minor */
4636 SET_DL( context, 0x00 ); /* revision */
4637 SET_DH( context, 0x08 ); /* DOS is in ROM */
4638 break;
4639
4640 default:
4641 INT_BARF( context, 0x21 );
4642 break;
4643 }
4644 break;
4645
4646 case 0x34: /* GET ADDRESS OF INDOS FLAG */
4647 TRACE( "GET ADDRESS OF INDOS FLAG\n" );
4648 context->SegEs = INT21_GetHeapSelector( context );
4649 SET_BX( context, offsetof(INT21_HEAP, misc_indos) );
4650 break;
4651
4652 case 0x35: /* GET INTERRUPT VECTOR */
4653 TRACE("GET INTERRUPT VECTOR 0x%02x\n",AL_reg(context));
4654 {
4655 FARPROC16 addr;
4656 if (!ISV86(context) && DOSVM_IsWin16())
4657 addr = DOSVM_GetPMHandler16( AL_reg(context) );
4658 else
4659 addr = DOSVM_GetRMHandler( AL_reg(context) );
4660 context->SegEs = SELECTOROF(addr);
4661 SET_BX( context, OFFSETOF(addr) );
4662 }
4663 break;
4664
4665 case 0x36: /* GET FREE DISK SPACE */
4666 TRACE("GET FREE DISK SPACE FOR DRIVE %s (limited to about 1GB)\n",
4667 INT21_DriveName( DL_reg(context) ));
4668 if (!INT21_GetFreeDiskSpace(context)) SET_AX( context, 0xffff );
4669 break;
4670
4671 case 0x37: /* SWITCHAR */
4672 {
4673 switch (AL_reg(context))
4674 {
4675 case 0x00: /* "SWITCHAR" - GET SWITCH CHARACTER */
4676 TRACE( "SWITCHAR - GET SWITCH CHARACTER\n" );
4677 SET_AL( context, 0x00 ); /* success*/
4678 SET_DL( context, '/' );
4679 break;
4680 case 0x01: /*"SWITCHAR" - SET SWITCH CHARACTER*/
4681 FIXME( "SWITCHAR - SET SWITCH CHARACTER: %c\n",
4682 DL_reg( context ));
4683 SET_AL( context, 0x00 ); /* success*/
4684 break;
4685 default:
4686 INT_BARF( context, 0x21 );
4687 break;
4688 }
4689 }
4690 break;
4691
4692 case 0x38: /* GET COUNTRY-SPECIFIC INFORMATION */
4693 TRACE( "GET COUNTRY-SPECIFIC INFORMATION\n" );
4694 if (AL_reg(context))
4695 {
4696 WORD country = AL_reg(context);
4697 if (country == 0xff)
4698 country = BX_reg(context);
4699 if (country != INT21_GetSystemCountryCode()) {
4700 FIXME( "Requested info on non-default country %04x\n", country );
4701 SET_AX(context, 2);
4702 SET_CFLAG(context);
4703 }
4704 }
4705 if(AX_reg(context) != 2 )
4706 {
4707 INT21_FillCountryInformation( CTX_SEG_OFF_TO_LIN(context,
4708 context->SegDs,
4709 context->Edx) );
4710 SET_AX( context, INT21_GetSystemCountryCode() );
4711 SET_BX( context, INT21_GetSystemCountryCode() );
4712 RESET_CFLAG(context);
4713 }
4714 break;
4715
4716 case 0x39: /* "MKDIR" - CREATE SUBDIRECTORY */
4717 if (!INT21_CreateDirectory( context ))
4718 bSetDOSExtendedError = TRUE;
4719 else
4720 RESET_CFLAG(context);
4721 break;
4722
4723 case 0x3a: /* "RMDIR" - REMOVE DIRECTORY */
4724 {
4725 WCHAR dirW[MAX_PATH];
4726 char *dirA = CTX_SEG_OFF_TO_LIN(context,
4727 context->SegDs, context->Edx);
4728
4729 TRACE( "REMOVE DIRECTORY %s\n", dirA );
4730
4731 MultiByteToWideChar(CP_OEMCP, 0, dirA, -1, dirW, MAX_PATH);
4732
4733 if (!RemoveDirectoryW( dirW ))
4734 bSetDOSExtendedError = TRUE;
4735 else
4736 RESET_CFLAG(context);
4737 }
4738 break;
4739
4740 case 0x3b: /* "CHDIR" - SET CURRENT DIRECTORY */
4741 if (!INT21_SetCurrentDirectory( context ))
4742 bSetDOSExtendedError = TRUE;
4743 else
4744 RESET_CFLAG(context);
4745 break;
4746
4747 case 0x3c: /* "CREAT" - CREATE OR TRUNCATE FILE */
4748 if (!INT21_CreateFile( context, context->Edx, FALSE,
4749 OF_READWRITE | OF_SHARE_COMPAT, 0x12 ))
4750 bSetDOSExtendedError = TRUE;
4751 else
4752 RESET_CFLAG(context);
4753 break;
4754
4755 case 0x3d: /* "OPEN" - OPEN EXISTING FILE */
4756 if (!INT21_CreateFile( context, context->Edx, FALSE,
4757 AL_reg(context), 0x01 ))
4758 bSetDOSExtendedError = TRUE;
4759 else
4760 RESET_CFLAG(context);
4761 break;
4762
4763 case 0x3e: /* "CLOSE" - CLOSE FILE */
4764 TRACE( "CLOSE handle %d\n", BX_reg(context) );
4765 if (_lclose16( BX_reg(context) ) == HFILE_ERROR16)
4766 bSetDOSExtendedError = TRUE;
4767 else
4768 RESET_CFLAG(context);
4769 break;
4770
4771 case 0x3f: /* "READ" - READ FROM FILE OR DEVICE */
4772 TRACE( "READ from %d to %04X:%04X for %d bytes\n",
4773 BX_reg(context),
4774 context->SegDs,
4775 DX_reg(context),
4776 CX_reg(context) );
4777 {
4778 DWORD result;
4779 WORD count = CX_reg(context);
4780 BYTE *buffer = CTX_SEG_OFF_TO_LIN( context,
4781 context->SegDs,
4782 context->Edx );
4783
4784 /* Some programs pass a count larger than the allocated buffer */
4785 if (DOSVM_IsWin16())
4786 {
4787 DWORD maxcount = GetSelectorLimit16( context->SegDs )
4788 - DX_reg(context) + 1;
4789 if (count > maxcount)
4790 count = maxcount;
4791 }
4792
4793 /*
4794 * FIXME: Reading from console (BX=1) in DOS mode
4795 * does not work as it is supposed to work.
4796 */
4797
4798 RESET_CFLAG(context); /* set if error */
4799 if (!DOSVM_IsWin16() && BX_reg(context) == 0)
4800 {
4801 result = INT21_BufferedInput( context, buffer, count );
4802 SET_AX( context, (WORD)result );
4803 }
4804 else if (ReadFile( DosFileHandleToWin32Handle(BX_reg(context)),
4805 buffer, count, &result, NULL ))
4806 SET_AX( context, (WORD)result );
4807 else
4808 bSetDOSExtendedError = TRUE;
4809 }
4810 break;
4811
4812 case 0x40: /* "WRITE" - WRITE TO FILE OR DEVICE */
4813 TRACE( "WRITE from %04X:%04X to handle %d for %d byte\n",
4814 context->SegDs, DX_reg(context),
4815 BX_reg(context), CX_reg(context) );
4816 {
4817 char *ptr = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
4818
4819 if (!DOSVM_IsWin16() &&
4820 (BX_reg(context) == 1 || BX_reg(context) == 2))
4821 {
4822 int i;
4823 for(i=0; i<CX_reg(context); i++)
4824 DOSVM_PutChar(ptr[i]);
4825 SET_AX(context, CX_reg(context));
4826 RESET_CFLAG(context);
4827 }
4828 else
4829 {
4830 HFILE handle = (HFILE)DosFileHandleToWin32Handle(BX_reg(context));
4831 LONG result = _hwrite( handle, ptr, CX_reg(context) );
4832 if (result == HFILE_ERROR)
4833 bSetDOSExtendedError = TRUE;
4834 else
4835 {
4836 SET_AX( context, (WORD)result );
4837 RESET_CFLAG(context);
4838 }
4839 }
4840 }
4841 break;
4842
4843 case 0x41: /* "UNLINK" - DELETE FILE */
4844 {
4845 WCHAR fileW[MAX_PATH];
4846 char *fileA = CTX_SEG_OFF_TO_LIN(context,
4847 context->SegDs,
4848 context->Edx);
4849
4850 TRACE( "UNLINK %s\n", fileA );
4851 MultiByteToWideChar(CP_OEMCP, 0, fileA, -1, fileW, MAX_PATH);
4852
4853 if (!DeleteFileW( fileW ))
4854 bSetDOSExtendedError = TRUE;
4855 else
4856 RESET_CFLAG(context);
4857 }
4858 break;
4859
4860 case 0x42: /* "LSEEK" - SET CURRENT FILE POSITION */
4861 TRACE( "LSEEK handle %d offset %d from %s\n",
4862 BX_reg(context),
4863 MAKELONG( DX_reg(context), CX_reg(context) ),
4864 (AL_reg(context) == 0) ?
4865 "start of file" : ((AL_reg(context) == 1) ?
4866 "current file position" : "end of file") );
4867 {
4868 HANDLE handle = DosFileHandleToWin32Handle(BX_reg(context));
4869 LONG offset = MAKELONG( DX_reg(context), CX_reg(context) );
4870 DWORD status = SetFilePointer( handle, offset,
4871 NULL, AL_reg(context) );
4872 if (status == INVALID_SET_FILE_POINTER)
4873 bSetDOSExtendedError = TRUE;
4874 else
4875 {
4876 SET_AX( context, LOWORD(status) );
4877 SET_DX( context, HIWORD(status) );
4878 RESET_CFLAG(context);
4879 }
4880 }
4881 break;
4882
4883 case 0x43: /* FILE ATTRIBUTES */
4884 if (!INT21_FileAttributes( context, AL_reg(context), FALSE ))
4885 bSetDOSExtendedError = TRUE;
4886 else
4887 RESET_CFLAG(context);
4888 break;
4889
4890 case 0x44: /* IOCTL */
4891 INT21_Ioctl( context );
4892 break;
4893
4894 case 0x45: /* "DUP" - DUPLICATE FILE HANDLE */
4895 TRACE( "DUPLICATE FILE HANDLE %d\n", BX_reg(context) );
4896 {
4897 HANDLE handle32;
4898 HFILE handle16 = HFILE_ERROR;
4899
4900 if (DuplicateHandle( GetCurrentProcess(),
4901 DosFileHandleToWin32Handle(BX_reg(context)),
4902 GetCurrentProcess(),
4903 &handle32,
4904 0, TRUE, DUPLICATE_SAME_ACCESS ))
4905 handle16 = Win32HandleToDosFileHandle(handle32);
4906
4907 if (handle16 == HFILE_ERROR)
4908 bSetDOSExtendedError = TRUE;
4909 else
4910 {
4911 SET_AX( context, handle16 );
4912 RESET_CFLAG(context);
4913 }
4914 }
4915 break;
4916
4917 case 0x46: /* "DUP2", "FORCEDUP" - FORCE DUPLICATE FILE HANDLE */
4918 TRACE( "FORCEDUP - FORCE DUPLICATE FILE HANDLE %d to %d\n",
4919 BX_reg(context), CX_reg(context) );
4920 if (!INT21_Dup2(BX_reg(context), CX_reg(context)))
4921 bSetDOSExtendedError = TRUE;
4922 else
4923 RESET_CFLAG(context);
4924 break;
4925
4926 case 0x47: /* "CWD" - GET CURRENT DIRECTORY */
4927 if (!INT21_GetCurrentDirectory( context, FALSE ))
4928 bSetDOSExtendedError = TRUE;
4929 else
4930 RESET_CFLAG(context);
4931 break;
4932
4933 case 0x48: /* ALLOCATE MEMORY */
4934 TRACE( "ALLOCATE MEMORY for %d paragraphs\n", BX_reg(context) );
4935 {
4936 WORD selector = 0;
4937 DWORD bytes = (DWORD)BX_reg(context) << 4;
4938
4939 if (!ISV86(context) && DOSVM_IsWin16())
4940 {
4941 DWORD rv = GlobalDOSAlloc16( bytes );
4942 selector = LOWORD( rv );
4943 }
4944 else
4945 DOSMEM_AllocBlock( bytes, &selector );
4946
4947 if (selector)
4948 {
4949 SET_AX( context, selector );
4950 RESET_CFLAG(context);
4951 }
4952 else
4953 {
4954 SET_CFLAG(context);
4955 SET_AX( context, 0x0008 ); /* insufficient memory */
4956 SET_BX( context, DOSMEM_Available() >> 4 );
4957 }
4958 }
4959 break;
4960
4961 case 0x49: /* FREE MEMORY */
4962 TRACE( "FREE MEMORY segment %04X\n", context->SegEs );
4963 {
4964 BOOL ok;
4965
4966 if (!ISV86(context) && DOSVM_IsWin16())
4967 {
4968 ok = !GlobalDOSFree16( context->SegEs );
4969
4970 /* If we don't reset ES_reg, we will fail in the relay code */
4971 if (ok)
4972 context->SegEs = 0;
4973 }
4974 else
4975 ok = DOSMEM_FreeBlock( PTR_REAL_TO_LIN(context->SegEs, 0) );
4976
4977 if (!ok)
4978 {
4979 TRACE("FREE MEMORY failed\n");
4980 SET_CFLAG(context);
4981 SET_AX( context, 0x0009 ); /* memory block address invalid */
4982 }
4983 }
4984 break;
4985
4986 case 0x4a: /* RESIZE MEMORY BLOCK */
4987 TRACE( "RESIZE MEMORY segment %04X to %d paragraphs\n",
4988 context->SegEs, BX_reg(context) );
4989 {
4990 DWORD newsize = (DWORD)BX_reg(context) << 4;
4991
4992 if (!ISV86(context) && DOSVM_IsWin16())
4993 {
4994 FIXME( "Resize memory block - unsupported under Win16\n" );
4995 SET_CFLAG(context);
4996 }
4997 else
4998 {
4999 LPVOID address = (void*)(context->SegEs << 4);
5000 UINT blocksize = DOSMEM_ResizeBlock( address, newsize, FALSE );
5001
5002 RESET_CFLAG(context);
5003 if (blocksize == (UINT)-1)
5004 {
5005 SET_CFLAG( context );
5006 SET_AX( context, 0x0009 ); /* illegal address */
5007 }
5008 else if(blocksize != newsize)
5009 {
5010 SET_CFLAG( context );
5011 SET_AX( context, 0x0008 ); /* insufficient memory */
5012 SET_BX( context, blocksize >> 4 ); /* new block size */
5013 }
5014 }
5015 }
5016 break;
5017
5018 case 0x4b: /* "EXEC" - LOAD AND/OR EXECUTE PROGRAM */
5019 {
5020 char *program = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
5021 BYTE *paramblk = CTX_SEG_OFF_TO_LIN(context, context->SegEs, context->Ebx);
5022
5023 TRACE( "EXEC %s\n", program );
5024
5025 RESET_CFLAG(context);
5026 if (DOSVM_IsWin16())
5027 {
5028 HINSTANCE16 instance = WinExec16( program, SW_NORMAL );
5029 if (instance < 32)
5030 {
5031 SET_CFLAG( context );
5032 SET_AX( context, instance );
5033 }
5034 }
5035 else
5036 {
5037 if (!MZ_Exec( context, program, AL_reg(context), paramblk))
5038 bSetDOSExtendedError = TRUE;
5039 }
5040 }
5041 break;
5042
5043 case 0x4c: /* "EXIT" - TERMINATE WITH RETURN CODE */
5044 TRACE( "EXIT with return code %d\n", AL_reg(context) );
5045 if (DOSVM_IsWin16())
5046 DOSVM_Exit( AL_reg(context) );
5047 else if(ISV86(context))
5048 MZ_Exit( context, FALSE, AL_reg(context) );
5049 else
5050 {
5051 /*
5052 * Exit from DPMI.
5053 */
5054 ULONG_PTR rv = AL_reg(context);
5055 RaiseException( EXCEPTION_VM86_INTx, 0, 1, &rv );
5056 }
5057 break;
5058
5059 case 0x4d: /* GET RETURN CODE */
5060 TRACE("GET RETURN CODE (ERRORLEVEL)\n");
5061 SET_AX( context, DOSVM_retval );
5062 DOSVM_retval = 0;
5063 break;
5064
5065 case 0x4e: /* "FINDFIRST" - FIND FIRST MATCHING FILE */
5066 TRACE("FINDFIRST mask 0x%04x spec %s\n",CX_reg(context),
5067 (LPCSTR)CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx));
5068 if (!INT21_FindFirst(context)) break;
5069 /* fall through */
5070
5071 case 0x4f: /* "FINDNEXT" - FIND NEXT MATCHING FILE */
5072 TRACE("FINDNEXT\n");
5073 if (!INT21_FindNext(context))
5074 {
5075 SetLastError( ERROR_NO_MORE_FILES );
5076 SET_AX( context, ERROR_NO_MORE_FILES );
5077 SET_CFLAG(context);
5078 }
5079 else SET_AX( context, 0 ); /* OK */
5080 break;
5081
5082 case 0x50: /* SET CURRENT PROCESS ID (SET PSP ADDRESS) */
5083 TRACE("SET CURRENT PROCESS ID (SET PSP ADDRESS)\n");
5084 DOSVM_psp = BX_reg(context);
5085 break;
5086
5087 case 0x51: /* GET PSP ADDRESS */
5088 INT21_GetPSP( context );
5089 break;
5090
5091 case 0x52: /* "SYSVARS" - GET LIST OF LISTS */
5092 {
5093 SEGPTR ptr = DOSDEV_GetLOL( ISV86(context) || !DOSVM_IsWin16() );
5094 context->SegEs = SELECTOROF(ptr);
5095 SET_BX( context, OFFSETOF(ptr) );
5096 }
5097 break;
5098
5099 case 0x54: /* Get Verify Flag */
5100 TRACE("Get Verify Flag - Not Supported\n");
5101 SET_AL( context, 0x00 ); /* pretend we can tell. 00h = off 01h = on */
5102 break;
5103
5104 case 0x56: /* "RENAME" - RENAME FILE */
5105 if (!INT21_RenameFile( context ))
5106 bSetDOSExtendedError = TRUE;
5107 else
5108 RESET_CFLAG(context);
5109 break;
5110
5111 case 0x57: /* FILE DATE AND TIME */
5112 if (!INT21_FileDateTime( context ))
5113 bSetDOSExtendedError = TRUE;
5114 else
5115 RESET_CFLAG(context);
5116 break;
5117
5118 case 0x58: /* GET OR SET MEMORY ALLOCATION STRATEGY */
5119 switch (AL_reg(context))
5120 {
5121 case 0x00: /* GET MEMORY ALLOCATION STRATEGY */
5122 TRACE( "GET MEMORY ALLOCATION STRATEGY\n" );
5123 SET_AX( context, 0 ); /* low memory first fit */
5124 break;
5125
5126 case 0x01: /* SET ALLOCATION STRATEGY */
5127 TRACE( "SET MEMORY ALLOCATION STRATEGY to %d - ignored\n",
5128 BL_reg(context) );
5129 break;
5130
5131 case 0x02: /* GET UMB LINK STATE */
5132 TRACE( "GET UMB LINK STATE\n" );
5133 SET_AL( context, 0 ); /* UMBs not part of DOS memory chain */
5134 break;
5135
5136 case 0x03: /* SET UMB LINK STATE */
5137 TRACE( "SET UMB LINK STATE to %d - ignored\n",
5138 BX_reg(context) );
5139 break;
5140
5141 default:
5142 INT_BARF( context, 0x21 );
5143 }
5144 break;
5145
5146 case 0x59: /* GET EXTENDED ERROR INFO */
5147 INT21_GetExtendedError( context );
5148 break;
5149
5150 case 0x5a: /* CREATE TEMPORARY FILE */
5151 TRACE("CREATE TEMPORARY FILE\n");
5152 bSetDOSExtendedError = !INT21_CreateTempFile(context);
5153 break;
5154
5155 case 0x5b: /* CREATE NEW FILE */
5156 if (!INT21_CreateFile( context, context->Edx, FALSE,
5157 OF_READWRITE | OF_SHARE_COMPAT, 0x10 ))
5158 bSetDOSExtendedError = TRUE;
5159 else
5160 RESET_CFLAG(context);
5161 break;
5162
5163 case 0x5c: /* "FLOCK" - RECORD LOCKING */
5164 {
5165 DWORD offset = MAKELONG(DX_reg(context), CX_reg(context));
5166 DWORD length = MAKELONG(DI_reg(context), SI_reg(context));
5167 HANDLE handle = DosFileHandleToWin32Handle(BX_reg(context));
5168
5169 RESET_CFLAG(context);
5170 switch (AL_reg(context))
5171 {
5172 case 0x00: /* LOCK */
5173 TRACE( "lock handle %d offset %d length %d\n",
5174 BX_reg(context), offset, length );
5175 if (!LockFile( handle, offset, 0, length, 0 ))
5176 bSetDOSExtendedError = TRUE;
5177 break;
5178
5179 case 0x01: /* UNLOCK */
5180 TRACE( "unlock handle %d offset %d length %d\n",
5181 BX_reg(context), offset, length );
5182 if (!UnlockFile( handle, offset, 0, length, 0 ))
5183 bSetDOSExtendedError = TRUE;
5184 break;
5185
5186 default:
5187 INT_BARF( context, 0x21 );
5188 }
5189 }
5190 break;
5191
5192 case 0x5d: /* NETWORK 5D */
5193 FIXME( "Network function 5D not implemented.\n" );
5194 SetLastError( ER_NoNetwork );
5195 bSetDOSExtendedError = TRUE;
5196 break;
5197
5198 case 0x5e: /* NETWORK 5E */
5199 bSetDOSExtendedError = INT21_NetworkFunc( context);
5200 break;
5201
5202 case 0x5f: /* NETWORK 5F */
5203 /* FIXME: supporting this would need to 1:
5204 * - implement per drive current directory (as kernel32 doesn't)
5205 * - assign enabled/disabled flag on a per drive basis
5206 */
5207 /* network software not installed */
5208 TRACE("NETWORK function AX=%04x not implemented\n",AX_reg(context));
5209 SetLastError( ER_NoNetwork );
5210 bSetDOSExtendedError = TRUE;
5211 break;
5212
5213 case 0x60: /* "TRUENAME" - CANONICALIZE FILENAME OR PATH */
5214 {
5215 WCHAR pathW[MAX_PATH], res[MAX_PATH];
5216 /* FIXME: likely to be broken */
5217
5218 TRACE("TRUENAME %s\n",
5219 (LPCSTR)CTX_SEG_OFF_TO_LIN(context, context->SegDs,context->Esi));
5220 MultiByteToWideChar(CP_OEMCP, 0, CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Esi), -1, pathW, MAX_PATH);
5221 if (!GetFullPathNameW( pathW, 128, res, NULL ))
5222 bSetDOSExtendedError = TRUE;
5223 else
5224 {
5225 SET_AX( context, 0 );
5226 WideCharToMultiByte(CP_OEMCP, 0, res, -1,
5227 CTX_SEG_OFF_TO_LIN(context, context->SegEs, context->Edi),
5228 128, NULL, NULL);
5229 }
5230 }
5231 break;
5232
5233 case 0x61: /* UNUSED */
5234 SET_AL( context, 0 );
5235 break;
5236
5237 case 0x62: /* GET PSP ADDRESS */
5238 INT21_GetPSP( context );
5239 break;
5240
5241 case 0x63: /* MISC. LANGUAGE SUPPORT */
5242 switch (AL_reg(context)) {
5243 case 0x00: /* GET DOUBLE BYTE CHARACTER SET LEAD-BYTE TABLE */
5244 TRACE( "GET DOUBLE BYTE CHARACTER SET LEAD-BYTE TABLE\n" );
5245 context->SegDs = INT21_GetHeapSelector( context );
5246 SET_SI( context, offsetof(INT21_HEAP, dbcs_table) );
5247 SET_AL( context, 0 ); /* success */
5248 break;
5249 }
5250 break;
5251
5252 case 0x64: /* OS/2 DOS BOX */
5253 INT_BARF( context, 0x21 );
5254 SET_CFLAG(context);
5255 break;
5256
5257 case 0x65: /* EXTENDED COUNTRY INFORMATION */
5258 INT21_ExtendedCountryInformation( context );
5259 break;
5260
5261 case 0x66: /* GLOBAL CODE PAGE TABLE */
5262 switch (AL_reg(context))
5263 {
5264 case 0x01:
5265 TRACE( "GET GLOBAL CODE PAGE TABLE\n" );
5266 SET_BX( context, GetOEMCP() );
5267 SET_DX( context, GetOEMCP() );
5268 break;
5269 case 0x02:
5270 FIXME( "SET GLOBAL CODE PAGE TABLE, active %d, system %d - ignored\n",
5271 BX_reg(context), DX_reg(context) );
5272 break;
5273 }
5274 break;
5275
5276 case 0x67: /* SET HANDLE COUNT */
5277 TRACE( "SET HANDLE COUNT to %d\n", BX_reg(context) );
5278 if (SetHandleCount( BX_reg(context) ) < BX_reg(context) )
5279 bSetDOSExtendedError = TRUE;
5280 break;
5281
5282 case 0x68: /* "FFLUSH" - COMMIT FILE */
5283 TRACE( "FFLUSH - handle %d\n", BX_reg(context) );
5284 if (!FlushFileBuffers( DosFileHandleToWin32Handle(BX_reg(context)) ))
5285 bSetDOSExtendedError = TRUE;
5286 break;
5287
5288 case 0x69: /* DISK SERIAL NUMBER */
5289 switch (AL_reg(context))
5290 {
5291 case 0x00:
5292 TRACE("GET DISK SERIAL NUMBER for drive %s\n",
5293 INT21_DriveName(BL_reg(context)));
5294 if (!INT21_GetDiskSerialNumber(context)) bSetDOSExtendedError = TRUE;
5295 else SET_AX( context, 0 );
5296 break;
5297
5298 case 0x01:
5299 TRACE("SET DISK SERIAL NUMBER for drive %s\n",
5300 INT21_DriveName(BL_reg(context)));
5301 if (!INT21_SetDiskSerialNumber(context)) bSetDOSExtendedError = TRUE;
5302 else SET_AX( context, 1 );
5303 break;
5304 }
5305 break;
5306
5307 case 0x6a: /* COMMIT FILE */
5308 TRACE( "COMMIT FILE - handle %d\n", BX_reg(context) );
5309 if (!FlushFileBuffers( DosFileHandleToWin32Handle(BX_reg(context)) ))
5310 bSetDOSExtendedError = TRUE;
5311 break;
5312
5313 case 0x6b: /* NULL FUNCTION FOR CP/M COMPATIBILITY */
5314 SET_AL( context, 0 );
5315 break;
5316
5317 case 0x6c: /* EXTENDED OPEN/CREATE */
5318 if (!INT21_CreateFile( context, context->Esi, TRUE,
5319 BX_reg(context), DL_reg(context) ))
5320 bSetDOSExtendedError = TRUE;
5321 break;
5322
5323 case 0x70: /* MSDOS 7 - GET/SET INTERNATIONALIZATION INFORMATION */
5324 FIXME( "MS-DOS 7 - GET/SET INTERNATIONALIZATION INFORMATION\n" );
5325 SET_CFLAG( context );
5326 SET_AL( context, 0 );
5327 break;
5328
5329 case 0x71: /* MSDOS 7 - LONG FILENAME FUNCTIONS */
5330 INT21_LongFilename( context );
5331 break;
5332
5333 case 0x73: /* MSDOS7 - FAT32 */
5334 RESET_CFLAG( context );
5335 if (!INT21_Fat32( context ))
5336 bSetDOSExtendedError = TRUE;
5337 break;
5338
5339 case 0xdc: /* CONNECTION SERVICES - GET CONNECTION NUMBER */
5340 TRACE( "CONNECTION SERVICES - GET CONNECTION NUMBER - ignored\n" );
5341 break;
5342
5343 case 0xea: /* NOVELL NETWARE - RETURN SHELL VERSION */
5344 TRACE( "NOVELL NETWARE - RETURN SHELL VERSION - ignored\n" );
5345 break;
5346
5347 case 0xff: /* DOS32 EXTENDER (DOS/4GW) - API */
5348 /* we don't implement a DOS32 extender */
5349 TRACE( "DOS32 EXTENDER API - ignored\n" );
5350 break;
5351
5352 default:
5353 INT_BARF( context, 0x21 );
5354 break;
5355
5356 } /* END OF SWITCH */
5357
5358 /* Set general error condition. */
5359 if (bSetDOSExtendedError)
5360 {
5361 SET_AX( context, GetLastError() );
5362 SET_CFLAG( context );
5363 }
5364
5365 /* Print error code if carry flag is set. */
5366 if (context->EFlags & 0x0001)
5367 TRACE("failed, error %d\n", GetLastError() );
5368
5369 TRACE( "returning: AX=%04x BX=%04x CX=%04x DX=%04x "
5370 "SI=%04x DI=%04x DS=%04x ES=%04x EFL=%08x\n",
5371 AX_reg(context), BX_reg(context),
5372 CX_reg(context), DX_reg(context),
5373 SI_reg(context), DI_reg(context),
5374 (WORD)context->SegDs, (WORD)context->SegEs,
5375 context->EFlags );
5376 }
Maarten's multimedia branch