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