2 * DOS interrupt 21h handler
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
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 #include "wine/port.h"
32 #ifdef HAVE_SYS_FILE_H
33 # include <sys/file.h>
36 #ifdef HAVE_SYS_TIME_H
37 # include <sys/time.h>
39 #include <sys/types.h>
51 #include "winuser.h" /* SW_NORMAL */
52 #include "wine/winbase16.h"
60 #include "wine/unicode.h"
61 #include "wine/debug.h"
63 WINE_DEFAULT_DEBUG_CHANNEL(int21);
64 #if defined(__svr4__) || defined(_SCO_DS)
65 /* SVR4 DOESNT do locking the same way must implement properly */
72 #define DOS_GET_DRIVE(reg) ((reg) ? (reg) - 1 : DRIVE_GetCurrentDrive())
74 /* Define the drive parameter block, as used by int21/1F
75 * and int21/32. This table can be accessed through the
76 * global 'dpb' pointer, which points into the local dos
81 BYTE drive_num; /* 0=A, etc. */
82 BYTE unit_num; /* Drive's unit number (?) */
83 WORD sector_size; /* Sector size in bytes */
84 BYTE high_sector; /* Highest sector in a cluster */
85 BYTE shift; /* Shift count (?) */
86 WORD reserved; /* Number of reserved sectors at start */
87 BYTE num_FAT; /* Number of FATs */
88 WORD dir_entries; /* Number of root dir entries */
89 WORD first_data; /* First data sector */
90 WORD high_cluster; /* Highest cluster number */
91 WORD sectors_in_FAT; /* Number of sectors per FAT */
92 WORD start_dir; /* Starting sector of first dir */
93 DWORD driver_head; /* Address of device driver header (?) */
94 BYTE media_ID; /* Media ID */
95 BYTE access_flag; /* Prev. accessed flag (0=yes,0xFF=no) */
96 DWORD next; /* Pointer to next DPB in list */
97 WORD free_search; /* Free cluster search start */
98 WORD free_clusters; /* Number of free clusters (0xFFFF=unknown) */
101 struct EDPB /* FAT32 extended Drive Parameter Block */
102 { /* from Ralf Brown's Interrupt List */
103 struct DPB dpb; /* first 24 bytes = original DPB */
105 BYTE edpb_flags; /* undocumented/unknown flags */
106 DWORD next_edpb; /* pointer to next EDPB */
107 WORD free_cluster; /* cluster to start search for free space on write, typically
108 the last cluster allocated */
109 WORD clusters_free; /* number of free clusters on drive or FFFF = unknown */
110 WORD clusters_free_hi; /* hiword of clusters_free */
111 WORD mirroring_flags; /* mirroring flags: bit 7 set = do not mirror active FAT */
112 /* bits 0-3 = 0-based number of the active FAT */
113 WORD info_sector; /* sector number of file system info sector, or FFFF for none */
114 WORD spare_boot_sector; /* sector number of backup boot sector, or FFFF for none */
115 DWORD first_cluster; /* sector number of the first cluster */
116 DWORD max_cluster; /* sector number of the last cluster */
117 DWORD fat_clusters; /* number of clusters occupied by FAT */
118 DWORD root_cluster; /* cluster number of start of root directory */
119 DWORD free_cluster2; /* same as free_cluster: cluster at which to start
120 search for free space when writing */
131 static struct DosHeap *heap;
132 static WORD DosHeapHandle;
134 extern char TempDirectory[];
136 static BOOL INT21_CreateHeap(void)
138 if (!(DosHeapHandle = GlobalAlloc16(GMEM_FIXED,sizeof(struct DosHeap))))
140 WARN("Out of memory\n");
143 heap = (struct DosHeap *) GlobalLock16(DosHeapHandle);
144 dpbsegptr = MAKESEGPTR(DosHeapHandle,(int)&heap->dpb-(int)heap);
145 strcpy(heap->biosdate, "01/01/80");
149 static BYTE *GetCurrentDTA( CONTEXT86 *context )
151 TDB *pTask = TASK_GetCurrent();
153 /* FIXME: This assumes DTA was set correctly! */
154 return (BYTE *)CTX_SEG_OFF_TO_LIN( context, SELECTOROF(pTask->dta),
155 (DWORD)OFFSETOF(pTask->dta) );
159 void CreateBPB(int drive, BYTE *data, BOOL16 limited)
160 /* limited == TRUE is used with INT 0x21/0x440d */
165 setword(&data[3], 0);
167 setword(&data[6], 240);
168 setword(&data[8], 64000);
170 setword(&data[0x0b], 40);
171 setword(&data[0x0d], 56);
172 setword(&data[0x0f], 2);
173 setword(&data[0x11], 0);
175 setword(&data[0x1f], 800);
177 setword(&data[0x22], 1);
179 } else { /* 1.44mb */
182 setword(&data[3], 0);
184 setword(&data[6], 240);
185 setword(&data[8], 2880);
187 setword(&data[0x0b], 6);
188 setword(&data[0x0d], 18);
189 setword(&data[0x0f], 2);
190 setword(&data[0x11], 0);
192 setword(&data[0x1f], 80);
194 setword(&data[0x22], 2);
199 static int INT21_GetFreeDiskSpace( CONTEXT86 *context )
201 DWORD cluster_sectors, sector_bytes, free_clusters, total_clusters;
202 char root[] = "A:\\";
204 *root += DOS_GET_DRIVE( DL_reg(context) );
205 if (!GetDiskFreeSpaceA( root, &cluster_sectors, §or_bytes,
206 &free_clusters, &total_clusters )) return 0;
207 SET_AX( context, cluster_sectors );
208 SET_BX( context, free_clusters );
209 SET_CX( context, sector_bytes );
210 SET_DX( context, total_clusters );
214 static int INT21_GetDriveAllocInfo( CONTEXT86 *context )
216 if (!INT21_GetFreeDiskSpace( context )) return 0;
217 if (!heap && !INT21_CreateHeap()) return 0;
218 heap->mediaID = 0xf0;
219 context->SegDs = DosHeapHandle;
220 SET_BX( context, (int)&heap->mediaID - (int)heap );
224 static int FillInDrivePB( int drive )
226 if(!DRIVE_IsValid(drive))
228 SetLastError( ERROR_INVALID_DRIVE );
231 else if (heap || INT21_CreateHeap())
233 /* FIXME: I have no idea what a lot of this information should
234 * say or whether it even really matters since we're not allowing
235 * direct block access. However, some programs seem to depend on
236 * getting at least _something_ back from here. The 'next' pointer
237 * does worry me, though. Should we have a complete table of
238 * separate DPBs per drive? Probably, but I'm lazy. :-) -CH
240 heap->dpb.drive_num = heap->dpb.unit_num = drive; /*The same?*/
241 heap->dpb.sector_size = 512;
242 heap->dpb.high_sector = 1;
243 heap->dpb.shift = drive < 2 ? 0 : 6; /*6 for HD, 0 for floppy*/
244 heap->dpb.reserved = 0;
245 heap->dpb.num_FAT = 1;
246 heap->dpb.dir_entries = 2;
247 heap->dpb.first_data = 2;
248 heap->dpb.high_cluster = 64000;
249 heap->dpb.sectors_in_FAT = 1;
250 heap->dpb.start_dir = 1;
251 heap->dpb.driver_head = 0;
252 heap->dpb.media_ID = (drive > 1) ? 0xF8 : 0xF0;
253 heap->dpb.access_flag = 0;
255 heap->dpb.free_search = 0;
256 heap->dpb.free_clusters = 0xFFFF; /* unknown */
263 static void GetDrivePB( CONTEXT86 *context, int drive )
265 if (FillInDrivePB( drive ))
267 SET_AL( context, 0x00 );
268 context->SegDs = SELECTOROF(dpbsegptr);
269 SET_BX( context, OFFSETOF(dpbsegptr) );
273 SET_AX( context, 0x00ff );
278 static BOOL ioctlGenericBlkDevReq( CONTEXT86 *context )
280 BYTE *dataptr = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
281 int drive = DOS_GET_DRIVE( BL_reg(context) );
283 if (!DRIVE_IsValid(drive))
285 SetLastError( ERROR_FILE_NOT_FOUND );
289 if (CH_reg(context) != 0x08)
291 INT_BARF( context, 0x21 );
295 switch (CL_reg(context))
297 case 0x60: /* get device parameters */
298 /* used by w4wgrp's winfile */
299 memset(dataptr, 0, 0x20); /* DOS 6.22 uses 0x20 bytes */
301 dataptr[6] = 0; /* media type */
304 dataptr[1] = 0x05; /* fixed disk */
305 setword(&dataptr[2], 0x01); /* non removable */
306 setword(&dataptr[4], 0x300); /* # of cylinders */
310 dataptr[1] = 0x07; /* block dev, floppy */
311 setword(&dataptr[2], 0x02); /* removable */
312 setword(&dataptr[4], 80); /* # of cylinders */
314 CreateBPB(drive, &dataptr[7], TRUE);
315 RESET_CFLAG(context);
318 case 0x66:/* get disk serial number */
320 char label[12],fsname[9],path[4];
323 strcpy(path,"x:\\");path[0]=drive+'A';
324 GetVolumeInformationA(
325 path,label,12,&serial,NULL,NULL,fsname,9
328 memcpy(dataptr+2,&serial,4);
329 memcpy(dataptr+6,label ,11);
330 memcpy(dataptr+17,fsname,8);
335 memset(dataptr+1, '\0', dataptr[0]-1);
336 dataptr[1] = dataptr[0];
337 dataptr[2] = 0x07; /* protected mode driver; no eject; no notification */
338 dataptr[3] = 0xFF; /* no physical drive */
342 /* Trail on error implementation */
343 SET_AX( context, GetDriveType16(BL_reg(context)) == DRIVE_UNKNOWN ? 0x0f : 0x01 );
344 SET_CFLAG(context); /* Seems to be set all the time */
348 INT_BARF( context, 0x21 );
353 static void INT21_ParseFileNameIntoFCB( CONTEXT86 *context )
356 CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Esi );
358 CTX_SEG_OFF_TO_LIN(context, context->SegEs, context->Edi );
364 SET_AL( context, 0xff ); /* failed */
366 TRACE("filename: '%s'\n", filename);
372 if ((*s != ' ') && (*s != '\r') && (*s != '\n'))
381 buffer_len = MultiByteToWideChar(CP_OEMCP, 0, filename, len, NULL, 0);
382 buffer = HeapAlloc( GetProcessHeap(), 0, (buffer_len + 1) * sizeof(WCHAR));
383 len = MultiByteToWideChar(CP_OEMCP, 0, filename, len, buffer, buffer_len);
385 DOSFS_ToDosFCBFormat(buffer, fcbW);
386 HeapFree(GetProcessHeap(), 0, buffer);
387 WideCharToMultiByte(CP_OEMCP, 0, fcbW, 12, fcb + 1, 12, NULL, NULL);
389 TRACE("FCB: '%s'\n", fcb + 1);
391 SET_AL( context, ((strchr(filename, '*')) || (strchr(filename, '$'))) != 0 );
393 /* point DS:SI to first unparsed character */
394 SET_SI( context, context->Esi + (int)s - (int)filename );
398 /* Many calls translate a drive argument like this:
399 drive number (00h = default, 01h = A:, etc)
401 static char drivestring[]="default";
403 char *INT21_DriveName(int drive)
408 drivestring[0]= (unsigned char)drive + '@';
414 static BOOL INT21_CreateFile( CONTEXT86 *context )
416 SET_AX( context, _lcreat16( CTX_SEG_OFF_TO_LIN(context, context->SegDs,
417 context->Edx ), CX_reg(context) ) );
418 return (AX_reg(context) == (WORD)HFILE_ERROR16);
421 static HFILE16 _lcreat16_uniq( LPCSTR path, INT attr )
423 /* Mask off all flags not explicitly allowed by the doc */
424 attr &= FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM;
425 return Win32HandleToDosFileHandle( CreateFileA( path, GENERIC_READ | GENERIC_WRITE,
426 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
427 CREATE_NEW, attr, 0 ));
430 static void OpenExistingFile( CONTEXT86 *context )
432 SET_AX( context, _lopen16( CTX_SEG_OFF_TO_LIN(context, context->SegDs,context->Edx),
434 if (AX_reg(context) == (WORD)HFILE_ERROR16)
436 SET_AX( context, GetLastError() );
441 static BOOL INT21_ExtendedOpenCreateFile(CONTEXT86 *context )
443 BOOL bExtendedError = FALSE;
444 BYTE action = DL_reg(context);
446 /* Shuffle arguments to call OpenExistingFile */
447 SET_AL( context, BL_reg(context) );
448 SET_DX( context, SI_reg(context) );
449 /* BX,CX and DX should be preserved */
450 OpenExistingFile(context);
452 if ((context->EFlags & 0x0001) == 0) /* File exists */
454 UINT16 uReturnCX = 0;
456 /* Now decide what do do */
458 if ((action & 0x07) == 0)
460 _lclose16( AX_reg(context) );
461 SET_AX( context, 0x0050 ); /*File exists*/
463 WARN("extended open/create: failed because file exists \n");
465 else if ((action & 0x07) == 2)
467 /* Truncate it, but first check if opened for write */
468 if ((BL_reg(context) & 0x0007)== 0)
470 _lclose16( AX_reg(context) );
471 WARN("extended open/create: failed, trunc on ro file\n");
472 SET_AX( context, 0x000C ); /*Access code invalid*/
477 TRACE("extended open/create: Closing before truncate\n");
478 if (_lclose16( AX_reg(context) ))
480 WARN("extended open/create: close before trunc failed\n");
481 SET_AX( context, 0x0019 ); /*Seek Error*/
482 SET_CX( context, 0 );
485 /* Shuffle arguments to call CreateFile */
487 TRACE("extended open/create: Truncating\n");
488 SET_AL( context, BL_reg(context) );
489 /* CX is still the same */
490 SET_DX( context, SI_reg(context) );
491 bExtendedError = INT21_CreateFile(context);
493 if (context->EFlags & 0x0001) /*no file open, flags set */
495 WARN("extended open/create: trunc failed\n");
496 return bExtendedError;
501 else uReturnCX = 0x1;
503 SET_CX( context, uReturnCX );
505 else /* file does not exist */
507 RESET_CFLAG(context); /* was set by OpenExistingFile(context) */
508 if ((action & 0xF0)== 0)
510 SET_CX( context, 0 );
512 WARN("extended open/create: failed, file dosen't exist\n");
516 /* Shuffle arguments to call CreateFile */
517 TRACE("extended open/create: Creating\n");
518 SET_AL( context, BL_reg(context) );
519 /* CX should still be the same */
520 SET_DX( context, SI_reg(context) );
521 bExtendedError = INT21_CreateFile(context);
522 if (context->EFlags & 0x0001) /*no file open, flags set */
524 WARN("extended open/create: create failed\n");
525 return bExtendedError;
527 SET_CX( context, 2 );
531 return bExtendedError;
535 static int INT21_FindFirst( CONTEXT86 *context )
539 DOS_FULL_NAME full_name;
540 FINDFILE_DTA *dta = (FINDFILE_DTA *)GetCurrentDTA(context);
541 WCHAR pathW[MAX_PATH];
544 path = (const char *)CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
545 MultiByteToWideChar(CP_OEMCP, 0, path, -1, pathW, MAX_PATH);
547 dta->unixPath = NULL;
548 if (!DOSFS_GetFullName( pathW, FALSE, &full_name ))
550 SET_AX( context, GetLastError() );
554 dta->unixPath = HeapAlloc( GetProcessHeap(), 0, strlen(full_name.long_name)+1 );
555 strcpy( dta->unixPath, full_name.long_name );
556 p = strrchr( dta->unixPath, '/' );
559 MultiByteToWideChar(CP_OEMCP, 0, p + 1, -1, pathW, MAX_PATH);
561 /* Note: terminating NULL in dta->mask overwrites dta->search_attr
562 * (doesn't matter as it is set below anyway)
564 if (!DOSFS_ToDosFCBFormat( pathW, maskW ))
566 HeapFree( GetProcessHeap(), 0, dta->unixPath );
567 dta->unixPath = NULL;
568 SetLastError( ERROR_FILE_NOT_FOUND );
569 SET_AX( context, ERROR_FILE_NOT_FOUND );
573 WideCharToMultiByte(CP_OEMCP, 0, maskW, 12, dta->mask, sizeof(dta->mask), NULL, NULL);
574 dta->drive = (path[0] && (path[1] == ':')) ? toupper(path[0]) - 'A'
575 : DRIVE_GetCurrentDrive();
577 dta->search_attr = CL_reg(context);
582 static int INT21_FindNext( CONTEXT86 *context )
584 FINDFILE_DTA *dta = (FINDFILE_DTA *)GetCurrentDTA(context);
585 WIN32_FIND_DATAA entry;
588 if (!dta->unixPath) return 0;
589 if (!(count = DOSFS_FindNext( dta->unixPath, dta->mask, NULL, dta->drive,
590 dta->search_attr, dta->count, &entry )))
592 HeapFree( GetProcessHeap(), 0, dta->unixPath );
593 dta->unixPath = NULL;
596 if ((int)dta->count + count > 0xffff)
598 WARN("Too many directory entries in %s\n", dta->unixPath );
599 HeapFree( GetProcessHeap(), 0, dta->unixPath );
600 dta->unixPath = NULL;
604 dta->fileattr = entry.dwFileAttributes;
605 dta->filesize = entry.nFileSizeLow;
606 FileTimeToDosDateTime( &entry.ftLastWriteTime,
607 &dta->filedate, &dta->filetime );
608 strcpy( dta->filename, entry.cAlternateFileName );
609 if (!memchr(dta->mask,'?',11)) {
610 /* wildcardless search, release resources in case no findnext will
611 * be issued, and as a workaround in case file creation messes up
612 * findnext, as sometimes happens with pkunzip */
613 HeapFree( GetProcessHeap(), 0, dta->unixPath );
614 dta->unixPath = NULL;
620 static BOOL INT21_CreateTempFile( CONTEXT86 *context )
622 static int counter = 0;
623 char *name = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx );
624 char *p = name + strlen(name);
626 /* despite what Ralf Brown says, some programs seem to call without
627 * ending backslash (DOS accepts that, so we accept it too) */
628 if ((p == name) || (p[-1] != '\\')) *p++ = '\\';
632 sprintf( p, "wine%04x.%03d", (int)getpid(), counter );
633 counter = (counter + 1) % 1000;
635 SET_AX( context, _lcreat16_uniq( name, 0 ) );
636 if (AX_reg(context) != HFILE_ERROR16)
638 TRACE("created %s\n", name );
641 if (GetLastError() != ERROR_FILE_EXISTS) return FALSE;
646 static int INT21_GetDiskSerialNumber( CONTEXT86 *context )
648 BYTE *dataptr = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
649 int drive = DOS_GET_DRIVE( BL_reg(context) );
651 if (!DRIVE_IsValid(drive))
653 SetLastError( ERROR_INVALID_DRIVE );
657 *(WORD *)dataptr = 0;
658 *(DWORD *)(dataptr + 2) = DRIVE_GetSerialNumber( drive );
659 memcpy( dataptr + 6, DRIVE_GetLabel( drive ), 11 );
660 strncpy(dataptr + 0x11, "FAT16 ", 8);
665 static int INT21_SetDiskSerialNumber( CONTEXT86 *context )
667 BYTE *dataptr = CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
668 int drive = DOS_GET_DRIVE( BL_reg(context) );
670 if (!DRIVE_IsValid(drive))
672 SetLastError( ERROR_INVALID_DRIVE );
676 DRIVE_SetSerialNumber( drive, *(DWORD *)(dataptr + 2) );
681 /* microsoft's programmers should be shot for using CP/M style int21
682 calls in Windows for Workgroup's winfile.exe */
684 static int INT21_FindFirstFCB( CONTEXT86 *context )
686 BYTE *fcb = (BYTE *)CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
691 if (*fcb == 0xff) pFCB = (FINDFILE_FCB *)(fcb + 7);
692 else pFCB = (FINDFILE_FCB *)fcb;
693 drive = DOS_GET_DRIVE( pFCB->drive );
694 if (!DRIVE_IsValid( drive )) return 0;
695 root = DRIVE_GetRoot( drive );
696 cwd = DRIVE_GetUnixCwd( drive );
697 pFCB->unixPath = HeapAlloc( GetProcessHeap(), 0,
698 strlen(root)+strlen(cwd)+2 );
699 if (!pFCB->unixPath) return 0;
700 strcpy( pFCB->unixPath, root );
701 strcat( pFCB->unixPath, "/" );
702 strcat( pFCB->unixPath, cwd );
708 static int INT21_FindNextFCB( CONTEXT86 *context )
710 BYTE *fcb = (BYTE *)CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx);
712 DOS_DIRENTRY_LAYOUT *pResult = (DOS_DIRENTRY_LAYOUT *)GetCurrentDTA(context);
713 WIN32_FIND_DATAA entry;
717 if (*fcb == 0xff) /* extended FCB ? */
720 pFCB = (FINDFILE_FCB *)(fcb + 7);
725 pFCB = (FINDFILE_FCB *)fcb;
728 if (!pFCB->unixPath) return 0;
729 if (!(count = DOSFS_FindNext( pFCB->unixPath, pFCB->filename, NULL,
730 DOS_GET_DRIVE( pFCB->drive ), attr,
731 pFCB->count, &entry )))
733 HeapFree( GetProcessHeap(), 0, pFCB->unixPath );
734 pFCB->unixPath = NULL;
737 pFCB->count += count;
739 if (*fcb == 0xff) { /* place extended FCB header before pResult if called with extended FCB */
740 *(BYTE *)pResult = 0xff;
741 (BYTE *)pResult +=6; /* leave reserved field behind */
742 *(BYTE *)pResult = entry.dwFileAttributes;
745 *(BYTE *)pResult = DOS_GET_DRIVE( pFCB->drive ); /* DOS_DIRENTRY_LAYOUT after current drive number */
747 pResult->fileattr = entry.dwFileAttributes;
748 pResult->cluster = 0; /* what else? */
749 pResult->filesize = entry.nFileSizeLow;
750 memset( pResult->reserved, 0, sizeof(pResult->reserved) );
751 FileTimeToDosDateTime( &entry.ftLastWriteTime,
752 &pResult->filedate, &pResult->filetime );
754 /* Convert file name to FCB format */
756 memset( pResult->filename, ' ', sizeof(pResult->filename) );
757 if (!strcmp( entry.cAlternateFileName, "." )) pResult->filename[0] = '.';
758 else if (!strcmp( entry.cAlternateFileName, ".." ))
759 pResult->filename[0] = pResult->filename[1] = '.';
762 char *p = strrchr( entry.cAlternateFileName, '.' );
763 if (p && p[1] && (p != entry.cAlternateFileName))
765 memcpy( pResult->filename, entry.cAlternateFileName,
766 min( (p - entry.cAlternateFileName), 8 ) );
767 memcpy( pResult->filename + 8, p + 1, min( strlen(p), 3 ) );
770 memcpy( pResult->filename, entry.cAlternateFileName,
771 min( strlen(entry.cAlternateFileName), 8 ) );
778 INT21_networkfunc (CONTEXT86 *context)
780 switch (AL_reg(context)) {
781 case 0x00: /* Get machine name. */
783 char *dst = CTX_SEG_OFF_TO_LIN (context,context->SegDs,context->Edx);
784 TRACE("getting machine name to %p\n", dst);
785 if (gethostname (dst, 15))
788 SetLastError( ER_NoNetwork );
791 int len = strlen (dst);
795 SET_CH( context, 1 ); /* Valid */
796 SET_CL( context, 1 ); /* NETbios number??? */
797 TRACE("returning %s\n", debugstr_an (dst, 16));
803 SetLastError( ER_NoNetwork );
809 /***********************************************************************
812 void WINAPI INT_Int21Handler( CONTEXT86 *context )
814 BOOL bSetDOSExtendedError = FALSE;
816 switch(AH_reg(context))
818 case 0x11: /* FIND FIRST MATCHING FILE USING FCB */
819 TRACE("FIND FIRST MATCHING FILE USING FCB %p\n",
820 CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx));
821 if (!INT21_FindFirstFCB(context))
823 SET_AL( context, 0xff );
826 /* else fall through */
828 case 0x12: /* FIND NEXT MATCHING FILE USING FCB */
829 SET_AL( context, INT21_FindNextFCB(context) ? 0x00 : 0xff );
832 case 0x1b: /* GET ALLOCATION INFORMATION FOR DEFAULT DRIVE */
833 SET_DL( context, 0 );
834 if (!INT21_GetDriveAllocInfo(context)) SET_AX( context, 0xffff );
837 case 0x1c: /* GET ALLOCATION INFORMATION FOR SPECIFIC DRIVE */
838 if (!INT21_GetDriveAllocInfo(context)) SET_AX( context, 0xffff );
841 case 0x1f: /* GET DRIVE PARAMETER BLOCK FOR DEFAULT DRIVE */
842 GetDrivePB(context, DRIVE_GetCurrentDrive());
845 case 0x29: /* PARSE FILENAME INTO FCB */
846 INT21_ParseFileNameIntoFCB(context);
849 case 0x32: /* GET DOS DRIVE PARAMETER BLOCK FOR SPECIFIC DRIVE */
850 TRACE("GET DOS DRIVE PARAMETER BLOCK FOR DRIVE %s\n",
851 INT21_DriveName( DL_reg(context)));
852 GetDrivePB(context, DOS_GET_DRIVE( DL_reg(context) ) );
855 case 0x36: /* GET FREE DISK SPACE */
856 TRACE("GET FREE DISK SPACE FOR DRIVE %s\n",
857 INT21_DriveName( DL_reg(context)));
858 if (!INT21_GetFreeDiskSpace(context)) SET_AX( context, 0xffff );
861 case 0x3c: /* "CREAT" - CREATE OR TRUNCATE FILE */
862 TRACE("CREAT flag 0x%02x %s\n",CX_reg(context),
863 (LPCSTR)CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx));
864 bSetDOSExtendedError = INT21_CreateFile( context );
867 case 0x3d: /* "OPEN" - OPEN EXISTING FILE */
868 TRACE("OPEN mode 0x%02x %s\n",AL_reg(context),
869 (LPCSTR)CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx));
870 OpenExistingFile(context);
873 case 0x44: /* IOCTL */
874 switch (AL_reg(context))
877 TRACE("IOCTL - GENERIC BLOCK DEVICE REQUEST %s\n",
878 INT21_DriveName( BL_reg(context)));
879 bSetDOSExtendedError = ioctlGenericBlkDevReq(context);
882 case 0x0F: /* Set logical drive mapping */
885 TRACE("IOCTL - SET LOGICAL DRIVE MAP for drive %s\n",
886 INT21_DriveName( BL_reg(context)));
887 drive = DOS_GET_DRIVE ( BL_reg(context) );
888 if ( ! DRIVE_SetLogicalMapping ( drive, drive+1 ) )
891 SET_AX( context, 0x000F ); /* invalid drive */
898 case 0x4e: /* "FINDFIRST" - FIND FIRST MATCHING FILE */
899 TRACE("FINDFIRST mask 0x%04x spec %s\n",CX_reg(context),
900 (LPCSTR)CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx));
901 if (!INT21_FindFirst(context)) break;
904 case 0x4f: /* "FINDNEXT" - FIND NEXT MATCHING FILE */
906 if (!INT21_FindNext(context))
908 SetLastError( ERROR_NO_MORE_FILES );
909 SET_AX( context, ERROR_NO_MORE_FILES );
912 else SET_AX( context, 0 ); /* OK */
915 case 0x5a: /* CREATE TEMPORARY FILE */
916 TRACE("CREATE TEMPORARY FILE\n");
917 bSetDOSExtendedError = !INT21_CreateTempFile(context);
920 case 0x5b: /* CREATE NEW FILE */
921 TRACE("CREATE NEW FILE 0x%02x for %s\n", CX_reg(context),
922 (LPCSTR)CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edx));
924 _lcreat16_uniq( CTX_SEG_OFF_TO_LIN(context, context->SegDs,context->Edx),
926 bSetDOSExtendedError = (AX_reg(context) != 0);
930 bSetDOSExtendedError = INT21_networkfunc (context);
933 case 0x5f: /* NETWORK */
934 switch (AL_reg(context))
936 case 0x07: /* ENABLE DRIVE */
937 TRACE("ENABLE DRIVE %c:\n",(DL_reg(context)+'A'));
938 if (!DRIVE_Enable( DL_reg(context) ))
940 SetLastError( ERROR_INVALID_DRIVE );
941 bSetDOSExtendedError = TRUE;
945 case 0x08: /* DISABLE DRIVE */
946 TRACE("DISABLE DRIVE %c:\n",(DL_reg(context)+'A'));
947 if (!DRIVE_Disable( DL_reg(context) ))
949 SetLastError( ERROR_INVALID_DRIVE );
950 bSetDOSExtendedError = TRUE;
955 /* network software not installed */
956 TRACE("NETWORK function AX=%04x not implemented\n",AX_reg(context));
957 SetLastError( ER_NoNetwork );
958 bSetDOSExtendedError = TRUE;
963 case 0x60: /* "TRUENAME" - CANONICALIZE FILENAME OR PATH */
964 TRACE("TRUENAME %s\n",
965 (LPCSTR)CTX_SEG_OFF_TO_LIN(context, context->SegDs,context->Esi));
967 if (!GetFullPathNameA( CTX_SEG_OFF_TO_LIN(context, context->SegDs,
969 CTX_SEG_OFF_TO_LIN(context, context->SegEs,
971 bSetDOSExtendedError = TRUE;
972 else SET_AX( context, 0 );
976 case 0x69: /* DISK SERIAL NUMBER */
977 switch (AL_reg(context))
980 TRACE("GET DISK SERIAL NUMBER for drive %s\n",
981 INT21_DriveName(BL_reg(context)));
982 if (!INT21_GetDiskSerialNumber(context)) bSetDOSExtendedError = TRUE;
983 else SET_AX( context, 0 );
987 TRACE("SET DISK SERIAL NUMBER for drive %s\n",
988 INT21_DriveName(BL_reg(context)));
989 if (!INT21_SetDiskSerialNumber(context)) bSetDOSExtendedError = TRUE;
990 else SET_AX( context, 1 );
995 case 0x6C: /* Extended Open/Create*/
996 TRACE("EXTENDED OPEN/CREATE %s\n",
997 (LPCSTR)CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Edi));
998 bSetDOSExtendedError = INT21_ExtendedOpenCreateFile(context);
1001 case 0x71: /* MS-DOS 7 (Windows95) - LONG FILENAME FUNCTIONS */
1002 switch(AL_reg(context))
1004 case 0x4e: /* Find first file */
1005 TRACE(" LONG FILENAME - FIND FIRST MATCHING FILE for %s\n",
1006 (LPCSTR)CTX_SEG_OFF_TO_LIN(context, context->SegDs,context->Edx));
1007 /* FIXME: use attributes in CX */
1008 SET_AX( context, FindFirstFile16(
1009 CTX_SEG_OFF_TO_LIN(context, context->SegDs,context->Edx),
1010 (WIN32_FIND_DATAA *)CTX_SEG_OFF_TO_LIN(context, context->SegEs,
1012 if (AX_reg(context) == INVALID_HANDLE_VALUE16)
1013 bSetDOSExtendedError = TRUE;
1015 case 0x4f: /* Find next file */
1016 TRACE("LONG FILENAME - FIND NEXT MATCHING FILE for handle %d\n",
1018 if (!FindNextFile16( BX_reg(context),
1019 (WIN32_FIND_DATAA *)CTX_SEG_OFF_TO_LIN(context, context->SegEs,
1021 bSetDOSExtendedError = TRUE;
1025 LPCSTR driveroot = (LPCSTR)CTX_SEG_OFF_TO_LIN(context, context->SegDs,context->Edx);
1026 LPSTR buffer = (LPSTR)CTX_SEG_OFF_TO_LIN(context, context->SegEs,context->Edi);
1027 DWORD filename_len, flags;
1029 TRACE("LONG FILENAME - GET VOLUME INFORMATION for drive having root dir '%s'.\n", driveroot);
1030 SET_AX( context, 0 );
1031 if (!GetVolumeInformationA( driveroot, NULL, 0, NULL, &filename_len,
1032 &flags, buffer, 8 ))
1034 INT_BARF( context, 0x21 );
1038 SET_BX( context, flags | 0x4000 ); /* support for LFN functions */
1039 SET_CX( context, filename_len );
1040 SET_DX( context, MAX_PATH ); /* FIXME: which len if DRIVE_SHORT_NAMES ? */
1043 case 0xa1: /* Find close */
1044 TRACE("LONG FILENAME - FINDCLOSE for handle %d\n",
1046 bSetDOSExtendedError = (!FindClose16( BX_reg(context) ));
1049 switch(CL_reg(context))
1051 case 0x01: /* Get short filename or path */
1052 if (!GetShortPathNameA
1053 ( CTX_SEG_OFF_TO_LIN(context, context->SegDs,
1055 CTX_SEG_OFF_TO_LIN(context, context->SegEs,
1057 bSetDOSExtendedError = TRUE;
1058 else SET_AX( context, 0 );
1060 case 0x02: /* Get canonical long filename or path */
1061 if (!GetFullPathNameA
1062 ( CTX_SEG_OFF_TO_LIN(context, context->SegDs,
1064 CTX_SEG_OFF_TO_LIN(context, context->SegEs,
1065 context->Edi),NULL))
1066 bSetDOSExtendedError = TRUE;
1067 else SET_AX( context, 0 );
1070 FIXME("Unimplemented long file name function:\n");
1071 INT_BARF( context, 0x21 );
1073 SET_AL( context, 0 );
1077 case 0x6c: /* Create or open file */
1078 TRACE("LONG FILENAME - CREATE OR OPEN FILE %s\n",
1079 (LPCSTR)CTX_SEG_OFF_TO_LIN(context, context->SegDs, context->Esi));
1080 /* translate Dos 7 action to Dos 6 action */
1081 bSetDOSExtendedError = INT21_ExtendedOpenCreateFile(context);
1085 FIXME("Unimplemented long file name function:\n");
1086 INT_BARF( context, 0x21 );
1088 SET_AL( context, 0 );
1094 case 0x73: /* MULTIPLEXED: Win95 OSR2/Win98 FAT32 calls */
1095 TRACE("windows95 function AX %04x\n",
1098 switch (AL_reg(context))
1100 case 0x02: /* Get Extended Drive Parameter Block for specific drive */
1101 /* ES:DI points to word with length of data (should be 0x3d) */
1105 DWORD cluster_sectors, sector_bytes, free_clusters, total_clusters;
1106 char root[] = "A:\\";
1108 buffer = (WORD *)CTX_SEG_OFF_TO_LIN(context, context->SegEs, context->Edi);
1110 TRACE("Get Extended DPB: linear buffer address is %p\n", buffer);
1112 /* validate passed-in buffer lengths */
1113 if ((*buffer != 0x3d) || (context->Ecx != 0x3f))
1115 WARN("Get Extended DPB: buffer lengths incorrect\n");
1116 WARN("CX = %lx, buffer[0] = %x\n", context->Ecx, *buffer);
1118 SET_AL( context, 0x18 ); /* bad buffer length */
1121 /* buffer checks out */
1122 buffer++; /* skip over length word now */
1123 if (FillInDrivePB( DX_reg(context) ) )
1125 edpb = (struct EDPB *)buffer;
1127 /* copy down the old-style DPB portion first */
1128 memcpy(&edpb->dpb, &heap->dpb, sizeof(struct DPB));
1130 /* now fill in the extended entries */
1131 edpb->edpb_flags = 0;
1132 edpb->next_edpb = 0;
1133 edpb->free_cluster = edpb->free_cluster2 = 0;
1135 /* determine free disk space */
1136 *root += DOS_GET_DRIVE( DX_reg(context) );
1137 GetDiskFreeSpaceA( root, &cluster_sectors, §or_bytes,
1138 &free_clusters, &total_clusters );
1140 edpb->clusters_free = (free_clusters&0xffff);
1142 edpb->clusters_free_hi = free_clusters >> 16;
1143 edpb->mirroring_flags = 0;
1144 edpb->info_sector = 0xffff;
1145 edpb->spare_boot_sector = 0xffff;
1146 edpb->first_cluster = 0;
1147 edpb->max_cluster = total_clusters;
1148 edpb->fat_clusters = 32; /* made-up value */
1149 edpb->root_cluster = 0;
1151 RESET_CFLAG(context); /* clear carry */
1152 SET_AX( context, 0 );
1156 SET_AX( context, 0x00ff );
1162 case 0x03: /* Get Extended free space on drive */
1163 case 0x04: /* Set DPB for formatting */
1164 case 0x05: /* extended absolute disk read/write */
1165 FIXME("Unimplemented FAT32 int32 function %04x\n", AX_reg(context));
1167 SET_AL( context, 0 );
1174 INT_BARF( context, 0x21 );
1177 } /* END OF SWITCH */
1179 if( bSetDOSExtendedError ) /* set general error condition */
1181 SET_AX( context, GetLastError() );