|
|
PAGE ,132 TITLE DXMAIN.ASM -- Main Module for Dos Extender
; Copyright (c) Microsoft Corporation 1988-1991. All Rights Reserved.
;****************************************************************;* *;* DXMAIN.ASM - Dos Extender Main Module *;* *;****************************************************************;* *;* Module Description: *;* *;* This module contains the main routines for the Dos *;* Extender. This is based on code written for Microsoft *;* by Murray Sargent of Scroll Systems from Tucson Arizona. *;* *;* The Dos Extender provides support to allows specially *;* written programs to run in protected mode mode on the *;* 80286 and 80386 under MS-DOS. The following areas of *;* support are provided to accomplish this: *;* *;* Program Loading and Initialization *;* This involves creating a program segment prefix and *;* then loading and relocating the exe file. When *;* loading an exe for protected mode operation, it is *;* necessary to create segment descriptors for all *;* segments used by the program and to then substitute *;* the corresponding selectors when fixing up the segment *;* references in the code. *;* *;* Dos Function Call Support *;* Since Dos must execute in real mode, it is necessary *;* to perform mode switching into real mode and the back *;* to protected mode when the application makes Dos calls. *;* Also, any far pointers that are parameters to the *;* function must be converted from the selector:offset *;* form that the application uses to a segment:offset form *;* that Dos can use, with the corresponding data being *;* buffered from the application's extended memory address *;* space to Dos's real mode address space. *;* *;* Other Interrupt Support *;* Hardware interrupts are processed in real mode, and *;* so the Dos Extender performs mode switching on each *;* interrupt. Also other system resources (such as the *;* mouse driver and the bios) are entered through software *;* interrupts, and require the same kind of buffering *;* and parameter translation that the Dos functions *;* require. *;* *;* Extended Memory Management *;* The protected mode application has access to the full *;* address space of the machine, and a memory manager is *;* provided that duplicates the functions of the Dos *;* memory manager over the entire address space of the *;* machine. *;* *;****************************************************************;* Revision History: *;* *;* 08/08/90 earleh DOSX and Client privilege ring determined *;* by equate in pmdefs.inc *;* 03/23/90 davidw Added the reflecting of it 23h, ^C. *;* 11/09/89 jimmat Added more IOCTL 0Dh support for Windows. *;* 10/11/89 jimmat Changed hooking of Int 1,2,3 under a *;* debugger to work better with CVW. *;* 07/28/89 jimmat Fixed Int 21h/56h (Rename), fixed Int 21 *;* calls that just returned a pointer. *;* 06/07/89 jimmat Fixed length of FCB moves and special *;* case hooking Int 1Eh. *;* 05/30/89 jimmat Completed Int 21h/5Ah processing. *;* 04/25/89 jimmat Added support for undocumented INT 21h *;* 5Fh/05 DOS call. *;* 04/12/89 jimmat Allow one level of nested DOS calls to *;* support PM critical error handlers *;* 04/10/89 jimmat Supported INT 21h/5Eh & 5Fh--also small *;* clean-up of the dosentry/dosexit code. *;* 04/05/89 jimmat Fixed MOVDAT FCB length check. *;* 04/04/89 jimmat Stop reflecting real mode software ints *;* to protect mode. This is how Windows/386 *;* works, and it fixes a problem with DOS *;* networks since the real mode redirector *;* expects to have access to the DOS stack, *;* not a DOS extender interrupt stack frame. *;* 03/28/89 jimmat Incorporated bug fixes from GeneA *;* 03/17/89 jimmat Some code clean-up and debugging checks *;* 03/15/89 jimmat Minor changes to run child in ring 1 *;* 02/22/89 (GeneA): removed dead code and data left over *;* from the Murray Sargent/SST days. *;* 02/22/89 (GeneA): moved handlers for all interrupts but *;* Int 21h to DXINTR.ASM. Fixed problem with re-entrancy *;* caused when the other interrupts were executed while *;* in DOS. (int 15h was causing the specific problem). *;* 02/14/89 (GeneA): fixed bug in IntExitMisc. Was storing *;* return value in rmrg.xes, changed to pmrg.xes. *;* 02/10/89 (GeneA): changed Dos Extender from small model to *;* medium model. *;* 12/01/88 (GeneA): Changed name of mentry and mexit to *;* IntEntryMouse and IntExitMouse. Added functions *;* IntEntryMisc and IntExitMisc to handle entry and *;* exit processing for BIOS INT 15h. *;* 11/20/88 (GeneA): modified DFSetVector so that is checks to *;* see if a vector has already been hooked before saving *;* the old value in the real mode interrupt vector shadow *;* buffer. *;* 09/15/88 (GeneA): created by extracting code from the *;* SST debugger modules DOSXTND.ASM, VIRTMD.ASM, *;* VRTUTIL.ASM, and INTERRPT.ASM *;* *;****************************************************************
.286p .287
; -------------------------------------------------------; INCLUDE FILE DEFINITIONS; -------------------------------------------------------
.xlist .sallinclude segdefs.incinclude gendefs.incinclude pmdefs.incinclude intmac.incinclude bop.incinclude dpmi.incinclude hostdata.inc .list
; -------------------------------------------------------; GENERAL SYMBOL DEFINITIONS; -------------------------------------------------------
; STKSTR -- stack layout structure for user registers in the pmrg and; rmrg arrays in the data segment DXDATA. pmrg is an exact replica of the pm; user registers on entry to the Dos Extender (DE). rmrg is a translated; version used to communicate with the real-mode world. The rmrg array is; initially set equal to the pm user values by the instructions push ds, push; es, pusha. The pmrg array es and ds are inevitably set equal to the pm user; values and its general register values are defined if data translations may be; required (int-10/21).
stkstr struc ;Level-0 Stack structure. bp is set = sp herexdi dw ?xsi dw ?xbp dw ?xasp dw ? ;Alternate spxbx dw ?xdx dw ?xcx dw ?xax dw ? ;pusha pushes xax to xdixes dw ?xds dw ?stkstr ends
; -------------------------------------------------------; This structure describes the EXEC parameter block used; by MS-DOS function 4Bh.
execblk struc ;INT-21 ah=4bh EXEC parameter blockevrnmt dw ? ;Paragraph of environment string to be passedcmdptr dd ? ;Ptr to command line to be placed at PSP+80hfcb1ptr dd ? ;Ptr to default FCB to be passed at PSP+5chfcb2ptr dd ? ;Ptr to default FCB to be passed at PSP+6chxsssp dd ? ;Initial program stack ss:spxcsip dd ? ;Program entry point cs:ipexecblk ends
; -------------------------------------------------------; EXTERNAL SYMBOL DEFINITIONS; -------------------------------------------------------
extrn gtpara:NEAR extrn GetSegmentAddress:NEAR extrn EnterRealMode:NEAR extrn EnterProtectedMode:NEAR extrn SelOff2SegOff:NEAR extrn ParaToLDTSelector:NEAR extrn NSetSegmentDscr:FAR extrn ChildTerminationHandler:NEAR
; -------------------------------------------------------; DATA SEGMENT DEFINITIONS; -------------------------------------------------------
DXDATA segment
extrn selGDT:WORD extrn segPSPChild:WORD extrn npXfrBuf1:WORD extrn rgbXfrBuf0:BYTEIFDEF WOW_x86 extrn FastBop:FWORDENDIF
extrn segDXCode:word extrn segCurrentHostData:word; -------------------------------------------------------; General DOS EXTENDER Variables; -------------------------------------------------------
pmdta dw 2 dup(?) ;PM DTA. Used for getting dir info
EntryFlag db -1 ;Flag to check for nested DOS interrupts
rcount dw ? ;Remaining requested file byte count to read/writeccount dw ? ;Current count of total read/written
;=======================================================================;Keep from here thru Iend in the following order:
align 2Ibegin label byte ;start of PMIntrDos nested 'Instance' data
dw 128 dup(?) ;Extra stack for real mode
rmrg stkstr <> ;Corresponding real-mode setrmivip dw ? ;Real-mode interrupt-vector offsetrmivcs dw ? ;Real-mode interrupt-vector segmentrmivfl dw ? ;Real-mode interrupt flags to be usedrmroff dw ? ;Real-mode return address offsetrmrseg dw ? ;Real-mode return address segmentrmflags dw ? ;flags
pmrg stkstr <> ;Protected-mode user registers
public pmusrss, pmusrsp
pmusrsp dw ? ;PM user sppmusrss dw ? ;PM user ss
enxseg dw ? ;transfer segment used on dos function exit
Iend label byte ;end of PMIntrDos nested 'Instance' data;=======================================================================
ILENGTH equ Iend - Ibegin ;length of instance data
Isave db ILENGTH dup (?) ;instance data save area
DXDATA ends
; -------------------------------------------------------; CODE SEGMENT VARIABLES; -------------------------------------------------------
DXCODE segment
extrn segDXData:WORD extrn selDgroup:WORD
DXCODE ends
DXPMCODE segment
extrn selDgroupPM:WORD extrn segDXCodePM:WORD extrn segDXDataPM:WORD
; -------------------------------------------------------; Dos Function Parameter Tables; -------------------------------------------------------
; The Dos Extender provides parameter buffering and translation; on entry to and exit from Dos system calls. The following table; is used to describe the operations to be performed for this process.; The basic idea is that there is an entry parameter code and an; exit paramter code. This code describes whether any data buffering; is necessary. If buffering is necessary, it describes the nature of; the data being transferred (e.g. ASCIIZ string, FCB, etc.) which is; used to determine the transfer length. The entry/exit code also; describes which temporary buffer to use for the transfer, and which; user register (e.g. DS:DX, ES:BX, etc) points to the data to transfer.;; The data transfers described by this table is sufficient to handle; the majority of the Dos system calls. However, any Dos call which; requires the transfer of more than one buffer of data, or which requires; that additional processing be performed other than simply copying a; buffer is handled with special case code.
; The following symbols define various parts of the entry/exit codes; used in the parameter table.
; Nibble 0 of a transfer word is a code that specifies the length of the; transfer as follows:
; 0 no xfer; 1 FCB to/from (f,10,11,12,13,16,17,23,24,29; 2 PTR$ from (1b,1c,34); 3 ASCZ to/from (39,3a,3b,3c,3d,41,43,4b,4e,56; 5a,5b); 4 DOLLAR terminated to DOS (9); 5 AX$ from (3f); 6 CX$ to/from (3f,40,44); 7 KEYBUF to/from DOS (a); 8 Country INFO (34) to/from (38); 9 EXTERR (22) to (5d); a DIRectory (64) from (47); b EXEC parm (14) to (4b); c file MATCH (43) to/from (4e,4f); d CMND line (128) to (29); e PALETTE (17) to (int-10/1002); f VBIOS (64) from (int-10/1b);;; Nibble 1 specifies the segment value transferred as follows (DOS entries; affected are listed in parentheses):;; Segment ptr;; 0 none; 1 ds:dx to/from DOS (9,a,f,10,11,12,13,14,16,17,21,22,23,24,25,27; 28,39,3a,3b,3c,3d,3f,40,41,43,44,4b,4e,4f,56; 5a,5b); 2 DTA to/from (11,12,14,15,21,22,27,28,4e); 3 ds:bx from (1b,1c) (Allocation table info); 4 ds:si to/from (29,47) (Parse FN, get dir); 5 es:di to/from (29,56) (Parse FN, rename); 6 es:bx to/from (2f,35,4b) (Get DTA, intvct, EXEC); 7 es to (49,4a) (RAM allocation);; Byte 1 (high byte) on has meanings:;; bit 0 = 1 (A0) use small data area 0 (limited to 60h bytes); bit 1 = 1 (A1) use large area 1 (4K); bit 2 = 1 (RP) Real/Protect mode transfer needed (for int 21 ah = 3f/40); bit 7 = 1/0 (EX) exitcd/entrycd
entrycd record EnArea:4,EnSegCod:4,EnLenCod:4exitcd record ExArea:8,ExSegCod:4,ExLenCod:4
;Length codes:
FCB equ 1PTR$ equ 2 ;only supports DSBX & ESBX for now (and DSSI if DBCS)ASCZ equ 3DOL equ 4AX$ equ 5CX$ equ 6KYB equ 7INFO equ 8 ;Constant length transfers from here down vvvvvvvvEXTERR equ 9DIR equ 0AhEXEC equ 0BhMTCH equ 0ChCMD equ 0DhPALETTE equ 0EhVBIOS equ 0Fh ;Constant length transfers from here up ^^^^^^^^^^
;Segment codes:
DSDX equ 1DTA equ 2DSBX equ 3DSSI equ 4ESDI equ 5 ;Also used by int-10/ah=1bhESBX equ 6 ;Also used by int-10/ah=1chES$ equ 7ESDX equ 8 ;Used by int-10/ah=10,12, int-33/ah=22,23ESBP equ 9 ;Used by int-10/ah=11,13
;RAM area codes:
A0 equ 1A1 equ 2RP equ 4EX equ 80h
pmrmxfr entrycd <> ;0 - Program Terminate exitcd <> entrycd <> ;1 - Keyboard Input exitcd <> entrycd <> ;2 - Display output exitcd <> entrycd <> ;3 - Auxiliary Input exitcd <> entrycd <> ;4 - Auxiliary Output exitcd <> entrycd <> ;5 - Printer Output exitcd <> entrycd <> ;6 - Direct Console I/O exitcd <> entrycd <> ;7 - Direct Console Input Without Echo exitcd <> entrycd <> ;8 - Console Input Without Echo exitcd <> entrycd <A1,DSDX,DOL> ;9 - Print string exitcd <> entrycd <A1,DSDX,KYB> ;0A - Buffered Keyboard Input exitcd <EX+A0,DSDX,KYB> entrycd <> ;0B - Check Standard Input Status exitcd <> entrycd <> ;0C - Clear Kbd Buffer and Invoke Kbd Function exitcd <> entrycd <> ;0D - Disk Reset exitcd <> entrycd <> ;0E - Select Disk exitcd <> entrycd <> ;0F - Open File ** Unsupported! ** exitcd <> entrycd <> ;10 - Close File ** Unsupported! ** exitcd <> entrycd <A0,DSDX,FCB> ;11 - Search for First Entry exitcd <EX+A1,DTA,FCB> entrycd <A0,DSDX,FCB> ;12 - Search for Next Entry exitcd <EX+A1,DTA,FCB> entrycd <A0,DSDX,FCB> ;13 - Delete File exitcd <> entrycd <> ;14 - Sequential Read ** Unsupported! ** exitcd <> entrycd <> ;15 - Sequential Write ** Unsupported! ** exitcd <> entrycd <> ;16 - Create File ** Unsupported! ** exitcd <> entrycd <A0,DSDX,FCB> ;17 - Rename File exitcd <> entrycd <> ;18 - Used Internally by DOS exitcd <> entrycd <> ;19 - Current Disk exitcd <> entrycd <A1,DSDX,> ;1A - Set Disk Transfer Address exitcd <> entrycd <> ;1B - Allocation Table Info exitcd <,DSBX,PTR$> entrycd <> ;1C - Alloc Table Info for Specific Device exitcd <,DSBX,PTR$> entrycd <> ;1D - Used Internally by DOS exitcd <> entrycd <> ;1E - Used Internally by DOS exitcd <> entrycd <> ;1F - Used Internally by DOS exitcd <> entrycd <> ;20 - Used Internally by DOS exitcd <> entrycd <> ;21 - Random Read ** Unsupported! ** exitcd <> entrycd <> ;22 - Random Write ** Unsupported! ** exitcd <> entrycd <> ;23 - File Size ** Unsupported! ** exitcd <> entrycd <> ;24 - Set Relative Record Field ** Unsupported! ** exitcd <> entrycd <,DSDX,> ;25 - Set Interrupt Vector (0/ds:dx/0) exitcd <> entrycd <,DSDX,> ;26 - Create new PSP exitcd <> entrycd <> ;27 - Random Block Read ** Unsupported! ** exitcd <> entrycd <> ;28 - Random Block Write ** Unsupported! ** exitcd <> entrycd <A0,DSSI,ASCZ> ;29 - Parse Filename exitcd <EX+A1,ESDI,FCB> entrycd <> ;2A - Get Date exitcd <> entrycd <> ;2B - Set Date exitcd <> entrycd <> ;2C - Get Time exitcd <> entrycd <> ;2D - Set Time exitcd <> entrycd <> ;2E - Set/Reset Verify Switch exitcd <> entrycd <> ;2F - Get Disk Transfer Address exitcd <EX+A0,ESBX,> entrycd <> ;30 - Get DOS Version Number exitcd <> entrycd <> ;31 - Terminate and Stay Resident exitcd <> entrycd <> ;32 - Get Drive Parameter Block exitcd <,DSBX,PTR$> entrycd <> ;33 - Ctrl-Break Check exitcd <> entrycd <> ;34 - Get InDOS flag address exitcd <,ESBX,PTR$> entrycd <> ;35 - Get Interrupt Vector exitcd <EX,ESBX,> entrycd <> ;36 - Get Disk Free Space exitcd <> entrycd <> ;37 - Used Internally by DOS exitcd <> entrycd <A1,DSDX,> ;38 - Set/Get Country Dependent Info exitcd <EX+A1,DSDX,INFO> entrycd <A0,DSDX,ASCZ> ;39 - MKDIR exitcd <> entrycd <A0,DSDX,ASCZ> ;3A - RMDIR exitcd <> entrycd <A0,DSDX,ASCZ> ;3B - CHDIR exitcd <> entrycd <A0,DSDX,ASCZ> ;3C - Create a File exitcd <> entrycd <A0,DSDX,ASCZ> ;3D - Open a File exitcd <> entrycd <> ;3E - Close a File Handle exitcd <> entrycd <RP,DSDX,> ;3F - Read from a File or Device exitcd <EX+RP,DSDX,AX$> entrycd <RP,DSDX,CX$> ;40 - Write to a File or Device exitcd <> entrycd <A0,DSDX,ASCZ> ;41 - Delete a File from a Specified Directory exitcd <> entrycd <> ;42 - Move File Read/Write Pointer exitcd <> entrycd <A0,DSDX,ASCZ> ;43 - Change File Mode exitcd <> entrycd <> ;44 - I/O Control for Devices exitcd <> ;See ioctlw for write entrycd <> ;45 - Duplicate a File Handle exitcd <> entrycd <> ;46 - Force a Duplicate of a File Handle exitcd <> entrycd <A0,DSSI,> ;47 - Get Current Directory exitcd <EX+A0,DSSI,ASCZ> entrycd <> ;48 - Allocate Memory exitcd <> entrycd <,ES$,> ;49 - Free Allocated Memory exitcd <> entrycd <,ES$,> ;4A - Modify Allocated Memory Blocks exitcd <> entrycd <A0,DSDX,ASCZ> ;4B - Load or Execute a Program (EXEC) exitcd <> entrycd <> ;4C - Terminate a Process exitcd <> entrycd <> ;4D - Get Return Code of a Sub-process exitcd <> entrycd <A0,DSDX,ASCZ> ;4E - Find First Matching File exitcd <EX+A1,DTA, MTCH> entrycd <A1,DTA,MTCH> ;4F - Find Next Matching File exitcd <EX+A1,DTA, MTCH> entrycd <,ESBX,> ;50 - Set current PSP (code restores bx) exitcd <> entrycd <> ;51 - Get current PSP exitcd <> entrycd <> ;52 - Get Pointer to SysInit Variables exitcd <,ESBX,PTR$> entrycd <A1,DSSI,DIR> ;53 - Set Drive Parameter Block exitcd <> entrycd <> ;54 - Get Verify Setting exitcd <> entrycd <,DSDX,> ;55 - Duplicate PSP exitcd <> entrycd <A0,DSDX,ASCZ> ;56 - Rename a File exitcd <> entrycd <> ;57 - Get/Set a File's Date and Time exitcd <> entrycd <> ;58 - Get/Set Allocation Strategy exitcd <> entrycd <> ;59 - Get Extended Error exitcd <> entrycd <A0,DSDX,ASCZ> ;5A - Create Temporary File exitcd <EX+A0,DSDX,ASCZ> entrycd <A0,DSDX,ASCZ> ;5B - Create New File exitcd <> entrycd <> ;5C - Lock/Unlock File Access exitcd <> entrycd <A0,DSDX,EXTERR> ;5D - Used Internally by DOS exitcd <> entrycd <> ;5E - Network Machine Name/Printer Setup exitcd <> entrycd <> ;5F - Get/Make Assign-List Entry exitcd <> entrycd <> ;60 - Used Internally by DOS exitcd <> entrycd <> ;61 - Used Internally by DOS exitcd <> entrycd <> ;62 - Get PSP Address exitcd <> entrycd <> ;63 - Get Lead Byte Table ** Unsupported! ** exitcd <> entrycd <> ;64 - Used Internally by DOS exitcd <> entrycd <> ;65 - Get Extended Country Info exitcd <EX+A1,ESDI,CX$>; ** Only Partially Supported ** entrycd <> ;66 - Get/Set Code Page exitcd <> entrycd <> ;67 - Set Handle Count exitcd <> entrycd <> ;68 - Commit File exitcd <> entrycd <> ;69 - Used Internally by DOS exitcd <> entrycd <> ;6A - Used Internally by DOS exitcd <> entrycd <> ;6B - Used Internally by DOS exitcd <> entrycd <A0,DSSI,ASCZ> ;6C - Extended Open File exitcd <>
MaxInt21 equ 06Ch ;max supported Int 21h function
UnSupported entrycd <> ;for unsupported DOS calls exitcd <>
if DEBUG ;------------------------------------------------------------
; Table of partially supported/unsupported/unknown Int 21h functions
ifdef DBCStblBad21 db 18h,1Dh,1Eh,1Fh,20h,37h,5Dh,60h,61h db 64h,65h,6Ah,6Bh,0elsetblBad21 db 18h,1Dh,1Eh,1Fh,20h,37h,5Dh,60h,61h,63h db 64h,65h,6Ah,6Bh,0endifendif ;DEBUG --------------------------------------------------------;; For compatibility with WIN386, the following FCB calls are failed; unconditionally.;MIN_REAL_BAD_21 equ 0fhMAX_REAL_BAD_21 equ 28h
tblRealBad21 db 0fh,10h,14h,15h,16h,21h,22h,23h,24h,27h,28h,0
; Special codes for special INT 21h functions
int215E entrycd <A0,DSDX,> ;5E/00 - Get Machine Name exitcd <EX+A0,DSDX,ASCZ> entrycd <A0,DSDX,ASCZ> ;5E/01 - Set Machine name exitcd <> entrycd <A0,DSSI,CX$> ;5E/02 - Set Printer Setup Str exitcd <> entrycd <A0,ESDI,> ;5E/03 - Get Printer Setup Str exitcd <EX+A0,ESDI,CX$>
int215F02 entrycd <A0,DSSI> ;5F/02 - Get Redir List Entry exitcd <EX+A0,DSSI,ASCZ> entrycd <A0,DSSI,ASCZ> ;5F/03 - Set Redir List Entry exitcd <> entrycd <A0,DSSI,ASCZ> ;5F/04 - Cancel Redirection exitcd <> entrycd <A0,DSSI> ;5F/05 - Get Redir List Entry exitcd <EX+A0,DSSI,ASCZ>
ifdef DBCSint2163 entrycd <> ;63/00 - Get Lead Byte Table Entry exitcd <,DSSI,PTR$>endif ; DBCS
int21esdi entrycd <A1,ESDI,ASCZ> ;56 & 5F/02&03&05 eXtra buffer exitcd <EX+A1,ESDI,ASCZ>
;; We only use the entry code from the following. If we don't; we trash the stack in applications like borland c++;int21pfn entrycd <A1,ESDI,FCB> ;29, fcb buffer exitcd <>
; Additional tables for run time support associated with register; translation and buffering.
; 8 9 a b c d e f; INFO EXTERR DIR EXEC MATCH CMND PALETTE VBIOSmvcnt db 34, 22, 40h, 0Eh, 43, 80h, 17, 64
; 1 2 3 4 5 6 7 8 9; DSDX, DTA, DSBX, DSSI, ESDI, ESBX, ES$, esdx, esbpregoffs dw xdx, 0, xbx, xsi, xdi, xbx, 0, xdx, xbp
DXPMCODE ends
; ------------------------------------------------------- subttl Main Program page; -------------------------------------------------------; MAIN PROGRAM; -------------------------------------------------------
DXPMCODE segment assume cs:DXPMCODE
; -------------------------------------------------------; PMIntrDos -- This function is the main handler for int 21h calls; that require special case processing. Most interrupts; go through the interrupt reflector (PMIntrReflector in; dxintr.asm). DOS int 21h interrupts are vectored here.;; This routine performs any register manipulation, data buffering; etc. needed to pass the interrupt parameters from the; protected mode caller to the real mode handler. Register; manipulation and data transfers can occur either on entry; to the interrupt handler or on exit from the interrupt; handler (to fix up return values.);; Input: normal registers for Dos calls; Output: normal register returns for Dos calls; Errors: normal Dos errors; Uses: In general, all registers are preserved. For interrupts where; register translation or buffering occurs, some registers may; be changed, depending on the interrupt and its parameters.
assume ds:NOTHING,es:NOTHING,ss:NOTHING public PMIntrDos
PMIntrDos proc far
push ds push ax mov ax,SEL_DXDATA OR STD_RING mov ds,ax assume ds:DGROUP mov ax,ss mov pmusrss,ax mov ax,sp add ax,4 mov pmusrsp,ax pop ax
FBOP BOP_DPMI,XlatInt21Call,FastBop; If we get here, the api wasn't translated. The translation code will; simulate the iret assume ds:nothing
NotXlated: cld ;Code assumes direction flag is cleared
; Save PM user ds, es, and flags, and switch to DOS extender stack
push ax ;Save caller's AX push bp mov bp,sp ;[bp] = bp ax ip cs fl - 286 int gates assumed ; 0 2 4 6 8 push es
mov es,selDgroupPM ;Address our DGROUP assume es:DGROUP
; Check for nested DOS interrupts--this code was written with the assumption; that we would never be reentered, but it turns out that we may need to; support nested DOS calls from a critical error handler. If this is one; of those ultra-rare occasions, save our previous 'instance' data in Isave.
inc EntryFlag ;The normal case will be to jump jz @f
push cx ;Being reentered, save last instance data push di push si
mov cx,ILENGTH ;NOTE!!! The next movs has mov si,offset DGROUP:Ibegin ; an es override, if ints mov di,offset DGROUP:Isave ; are enabled, an interrupt rep movs byte ptr [di],byte ptr es:[si] ; on this instr can 'forget' ; about the es override with pop si ; some processors pop di pop cx@@:
; Start saving callers state.
mov pmrg.xds,ds ;Save PM user ds mov ax,[bp+8] ;Get ax = flags when int occurred mov rmflags,ax ;Store flags for real-mode handler
pop pmrg.xes ;Save PM user es
pop bp pop ax ;Recover user ax. [sp] = ip cs fl
; At this point all general registers (but not ES) have the user's values
push es ;Address DGROUP, user's DS already pop ds ; saved in pmrg.xds assume ds:DGROUP
mov pmusrss,ss ;Save PM user stack ptr mov pmusrsp,sp ;[sp] = ds ip cs fl ; 0 2 4 6 mov pmrg.xsi,si ;Save PM si since need to use before pusha
push ds ;Switch to rmrg stack for this routine pop ss mov sp,offset DGROUP:rmflags ;PM flags already on stack FSTI ;We don't really need interrupts disabled
; Setup iret frames for iret'ing to real-mode handler and for that handler; returning to the DOS extender
pop si ;Get rmflags and si,not 4100h ;Kill NT, TF push si ;Push flags for iret to BackFromDOS push segDXCodePM ;Push return cs:ip for iret push offset BackFromDOS
and si,not 0200h ;Kill IF push si ;Push flags for iret to real-mode handler
sub sp,4 ; make room for stack frame push bp mov bp,sp push es push ax
mov ax,SEL_RMIVT OR STD_RING mov es,ax mov ax,es:[21h*4] mov [bp + 2],ax mov ax,es:[21h*4 + 2] mov [bp + 4],ax pop ax pop es pop bp
; Setup protected mode and real mode copies of registers.
mov si,pmrg.xsi ;Restore si push ds ;Save space for real mode ds push es ; and es pusha ;Save user general registers
mov si,offset DGROUP:rmrg ;Copy user values to PM set for mov di,offset DGROUP:pmrg ; reference (real-mode set may change) mov cx,8 ;8 general registers (es and ds already stored) rep movsw
mov ax,segDXDataPM ;ax = DOS extender real-mode dgroup segment mov rmrg.xds,ax ;Default real-mode data segments mov rmrg.xes,ax ; (dosentry may change them)
mov ax,rmrg.xax
if DEBUG ;------------------------------------------------------------
; Check for partially supported/unsupported/unknown DOS calls
cmp ah,0DCh ;krnl286 is doing this now, quit jz goodfunc ; complaining about it
cmp ax,5D0Ah ;Set Extended Error is the only jz goodfunc ;5Dh function handled properly!
cmp ah,MaxInt21 ;is the request within our range? ja badfunc
mov bx,offset DXPMCODE:tblBad21@@: cmp ah,cs:[bx] jb goodfunc jz badfunc inc bx jmp short @b
badfunc: Trace_Out "Possible Unsupported DOS Call! AX=#AX"
goodfunc:
endif ;DEBUG --------------------------------------------------------
; Check for FCB calls that we fail unconditionally (because WIN386 does.)
cmp ah,MIN_REAL_BAD_21 jb goodfunc1 cmp ah,MAX_REAL_BAD_21 ja goodfunc1
mov bx,offset DXPMCODE:tblRealBad21@@: cmp ah,cs:[bx] je badfunc1 inc bx cmp byte ptr cs:[bx],0 jz goodfunc1 ; Ran off end of table. jmp short @b
badfunc1:
if DEBUG Debug_Out "Unsupported DOS Call! AX=#AX"endif ;DEBUG
or byte ptr rmflags,1 ; Set CF call xfrflg jmp LeaveDOSExtender
goodfunc1:
; int 21 entry register translations and data transfers cmp ah,00h ;old style DOS Exit call? jnz @f call DosExitCall ;sets CY if it handles the call, otherwise jnc @f ; do it normally... jmp LeaveDOSExtender@@: ; ; Handle terminate specially. We mess with the PSP here to set ; up a terminate vector we like. We don't do anything special for ; TSR (31h) ; cmp ah,4ch ; terminate? jnz @f
call TerminateProcess@@:
cmp ah, 5dh ; check for unsupported 5d codes jnz short @f cmp al, 0ah jz short @f jmp LeaveDOSExtender@@:
mov rcount,0 ;Default no remaining bytes to read/write mov ccount,0 ;No bytes read or written yet
cmp ah,3Fh ;If read jz @f cmp ah,40h ; or write, jnz TransferLoop@@: mov cx,pmrg.xcx ; initialize remaining count = requested value mov rcount,cx
; Start of loop for doing large read/write transfers
TransferLoop:
call dosentry ;Do selector translations, data buffering
; Come here after entry register translations and data transfers are complete
SwitchToRealMode ;Switch back to real mode. ds = es = rm dgroup ;Stack is at same place in memory
; Set registers to possibly translated values and iret to real-mode DOS.; DOS then irets to BackFromDOS.
popa ;Set appropriate general register values
pop es pop ds
public GoingToDOS
GoingToDOS: ;for debugging, etc.
iret ;invoke real mode DOS
assume ds:NOTHING, es:NOTHING, ss:NOTHING
; Return here from real-mode interrupt handler (DOS)
public BackFromDOS
BackFromDOS:
pushf ;Save return flags (to rmflags) cld ; (better safe than sorry)
push cs ;Push return cs:ip for multiple xfers push offset BackFromDOS
sub sp,2*3 ;Bypass room for iret to interrupt handler ; (to keep stack layout the same as on entry)
push ds ;Save register set push es pusha
mov ds,segDXData assume ds:DGROUP
; "push" iret frame for real mode int 21 rtn in case we need to do it again
mov ax,rmflags and ax,not 4300h ;Kill NT, TF, and IF mov rmivfl,ax
xor ax,ax mov es,ax mov ax,word ptr es:[21h*4+2] mov rmivcs,ax mov ax,word ptr es:[21h*4] mov rmivip,ax
; Switch back to protected mode
SwitchToProtectedMode ;Switch back to protected mode assume ds:DGROUP,es:DGROUP
FSTI ;Don't need ints disabled
call xfrflg ;Transfer relevant return flags over to pm iret frame
mov ax,pmrg.xax ;Recover AX from caller
; Perform any int-21 selector translations, data buffering
call dosexit
; Check for large xfers (Read File 3Fh, Write File 40h, some IOCTL 44h)
cmp rcount,0 ;Read/write more bytes? jz TransferDone
mov cx,rmrg.xax ;Maybe. cx = count transferred (if 3Fh or 40h) mov ax,pmrg.xax ;Restore entry code mov rmrg.xax,ax
cmp ah,40h ;Write? jnz @f
sub rcount,cx ;Yes. Written all originally requested? jz TransferDone
cmp cx,rmrg.xcx ; No. Written all last specified? jz @f ; Yes. Go do some more
mov ax,ccount ;A large write has failed! ccount has already sub ax,rmrg.xcx ; been updated assuming success, back out the add ax,cx ; attempted xfer amount, and add in jmp short TransferCount ; the actual, then split@@: jmp TransferLoop ;Yep (or 3Fh or 44h). Do another xfer
TransferDone: mov ax,ccount ;Multiple count xfer? or ax,ax jz LeaveDOSExtender
TransferCount: mov rmrg.xax,ax ;Yes update return amount mov ax,pmrg.xcx mov rmrg.xcx,ax ;Restore initial request count
; Restore possibly translated registers and to return to pm caller
public LeaveDOSExtender
LeaveDOSExtender:
popa ;Restore possibly changed user registers
mov ss,pmusrss ;Restore pm user stack mov sp,pmusrsp assume ss:NOTHING
push pmrg.xds ;push user seg regs on user stack push pmrg.xes
dec EntryFlag ;dec nested entry flag - normal case is to jmp jnz NotNested ;If this was a nested DOS call (from push cx ; a critical error handler), restore push si ; the state for the prior DOS call push di ; which is still in progress
mov cx,ds ;make darn sure es -> DGROUP mov es,cx
cld ;NOTE: we need to retreive mov cx,ILENGTH ; all current user registers mov di,offset DGROUP:Ibegin ; before moving this data mov si,offset DGROUP:Isave rep movsb
pop di pop si pop cx
NotNested: pop es ;restore user seg regs pop ds assume ds:NOTHING,es:NOTHING
public DOSXiretDOSXiret: ;for debugging, etc.
iret ;return to caller
PMIntrDos endp
; -------------------------------------------------------; DOSENTRY -- This function performs buffering and register; translation for entry into MS-DOS functions.;; Input: AX: AX value at time of INT 21h; Output:; Errors:; Uses:
assume ds:DGROUP,es:DGROUP,ss:DGROUP
dosentry:
cmp ah,26h ;Create new PSP? jnz @f mov si,rmrg.xdx ;yes, translate selector to paragraph call gtpara mov rmrg.xdx,ax return@@: cmp ah,53h ;Set drive parameter block? jnz @f push ax mov si,pmrg.xes ;int 21h/53h has an extra parameter in ES:BP call gtpara ; we change the selector to a segment, but mov rmrg.xes,ax ; the segment had better already be in pop ax ; conventional memory jmp short dentr2b@@: cmp ah,50h ;Set current PSP? jnz dentr1 mov si,rmrg.xbx ;Yes. Translate selector to paragraph call gtpara mov rmrg.xbx,ax return
dentr1: cmp ah,55h ;Duplicate PSP? jnz dentr2 mov si,rmrg.xbx ;Translate selector bx to paragraph call gtpara mov rmrg.xbx,ax mov si,rmrg.xdx ; and dx also call gtpara mov rmrg.xdx,ax return
dentr2: cmp ah,56h ;Rename? jnz dentr2a push ax ;rename has a second ASCIIZ buffer push pmrg.xes ; pointed to by es:di -- move that pop enxseg ; now, the ds:dx one below mov ax,int21esdi call gtarea ;let the 'standard' gtarea/movdat mov dx,enxseg ; routines take care of it call movdat pop ax jmp short dentr2b
dentr2a: cmp ah,5Fh ;Get/Make Assign-List Entry? jne dentr2a1 call net5Fenter ; Yes, may require extra buffering jmp short dentr2b
dentr2a1: cmp ah,29h ; parse filename? jne dentr2b
push ax push pmrg.xes pop enxseg mov ax,int21pfn call gtarea mov dx,enxseg call movdat pop ax;; jmp short dentr2b
dentr2b: call GetEntryCd ;ax = func entry code, di = ptr to entry cd
or ax,ax ;Entry code specify something to do? rz
cmp byte ptr pmrg.xax+1,1Ah ;Store DTA? jnz dentr3
mov pmdta,dx ; Yes. Save it for data returns push pmrg.xds pop pmdta+2 jmp short dentr4
dentr3: cmp byte ptr pmrg.xax+1,4Bh ;EXEC program? callz dosxec
; DENTR4 - enter with ax = entrycd/exitcd. Translate ptr's for real-; mode calls and transfer any data indicated.
dentr4: push pmrg.xds pop enxseg call gtarea ;Get es:di = area for transfer rz ;Something to xfer? mov dx,enxseg ;Yes. Fall thru to movdat
errnz <movdat-$>
; -------------------------------------------------------; MOVDAT -- This routine performs the buffer transfer; for entry into or exit from an MS-DOS function. The data; is copied from DX:SI to ES:DI. The code in CX determines; the type of data being transferred, which is used to determine; the length.;; Input: DX:SI - far pointer to source buffer; ES:DI - far pointer to destination buffer; CX - transfer length code; Output: none; Errors: none; Uses: AX, BX, CS, SI, DI modified
assume ds:DGROUP,es:NOTHING,ss:DGROUP public movdat
movdat: push ds mov bx,cx ;Simple count? sub bl,INFO jc movda2 cmp bl,PALETTE-INFO ;Yes. Use pm es? jc movda0 mov dx,pmrg.xes ;Yesmovda0: mov cl,mvcnt[bx] ;cx = countmovda1: mov ds,dx
if DEBUG ;------------------------------------------------------------
push ax mov ax,es lsl ax,ax sub ax,di jc movbad cmp ax,cx jnc @fmovbad: Debug_Out "Movdat: copy beyond end of dest seg!"@@: pop ax
endif ;DEBUG --------------------------------------------------------
movd1a: rep movsb ;Move data pop ds return
movda2: cmp cl,CX$ ;Use pmrg.xcx? jnz movda3 mov cx,rmrg.xcx ;cx usually = pmrg.xcx, but in any event ; cx < CB_XFRBUF1movd21: add ccount,cx jmp short movda1
movda3: mov ah,0 cmp cl,ASCZ jz movda4 cmp cl,DOL jnz movda5 mov ah,"$"movda4: mov ds,dxmovd42: lodsb stosb cmp al,ah jnz movd42 pop ds return
movda5: cmp cl,AX$ ;Use rmrg.xax? jnz movda6 mov cx,rmrg.xax ;Yes (only occurs for ah=3fh - read - on exit) jmp short movd21
movda6: cmp cl,FCB jnz movda7 mov ds,dx mov cl,byte ptr ds:[si] cmp cl,0ffh ;standard or extended FCB? mov cx,37 ;standard FCB len jnz movd1a mov cx,44 ;extended FCB len jmp short movd1a
movda7: ;KYB remains pop ds return
; -------------------------------------------------------; DOSEXIT -- This function is called on exit from the MS-DOS; functions to perform any data buffering and register translation; needed.;; Input: AX: AX value at time of INT 21h; Output:; Errors:; Uses:
assume ds:DGROUP,es:DGROUP,ss:DGROUP public dosexit
dosexit: cmp ah,51h ;Get current PSP? jz dose0a cmp ah,62h ;Get PSP address? jnz dose00dose0a: mov ax,rmrg.xbx ;Yes. Translate segment to selector mov bx,STD_DATA call ParaToLDTSelector mov rmrg.xbx,ax return
dose00: cmp ah,2fh ;Get current DTA? jnz dose01 mov ax,pmdta ;Yes. Load PM DTA into caller's registers mov rmrg.xbx,ax mov ax,pmdta+2 verr ax ; if the dta selector is no longer valid, jz @f ; return the NULL selector instead (so we xor ax,ax ; don't GP fault in DOSX).@@: mov pmrg.xes,ax return
dose01: cmp ah,55h ;Duplicate PSP? jnz dosex1 mov ax,rmrg.xbx ;Yes, translate segments to selectors mov bx,STD_DATA call ParaToLDTSelector mov rmrg.xbx,ax mov ax,rmrg.xdx mov bx,STD_DATA call ParaToLDTSelector mov rmrg.xdx,ax return
dosex1: cmp ah,56h ;Rename? jnz dosex2 push pmrg.xdi ;Rename has a second pointer in ES:DI--we pop rmrg.xdi ; need to restore DI here, DX below jmp short dosex3
dosex2: cmp ah,5Fh ;Get/Make Assign-List Entry? callz net5Fexit ; Yes, extra buffering may be needed
dosex3: call GetEntryCd ;ax=func entry code, di=ptr to entry code
call rstreg ;Restore entry register? jz dosex6
cmp byte ptr pmrg.xax+1,29h ;Yes, Parse filename? jnz dosex4
add ax,rmrg.xsi ;Yes. Increment past string sub ax,offset DGROUP:rgbXfrBuf0 ; that was parsed push pmrg.xdi pop rmrg.xdi ;Restore pm di (for es:di ptr)
dosex4: mov word ptr rmrg[si],ax ;Restore register
cmp byte ptr pmrg.xax+1,4Bh ;EXEC program jnz dosex6
push di mov di,pmrg.xbx ;Yes, restore bx too (dx restored above) mov rmrg.xbx,di ;es and ds are restored automatically cmp byte ptr pmrg.xax,1 ;INT-21/4b01h (undocumented debug)? jnz @f
mov si,npXfrBuf1 ;Yes. Pass back user ss:sp and cs:ip lea si,[si].xsssp lea di,[di].xsssp mov es,pmrg.xes movsw ;Move ss:sp movsw movsw ;Move cs:ip movsw@@: pop di
dosex6: mov ax,cs:[di+2] ;Exit xfer? or ax,ax rz
dosex7: call CheckStatus ;Check the DOS return status to see if the rnz ; data should be transfered back to PM
mov cx,ax ;Is a pointer being returned? (no data and cl,0fh ; transfer) cmp cl,PTR$ jnz dosex8
shr al,4 ; yes, isolate pointer type mov si,offset rmrg.xds mov di,offset pmrg.xds cmp al,DSBX jz dosex7aifdef DBCS ; for function 63h (Get Lead Byte) cmp al,DSSI jz dosex7aendif ; DBCS mov si,offset rmrg.xes mov di,offset pmrg.xesdosex7a: mov ax,[si] ; get a selector for the segment, and mov bx,STD_DATA ; setup to return it to caller call ParaToLDTSelector mov [di],ax return
dosex8: push pmrg.xds pop enxseg call gtarea ;Get area for xfer from PM to DOS rz ;Something to move?
xchg si,di ;Turn pointers around mov dx,ds ;dx:si -> DOS xfer area in dgroup mov es,enxseg ;es:di -> PM-caller data area jmp movdat ;Yes
; -------------------------------------------------------; DosExitCall -- Special processing for DOS exit call service (Int 21h/00h);; This procedure handles the obsolete Int 21h/00h terminate process; call in a special slimy way for Windows. Instead of doing a 00h; DOS call in real mode, it hacks up the parent's PSP and does a 4Ch; that causes control to return to the extender, who then RETURNS TO; THE CALLER!!! The caller must then do appropriate set PSP calls, etc.; This was implemented so pMode Windows kernel could have DOS clean up; after a Windows app terminates, but still have kernel get control; back.;; Note: This code assumes that the Parent PID field contains a; SELECTOR!;; Note^2: If for some reason it's the DOS Extender's child that's 1800doing; the terminate call, we let it go through normally.;; Input: none; Output: CY set if exit call processed by this routine, clear otherwise; Errors:; Uses: none
assume ds:DGROUP,es:DGROUP,ss:DGROUP public DosExitCall
DosExitCall proc near
push ax push bx push dx push es
SwitchToRealMode ;much of this is easier in real mode FSTI ;allow interrupts
mov ah,51h ;get PSP of current task pushf FCLI sub sp,8 ; make room for stack frame push bp mov bp,sp push es push ax
xor ax,ax mov es,ax mov [bp + 8],cs mov [bp + 6],word ptr (offset dec_10) mov ax,es:[21h*4] mov [bp + 2],ax mov ax,es:[21h*4 + 2] mov [bp + 4],ax pop ax pop es pop bp retf
dec_10: cmp bx,segPSPChild ;is this our child terminating? jnz @f ;if not, go process the call ourselves jmp decTermChild ; yes...@@: FCLI ;we want to preserve the current xor ax,ax ; rMode Int 24h handler across this mov es,ax ; exit call (the terminating PSP mov ax,es:[24h*4] ; has the pMode handler address). mov dx,es:[24h*4+2] ; So get the current Int 24h handler FSTI ; address from the rMode IDT.
mov es,bx ;address terminating PSP assume es:PSPSEG
mov word ptr [lpfnInt24],ax ;point PSP to same Int 24h mov word ptr [lpfnInt24+2],dx ; handler
mov ax,offset DXCODE:decTermHandler ;point PSP to our termination mov word ptr [lpfnParent],ax ; handler mov word ptr [lpfnParent+2],cs
push es mov ax,segParentPSP ;Windows has the PSP's parent push ax ; field as a selector, we need the seg mov dx, [segEnviron] push dx SwitchToProtectedMode assume ds:DGROUP,es:DGROUP
FSTI pop ax ;get selector for environment or ax,ax ; NULL selector (krnl386 does this) jnz @f xor bx,bx ; zero environment segment jmp dec_HaveEnvSeg@@: call GetSegmentAddress test bx,0fff0h ; >1mb? jz @f ; no xor bx,bx ; yes, zero environment segment xor dx,dx@@: shr dx, 4 shl bx, 12 or bx, dx ;seg of environment
dec_HaveEnvSeg: pop ax ;get parent psp off stack push bx ;save seg of environment
call GetSegmentAddress ;returns BX:DX = lma of segment shr dx,4 shl bx,12 or bx,dx ;bx now = seg of parent psp
SwitchToRealMode ;back to the shadows again... FSTI pop cx ;seg of environment
pop dx ;terminating PSP segment from stack mov es,bx ;address the parent's PSP assume es:PSPSEG
mov ax,sp sub ax,12*2 ;some magic for DOS mov word ptr [lpStack],ax ;set our stack in parent's PSP mov word ptr [lpStack+2],ss
mov es,dx ;(re)address terminating PSP assume es:PSPSEG mov [segEnviron], cx
mov segParentPSP,bx ;real DOS doesn't like selectors in ; parent PSP field, zap it to segment
mov ax,pmrg.xax ;terminate the process mov ah,4Ch ; with a 4Ch DOS call pushf FCLI sub sp,8 ; make room for stack frame push bp mov bp,sp push es push ax
xor ax,ax mov es,ax mov [bp + 8],cs mov word ptr [bp + 6],offset decTermHandler mov ax,es:[21h*4] mov [bp + 2],ax mov ax,es:[21h*4 + 2] mov [bp + 4],ax pop ax pop es pop bp retf assume ds:NOTHING,es:NOTHING,ss:NOTHING ;play it safe
decTermHandler: ;should return back here
push ss pop ds
SwitchToProtectedMode ;back to pMode assume ds:DGROUP,es:DGROUP
FSTI
les bx,dword ptr pmusrsp ;es:bx -> ip cs flag and byte ptr es:[bx+2*2],not 1 ;clear CY in caller's flags
stc ;exit call has been processed
dec90: pop es pop dx pop bx pop ax
ret
EndHighSegment
BeginLowSegment
decTermChild:
SwitchToProtectedMode assume ds:DGROUP,es:DGROUP
FSTI clc
jmp short dec90
DosExitCall endp
; -------------------------------------------------------; net5Fenter -- Additional entry processing for INT 21h/5Fh; functions.;; INT 21h/5Fh subfunctions 2, 3, and 5 have two buffers of data to; transfer. The normal DOSENTRY processing only does one, so we; setup the other buffer here.
assume ds:DGROUP,es:DGROUP,ss:DGROUP public net5Fenter
net5Fenter proc near
cmp al,2 ;This routine only works on rc ; subfunctions 2, 3, and 5 cmp al,4 rz cmp al,6 rnc
push ax mov ax,int21esdi ;entry code for INT 21h/5Fh extra buff call gtarea ;let gtarea set it up pop ax
cmp al,3 ;Make redirection function? rnz
; 5F/03 needs a buffer copied down to A1, but it's non standard in that; the buffer contains two (count'em 2) asciiz strings
push ax push cx push ds
mov ds,pmrg.xes ;user's ES:DI -> buffer, gtarea sets xor ah,ah ; up our si to have user's di mov cl,2
@@: lodsb ;copy one asciiz string stosb cmp al,ah jnz @b
dec cl ; and then the other jnz @b
pop ds pop cx pop ax return
net5Fenter endp
; -------------------------------------------------------; net5Fexit -- Additional exit processing for INT 21h/5Fh; functions.;; INT 21h/5Fh subfunctions 2, 3, & 5 have 2 buffers of data to transfer.; The normal DOSENTRY processing only does one, so do the other; buffer here.
assume ds:DGROUP,es:DGROUP,ss:DGROUP public net5Fexit
net5Fexit proc near
cmp al,2 ;This routine only works on rc ; subfunctions 2, 3 and 5 cmp al,4 rz cmp al,6 rnc
push pmrg.xdi ;Restore protected mode DI register pop rmrg.xdi
cmp al,2 ;Get redirection function? jz @f cmp al,5 rnz@@:
; 5F/02 & 05 need a buffer copied from A1
test byte ptr rmflags,1 ;Success? (carry flag) rnz ; No, don't transfer anything
push ax
mov ax,int21esdi+2 ;exit code for int 21/5F extra buffer push pmrg.xes pop enxseg call gtarea ;let gtarea setup the move xchg si,di mov dx,ds mov es,enxseg call movdat ; and let movdat move it
pop ax return
net5Fexit endp
; -------------------------------------------------------; RSTREG -- This function sets up to restore the original; protected-mode registers. This cleans up after register; translations performed when going into the or returning; from an MS-DOS call. On entry, AX contains the entry code; value from the entry/exit operations table. If this code; implies that a register needs to be restored this function; will return with NZ true and AX = original register value; and SI pointing to the appropriate location in the PMRG array.; If no register needs to be restored, return with Z true.;; Input: AX - entry code value; Output: NZ true if register needs to be restores; AX - register value to restore; SI - pointer into PMRG to the register image; ZR true if no restoration needed; Errors: none; Uses: AX, SI modified
assume ds:DGROUP,es:DGROUP,ss:DGROUP public rstreg
rstreg: or ax,ax rz
shr ax,3 and ax,1Eh rz
cmp al,2*DTA ;DTA? rz
xchg si,ax ;No. Restore appropriate register, e.g., dx mov si,regoffs[si-2] mov ax,word ptr pmrg[si] return
; -------------------------------------------------------; GTAREA -- This function examines the entry code/exit code; parameter and determines if any data transfer needs to be; performed. If so, it sets up pointers and length codes for; the transfer.; There are two transfer buffers used. The A0 buffer is 60h bytes; long and the A1 buffer is CB_XFRBUF1 bytes (about 4k) long.;; Input: AX - entry code/exit code; Output: NZ true if something needs to be transferred; SI - offset of source pointer; DI - offset of destination pointer; ENXSEG - segment for caller's buffer; (source on entry, destination on exit); CX - transfer length/type code; Errors: none; Uses: AX, CX, SI, DI, ES modified; ENXSEG modified
assume ds:DGROUP,es:DGROUP,ss:DGROUP public gtarea
gtarea: test ah,RP ;Real/PM xfer (ah = 3f/40)? jz gtare2
mov si,pmrg.xds ;Yes. *si:pmrg.xdx = pm caller's xfer area and si,SELECTOR_INDEX test ah,EX ;Exit call? jz gtare1 push es push ax mov es,selGDT mov al,es:[si].adrBaseHigh mov ah,es:[si].adrbBaseHi386 test ax,0FFF0h ; check for transfer to extended ; memory pop ax pop es jnz @f jmp gtar54@@: mov cx,rmrg.xax ;Yes. cx = amount read/written sub rcount,cx ;Update remaining count cmp cx,rmrg.xcx ;All that was requested? jnc gtare3 mov rcount,0 ;No: done jmp short gtare3
gtare1: push ax ;Read/Write entry mov ax,si mov dx,pmrg.xdx ;ax:dx = selector:offset of buffer call SelOff2SegOff ;translate to seg:off if in conventional mem jnz gtar12 mov rmrg.xds,ax ;store corresponding paragraph mov rmrg.xdx,dx ; and offset pop ax jmp short gtar54 ;No more setup needed
gtar12: pop ax ;XRAM/RRAM read/write entry mov cx,rcount ;Try to xfer remaining amount cmp cx,CB_XFRBUF1 ;Too much to fit in buffer? jbe gtar14 mov cx,CB_XFRBUF1 ;Yes, only transfer a buffer sizegtar14: mov rmrg.xcx,cx jmp short gtare3
gtare2: test ah,A0+A1 ;xfer area? jz gtare4
gtare3: mov di,offset DGROUP:rgbXfrBuf0 ;Point at small buffer (90h bytes) test ah,1 ;Area 0 (small area) ? jnz gtare4 mov di,npXfrBuf1 ;No. Point at large buffer (4K)
gtare4: push ax ;Store ptr to communication area for DOS mov si,di shr al,3 ;Get al = 2 * data ptr type, e.g., DSDX (ds:dx) and al,1Eh ;al = word offset for data ptr type jz gtare7 cmp al,2*DTA ;DOS Data Transfer Area? jnz gtare5 mov si,pmdta ;Yes, load DTA offset push pmdta+2 ;and the segment pop enxseg jmp short gtare7
gtare5: cmp al,2*ES$ jnz gtare6 test ah,80h ;INT-21 49/4A. Ignore exit call mov ax,0 jnz gtar52 mov si,pmrg.xes ;Entry call. si = RAM xfer selector call gtpara ;Get paragraph given by [si].gdt jnz gtar52 ;XRAM? mov rmrg.xes,ax ;No, store RRAM paragraphgtar52: pop cx ;Kill saved ptr
gtar54: xor cx,cx ;RZ with zero count, i.e., no RM/PM xfer needed mov rcount,cx return
gtare6: test ah,80h ;Entry? cbw push ax xchg di,ax ;Save real-mode area offset mov di,regoffs[di-2] ;di = offset of saved register value mov si,word ptr pmrg[di] ;si = saved value jnz gtar62 mov word ptr rmrg[di],ax ;Entry. Store real-mode area offset cmp byte ptr pmrg.xax+1,29h ;Parse filename? jnz gtar62 mov cx,npXfrBuf1 ;Yes. Use npXfrBuf1 for FCB info mov word ptr rmrg.xdi,cxgtar62: xchg di,ax ;Restore di = real-mode area offset
pop ax cmp ax,ESDI*2 jne gtare7
push pmrg.xes pop enxseg
gtare7: pop cx ;Recover entrycd/exitcd and cx,0Fh ;RNZ if something to xfer rz ;No
mov dx,pmrg.xds ;Xfer needed. dx = original XRAM data selector cmp cl,AX$ ;Use rmrg.xax? jz gtare8 cmp cl,CX$ ;Use pmrg.xcx? rnz ;No, just RNZ
;Return dx:0 = pmrg.xds:si+ccount, where dx is a scratch selector;and si = 0. This ensures that dx:si can address a bufferful of bytes;without overflowing si (sort of like a huge ptr).
gtare8: xchg ax,si ;ax = original offset mov si,dx ;si = pmrg.xds (PM data selector) and si,SELECTOR_INDEX xor dx,dx ;dxax = original offset in 32-bit form add ax,ccount adc dx,0 ;dxax += ccount (current xfer count) push es mov es,selGDT ;Point at GDT add ax,es:[si].adrBaseLow adc dl,es:[si].adrBaseHigh ;dxax absolute XRAM address adc dh,es:[si].adrbBaseHi386 mov si,SEL_DOSSCR cCall NSetSegmentDscr,<si,dx,ax,0,0ffffh,STD_DATA> pop es
; original code... changed to line below to fix file read problem.; may cause other bugs.....; mov dx,si ;Return scratch selector with 0 offset since; or si,SELECTOR_TI mov enxseg,si ;Return scratch selector with 0 offset since xor si,si ; it points directly to the transfer location or sp,sp ;RNZ to indicate xfer needed return
; -------------------------------------------------------; GetEntryCd -- This routine puts the entry code for the; DOS function into ax.;; Input: AH - MS-DOS function number; Output: AX - entry code for function; DI - address of entry code returned;; Errors: none; Uses: AX, DI modified
assume ds:DGROUP,es:DGROUP,ss:DGROUP public GetEntryCd
GetEntryCd proc near
push bx
cmp ah,MaxInt21 ;Check for unsupported DOS call jbe @f mov di,offset DXPMCODE:Unsupported jmp gec90@@: mov di,offset DXPMCODE:pmrmxfr
ifdef DBCS cmp ah,63h ;Get Lead Byte Table? jnz gec10
if DEBUG ;------------------------------------------------------------
cmp al,2 jbe gec15
Debug_Out "Int 21h/63h Unsupported Function (#AX)" jmp short gec80gec15:
endif ;DEBUG --------------------------------------------------------
cmp al,0 ;Int 21/63/00 is special jne gec80
mov di,offset DXPMCODE:int2163 jmp short gec90gec10:ENDIF ; DBCS
gec20: cmp ah,5Eh ;Network Machine Name/Printer Setup Str? jnz gec40
if DEBUG ;------------------------------------------------------------
cmp al,3 jna gec25
Debug_Out "Int 21h/5Eh Unsupported Function (#AX)" jmp short gec80gec25:
endif ;DEBUG --------------------------------------------------------
cmp al,3 ;Int 21-5E/00-03 are special ja gec80
mov bl,al mov di,offset DXPMCODE:int215E jmp short gec85
gec40: cmp ah,5Fh ;Get/Make Assign-List Entry? jnz gec80
if DEBUG ;------------------------------------------------------------
cmp al,5 ja @f cmp al,2 jnb gec45@@: cmp al,30h ;Register based. Get Redirector version ;used by Lanman Enhanced. je gec80 Debug_Out "Int 21h/5Fh Unsupported Function (#AX)" jmp short gec80gec45:
endif ;DEBUG --------------------------------------------------------
cmp al,2 ;Int 21/5F/02-05 are special jb gec80 cmp al,5 ja gec80
mov bl,al sub bl,2 mov di,offset DXPMCODE:int215F02 jmp short gec85
gec80: mov bl,ahgec85: xor bh,bh shl bx,2
add di,bx ;Address of entry codegec90: mov ax,word ptr cs:[di] ;The entry code itself pop bx return
GetEntryCd endp
; -------------------------------------------------------; CheckStatus -- This routine determines if data should be copied; back to protect mode by checking the DOS function; return status.;; Input: none; Output: NZ - if data should NOT be copied, Z otherwise;; Errors: none; Uses: none
assume ds:DGROUP,es:DGROUP,ss:DGROUP public CheckStatus
CheckStatus proc near
; For now, only worry about the functions that return variable length; results, like ASCIIZ strings.
cmp byte ptr pmrg.xax+1,32h jz @f cmp byte ptr pmrg.xax+1,47h ;Get Current Directory jz @f cmp byte ptr pmrg.xax+1,5Ah ;Create Temporary File jz @f cmp byte ptr pmrg.xax+1,5Eh ;Get Machine Name/Printer Str jc cks90 cmp byte ptr pmrg.xax+1,5Fh ;Get Redirection Entry ja cks90@@: test byte ptr rmflags,1 ;Carry set? return
cks90: cmp al,al ;Assume status is okay (or doesn't return ; matter) -- set Z and return
CheckStatus endp
; -------------------------------------------------------; DOSXEC -- This function performs the transfer of the; DOS exec parameter block on entry to DOS function 4Bh.;; transfer int-21 ah = 4b0x EXEC block and associated strings; to Area 1. This area is laid out partly analogously to a PSP as follows:;; 0-1f EXEC block defined according to the execblk struc above; 20-2f FCB1; 30-3f FCB2; 40-bf command line;; cx, si, di changed.
assume ds:DGROUP,es:DGROUP,ss:DGROUP public dosxec
dosxec: push ax ;Save entrcd code push bx push dx
mov cx,10h ;Setup parameter block. Xfer pm user block first mov bx,npXfrBuf1 ;Point at larger buffer mov di,bx mov dx,segDXDataPM mov rmrg.xbx,di ;int-21 4b0x expects es:bx -> exec block mov si,pmrg.xbx ;npXfrBuf1:0 - 1f (xtra room for undocumented) mov ds,pmrg.xes rep movsw ;copy caller's exec param block to our buffer
; Copy FCB1 down if the user has specified one.
dsxc20: mov ax,word ptr es:[bx].fcb1ptr cmp ax,0FFFFh jz dsxc22 or ax,word ptr es:[bx].fcb1ptr+2 jz dsxc22
lds si,es:[bx].fcb1ptr ;Get pointer to FCB1 mov word ptr es:[bx].fcb1ptr,di ;store new pointer in the copy of the mov word ptr es:[bx].fcb1ptr+2,dx ; exec block we are building mov cl,8 ;copy FCB1 down to our buffer rep movsw jmp short dsxc24dsxc22: add di,10h
; Copy FCB2 down if the user has specified one.
dsxc24: mov ax,word ptr es:[bx].fcb2ptr cmp ax,0FFFFh jz dsxc26 or ax,word ptr es:[bx].fcb2ptr+2 jz dsxc26
lds si,es:[bx].fcb2ptr ;Move FCB2 mov word ptr es:[bx].fcb2ptr,di mov word ptr es:[bx].fcb2ptr+2,dx mov cl,8 rep movsw jmp short dsxc30dsxc26: add di,10h
; Copy the command line down.
dsxc30: lds si,es:[bx].cmdptr ;Move command line mov word ptr es:[bx].cmdptr,di mov word ptr es:[bx].cmdptr+2,dx mov cl,[si] inc cx ;Include count inc cx ;Include final CR not included in count rep movsb
; Now, we need to set up the enviroment table to be passed to the; child program.
mov di,bx ;di = npXfrBuf1 mov dx,es:[di] ;Setup desired environment or dx,dx ;Use parent's environment? jnz dosxegotenv
; pick up the environment segment from the current PDB. It's a selector,; so it has to be translated. push bx push di push es mov ax,SEL_DXDATA OR STD_RING mov ds,ax
SwitchToRealMode ;much of this is easier in real mode
mov ah,51h ;get PSP of current task pushf sub sp,8 ; make room for stack frame push bp mov bp,sp push es push ax
xor ax,ax mov es,ax mov [bp + 8],cs mov [bp + 6],word ptr (offset dosxeret) mov ax,es:[21h*4] mov [bp + 2],ax mov ax,es:[21h*4 + 2] mov [bp + 4],ax pop ax pop es pop bp retfdosxeret: assume es:PSPSEG mov es, bx ;current PSP mov dx, es:[segEnviron] ;get environment (currently selector) push dx ;save over call (bugbug is this needed?) SwitchToProtectedMode pop dx ;bugbug is this needed?
pop es pop di pop bx
dosxegotenv: xor si,si ;No. Setup to copy desired environment down mov ds,dx ;ds = dx has caller's selector. Use 0 offset add di,100h shr di,4 ;Convert offset to paragraph mov dx,segDXDataPM add dx,di ;dx = absolute paragraph within larger buffer shl di,4 ;Convert back (with low nibble cleared) mov cx,CB_XFRBUF1 ;Max room available for environment sub cx,100h
dosxe2: lodsw ;Copy environment down stosw or ax,ax jz dosxe4 dec si ;Check every byte offset in environment for double 0 dec di loop dosxe2 xor dx,dx ;Environment too large for buffer: use parent's ;Issue error message? Program might run with parent's ; and not with desired monster environmentdosxe4: push es ;Fix up parameter block entry pop ds ;ds:dgroup mov [bx].evrnmt,dx
pop dx pop bx pop ax ;Restore entrcd code return
; -------------------------------------------------------; XFRFLG -- This function will transfer the relevant real-mode; flags to the protected mode IRET return information on the; stack for returning to the protected mode caller.;; Input:; Output:; Errors:; Uses: AX, CX, DI modified
assume ds:DGROUP,es:NOTHING,ss:NOTHING public xfrflg
xfrflg: push es les di,dword ptr pmusrsp ;es:[di] = ip cs fl (assume 80286) mov ax,rmflags mov cx,es:[di+2*2] ;Get pm user entry flags and ch,not 19h ;Only allow real-mode program to and ah,18h ; change OF and DF in high byte of flags or ah,ch mov es:[di+2*2],ax pop es return
; ------------------------------------------------------- subttl Handlers for Special Case Dos Functions page; -------------------------------------------------------; HANDLERS FOR SPECIAL CASE DOS FUNCTIONS; -------------------------------------------------------
; -------------------------------------------------------; Terminate process -- This routine replaces the apps; termination vector in the PSP with ours. This allows; us to clean up the dos extender.;; Entry: nothing; Exit: nothing; Uses: none; assume ds:dgroup,es:nothing public TerminateProcessTerminateProcess proc near pusha push es ; ; Get the childs PSP (bugbug do we need to get the current psp?) ;
SwitchToRealMode
mov ah,51h pushf sub sp,8 ; make room for stack frame push bp mov bp,sp push es push ax
xor ax,ax mov es,ax mov [bp + 8],cs mov [bp + 6],offset tp_10 mov ax,es:[21h*4] mov [bp + 2],ax mov ax,es:[21h*4 + 2] mov [bp + 4],ax pop ax pop es pop bp retf
tp_10: FSTI
; ; Change the termination vector to point to the dos extender ; mov es,bx mov bx,es:[0ah] mov ax,es:[0ch] mov cx,offset ChildTerminationHandler mov es:[0ah],cx mov cx,segDXCode mov es:[0ch],cx
; ; Save the old termination vector for restoration later ; mov cx,segCurrentHostData mov es,cx mov word ptr es:[HdPspTerminate],bx mov word ptr es:[HdPspTerminate+2],ax
SwitchToProtectedMode
pop es popa ret
TerminateProcess endp
DXPMCODE ends
;****************************************************************
end
|
