diff options
Diffstat (limited to 'private/nw/nw16/drv/ints.asm')
-rw-r--r-- | private/nw/nw16/drv/ints.asm | 368 |
1 files changed, 368 insertions, 0 deletions
diff --git a/private/nw/nw16/drv/ints.asm b/private/nw/nw16/drv/ints.asm new file mode 100644 index 000000000..1dfe878ca --- /dev/null +++ b/private/nw/nw16/drv/ints.asm @@ -0,0 +1,368 @@ +page ,132 + +if 0 + +/*++ + +Copyright (c) 1993 Microsoft Corporation + +Module Name: + + ints.asm + +Abstract: + + Contains handler for Windows protect-mode NetwareRequest function, exported + by NETWARE.DRV. Code in this file access real mode memory via an LDT descriptor + created especially for this purpose. This selector gives us access to all + code and data contained in the Nw16 TSR + +Author: + + Richard L Firth 22-Jan-1994 + +Environment: + + Windows protect mode only + +Revision History: + + 22-Jan-1994 rfirth + Created + +--*/ + +endif + +include nwdos.inc ; NWDOSTABLE_ASM structure +include isvbop.inc ; DispatchCall + +.286 +.model medium,pascal + +_DATA segment word public 'DATA' + +OldInt21Handler dd ? +RMSegment dw ? +RMBase dw ? ; MUST be in this order - loaded +RMSelector dw ? ; via lds dx,word ptr RMBase + +.errnz (RMSelector - (RMBase + 2)) + +_DATA ends + +; +; code segment ordering +; + +INIT_TEXT segment byte public 'CODE' +INIT_TEXT ends + +_TEXT segment byte public 'CODE' +_TEXT ends + +; +; macros +; + +LOAD_DS macro + push _DATA + pop ds + assume ds:_DATA + endm + +SET_DS macro + push ds + LOAD_DS + endm + +RESTORE_DS macro + pop ds + assume ds:nothing + endm + +LOAD_RM_DS_BX macro + LOAD_DS + lds bx,dword ptr RMBase + assume ds:nothing + endm + +RESTORE_DS_BX macro + RESTORE_DS + pop bx + endm + +INIT_TEXT segment byte public 'CODE' + + assume cs:INIT_TEXT + + public GetLowRedirInfo +GetLowRedirInfo proc far + mov ax,9f00h + int 21h ; get the RM data segment in BX + jc @f + SET_DS + mov RMSegment,bx + mov RMBase,dx + mov ax,2 + int 31h + jc @f ; can't create selector + mov RMSelector,ax + +; +; now that we have the selector, we write the selector value into the low +; memory area. The 32-bit DLL will use this value when setting output DS or ES +; register values if the call originated in Protect Mode +; + + lds bx,dword ptr RMBase + mov [bx]._PmSelector,ax + +; +; we now hook int 21 +; + + LOAD_DS + push es + mov ax,3521h + int 21h + mov word ptr OldInt21Handler,bx + mov word ptr OldInt21Handler[2],es + mov cx,_TEXT + mov dx,offset _TEXT:NewInt21Handler + mov ax,205h + mov bl,21h + int 31h + pop es + RESTORE_DS + xor ax,ax ; success: return TRUE + inc ax + ret +@@: xor ax,ax ; failure: return FALSE + ret +GetLowRedirInfo endp + +INIT_TEXT ends + +_TEXT segment byte public 'CODE' + + assume cs:_TEXT + + public NewInt21Handler +NewInt21Handler proc far + sti + cmp ah,0e3h + jb @f + call far ptr NetwareRequest + retf 2 +@@: sub sp,4 + push bp + mov bp,sp + push es + push bx + SET_DS + les bx,OldInt21Handler + mov [bp+2],bx + mov [bp+4],es + RESTORE_DS + pop bx + pop es + pop bp + retf +NewInt21Handler endp + + public NetwareRequest +NetwareRequest proc far + push bx + push ds + LOAD_RM_DS_BX + cmp ah,0f0h + jne for_dll + +; +; these are the 0xF000, 0xF001, 0xF002, 0xF004, 0xF005 calls that we can handle +; here without having to BOP. All we need do is access the table in the shared +; real-mode/protect-mode (low) memory +; + +.errnz (_PrimaryServer - (_PreferredServer + 1)) + +; +; point bx at PreferredServer in the low memory area. If the request is a +; PrimaryServer request (0xF004, 0xF005) then point bx at PrimaryServer +; + + lea bx,[bx]._PreferredServer; bx = offset of PreferredServer + cmp al,3 + cmc + adc bx,0 ; bx = &PrimaryServer if F004 or F005 + or al,al ; f000 = set preferred server + jz set_server + cmp al,4 ; f004 = set primary server + jnz try_01 + +; +; 0xF000 or 0xF004: set Preferred or Primary Server to value contained in DL. +; If DL > 8, set respective server index to 0 +; + +set_server: + xor al,al + cmp dl,8 + ja @f + mov al,dl +@@: mov [bx],al + jmp short exit_f0 + +; +; 0xF001 or 0xF005: get Preferred or Primary Server +; + +try_01: cmp al,1 ; f001 = get preferred server + jz get_server + cmp al,5 + jnz try_02 + +get_server: + mov al,[bx] + jmp short exit_f0 + +try_02: cmp al,2 ; f002 = get default server + jnz for_dll ; try to handle on 32-bit side + mov al,[bx] ; al = PreferredServer + or al,al + jnz exit_f0 + mov al,[bx+1] ; al = PrimaryServer + +exit_f0:RESTORE_DS_BX + ret + +; +; if we're here then the call must go through to the 32-bit DLL. Save any relevant +; info in the low memory area, load the handle and BOP (DispatchCall) +; + +for_dll:mov [bx]._SavedAx,ax ; save AX value for DLL + push word ptr [bx]._hVdd ; put VDD handle on top of stack + + cmp ah,0BCh ; bc, bd, be need handle mapping + jb @f + cmp ah,0BEh + ja @f + pop ax ; ax = hVdd + RESTORE_DS_BX ; ds, bx = user ds, bx + call MapNtHandle + jmp dispatchola + +@@: push bp + cmp ah, 0E3h ; Is it new or old Create Job request? + je lookupcode + cmp ax, 0F217h + jne check_f3 + +lookupcode: + mov bp,sp + mov ds,[bp+4] + cmp byte ptr [si+2],68h + je createjob + cmp byte ptr [si+2],79h + je createjob + jmp short outtahere + +createjob: + LOAD_RM_DS_BX + mov [bx]._SavedAx,9f02h + push ax ; Open \\Server\queue for NCP + mov ax,[bp+2] ; ax = hVdd + mov ds,[bp+4] ; ds = users ds + push ds + push dx ; users dx + DispatchCall ; Set DeNovellBuffer to \\Server\queue + ; and registers ready for DOS OpenFile + int 21h ; Open \\server\queue + LOAD_RM_DS_BX + jc openfailed + mov [bx]._JobHandle, al + mov [bx]._CreatedJob, 1 ; Flag JobHandle is valid + push bx + mov bx, ax ; JobHandle + call MapNtHandle ; take bx and find the Nt handle + pop bx + +openfailed: + pop dx + pop ds ; Proceed and send the NCP + pop ax + + push ds + push bx + LOAD_RM_DS_BX + mov [bx]._SavedAx, ax + pop bx + pop ds ; users DS + jmp short outtahere + +check_f3: + cmp ah, 0F3h + jne outtahere + ; FileServerCopy, change both + ; handles in the structure es:di + push bx + + mov bx,word ptr es:[di] ; Map Source Handle + call MapNtHandle + + pop bx + mov ax,[bx]._NtHandleHi + mov [bx]._NtHandleSrcHi,ax + mov ax,[bx]._NtHandleLow + mov [bx]._NtHandleSrcLow,ax + + mov bx,word ptr es:[di+2] ; Map Destination Handle + call MapNtHandle + +outtahere: + pop bp + pop ax ; ax = hVdd + RESTORE_DS_BX ; ds, bx = user ds, bx +dispatchola: + DispatchCall ; BOP: DLL performs action + ret ; return to the application + +; +; if the request was not recognized by the DLL, it modifies IP so that control +; will resume at the next int 21. We just fill the intervening space with NOPs +; (space that makes up a retf <n> instruction in the RM TSR) +; + + nop + nop + int 21h + ret +NetwareRequest endp + +; *** MapNtHandle +; * +; * Given a handle in BX, map it to a 32-bit Nt handle in NtHandle[Hi|Low] +; * +; * ENTRY bx = handle to map +; * +; * EXIT Success - NtHandle set to 32-bit Nt handle from SFT +; * +; * USES ax, bx, flags +; * +; * ASSUMES nothing +; * +; *** + +MapNtHandle proc near + push ax + mov ax,9f01h ; call MapNtHandle on (BX) in RM + int 21h ; update NtHandleHi, NtHandleLow + pop ax +@@: ret +MapNtHandle endp + +_TEXT ends + +end |